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

- Blood: Replace XSPRITE targetx with TargetPos.X calls.

Browse source
This commit is contained in:
Mitchell Richters 2021-12-30 21:22:43 +11:00
parent 22275a16f6
commit 1d29716e6b
26 changed files with 72 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -5557,7 +5557,7 @@ static void actCheckProximity()
case kThingBloodBits:
case kThingBloodChunks:
case kThingZombieHead:
if (actor->xspr.locked && PlayClock >= actor->xspr.targetX) actor->xspr.locked = 0;
if (actor->xspr.locked && PlayClock >= actor->xspr.TargetPos.X) actor->xspr.locked = 0;
break;
}
@ -6360,7 +6360,7 @@ DBloodActor* actSpawnThing(sectortype* pSector, int x, int y, int z, int nThingT
actor->xspr.data2 = 0;
actor->xspr.data3 = 0;
actor->xspr.data4 = 318;
actor->xspr.targetX = PlayClock + 180;
actor->xspr.TargetPos.X = PlayClock + 180;
actor->xspr.locked = 1;
actor->xspr.state = 1;
actor->xspr.triggerOnce = 0;
@ -6373,7 +6373,7 @@ DBloodActor* actSpawnThing(sectortype* pSector, int x, int y, int z, int nThingT
actor->xspr.data2 = 0;
actor->xspr.data3 = 0;
actor->xspr.data4 = 318;
actor->xspr.targetX = PlayClock + 180;
actor->xspr.TargetPos.X = PlayClock + 180;
actor->xspr.locked = 1;
actor->xspr.state = 1;
actor->xspr.triggerOnce = 0;
@ -7012,7 +7012,7 @@ void DudeToGibCallback1(int, DBloodActor* actor)
actor->xspr.triggerOnce = 0;
actor->xspr.isTriggered = 0;
actor->xspr.locked = 0;
actor->xspr.targetX = PlayClock;
actor->xspr.TargetPos.X = PlayClock;
actor->xspr.state = 1;
}
@ -7027,7 +7027,7 @@ void DudeToGibCallback2(int, DBloodActor* actor)
actor->xspr.triggerOnce = 0;
actor->xspr.isTriggered = 0;
actor->xspr.locked = 0;
actor->xspr.targetX = PlayClock;
actor->xspr.TargetPos.X = PlayClock;
actor->xspr.state = 1;
}

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

@ -364,7 +364,7 @@ void aiActivateDude(DBloodActor* actor)
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!actor->xspr.state)
{
aiChooseDirection(actor, getangle(actor->xspr.targetX - actor->spr.pos.X, actor->xspr.targetY - actor->spr.pos.Y));
aiChooseDirection(actor, getangle(actor->xspr.TargetPos.X - actor->spr.pos.X, actor->xspr.targetY - actor->spr.pos.Y));
actor->xspr.state = 1;
}
switch (actor->spr.type)
@ -916,7 +916,7 @@ void aiActivateDude(DBloodActor* actor)
void aiSetTarget(DBloodActor* actor, int x, int y, int z)
{
actor->SetTarget(nullptr);
actor->xspr.targetX = x;
actor->xspr.TargetPos.X = x;
actor->xspr.targetY = y;
actor->xspr.targetZ = z;
}
@ -934,7 +934,7 @@ void aiSetTarget(DBloodActor* actor, DBloodActor* target)
{
actor->SetTarget(target);
DUDEINFO* pDudeInfo = getDudeInfo(target->spr.type);
actor->xspr.targetX = target->spr.pos.X;
actor->xspr.TargetPos.X = target->spr.pos.X;
actor->xspr.targetY = target->spr.pos.Y;
actor->xspr.targetZ = target->spr.pos.Z - ((pDudeInfo->eyeHeight * target->spr.yrepeat) << 2);
}
@ -1706,7 +1706,7 @@ void aiInitSprite(DBloodActor* actor)
{
stateTimer = actor->xspr.stateTimer;
pTargetMarker = actor->GetTarget();
targetX = actor->xspr.targetX;
targetX = actor->xspr.TargetPos.X;
targetY = actor->xspr.targetY;
targetZ = actor->xspr.targetZ;
}
@ -1926,7 +1926,7 @@ void aiInitSprite(DBloodActor* actor)
if (pTargetMarker)
{
actor->SetTarget(pTargetMarker);
actor->xspr.targetX = targetX;
actor->xspr.TargetPos.X = targetX;
actor->xspr.targetY = targetY;
actor->xspr.targetZ = targetZ;
}

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

@ -137,7 +137,7 @@ static void batThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -319,7 +319,7 @@ static void batMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x200)
@ -351,7 +351,7 @@ static void batMoveSwoop(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x200)
@ -381,7 +381,7 @@ static void batMoveFly(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x200)

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

@ -179,7 +179,7 @@ static void beastThinkGoto(DBloodActor* actor)
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -330,7 +330,7 @@ static void beastThinkSwimGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -403,7 +403,7 @@ static void beastMoveForward(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (abs(nAng) > 341)
return;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x400 && Random(64) < 32)
@ -424,7 +424,7 @@ static void sub_628A0(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
@ -460,7 +460,7 @@ static void sub_62AE0(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
@ -495,7 +495,7 @@ static void sub_62D7C(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);

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

@ -151,7 +151,7 @@ static void eelThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -329,7 +329,7 @@ static void eelMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x399)
@ -358,7 +358,7 @@ static void eelMoveSwoop(DBloodActor* actor)
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2;
if (abs(nAng) > 341)
return;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x8000) && nDist <= 0x399)
@ -385,7 +385,7 @@ static void eelMoveAscend(DBloodActor* actor)
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2;
if (abs(nAng) > 341)
return;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x399)

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

@ -84,7 +84,7 @@ static void burnThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -94,7 +94,7 @@ static void calebThinkGoto(DBloodActor* actor)
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -212,7 +212,7 @@ static void calebThinkSwimGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -282,7 +282,7 @@ static void sub_65D04(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
@ -319,7 +319,7 @@ static void sub_65F44(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
@ -355,7 +355,7 @@ static void sub_661E0(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);

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

@ -297,7 +297,7 @@ static void cerberusThinkGoto(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -193,7 +193,7 @@ static void cultThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -263,7 +263,7 @@ static void gargThinkGoto(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -532,7 +532,7 @@ static void gargMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
@ -567,7 +567,7 @@ static void gargMoveSlow(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -608,7 +608,7 @@ static void gargMoveSwoop(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -648,7 +648,7 @@ static void gargMoveFly(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -242,7 +242,7 @@ static void ghostThinkGoto(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -428,7 +428,7 @@ static void ghostMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
@ -463,7 +463,7 @@ static void ghostMoveSlow(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -501,7 +501,7 @@ static void ghostMoveSwoop(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -538,7 +538,7 @@ static void ghostMoveFly(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -85,7 +85,7 @@ static void gillThinkGoto(DBloodActor* actor)
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -199,7 +199,7 @@ static void gillThinkSwimGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -274,7 +274,7 @@ static void sub_6CB00(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
@ -310,7 +310,7 @@ static void sub_6CD74(DBloodActor* actor)
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
@ -345,7 +345,7 @@ static void sub_6D03C(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);

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

@ -66,7 +66,7 @@ static void handThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -81,7 +81,7 @@ static void houndThinkGoto(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -50,7 +50,7 @@ static void innocThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -139,7 +139,7 @@ static void aiPodMove(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -62,7 +62,7 @@ static void ratThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -136,7 +136,7 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -171,7 +171,7 @@ static void spidThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -264,7 +264,7 @@ static void sub_72850(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -419,7 +419,7 @@ static void unicultThinkGoto(DBloodActor* actor)
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
@ -1122,7 +1122,7 @@ void aiGenDudeMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)

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

@ -64,7 +64,7 @@ void HackSeqCallback(int, DBloodActor* actor)
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int tx = actor->xspr.targetX - actor->spr.pos.X;
int tx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int ty = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(tx, ty);
int height = (actor->spr.yrepeat * pDudeInfo->eyeHeight) << 2;
@ -91,7 +91,7 @@ static void zombaThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -266,7 +266,7 @@ static void entryAIdle(DBloodActor* actor)
static void entryEStand(DBloodActor* actor)
{
sfxPlay3DSound(actor, 1100, -1, 0);
actor->spr.ang = getangle(actor->xspr.targetX - actor->spr.pos.X, actor->xspr.targetY - actor->spr.pos.Y);
actor->spr.ang = getangle(actor->xspr.TargetPos.X - actor->spr.pos.X, actor->xspr.targetY - actor->spr.pos.Y);
}
END_BLD_NS

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

@ -66,7 +66,7 @@ void PukeSeqCallback(int, DBloodActor* actor)
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat);
int height2 = (pDudeInfoT->eyeHeight * target->spr.yrepeat);
int tx = actor->xspr.targetX - actor->spr.pos.X;
int tx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int ty = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(tx, ty);
int dx = bcos(nAngle);
@ -90,7 +90,7 @@ static void zombfThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);

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

@ -573,7 +573,7 @@ void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, sect
pXSprite->dudeGuard = bitReader.readUnsigned(1);
pXSprite->dudeFlag4 = bitReader.readUnsigned(1);
/*pXSprite->target_i = */ bitReader.readSigned(16);
pXSprite->targetX = bitReader.readSigned(32);
pXSprite->TargetPos.X = bitReader.readSigned(32);
pXSprite->targetY = bitReader.readSigned(32);
pXSprite->targetZ = bitReader.readSigned(32);
pXSprite->burnTime = bitReader.readUnsigned(16);

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

@ -623,7 +623,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, XSPRITE& w, XSPRIT
("data2", w.data2, def->data2)
("data3", w.data3, def->data3)
("data4", w.data4, def->data4)
("targetX", w.targetX, def->targetX)
("targetX", w.TargetPos.X, def->TargetPos.X)
("targetY", w.targetY, def->targetY)
("targetZ", w.targetZ, def->targetZ)
("target", w.target, def->target)

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

@ -101,9 +101,9 @@ struct XSPRITE {
TObjPtr<DBloodActor*> target; // target sprite
TObjPtr<DBloodActor*> burnSource;
int32_t targetX; // target x
int32_t targetY; // target y
int32_t targetZ; // target z
vec3_t TargetPos;
int32_t sysData1; // used to keep here various system data, so user can't change it in map editor
int32_t sysData2; //
int32_t scale; // used for scaling SEQ size on sprites

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

@ -689,7 +689,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
actor->xspr.Proximity = actor->xspr.Push = actor->xspr.Vector = actor->xspr.triggerOn = false;
actor->xspr.state = actor->xspr.restState = 0;
actor->xspr.targetX = actor->xspr.targetY = actor->xspr.targetZ = actor->xspr.sysData2 = -1;
actor->xspr.TargetPos.X = actor->xspr.targetY = actor->xspr.targetZ = actor->xspr.sysData2 = -1;
actor->SetTarget(nullptr);
ChangeActorStat(actor, kStatModernCondition);
auto oldStat = actor->spr.cstat;
@ -3008,7 +3008,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
if (actor->spr.statnum == kStatDude && actor->IsDudeActor() && !actor->IsPlayerActor())
{
int x = actor->xspr.targetX;
int x = actor->xspr.TargetPos.X;
int y = actor->xspr.targetY;
int z = actor->xspr.targetZ;
auto target = actor->GetTarget();
@ -3017,7 +3017,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
if (target != nullptr)
{
actor->xspr.targetX = x;
actor->xspr.TargetPos.X = x;
actor->xspr.targetY = y;
actor->xspr.targetZ = z;
actor->SetTarget(target);
@ -6824,7 +6824,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
{
actor->SetTarget(pMateTargetActor);
auto pMate = pMateTargetActor->GetTarget();
actor->xspr.targetX = pMate->spr.pos.X;
actor->xspr.TargetPos.X = pMate->spr.pos.X;
actor->xspr.targetY = pMate->spr.pos.Y;
actor->xspr.targetZ = pMate->spr.pos.Z;
if (!isActive(actor))
@ -7640,7 +7640,7 @@ void aiPatrolSetMarker(DBloodActor* actor)
while (auto nextactor = it.Next())
{
if (nextactor == targetactor || !nextactor->hasX()) continue;
else if (actor->xspr.targetX >= 0 && nextactor == prevactor && node)
else if (actor->xspr.TargetPos.X >= 0 && nextactor == prevactor && node)
{
if (targetactor->xspr.data2 == prevactor->xspr.data1)
continue;
@ -7691,7 +7691,7 @@ void aiPatrolStop(DBloodActor* actor, DBloodActor* targetactor, bool alarm)
actor->xspr.unused1 &= ~kDudeFlagCrouch; // reset the crouch status
actor->xspr.unused2 = kPatrolMoveForward; // reset path direction
actor->prevmarker = nullptr;
actor->xspr.targetX = -1; // reset the previous marker index
actor->xspr.TargetPos.X = -1; // reset the previous marker index
if (actor->xspr.health <= 0)
return;
@ -7720,7 +7720,7 @@ void aiPatrolStop(DBloodActor* actor, DBloodActor* targetactor, bool alarm)
else
{
aiInitSprite(actor);
aiSetTarget(actor, actor->xspr.targetX, actor->xspr.targetY, actor->xspr.targetZ);
aiSetTarget(actor, actor->xspr.TargetPos.X, actor->xspr.targetY, actor->xspr.targetZ);
}
actor->xspr.dudeFlag4 = patrol; // this must be kept so enemy can patrol after respawn again