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

- handle all target sprites in AI code.

Browse source
This commit is contained in:
Christoph Oelckers 2021-12-22 20:02:43 +01:00
parent 18c32d8fe9
commit bff3bbea73
18 changed files with 211 additions and 211 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -66,11 +66,11 @@ void SlashSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
// Correct ?
int dz = pSprite->pos.Z - pTarget->pos.Z;
int dz = pSprite->pos.Z - target->spr.pos.Z;
dx += Random3(4000 - 700 * gGameOptions.nDifficulty);
dy += Random3(4000 - 700 * gGameOptions.nDifficulty);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGargSlash);
@ -220,10 +220,10 @@ static void beastThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
auto pSector = pSprite->sector();
@ -237,7 +237,7 @@ static void beastThinkChase(DBloodActor* actor)
aiNewState(actor, &beastSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &beastSwimSearch);
@ -250,14 +250,14 @@ static void beastThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
if (nDist < 0x1400 && nDist > 0xa00 && abs(nDeltaAngle) < 85 && (pTarget->flags & 2)
&& IsPlayerSprite(pTarget) && Chance(0x8000))
actor->dudeSlope = nDist == 0? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
if (nDist < 0x1400 && nDist > 0xa00 && abs(nDeltaAngle) < 85 && (target->spr.flags & 2)
&& target->IsPlayerActor() && Chance(0x8000))
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (pXTarget->health > (unsigned)gPlayerTemplate[0].startHealth / 2)
@ -363,17 +363,17 @@ static void beastThinkSwimChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &beastSwimSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &beastSwimSearch);
return;
@ -385,7 +385,7 @@ static void beastThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -467,9 +467,9 @@ static void sub_62AE0(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -504,9 +504,9 @@ static void sub_62D7C(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

@ -78,14 +78,14 @@ void eelBiteSeqCallback(int, DBloodActor* actor)
return;
}
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (pTarget->yrepeat * pDudeInfoT->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
actFireVector(actor, 0, 0, dx, dy, height2 - height, kVectorBoneelBite);
}
@ -178,10 +178,10 @@ static void eelThinkPonder(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -193,10 +193,10 @@ static void eelThinkPonder(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int height2 = (getDudeInfo(pTarget->type)->eyeHeight * pTarget->yrepeat) << 2;
int height2 = (getDudeInfo(target->spr.type)->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < -0x2000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -284,17 +284,17 @@ static void eelThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &eelSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &eelSearch);
return;
@ -307,8 +307,8 @@ static void eelThinkChase(DBloodActor* actor)
int top, bottom;
GetActorExtents(actor, &top, &bottom);
int top2, bottom2;
GetSpriteExtents(pTarget, &top2, &bottom2);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
GetActorExtents(target, &top2, &bottom2);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -159,10 +159,10 @@ static void burnThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -199,7 +199,7 @@ static void burnThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -129,10 +129,10 @@ static void calebThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -145,7 +145,7 @@ static void calebThinkChase(DBloodActor* actor)
}
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &tinycalebSwimSearch);
@ -158,12 +158,12 @@ static void calebThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z-pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z-pSprite->pos.Z, nDist, 10);
if (nDist < 0x599 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
@ -239,17 +239,17 @@ static void calebThinkSwimChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &tinycalebSwimSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &tinycalebSwimSearch);
return;
@ -261,7 +261,7 @@ static void calebThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -319,9 +319,9 @@ static void sub_65F44(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -357,9 +357,9 @@ static void sub_661E0(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

@ -66,8 +66,8 @@ void cerberusBiteSeqCallback(int, DBloodActor* actor)
return;
}
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int dz = pTarget->pos.Z - pSprite->pos.Z;
auto target = actor->GetTarget();
int dz = target->spr.pos.Z - pSprite->pos.Z;
actFireVector(actor, 350, -100, dx, dy, dz, kVectorCerberusHack);
actFireVector(actor, -350, 0, dx, dy, dz, kVectorCerberusHack);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorCerberusHack);
@ -353,10 +353,10 @@ static void cerberusThinkChase(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0) {
@ -371,7 +371,7 @@ static void cerberusThinkChase(DBloodActor* actor)
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0) {
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0) {
switch (pSprite->type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusSearch);
@ -388,7 +388,7 @@ static void cerberusThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

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

@ -132,11 +132,11 @@ void cultThrowSeqCallback(int, DBloodActor* actor)
uint8_t v4 = Chance(0x6000);
sfxPlay3DSound(actor, 455, -1, 0);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
int dz = target->spr.pos.Z - pSprite->pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
if (nDist > 0x1e00)
@ -166,20 +166,20 @@ void sub_68230(int, DBloodActor* actor)
nMissile = kThingArmedTNTBundle;
sfxPlay3DSound(actor, 455, -1, 0);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
int dz = target->spr.pos.Z - pSprite->pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
auto pMissile = actFireThing(actor, 0, 0, dz / 128 - 14500, nMissile, (nDist2 << 17) / 120);
pMissile->xspr.Impact = 1;
}
static bool TargetNearExplosion(spritetype* pSprite)
static bool TargetNearExplosion(sectortype* sector)
{
BloodSectIterator it(pSprite->sector());
BloodSectIterator it(sector);
while (auto actor = it.Next())
{
if (actor->spr.type == kThingArmedTNTStick || actor->spr.statnum == kStatExplosion)
@ -242,10 +242,10 @@ static void cultThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -265,7 +265,7 @@ static void cultThinkChase(DBloodActor* actor)
}
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
switch (pXSprite->medium)
{
@ -284,16 +284,16 @@ static void cultThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
switch (pSprite->type) {
case kDudeCultistTommy:
if (nDist < 0x1e00 && nDist > 0xe00 && abs(nDeltaAngle) < 85 && !TargetNearExplosion(pTarget)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
if (nDist < 0x1e00 && nDist > 0xe00 && abs(nDeltaAngle) < 85 && !TargetNearExplosion(target->spr.sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
@ -360,8 +360,8 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistShotgun:
if (nDist < 0x2c00 && nDist > 0x1400 && !TargetNearExplosion(pTarget)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty >= 2 && IsPlayerSprite(pTarget) && !gPlayer[pTarget->type - kDudePlayer1].isRunning
if (nDist < 0x2c00 && nDist > 0x1400 && !TargetNearExplosion(target->spr.sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty >= 2 && target->IsPlayerActor() && !gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
@ -428,8 +428,8 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistTesla:
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(pTarget)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->spr.sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
@ -497,7 +497,7 @@ static void cultThinkChase(DBloodActor* actor)
break;
case kDudeCultistTNT:
if (nDist < 0x2c00 && nDist > 0x1400 && abs(nDeltaAngle) < 85
&& (pTarget->flags & 2) && IsPlayerSprite(pTarget))
&& (target->spr.flags & 2) && target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
@ -518,7 +518,7 @@ static void cultThinkChase(DBloodActor* actor)
}
}
else if (nDist < 0x1400 && abs(nDeltaAngle) < 85
&& (pTarget->flags & 2) && IsPlayerSprite(pTarget))
&& (target->spr.flags & 2) && target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
@ -540,8 +540,8 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistBeast:
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(pTarget)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->spr.sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);

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

@ -79,11 +79,11 @@ void SlashFSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (pTarget->yrepeat * pDudeInfoT->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
@ -107,7 +107,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
@ -180,12 +180,12 @@ void BlastSSeqCallback(int, DBloodActor* actor)
}
#ifdef NOONE_EXTENSIONS
// allow to fire missile in non-player targets
if (IsPlayerSprite(pTarget) || gModernMap) {
if (target->IsPlayerActor() || gModernMap) {
actFireMissile(actor, -120, 0, aim.dx, aim.dy, aim.dz, kMissileArcGargoyle);
actFireMissile(actor, 120, 0, aim.dx, aim.dy, aim.dz, kMissileArcGargoyle);
}
#else
if (IsPlayerSprite(pTarget)) {
if (target->IsPlayerActor()) {
actFireMissile(actor, -120, 0, aim.dx, aim.dy, aim.dz, kMissileArcGargoyle);
actFireMissile(actor, 120, 0, aim.dx, aim.dy, aim.dz, kMissileArcGargoyle);
}
@ -358,17 +358,17 @@ static void gargThinkChase(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &gargoyleFSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &gargoyleFSearch);
return;
@ -378,11 +378,11 @@ static void gargThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
// Should be dudeInfo[pTarget->type-kDudeBase]
int height2 = (pDudeInfo->eyeHeight * pTarget->yrepeat) << 2;
// Should be dudeInfo[target->spr.type-kDudeBase]
int height2 = (pDudeInfo->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -64,11 +64,11 @@ void ghostSlashSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (pTarget->yrepeat * pDudeInfoT->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
@ -93,7 +93,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
@ -166,12 +166,12 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
}
#ifdef NOONE_EXTENSIONS
// allow fire missile in non-player targets if not a demo
if (IsPlayerSprite(pTarget) || gModernMap) {
if (target->IsPlayerActor() || gModernMap) {
sfxPlay3DSound(actor, 489, 0, 0);
actFireMissile(actor, 0, 0, aim.dx, aim.dy, aim.dz, kMissileEctoSkull);
}
#else
if (IsPlayerSprite(pTarget)) {
if (target->IsPlayerActor()) {
sfxPlay3DSound(actor, 489, 0, 0);
actFireMissile(actor, 0, 0, aim.dx, aim.dy, aim.dz, kMissileEctoSkull);
}
@ -338,17 +338,17 @@ static void ghostThinkChase(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &ghostSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &ghostSearch);
return;
@ -358,11 +358,11 @@ static void ghostThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
// Should be dudeInfo[pTarget->type-kDudeBase]
int height2 = (pDudeInfo->eyeHeight * pTarget->yrepeat) << 2;
// Should be dudeInfo[target->spr.type-kDudeBase]
int height2 = (pDudeInfo->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -61,10 +61,10 @@ void GillBiteSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dz = pSprite->pos.Z - pTarget->pos.Z;
int dz = pSprite->pos.Z - target->spr.pos.Z;
dx += Random3(2000);
dy += Random3(2000);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGillBite);
@ -121,10 +121,10 @@ static void gillThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -134,7 +134,7 @@ static void gillThinkChase(DBloodActor* actor)
aiNewState(actor, &gillBeastSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &gillBeastSwimSearch);
@ -147,12 +147,12 @@ static void gillThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
if (nDist < 921 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
@ -228,17 +228,17 @@ static void gillThinkSwimChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &gillBeastSwimSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &gillBeastSwimSearch);
return;
@ -250,7 +250,7 @@ static void gillThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -313,9 +313,9 @@ static void sub_6CD74(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -350,9 +350,9 @@ static void sub_6D03C(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int z2 = target->spr.pos.Z + getDudeInfo(target->spr.type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

@ -44,10 +44,10 @@ AISTATE handJump = { kAiStateChase, 7, nJumpClient, 120, NULL, NULL, NULL, &hand
void HandJumpSeqCallback(int, DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
if (IsPlayerSprite(pTarget))
auto target = actor->GetTarget();
if (target->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[pTarget->type - kDudePlayer1];
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
if (!pPlayer->hand)
{
pPlayer->hand = 1;
@ -90,17 +90,17 @@ static void handThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &handSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &handSearch);
return;
@ -110,7 +110,7 @@ static void handThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -54,13 +54,13 @@ void houndBiteSeqCallback(int, DBloodActor* actor)
}
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
#ifdef NOONE_EXTENSIONS
if (IsPlayerSprite(pTarget) || gModernMap) // allow to hit non-player targets
actFireVector(actor, 0, 0, dx, dy, pTarget->pos.Z - pSprite->pos.Z, kVectorHoundBite);
if (target->IsPlayerActor() || gModernMap) // allow to hit non-player targets
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - pSprite->pos.Z, kVectorHoundBite);
#else
if (IsPlayerSprite(pTarget))
actFireVector(actor, 0, 0, dx, dy, pTarget->z - pSprite->z, kVectorHoundBite);
if (target->IsPlayerActor())
actFireVector(actor, 0, 0, dx, dy, target->spr.z - pSprite->z, kVectorHoundBite);
#endif
}
@ -112,17 +112,17 @@ static void houndThinkChase(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &houndSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &houndSearch);
return;
@ -132,7 +132,7 @@ static void houndThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -76,17 +76,17 @@ static void innocThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &innocentSearch);
return;
}
if (IsPlayerSprite(pTarget))
if (target->IsPlayerActor())
{
aiNewState(actor, &innocentSearch);
return;
@ -96,7 +96,7 @@ static void innocThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -65,12 +65,12 @@ void podAttack(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int x = pTarget->pos.X - pSprite->pos.X;
int y = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int x = target->spr.pos.X - pSprite->pos.X;
int y = target->spr.pos.Y - pSprite->pos.Y;
int dz = target->spr.pos.Z - pSprite->pos.Z;
x += Random2(1000);
y += Random2(1000);
int nDist = approxDist(x, y);
@ -188,10 +188,10 @@ static void aiPodChase(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0) {
@ -212,12 +212,12 @@ static void aiPodChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
if (abs(nDeltaAngle) < 85 && pTarget->type != kDudePodGreen && pTarget->type != kDudePodFire) {
if (abs(nDeltaAngle) < 85 && target->spr.type != kDudePodGreen && target->spr.type != kDudePodFire) {
switch (pSprite->type) {
case kDudePodGreen:
case kDudePodFire:

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

@ -48,9 +48,9 @@ void ratBiteSeqCallback(int, DBloodActor* actor)
int dy = bsin(pSprite->ang);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
if (IsPlayerSprite(pTarget))
actFireVector(actor, 0, 0, dx, dy, pTarget->pos.Z - pSprite->pos.Z, kVectorRatBite);
auto target = actor->GetTarget();
if (target->IsPlayerActor())
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - pSprite->pos.Z, kVectorRatBite);
}
static void ratThinkSearch(DBloodActor* actor)
@ -86,17 +86,17 @@ static void ratThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &ratSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &ratSearch);
return;
@ -106,7 +106,7 @@ static void ratThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -71,18 +71,18 @@ void SpidBiteSeqCallback(int, DBloodActor* actor)
auto const target = actor->GetTarget();
spritetype* pTarget = &target->s();
if (IsPlayerSprite(pTarget))
if (target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (hit == 3 && gHitInfo.actor()->IsPlayerActor())
{
dz += pTarget->pos.Z - pSprite->pos.Z;
PLAYER* pPlayer = &gPlayer[pTarget->type - kDudePlayer1];
dz += target->spr.pos.Z - pSprite->pos.Z;
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
switch (pSprite->type)
{
case kDudeSpiderBrown:
actFireVector(actor, 0, 0, dx, dy, dz, kVectorSpiderBite);
if (IsPlayerSprite(pTarget) && !pPlayer->godMode && powerupCheck(pPlayer, kPwUpDeathMask) <= 0 && Chance(0x4000))
if (target->IsPlayerActor() && !pPlayer->godMode && powerupCheck(pPlayer, kPwUpDeathMask) <= 0 && Chance(0x4000))
powerupActivate(pPlayer, kPwUpDeliriumShroom);
break;
case kDudeSpiderRed:
@ -118,9 +118,9 @@ void SpidJumpSeqCallback(int, DBloodActor* actor)
int dz = Random2(200);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
if (IsPlayerSprite(pTarget)) {
dz += pTarget->pos.Z - pSprite->pos.Z;
auto target = actor->GetTarget();
if (target->IsPlayerActor()) {
dz += target->spr.pos.Z - pSprite->pos.Z;
switch (pSprite->type) {
case kDudeSpiderBrown:
case kDudeSpiderRed:
@ -140,7 +140,7 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
@ -148,7 +148,7 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
int nDist = approxDist(dx, dy);
DBloodActor* spawned = nullptr;
if (IsPlayerSprite(pTarget) && pDudeExtraE->birthCounter < 10)
if (target->IsPlayerActor() && pDudeExtraE->birthCounter < 10)
{
if (nDist < 0x1a00 && nDist > 0x1400 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderRed, pSprite->clipdist, 0);
@ -200,17 +200,17 @@ static void spidThinkChase(DBloodActor* actor)
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &spidSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &spidSearch);
return;
@ -220,7 +220,7 @@ static void spidThinkChase(DBloodActor* actor)
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector())) {
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector())) {
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

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

@ -300,17 +300,17 @@ static void sub_72934(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &tchernobogSearch);
return;
}
if (IsPlayerSprite(pTarget) && powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0)
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0)
{
aiNewState(actor, &tchernobogSearch);
return;
@ -320,7 +320,7 @@ static void sub_72934(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -63,14 +63,14 @@ void HackSeqCallback(int, DBloodActor* actor)
XSPRITE* pXSprite = &actor->x();
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(tx, ty);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (pTarget->yrepeat * pDudeInfoT->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(nAngle);
int dy = bsin(nAngle);
@ -117,17 +117,17 @@ static void zombaThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &zombieASearch);
return;
}
if (IsPlayerSprite(pTarget) && (powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
if (target->IsPlayerActor() && (powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
{
aiNewState(actor, &zombieAGoto);
return;
@ -141,7 +141,7 @@ static void zombaThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -168,17 +168,17 @@ static void zombaThinkPonder(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &zombieASearch);
return;
}
if (IsPlayerSprite(pTarget) && (powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
if (target->IsPlayerActor() && (powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
{
aiNewState(actor, &zombieAGoto);
return;
@ -188,7 +188,7 @@ static void zombaThinkPonder(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -51,11 +51,11 @@ void zombfHackSeqCallback(int, DBloodActor* actor)
if (pSprite->type != kDudeZombieButcher)
return;
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
int height2 = (pDudeInfoT->eyeHeight * pTarget->yrepeat);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height2 = (pDudeInfoT->eyeHeight * target->spr.yrepeat);
actFireVector(actor, 0, 0, bcos(pSprite->ang), bsin(pSprite->ang), height - height2, kVectorCleaver);
}
@ -64,11 +64,11 @@ void PukeSeqCallback(int, DBloodActor* actor)
XSPRITE* pXSprite = &actor->x();
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat);
int height2 = (pDudeInfoT->eyeHeight * pTarget->yrepeat);
int height2 = (pDudeInfoT->eyeHeight * target->spr.yrepeat);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(tx, ty);
@ -118,17 +118,17 @@ static void zombfThinkChase(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
aiNewState(actor, &zombieFSearch);
return;
}
if (IsPlayerSprite(pTarget) && (powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[pTarget->type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
if (target->IsPlayerActor() && (powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0 || powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpDeathMaskUseless) > 0))
{
aiNewState(actor, &zombieFSearch);
return;
@ -138,7 +138,7 @@ static void zombfThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{