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

- pXSprite in AI... code.

Browse source
This commit is contained in:
Christoph Oelckers 2021-12-22 22:49:50 +01:00
parent f678e55daa
commit 49c43297cd
18 changed files with 235 additions and 321 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -139,8 +139,7 @@ void StompSeqCallback(int, DBloodActor* actor)
continue;
if (CheckSector(sectorMap, actor2) && CheckProximity(actor2, x, y, z, pSector, vc))
{
XSPRITE* pXSprite = &actor2->x();
if (pXSprite->locked)
if (actor2->xspr.locked)
continue;
int dx = abs(actor->spr.pos.X - actor2->spr.pos.X);
int dy = abs(actor->spr.pos.Y - actor2->spr.pos.Y);
@ -169,21 +168,19 @@ static void MorphToBeast(DBloodActor* actor)
static void beastThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void beastThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -331,11 +328,10 @@ static void beastThinkChase(DBloodActor* actor)
static void beastThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -400,16 +396,15 @@ static void beastThinkSwimChase(DBloodActor* actor)
static void beastMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x400 && Random(64) < 32)
return;
@ -419,10 +414,9 @@ static void beastMoveForward(DBloodActor* actor)
static void sub_628A0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -430,8 +424,8 @@ static void sub_628A0(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -451,24 +445,23 @@ static void sub_628A0(DBloodActor* actor)
static void sub_62AE0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -487,14 +480,13 @@ static void sub_62AE0(DBloodActor* actor)
static void sub_62D7C(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -503,8 +495,8 @@ static void sub_62D7C(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -65,8 +65,8 @@ void eelBiteSeqCallback(int, DBloodActor* actor)
{
/*
* workaround for
* pXSprite->target >= 0 in file NBlood/source/blood/src/aiboneel.cpp at line 86
* The value of pXSprite->target is -1.
* actor->xspr.target >= 0 in file NBlood/source/blood/src/aiboneel.cpp at line 86
* The value of actor->xspr.target is -1.
* copied from lines 177:181
* resolves this case, but may cause other issues?
*/
@ -89,7 +89,6 @@ void eelBiteSeqCallback(int, DBloodActor* actor)
static void eelThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
@ -98,7 +97,7 @@ static void eelThinkTarget(DBloodActor* actor)
else if (pDudeExtraE->thinkTime >= 10 && pDudeExtraE->active)
{
pDudeExtraE->thinkTime = 0;
pXSprite->goalAng += 256;
actor->xspr.goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
aiNewState(actor, &eelTurn);
@ -109,7 +108,7 @@ static void eelThinkTarget(DBloodActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -144,18 +143,16 @@ static void eelThinkTarget(DBloodActor* actor)
static void eelThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
eelThinkTarget(actor);
}
static void eelThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -219,10 +216,9 @@ static void eelThinkPonder(DBloodActor* actor)
static void eelMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
@ -231,7 +227,7 @@ static void eelMoveDodgeUp(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -243,13 +239,12 @@ static void eelMoveDodgeUp(DBloodActor* actor)
static void eelMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
if (actor->xspr.dodgeDir == 0)
return;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
@ -257,7 +252,7 @@ static void eelMoveDodgeDown(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -324,10 +319,9 @@ static void eelThinkChase(DBloodActor* actor)
static void eelMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2;
@ -335,8 +329,8 @@ static void eelMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x399)
return;
@ -356,17 +350,16 @@ static void eelMoveForward(DBloodActor* actor)
static void eelMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2;
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x8000) && nDist <= 0x399)
return;
@ -384,17 +377,16 @@ static void eelMoveSwoop(DBloodActor* actor)
static void eelMoveAscend(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2;
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x399)
return;
@ -412,11 +404,10 @@ static void eelMoveAscend(DBloodActor* actor)
void eelMoveToCeil(DBloodActor* actor)
{
auto pXSprite = &actor->x();
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = actor->spr.pos.Z;
if (z - pXSprite->targetZ < 0x1000)
if (z - actor->xspr.targetZ < 0x1000)
{
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
pDudeExtraE->active = 0;

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

@ -76,18 +76,16 @@ void BurnSeqCallback(int, DBloodActor*)
static void burnThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void burnThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -82,22 +82,20 @@ void SeqAttackCallback(int, DBloodActor* actor)
static void calebThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void calebThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -212,11 +210,10 @@ static void calebThinkChase(DBloodActor* actor)
static void calebThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -275,10 +272,9 @@ static void calebThinkSwimChase(DBloodActor* actor)
static void sub_65D04(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -286,8 +282,8 @@ static void sub_65D04(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -307,7 +303,6 @@ static void sub_65D04(DBloodActor* actor)
static void sub_65F44(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
@ -315,17 +310,17 @@ static void sub_65F44(DBloodActor* actor)
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -344,7 +339,6 @@ static void sub_65F44(DBloodActor* actor)
static void sub_661E0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
@ -352,7 +346,7 @@ static void sub_661E0(DBloodActor* actor)
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -361,8 +355,8 @@ static void sub_661E0(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -227,14 +227,12 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
static void cerberusThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void cerberusThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
@ -245,7 +243,7 @@ static void cerberusThinkTarget(DBloodActor* actor)
pDudeExtraE->thinkTime++;
else if (pDudeExtraE->thinkTime >= 10 && pDudeExtraE->active)
{
pXSprite->goalAng += 256;
actor->xspr.goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
if (actor->spr.type == kDudeCerberusTwoHead)
@ -259,7 +257,7 @@ static void cerberusThinkTarget(DBloodActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -294,14 +292,13 @@ static void cerberusThinkTarget(DBloodActor* actor)
static void cerberusThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -185,24 +185,22 @@ static bool TargetNearExplosion(sectortype* sector)
static void cultThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiLookForTarget(actor);
}
static void cultThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 5120 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
switch (pXSprite->medium)
switch (actor->xspr.medium)
{
case kMediumNormal:
aiNewState(actor, &cultistSearch);
@ -218,10 +216,9 @@ static void cultThinkGoto(DBloodActor* actor)
static void cultThinkChase(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (actor->GetTarget() == nullptr)
{
switch (pXSprite->medium)
switch (actor->xspr.medium)
{
case kMediumNormal:
aiNewState(actor, &cultistGoto);
@ -242,7 +239,7 @@ static void cultThinkChase(DBloodActor* actor)
aiChooseDirection(actor, getangle(dx, dy));
if (target->xspr.health == 0)
{
switch (pXSprite->medium)
switch (actor->xspr.medium)
{
case kMediumNormal:
aiNewState(actor, &cultistSearch);
@ -260,7 +257,7 @@ static void cultThinkChase(DBloodActor* actor)
}
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
switch (pXSprite->medium)
switch (actor->xspr.medium)
{
case kMediumNormal:
aiNewState(actor, &cultistSearch);
@ -293,14 +290,14 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistTThrow);
break;
case 0:
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistTThrow);
break;
default:
@ -314,39 +311,39 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTProneFire);
else if (dudeIsPlayingSeq(actor, 13) && (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo))
else if (dudeIsPlayingSeq(actor, 13) && (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo))
aiNewState(actor, &cultistTSwimFire);
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistTSwimFire);
}
else
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistDodge);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistProneDodge);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSwimDodge);
}
break;
default:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistTSwimFire);
break;
}
@ -361,14 +358,14 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
case 0:
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
default:
@ -382,39 +379,39 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
}
else
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistDodge);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistProneDodge);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSwimDodge);
}
break;
default:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
break;
}
@ -429,14 +426,14 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistTsThrow);
break;
case 0:
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistTsThrow);
break;
default:
@ -450,39 +447,39 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistTsSwimFire);
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistTsSwimFire);
}
else
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistDodge);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistProneDodge);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSwimDodge);
}
break;
default:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistTsProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistTsSwimFire);
break;
}
@ -496,13 +493,13 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistDThrow);
break;
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistDThrow);
break;
default:
@ -517,13 +514,13 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != 1 && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != 1 && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultist139A78);
break;
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultist139A78);
break;
default:
@ -541,14 +538,14 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
case 0:
case 4:
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun && actor->xspr.medium != kMediumWater && actor->xspr.medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
default:
@ -562,39 +559,39 @@ static void cultThinkChase(DBloodActor* actor)
switch (hit)
{
case -1:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
break;
case 3:
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
}
else
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistDodge);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistProneDodge);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSwimDodge);
}
break;
default:
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
if (!dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
else if (dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
else if (dudeIsPlayingSeq(actor, 14) && actor->xspr.medium == kMediumNormal)
aiNewState(actor, &cultistSProneFire);
else if (pXSprite->medium == kMediumWater || pXSprite->medium == kMediumGoo)
else if (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)
aiNewState(actor, &cultistSSwimFire);
break;
}
@ -605,7 +602,7 @@ static void cultThinkChase(DBloodActor* actor)
}
}
}
switch (pXSprite->medium)
switch (actor->xspr.medium)
{
case kMediumNormal:
aiNewState(actor, &cultistGoto);

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

@ -102,7 +102,6 @@ void ThrowFSeqCallback(int, DBloodActor* actor)
void BlastSSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -197,7 +196,6 @@ void ThrowSSeqCallback(int, DBloodActor* actor)
static void gargThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
@ -208,7 +206,7 @@ static void gargThinkTarget(DBloodActor* actor)
pDudeExtraE->thinkTime++;
else if (pDudeExtraE->thinkTime >= 10 && pDudeExtraE->active)
{
pXSprite->goalAng += 256;
actor->xspr.goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
aiNewState(actor, &gargoyleTurn);
@ -219,7 +217,7 @@ static void gargThinkTarget(DBloodActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -254,21 +252,19 @@ static void gargThinkTarget(DBloodActor* actor)
static void gargThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiLookForTarget(actor);
}
static void gargThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -279,13 +275,12 @@ static void gargThinkGoto(DBloodActor* actor)
static void gargMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
@ -294,7 +289,7 @@ static void gargMoveDodgeUp(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -306,16 +301,15 @@ static void gargMoveDodgeUp(DBloodActor* actor)
static void gargMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
if (actor->xspr.dodgeDir == 0)
return;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
@ -323,7 +317,7 @@ static void gargMoveDodgeDown(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -525,13 +519,12 @@ static void entrySStatue(DBloodActor* actor)
static void gargMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -539,8 +532,8 @@ static void gargMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - 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)
return;
@ -560,23 +553,22 @@ static void gargMoveForward(DBloodActor* actor)
static void gargMoveSlow(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -602,23 +594,22 @@ static void gargMoveSlow(DBloodActor* actor)
static void gargMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -643,13 +634,12 @@ static void gargMoveSwoop(DBloodActor* actor)
static void gargMoveFly(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -658,8 +648,8 @@ static void gargMoveFly(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;

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

@ -88,7 +88,6 @@ void ghostThrowSeqCallback(int, DBloodActor* actor)
void ghostBlastSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -177,7 +176,6 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
static void ghostThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
@ -188,7 +186,7 @@ static void ghostThinkTarget(DBloodActor* actor)
pDudeExtraE->thinkTime++;
else if (pDudeExtraE->thinkTime >= 10 && pDudeExtraE->active)
{
pXSprite->goalAng += 256;
actor->xspr.goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
aiNewState(actor, &ghostTurn);
@ -199,7 +197,7 @@ static void ghostThinkTarget(DBloodActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -233,21 +231,19 @@ static void ghostThinkTarget(DBloodActor* actor)
static void ghostThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void ghostThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -258,13 +254,12 @@ static void ghostThinkGoto(DBloodActor* actor)
static void ghostMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
@ -273,7 +268,7 @@ static void ghostMoveDodgeUp(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -285,16 +280,15 @@ static void ghostMoveDodgeUp(DBloodActor* actor)
static void ghostMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
if (actor->xspr.dodgeDir == 0)
return;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
@ -302,7 +296,7 @@ static void ghostMoveDodgeDown(DBloodActor* actor)
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
int t2 = DMulScale(dx, nSin, -dy, nCos, 30);
if (pXSprite->dodgeDir > 0)
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
else
t2 -= pDudeInfo->sideSpeed;
@ -314,7 +308,6 @@ static void ghostMoveDodgeDown(DBloodActor* actor)
static void ghostThinkChase(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (actor->GetTarget() == nullptr)
{
aiNewState(actor, &ghostGoto);
@ -422,13 +415,12 @@ static void ghostThinkChase(DBloodActor* actor)
static void ghostMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -436,8 +428,8 @@ static void ghostMoveForward(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - 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)
return;
@ -457,23 +449,22 @@ static void ghostMoveForward(DBloodActor* actor)
static void ghostMoveSlow(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -496,23 +487,22 @@ static void ghostMoveSlow(DBloodActor* actor)
static void ghostMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -534,13 +524,12 @@ static void ghostMoveSwoop(DBloodActor* actor)
static void ghostMoveFly(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
@ -549,8 +538,8 @@ static void ghostMoveFly(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;

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

@ -73,22 +73,20 @@ void GillBiteSeqCallback(int, DBloodActor* actor)
static void gillThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void gillThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -119,11 +117,10 @@ static void gillThinkChase(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
if (actor->xspr.health == 0)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &gillBeastSwimSearch);
@ -200,11 +197,10 @@ static void gillThinkChase(DBloodActor* actor)
static void gillThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -224,11 +220,10 @@ static void gillThinkSwimChase(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
if (actor->xspr.health == 0)
{
aiNewState(actor, &gillBeastSwimSearch);
return;
@ -269,11 +264,9 @@ static void gillThinkSwimChase(DBloodActor* actor)
static void sub_6CB00(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2;
@ -281,8 +274,8 @@ static void sub_6CB00(DBloodActor* actor)
return;
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -302,24 +295,23 @@ static void sub_6CB00(DBloodActor* actor)
static void sub_6CD74(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
actor->xspr.goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -338,14 +330,13 @@ static void sub_6CD74(DBloodActor* actor)
static void sub_6D03C(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int z = actor->spr.pos.Z + getDudeInfo(actor->spr.type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nAng = ((actor->xspr.goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = (pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2;
@ -354,8 +345,8 @@ static void sub_6D03C(DBloodActor* actor)
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -58,18 +58,16 @@ void HandJumpSeqCallback(int, DBloodActor* actor)
static void handThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void handThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -69,22 +69,20 @@ void houndBurnSeqCallback(int, DBloodActor* actor)
static void houndThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void houndThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -42,18 +42,16 @@ AISTATE innocentGoto = { kAiStateMove, 6, -1, 600, NULL, aiMoveForward, innocThi
static void innocThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void innocThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -64,7 +62,6 @@ static void innocThinkGoto(DBloodActor* actor)
static void innocThinkChase(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (actor->GetTarget() == nullptr)
{
aiNewState(actor, &innocentGoto);

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

@ -127,22 +127,20 @@ void sub_70284(int, DBloodActor* actor)
static void aiPodSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void aiPodMove(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -54,18 +54,16 @@ void ratBiteSeqCallback(int, DBloodActor* actor)
static void ratThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void ratThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -131,14 +131,13 @@ void SpidJumpSeqCallback(int, DBloodActor* actor)
void SpidBirthSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -164,18 +163,16 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
static void spidThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void spidThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -197,14 +197,12 @@ void sub_720AC(int, DBloodActor* actor)
static void sub_72580(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void sub_725A4(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
@ -215,7 +213,7 @@ static void sub_725A4(DBloodActor* actor)
pDudeExtraE->thinkTime++;
else if (pDudeExtraE->thinkTime >= 10 && pDudeExtraE->active)
{
pXSprite->goalAng += 256;
actor->xspr.goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
aiNewState(actor, &tcherno13AA28);
@ -226,7 +224,7 @@ static void sub_725A4(DBloodActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -261,14 +259,13 @@ static void sub_725A4(DBloodActor* actor)
static void sub_72850(DBloodActor* actor)
{
auto pXSprite = &actor->x();
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);

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

@ -60,13 +60,12 @@ AISTATE zombie13AC2C = { kAiStateOther, 11, nStandClient, 0, entryEZombie, NULL,
void HackSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int tx = pXSprite->targetX - actor->spr.pos.X;
int ty = pXSprite->targetY - actor->spr.pos.Y;
int tx = actor->xspr.targetX - 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;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
@ -84,18 +83,16 @@ void StandSeqCallback(int, DBloodActor* actor)
static void zombaThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiLookForTarget(actor);
}
static void zombaThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -213,7 +210,7 @@ static void myThinkTarget(DBloodActor* actor)
{
PLAYER* pPlayer = &gPlayer[p];
auto owneractor = actor->GetOwner();
if (owneractor == nullptr || owneractor == pPlayer->actor || pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
if (owneractor == nullptr || owneractor == pPlayer->actor || pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
@ -251,8 +248,7 @@ static void myThinkTarget(DBloodActor* actor)
static void myThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
myThinkTarget(actor);
}
@ -269,9 +265,8 @@ static void entryAIdle(DBloodActor* actor)
static void entryEStand(DBloodActor* actor)
{
auto pXSprite = &actor->x();
sfxPlay3DSound(actor, 1100, -1, 0);
actor->spr.ang = getangle(pXSprite->targetX - actor->spr.pos.X, pXSprite->targetY - actor->spr.pos.Y);
actor->spr.ang = getangle(actor->xspr.targetX - actor->spr.pos.X, actor->xspr.targetY - actor->spr.pos.Y);
}
END_BLD_NS

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

@ -60,15 +60,14 @@ void zombfHackSeqCallback(int, DBloodActor* actor)
void PukeSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat);
int height2 = (pDudeInfoT->eyeHeight * target->spr.yrepeat);
int tx = pXSprite->targetX - actor->spr.pos.X;
int ty = pXSprite->targetY - actor->spr.pos.Y;
int tx = actor->xspr.targetX - actor->spr.pos.X;
int ty = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(tx, ty);
int dx = bcos(nAngle);
int dy = bsin(nAngle);
@ -83,18 +82,16 @@ void ThrowSeqCallback(int, DBloodActor* actor)
static void zombfThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
aiChooseDirection(actor, pXSprite->goalAng);
aiChooseDirection(actor, actor->xspr.goalAng);
aiThinkTarget(actor);
}
static void zombfThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);