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

- quick replace of 'pSprite->' with 'actor->spr.' in AI files.

Browse source
This commit is contained in:
Christoph Oelckers 2021-12-22 20:22:35 +01:00
parent 612167cbf1
commit e123e61f99
18 changed files with 887 additions and 887 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -67,10 +67,10 @@ void SlashSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
// Correct ?
int dz = pSprite->pos.Z - target->spr.pos.Z;
int dz = actor->spr.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);
@ -82,18 +82,18 @@ void SlashSeqCallback(int, DBloodActor* actor)
void StompSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->pos.Z;
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = actor->spr.pos.Z;
int vc = 400;
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
int v1c = 5 + 2 * gGameOptions.nDifficulty;
int v10 = 25 + 30 * gGameOptions.nDifficulty;
const bool newSectCheckMethod = !cl_bloodvanillaenemies && !VanillaMode(); // use new sector checking logic
auto sectorMap = GetClosestSpriteSectors(pSector, x, y, vc, nullptr, newSectCheckMethod);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
DBloodActor* actor2 = nullptr;
actHitcodeToData(hit, &gHitInfo, &actor2);
@ -116,8 +116,8 @@ void StompSeqCallback(int, DBloodActor* actor)
GetActorExtents(actor, &top, &bottom);
if (abs(bottom - pSector->floorz) == 0)
{
int dx = abs(pSprite->pos.X - pSprite2->pos.X);
int dy = abs(pSprite->pos.Y - pSprite2->pos.Y);
int dx = abs(actor->spr.pos.X - pSprite2->pos.X);
int dy = abs(actor->spr.pos.Y - pSprite2->pos.Y);
int nDist2 = ksqrt(dx * dx + dy * dy);
if (nDist2 <= vc)
{
@ -146,8 +146,8 @@ void StompSeqCallback(int, DBloodActor* actor)
XSPRITE* pXSprite = &actor2->x();
if (pXSprite->locked)
continue;
int dx = abs(pSprite->pos.X - pSprite2->pos.X);
int dy = abs(pSprite->pos.Y - pSprite2->pos.Y);
int dx = abs(actor->spr.pos.X - pSprite2->pos.X);
int dy = abs(actor->spr.pos.Y - pSprite2->pos.Y);
int nDist2 = ksqrt(dx * dx + dy * dy);
if (nDist2 <= vc)
{
@ -169,7 +169,7 @@ static void MorphToBeast(DBloodActor* actor)
{
auto pSprite = &actor->s();
actHealDude(actor, dudeInfo[51].startHealth, dudeInfo[51].startHealth);
pSprite->type = kDudeBeast;
actor->spr.type = kDudeBeast;
}
static void beastThinkSearch(DBloodActor* actor)
@ -183,17 +183,17 @@ static void beastThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
auto pSector = pSprite->sector();
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 - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &beastSwimSearch);
@ -208,7 +208,7 @@ static void beastThinkChase(DBloodActor* actor)
auto const pSprite = &actor->s();
if (actor->GetTarget() == nullptr)
{
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (pXSector && pXSector->Underwater)
@ -217,16 +217,16 @@ static void beastThinkChase(DBloodActor* actor)
aiNewState(actor, &beastSearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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));
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (pXTarget->health == 0)
@ -248,18 +248,18 @@ static void beastThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0? 0 : DivScale(target->spr.pos.Z - actor->spr.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);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (pXTarget->health > (unsigned)gPlayerTemplate[0].startHealth / 2)
{
switch (hit)
@ -269,7 +269,7 @@ static void beastThinkChase(DBloodActor* actor)
aiNewState(actor, &beastStomp);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
{
if (!pXSector || !pXSector->Underwater)
aiNewState(actor, &beastStomp);
@ -291,7 +291,7 @@ static void beastThinkChase(DBloodActor* actor)
}
if (nDist < 921 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -301,7 +301,7 @@ static void beastThinkChase(DBloodActor* actor)
aiNewState(actor, &beastSlash);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &beastSwimSlash);
@ -340,14 +340,14 @@ static void beastThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &beastSwimSearch);
aiThinkTarget(actor);
}
@ -360,13 +360,13 @@ static void beastThinkSwimChase(DBloodActor* actor)
aiNewState(actor, &beastSwimGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -381,11 +381,11 @@ static void beastThinkSwimChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -411,43 +411,43 @@ static void beastMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x400 && Random(64) < 32)
return;
actor->xvel += MulScale(pDudeInfo->frontSpeed, Cos(pSprite->ang), 30);
actor->yvel += MulScale(pDudeInfo->frontSpeed, Sin(pSprite->ang), 30);
actor->xvel += MulScale(pDudeInfo->frontSpeed, Cos(actor->spr.ang), 30);
actor->yvel += MulScale(pDudeInfo->frontSpeed, Sin(actor->spr.ang), 30);
}
static void sub_628A0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
return;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -464,29 +464,29 @@ static void sub_62AE0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -501,29 +501,29 @@ static void sub_62D7C(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pSprite->ang = (pSprite->ang + 512) & 2047;
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);

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

@ -79,12 +79,12 @@ void eelBiteSeqCallback(int, DBloodActor* actor)
}
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);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height = (actor->spr.yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
actFireVector(actor, 0, 0, dx, dy, height2 - height, kVectorBoneelBite);
}
@ -93,8 +93,8 @@ static void eelThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
if (pDudeExtraE->active && pDudeExtraE->thinkTime < 10)
pDudeExtraE->thinkTime++;
@ -114,18 +114,18 @@ static void eelThinkTarget(DBloodActor* actor)
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
pDudeExtraE->thinkTime = 0;
@ -156,14 +156,14 @@ static void eelThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &eelSearch);
eelThinkTarget(actor);
}
@ -176,12 +176,12 @@ static void eelThinkPonder(DBloodActor* actor)
aiNewState(actor, &eelSearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -191,12 +191,12 @@ static void eelThinkPonder(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
int height2 = (getDudeInfo(target->spr.type)->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < -0x2000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -226,13 +226,13 @@ static void eelMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -251,15 +251,15 @@ static void eelMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -282,12 +282,12 @@ static void eelThinkChase(DBloodActor* actor)
aiNewState(actor, &eelGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -302,13 +302,13 @@ static void eelThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
int top2, bottom2;
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -334,23 +334,23 @@ static void eelMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if (nDist <= 0x399)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -367,21 +367,21 @@ static void eelMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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 - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x8000) && nDist <= 0x399)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -396,21 +396,21 @@ static void eelMoveAscend(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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 - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x399)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -425,18 +425,18 @@ void eelMoveToCeil(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->pos.Z;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = actor->spr.pos.Z;
if (z - pXSprite->targetZ < 0x1000)
{
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
pDudeExtraE->active = 0;
pSprite->flags = 0;
actor->spr.flags = 0;
aiNewState(actor, &eelIdle);
}
else
aiSetTarget(actor, x, y, pSprite->sector()->ceilingz);
aiSetTarget(actor, x, y, actor->spr.sector()->ceilingz);
}
END_BLD_NS

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

@ -85,16 +85,16 @@ static void burnThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeBurningCultist:
aiNewState(actor, &cultistBurnSearch);
@ -129,7 +129,7 @@ static void burnThinkChase(DBloodActor* actor)
auto pSprite = &actor->s();
if (actor->GetTarget() == nullptr)
{
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeBurningCultist:
aiNewState(actor, &cultistBurnGoto);
@ -157,16 +157,16 @@ static void burnThinkChase(DBloodActor* actor)
}
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeBurningCultist:
aiNewState(actor, &cultistBurnSearch);
@ -197,16 +197,16 @@ static void burnThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x333 && abs(nDeltaAngle) < 85)
{
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeBurningCultist:
aiNewState(actor, &cultistBurnAttack);
@ -238,7 +238,7 @@ static void burnThinkChase(DBloodActor* actor)
}
}
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeBurningCultist:
aiNewState(actor, &cultistBurnGoto);

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

@ -60,8 +60,8 @@ AISTATE tinycaleb139698 = { kAiStateOther, 8, -1, 120, NULL, aiMoveTurn, NULL, &
void SeqAttackCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int dz = actor->dudeSlope;
dx += Random2(1500);
dy += Random2(1500);
@ -92,18 +92,18 @@ static void calebThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &tinycalebSwimSearch);
@ -116,7 +116,7 @@ static void calebThinkGoto(DBloodActor* actor)
static void calebThinkChase(DBloodActor* actor)
{
auto const pSprite = &actor->s();
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (actor->GetTarget() == nullptr)
@ -127,12 +127,12 @@ static void calebThinkChase(DBloodActor* actor)
aiNewState(actor, &tinycalebSearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -156,17 +156,17 @@ static void calebThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z-pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z-actor->spr.pos.Z, nDist, 10);
if (nDist < 0x599 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -176,7 +176,7 @@ static void calebThinkChase(DBloodActor* actor)
aiNewState(actor, &tinycalebAttack);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &tinycalebSwimAttack);
@ -217,14 +217,14 @@ static void calebThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &tinycalebSwimSearch);
aiThinkTarget(actor);
}
@ -237,12 +237,12 @@ static void calebThinkSwimChase(DBloodActor* actor)
aiNewState(actor, &tinycalebSwimGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -257,11 +257,11 @@ static void calebThinkSwimChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -282,23 +282,23 @@ static void sub_65D04(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
return;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -315,30 +315,30 @@ static void sub_65F44(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -353,30 +353,30 @@ static void sub_661E0(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pSprite->ang = (pSprite->ang + 512) & 2047;
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);

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

@ -58,16 +58,16 @@ AISTATE cerberus1398AC = { kAiStateOther, 7, -1, 120, NULL, aiMoveTurn, NULL, &c
void cerberusBiteSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int dz = target->spr.pos.Z - pSprite->pos.Z;
int dz = target->spr.pos.Z - actor->spr.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);
@ -76,17 +76,17 @@ void cerberusBiteSeqCallback(int, DBloodActor* actor)
void cerberusBurnSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = pDudeInfo->eyeHeight * pSprite->yrepeat;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int height = pDudeInfo->eyeHeight * actor->spr.yrepeat;
if (!actor->ValidateTarget(__FUNCTION__)) return;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height; // ???
TARGETTRACK tt1 = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
aim.dx = bcos(pSprite->ang);
aim.dy = bsin(pSprite->ang);
aim.dx = bcos(actor->spr.ang);
aim.dy = bsin(actor->spr.ang);
aim.dz = actor->dudeSlope;
int nClosest = 0x7fffffff;
BloodStatIterator it(kStatDude);
@ -108,8 +108,8 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
y2 += (actor2->yvel * t) >> 12;
z2 += (actor2->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -123,11 +123,11 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt1.at8)
{
int tz = actor2->spr.pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
int tz = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -139,7 +139,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
}
}
}
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
actFireMissile(actor, -350, 0, aim.dx, aim.dy, aim.dz, kMissileFireballCerberus);
actFireMissile(actor, 350, -100, aim.dx, aim.dy, aim.dz, kMissileFireballCerberus);
@ -154,17 +154,17 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = pDudeInfo->eyeHeight * pSprite->yrepeat;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int height = pDudeInfo->eyeHeight * actor->spr.yrepeat;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height; // ???
TARGETTRACK tt1 = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
int ax, ay, az;
aim.dx = ax = bcos(pSprite->ang);
aim.dy = ay = bsin(pSprite->ang);
aim.dx = ax = bcos(actor->spr.ang);
aim.dy = ay = bsin(actor->spr.ang);
aim.dz = actor->dudeSlope;
az = 0;
int nClosest = 0x7fffffff;
@ -186,8 +186,8 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
y2 += (actor->yvel * t) >> 12;
z2 += (actor->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -201,13 +201,13 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt1.at8)
{
DUDEINFO* pDudeInfo2 = getDudeInfo(actor2->spr.type);
int height = (pDudeInfo2->aimHeight * actor2->spr.yrepeat) << 2;
int tz = (z2 - height) - z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -219,7 +219,7 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
}
}
}
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
actFireMissile(actor, 350, -100, aim.dx, aim.dy, -aim.dz, kMissileFlameHound);
actFireMissile(actor, -350, 0, ax, ay, az, kMissileFlameHound);
@ -241,12 +241,12 @@ static void cerberusThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
if (pDudeExtraE->active && pDudeExtraE->thinkTime < 10)
pDudeExtraE->thinkTime++;
@ -255,7 +255,7 @@ static void cerberusThinkTarget(DBloodActor* actor)
pXSprite->goalAng += 256;
POINT3D* pTarget = &actor->basePoint;
aiSetTarget(actor, pTarget->X, pTarget->Y, pTarget->Z);
if (pSprite->type == kDudeCerberusTwoHead)
if (actor->spr.type == kDudeCerberusTwoHead)
aiNewState(actor, &cerberus139890);
else
aiNewState(actor, &cerberus1398AC);
@ -268,18 +268,18 @@ static void cerberusThinkTarget(DBloodActor* actor)
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
pDudeExtraE->thinkTime = 0;
@ -303,20 +303,20 @@ static void cerberusThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusSearch);
break;
@ -332,7 +332,7 @@ static void cerberusThinkChase(DBloodActor* actor)
{
auto pSprite = &actor->s();
if (actor->GetTarget() == nullptr) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusGoto);
break;
@ -343,23 +343,23 @@ static void cerberusThinkChase(DBloodActor* actor)
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusSearch);
break;
@ -371,7 +371,7 @@ static void cerberusThinkChase(DBloodActor* actor)
}
if (target->IsPlayerActor() && powerupCheck(&gPlayer[target->spr.type - kDudePlayer1], kPwUpShadowCloak) > 0) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusSearch);
break;
@ -385,15 +385,15 @@ static void cerberusThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x1b00 && nDist > 0xd00 && abs(nDeltaAngle) < 85) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusBurn);
break;
@ -404,7 +404,7 @@ static void cerberusThinkChase(DBloodActor* actor)
}
else if (nDist < 0xb00 && nDist > 0x500 && abs(nDeltaAngle) < 85) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberus3Burn);
break;
@ -415,15 +415,15 @@ static void cerberusThinkChase(DBloodActor* actor)
}
else if (nDist < 0x200 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (pSprite->type) {
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
switch (hit) {
case -1:
aiNewState(actor, &cerberusBite);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeHellHound)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeHellHound)
aiNewState(actor, &cerberusBite);
break;
case 0:
@ -440,7 +440,7 @@ static void cerberusThinkChase(DBloodActor* actor)
aiNewState(actor, &cerberus2Bite);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeHellHound)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeHellHound)
aiNewState(actor, &cerberus2Bite);
break;
case 0:
@ -458,7 +458,7 @@ static void cerberusThinkChase(DBloodActor* actor)
}
}
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeCerberusTwoHead:
aiNewState(actor, &cerberusGoto);
break;

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

@ -75,8 +75,8 @@ AISTATE cultistSwimRecoil = { kAiStateRecoil, 5, -1, 0, NULL, NULL, NULL, &culti
void TommySeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int dz = actor->dudeSlope;
dx += Random3((5 - gGameOptions.nDifficulty) * 1000);
dy += Random3((5 - gGameOptions.nDifficulty) * 1000);
@ -90,8 +90,8 @@ void TeslaSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (Chance(dword_138BB0[gGameOptions.nDifficulty]))
{
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int dz = actor->dudeSlope;
dx += Random3((5 - gGameOptions.nDifficulty) * 1000);
dy += Random3((5 - gGameOptions.nDifficulty) * 1000);
@ -104,8 +104,8 @@ void TeslaSeqCallback(int, DBloodActor* actor)
void ShotSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int dz = actor->dudeSlope;
dx += Random2((5 - gGameOptions.nDifficulty) * 1000 - 500);
dy += Random2((5 - gGameOptions.nDifficulty) * 1000 - 500);
@ -133,10 +133,10 @@ void cultThrowSeqCallback(int, DBloodActor* actor)
sfxPlay3DSound(actor, 455, -1, 0);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
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;
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
int dz = target->spr.pos.Z - actor->spr.pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
if (nDist > 0x1e00)
@ -167,10 +167,10 @@ void sub_68230(int, DBloodActor* actor)
sfxPlay3DSound(actor, 455, -1, 0);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
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;
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
int dz = target->spr.pos.Z - actor->spr.pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
auto pMissile = actFireThing(actor, 0, 0, dz / 128 - 14500, nMissile, (nDist2 << 17) / 120);
@ -199,14 +199,14 @@ static void cultThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 5120 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 5120 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
switch (pXSprite->medium)
{
@ -240,12 +240,12 @@ static void cultThinkChase(DBloodActor* actor)
}
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -253,7 +253,7 @@ static void cultThinkChase(DBloodActor* actor)
{
case kMediumNormal:
aiNewState(actor, &cultistSearch);
if (pSprite->type == kDudeCultistTommy)
if (actor->spr.type == kDudeCultistTommy)
aiPlay3DSound(actor, 4021 + Random(4), AI_SFX_PRIORITY_1, -1);
else
aiPlay3DSound(actor, 1021 + Random(4), AI_SFX_PRIORITY_1, -1);
@ -282,21 +282,21 @@ static void cultThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist > 0 && nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
switch (pSprite->type) {
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - actor->spr.pos.Z, nDist, 10);
switch (actor->spr.type) {
case kDudeCultistTommy:
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);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -307,7 +307,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultistTThrow);
break;
default:
@ -317,7 +317,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x4600 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -329,7 +329,7 @@ static void cultThinkChase(DBloodActor* actor)
aiNewState(actor, &cultistTSwimFire);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistShotgun)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
aiNewState(actor, &cultistTFire);
@ -364,7 +364,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (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);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -375,7 +375,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
default:
@ -385,7 +385,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -397,7 +397,7 @@ static void cultThinkChase(DBloodActor* actor)
aiNewState(actor, &cultistSSwimFire);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
aiNewState(actor, &cultistSFire);
@ -432,7 +432,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (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);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -443,7 +443,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultistTsThrow);
break;
default:
@ -453,7 +453,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -465,7 +465,7 @@ static void cultThinkChase(DBloodActor* actor)
aiNewState(actor, &cultistTsSwimFire);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
aiNewState(actor, &cultistTsFire);
@ -499,7 +499,7 @@ static void cultThinkChase(DBloodActor* actor)
if (nDist < 0x2c00 && nDist > 0x1400 && abs(nDeltaAngle) < 85
&& (target->spr.flags & 2) && target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -509,7 +509,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultistDThrow);
break;
default:
@ -520,7 +520,7 @@ static void cultThinkChase(DBloodActor* actor)
else if (nDist < 0x1400 && abs(nDeltaAngle) < 85
&& (target->spr.flags & 2) && target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -530,7 +530,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultist139A78);
break;
default:
@ -544,7 +544,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (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);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -555,7 +555,7 @@ static void cultThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->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 && pXSprite->medium != kMediumWater && pXSprite->medium != kMediumGoo)
aiNewState(actor, &cultistSThrow);
break;
default:
@ -565,7 +565,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -577,7 +577,7 @@ static void cultThinkChase(DBloodActor* actor)
aiNewState(actor, &cultistSSwimFire);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeCultistTommy)
{
if (!dudeIsPlayingSeq(actor, 14) && pXSprite->medium == kMediumNormal)
aiNewState(actor, &cultistSFire);

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

@ -80,13 +80,13 @@ void SlashFSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height = (actor->spr.yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGargSlash);
int r1 = Random(50);
int r2 = Random(50);
@ -108,14 +108,14 @@ void BlastSSeqCallback(int, DBloodActor* actor)
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int height = (actor->spr.yrepeat * getDudeInfo(actor->spr.type)->eyeHeight) << 2;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
aim.dx = bcos(pSprite->ang);
aim.dy = bsin(pSprite->ang);
aim.dx = bcos(actor->spr.ang);
aim.dy = bsin(actor->spr.ang);
aim.dz = actor->dudeSlope;
int nClosest = 0x7fffffff;
BloodStatIterator it(kStatDude);
@ -136,8 +136,8 @@ void BlastSSeqCallback(int, DBloodActor* actor)
y2 += (actor->yvel * t) >> 12;
z2 += (actor->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -151,11 +151,11 @@ void BlastSSeqCallback(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = actor2->spr.pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
int tz = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -201,12 +201,12 @@ static void gargThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
if (pDudeExtraE->active && pDudeExtraE->thinkTime < 10)
pDudeExtraE->thinkTime++;
@ -225,18 +225,18 @@ static void gargThinkTarget(DBloodActor* actor)
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
pDudeExtraE->thinkTime = 0;
@ -267,18 +267,18 @@ static void gargThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &gargoyleFSearch);
aiThinkTarget(actor);
}
@ -287,17 +287,17 @@ static void gargMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -316,19 +316,19 @@ static void gargMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -351,16 +351,16 @@ static void gargThinkChase(DBloodActor* actor)
aiNewState(actor, &gargoyleFGoto);
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -375,24 +375,24 @@ static void gargThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.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(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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
switch (pSprite->type)
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
switch (actor->spr.type)
{
case kDudeGargoyleFlesh:
if (nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -403,7 +403,7 @@ static void gargThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleStone)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleStone)
{
sfxPlay3DSound(actor, 1408, 0, 0);
aiNewState(actor, &gargoyleFThrow);
@ -417,7 +417,7 @@ static void gargThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -428,7 +428,7 @@ static void gargThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleStone)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleStone)
{
sfxPlay3DSound(actor, 1406, 0, 0);
aiNewState(actor, &gargoyleFSlash);
@ -451,7 +451,7 @@ static void gargThinkChase(DBloodActor* actor)
case kDudeGargoyleStone:
if (nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -462,7 +462,7 @@ static void gargThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleFlesh)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleFlesh)
{
sfxPlay3DSound(actor, 1457, 0, 0);
aiNewState(actor, &gargoyleSBlast);
@ -476,7 +476,7 @@ static void gargThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -486,7 +486,7 @@ static void gargThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleFlesh)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudeGargoyleFlesh)
aiNewState(actor, &gargoyleFSlash);
break;
default:
@ -496,7 +496,7 @@ static void gargThinkChase(DBloodActor* actor)
}
else if ((height2 - height > 0x2000 || floorZ - bottom > 0x2000) && nDist < 0x1400 && nDist > 0x800)
{
if (pSprite->type == kDudeGargoyleFlesh)
if (actor->spr.type == kDudeGargoyleFlesh)
aiPlay3DSound(actor, 1400, AI_SFX_PRIORITY_1, -1);
else
aiPlay3DSound(actor, 1450, AI_SFX_PRIORITY_1, -1);
@ -525,7 +525,7 @@ static void entryFStatue(DBloodActor* actor)
auto pSprite = &actor->s();
DUDEINFO* pDudeInfo = &dudeInfo[6];
actHealDude(actor, pDudeInfo->startHealth, pDudeInfo->startHealth);
pSprite->type = kDudeGargoyleFlesh;
actor->spr.type = kDudeGargoyleFlesh;
}
static void entrySStatue(DBloodActor* actor)
@ -533,34 +533,34 @@ static void entrySStatue(DBloodActor* actor)
auto pSprite = &actor->s();
DUDEINFO* pDudeInfo = &dudeInfo[7];
actHealDude(actor, pDudeInfo->startHealth, pDudeInfo->startHealth);
pSprite->type = kDudeGargoyleStone;
actor->spr.type = kDudeGargoyleStone;
}
static void gargMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
return;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -577,28 +577,28 @@ static void gargMoveSlow(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -607,7 +607,7 @@ static void gargMoveSlow(DBloodActor* actor)
t2 >>= 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeGargoyleFlesh:
actor->zvel = 0x44444;
break;
@ -621,28 +621,28 @@ static void gargMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -650,7 +650,7 @@ static void gargMoveSwoop(DBloodActor* actor)
t1 += nAccel >> 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeGargoyleFlesh:
actor->zvel = t1;
break;
@ -664,28 +664,28 @@ static void gargMoveFly(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pSprite->ang = (pSprite->ang + 512) & 2047;
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -693,7 +693,7 @@ static void gargMoveFly(DBloodActor* actor)
t1 += nAccel >> 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeGargoyleFlesh:
actor->zvel = -t1;
break;

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

@ -65,13 +65,13 @@ void ghostSlashSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height = (actor->spr.yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
sfxPlay3DSound(actor, 1406, 0, 0);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGhost);
int r1 = Random(50);
@ -94,14 +94,14 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int height = (actor->spr.yrepeat * getDudeInfo(actor->spr.type)->eyeHeight) << 2;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
aim.dx = bcos(pSprite->ang);
aim.dy = bsin(pSprite->ang);
aim.dx = bcos(actor->spr.ang);
aim.dy = bsin(actor->spr.ang);
aim.dz = actor->dudeSlope;
int nClosest = 0x7fffffff;
BloodStatIterator it(kStatDude);
@ -122,8 +122,8 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
y2 += (actor->yvel * t) >> 12;
z2 += (actor->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -137,11 +137,11 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = actor2->spr.pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
int tz = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -181,12 +181,12 @@ static void ghostThinkTarget(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
if (pDudeExtraE->active && pDudeExtraE->thinkTime < 10)
pDudeExtraE->thinkTime++;
@ -205,18 +205,18 @@ static void ghostThinkTarget(DBloodActor* actor)
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
pDudeExtraE->thinkTime = 0;
@ -246,18 +246,18 @@ static void ghostThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &ghostSearch);
aiThinkTarget(actor);
}
@ -266,17 +266,17 @@ static void ghostMoveDodgeUp(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -295,19 +295,19 @@ static void ghostMoveDodgeDown(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
if (pXSprite->dodgeDir == 0)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int dx = actor->xvel;
int dy = actor->yvel;
int t1 = DMulScale(dx, nCos, dy, nSin, 30);
@ -331,16 +331,16 @@ static void ghostThinkChase(DBloodActor* actor)
aiNewState(actor, &ghostGoto);
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -355,22 +355,22 @@ static void ghostThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.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(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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
switch (pSprite->type) {
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
switch (actor->spr.type) {
case kDudePhantasm:
if (nDist < 0x2000 && nDist > 0x1000 && abs(nDeltaAngle) < 85) {
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -380,7 +380,7 @@ static void ghostThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudePhantasm)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudePhantasm)
aiNewState(actor, &ghostBlast);
break;
default:
@ -390,7 +390,7 @@ static void ghostThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -400,7 +400,7 @@ static void ghostThinkChase(DBloodActor* actor)
case 4:
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudePhantasm)
if (actor->spr.type != gHitInfo.actor()->spr.type && gHitInfo.actor()->spr.type != kDudePhantasm)
aiNewState(actor, &ghostSlash);
break;
default:
@ -435,27 +435,27 @@ static void ghostMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
return;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -472,28 +472,28 @@ static void ghostMoveSlow(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -502,7 +502,7 @@ static void ghostMoveSlow(DBloodActor* actor)
t2 >>= 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePhantasm:
actor->zvel = 0x44444;
break;
@ -513,28 +513,28 @@ static void ghostMoveSwoop(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pXSprite->goalAng = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -542,7 +542,7 @@ static void ghostMoveSwoop(DBloodActor* actor)
t1 += nAccel >> 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePhantasm:
actor->zvel = t1;
break;
@ -553,28 +553,28 @@ static void ghostMoveFly(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
int nAccel = pDudeInfo->frontSpeed << 2;
if (abs(nAng) > 341)
{
pSprite->ang = (pSprite->ang + 512) & 2047;
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -582,7 +582,7 @@ static void ghostMoveFly(DBloodActor* actor)
t1 += nAccel >> 1;
actor->xvel = DMulScale(t1, nCos, t2, nSin, 30);
actor->yvel = DMulScale(t1, nSin, -t2, nCos, 30);
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePhantasm:
actor->zvel = -t1;
break;

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

@ -62,9 +62,9 @@ void GillBiteSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dz = pSprite->pos.Z - target->spr.pos.Z;
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
int dz = actor->spr.pos.Z - target->spr.pos.Z;
dx += Random3(2000);
dy += Random3(2000);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGillBite);
@ -83,18 +83,18 @@ static void gillThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &gillBeastSwimSearch);
@ -107,7 +107,7 @@ static void gillThinkGoto(DBloodActor* actor)
static void gillThinkChase(DBloodActor* actor)
{
auto const pSprite = &actor->s();
auto pSector = pSprite->sector();
auto pSector = actor->spr.sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (actor->GetTarget() == nullptr)
@ -118,13 +118,13 @@ static void gillThinkChase(DBloodActor* actor)
aiNewState(actor, &gillBeastSearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -145,17 +145,17 @@ static void gillThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - pSprite->pos.Z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - actor->spr.pos.Z, nDist, 10);
if (nDist < 921 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -165,7 +165,7 @@ static void gillThinkChase(DBloodActor* actor)
aiNewState(actor, &gillBeastBite);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, &gillBeastSwimBite);
@ -205,14 +205,14 @@ static void gillThinkSwimGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &gillBeastSwimSearch);
aiThinkTarget(actor);
}
@ -225,13 +225,13 @@ static void gillThinkSwimChase(DBloodActor* actor)
aiNewState(actor, &gillBeastSwimSearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -246,11 +246,11 @@ static void gillThinkSwimChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -277,23 +277,23 @@ static void sub_6CB00(DBloodActor* actor)
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
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 nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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)
return;
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -310,29 +310,29 @@ static void sub_6CD74(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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 = (pSprite->ang + 512) & 2047;
pXSprite->goalAng = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);
@ -347,29 +347,29 @@ static void sub_6D03C(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
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 - pSprite->ang) & 2047) - 1024;
int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
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)
{
pSprite->ang = (pSprite->ang + 512) & 2047;
actor->spr.ang = (actor->spr.ang + 512) & 2047;
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;
int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang);
int nCos = Cos(actor->spr.ang);
int nSin = Sin(actor->spr.ang);
int vx = actor->xvel;
int vy = actor->yvel;
int t1 = DMulScale(vx, nCos, vy, nSin, 30);

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

@ -67,14 +67,14 @@ static void handThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &handSearch);
aiThinkTarget(actor);
}
@ -87,13 +87,13 @@ static void handThinkChase(DBloodActor* actor)
aiNewState(actor, &handGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -108,9 +108,9 @@ static void handThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -45,11 +45,11 @@ AISTATE houndBurn = { kAiStateChase, 7, nHoundBurnClient, 60, NULL, NULL, NULL,
void houndBiteSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
@ -57,17 +57,17 @@ void houndBiteSeqCallback(int, DBloodActor* actor)
auto target = actor->GetTarget();
#ifdef NOONE_EXTENSIONS
if (target->IsPlayerActor() || gModernMap) // allow to hit non-player targets
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - pSprite->pos.Z, kVectorHoundBite);
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - actor->spr.pos.Z, kVectorHoundBite);
#else
if (target->IsPlayerActor())
actFireVector(actor, 0, 0, dx, dy, target->spr.z - pSprite->z, kVectorHoundBite);
actFireVector(actor, 0, 0, dx, dy, target->spr.z - actor->spr.z, kVectorHoundBite);
#endif
}
void houndBurnSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
actFireMissile(actor, 0, 0, bcos(pSprite->ang), bsin(pSprite->ang), 0, kMissileFlameHound);
actFireMissile(actor, 0, 0, bcos(actor->spr.ang), bsin(actor->spr.ang), 0, kMissileFlameHound);
}
static void houndThinkSearch(DBloodActor* actor)
@ -81,19 +81,19 @@ static void houndThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &houndSearch);
aiThinkTarget(actor);
}
@ -106,16 +106,16 @@ static void houndThinkChase(DBloodActor* actor)
aiNewState(actor, &houndGoto);
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -130,9 +130,9 @@ static void houndThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -52,14 +52,14 @@ static void innocThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &innocentSearch);
aiThinkTarget(actor);
}
@ -73,13 +73,13 @@ static void innocThinkChase(DBloodActor* actor)
aiNewState(actor, &innocentGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -94,9 +94,9 @@ static void innocThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -67,16 +67,16 @@ void podAttack(int, DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int x = target->spr.pos.X - actor->spr.pos.X;
int y = target->spr.pos.Y - actor->spr.pos.Y;
int dz = target->spr.pos.Z - actor->spr.pos.Z;
x += Random2(1000);
y += Random2(1000);
int nDist = approxDist(x, y);
int nDist2 = nDist / 540;
DBloodActor* pMissile = nullptr;
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudePodGreen:
dz += 8000;
@ -112,7 +112,7 @@ void sub_70284(int, DBloodActor* actor)
sfxPlay3DSound(actor, 2502, -1, 0);
int nDist, nBurn;
DAMAGE_TYPE dmgType;
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeTentacleGreen:
default: // ???
nBurn = 0;
@ -125,7 +125,7 @@ void sub_70284(int, DBloodActor* actor)
nDist = 75;
break;
}
actRadiusDamage(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
actRadiusDamage(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
}
static void aiPodSearch(DBloodActor* actor)
@ -139,20 +139,20 @@ static void aiPodMove(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery) {
switch (pSprite->type) {
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery) {
switch (actor->spr.type) {
case kDudePodGreen:
case kDudePodFire:
aiNewState(actor, &podSearch);
@ -170,7 +170,7 @@ static void aiPodChase(DBloodActor* actor)
{
auto pSprite = &actor->s();
if (actor->GetTarget() == nullptr) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePodGreen:
case kDudePodFire:
aiNewState(actor, &podMove);
@ -182,20 +182,20 @@ static void aiPodChase(DBloodActor* actor)
}
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePodGreen:
case kDudePodFire:
aiNewState(actor, &podSearch);
@ -210,15 +210,15 @@ static void aiPodChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
if (abs(nDeltaAngle) < 85 && target->spr.type != kDudePodGreen && target->spr.type != kDudePodFire) {
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePodGreen:
case kDudePodFire:
aiNewState(actor, &podStartChase);
@ -234,7 +234,7 @@ static void aiPodChase(DBloodActor* actor)
}
}
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudePodGreen:
case kDudePodFire:
aiNewState(actor, &podMove);

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

@ -44,13 +44,13 @@ AISTATE ratBite = { kAiStateChase, 6, nRatBiteClient, 120, NULL, NULL, NULL, &ra
void ratBiteSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
if (target->IsPlayerActor())
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - pSprite->pos.Z, kVectorRatBite);
actFireVector(actor, 0, 0, dx, dy, target->spr.pos.Z - actor->spr.pos.Z, kVectorRatBite);
}
static void ratThinkSearch(DBloodActor* actor)
@ -64,14 +64,14 @@ static void ratThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &ratSearch);
aiThinkTarget(actor);
}
@ -84,12 +84,12 @@ static void ratThinkChase(DBloodActor* actor)
aiNewState(actor, &ratGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -104,9 +104,9 @@ static void ratThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -50,7 +50,7 @@ static void spidBlindEffect(DBloodActor* actor, int nBlind, int max)
{
nBlind <<= 4;
max <<= 4;
PLAYER* pPlayer = &gPlayer[pSprite->type - kDudePlayer1];
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (pPlayer->blindEffect < max)
{
pPlayer->blindEffect = ClipHigh(pPlayer->blindEffect + nBlind, max);
@ -61,23 +61,23 @@ static void spidBlindEffect(DBloodActor* actor, int nBlind, int max)
void SpidBiteSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
dx += Random2(2000);
dy += Random2(2000);
int dz = Random2(2000);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto const target = actor->GetTarget();
if (target->IsPlayerActor())
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (hit == 3 && gHitInfo.actor()->IsPlayerActor())
{
dz += target->spr.pos.Z - pSprite->pos.Z;
dz += target->spr.pos.Z - actor->spr.pos.Z;
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
switch (pSprite->type)
switch (actor->spr.type)
{
case kDudeSpiderBrown:
actFireVector(actor, 0, 0, dx, dy, dz, kVectorSpiderBite);
@ -110,17 +110,17 @@ void SpidBiteSeqCallback(int, DBloodActor* actor)
void SpidJumpSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dx = bcos(actor->spr.ang);
int dy = bsin(actor->spr.ang);
dx += Random2(200);
dy += Random2(200);
int dz = Random2(200);
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
if (target->IsPlayerActor()) {
dz += target->spr.pos.Z - pSprite->pos.Z;
switch (pSprite->type) {
dz += target->spr.pos.Z - actor->spr.pos.Z;
switch (actor->spr.type) {
case kDudeSpiderBrown:
case kDudeSpiderRed:
case kDudeSpiderBlack:
@ -136,25 +136,25 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
{
XSPRITE* pXSprite = &actor->x();
spritetype* pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
DBloodActor* spawned = nullptr;
if (target->IsPlayerActor() && pDudeExtraE->birthCounter < 10)
{
if (nDist < 0x1a00 && nDist > 0x1400 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderRed, pSprite->clipdist, 0);
else if (nDist < 0x1400 && nDist > 0xc00 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderBrown, pSprite->clipdist, 0);
else if (nDist < 0xc00 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderBrown, pSprite->clipdist, 0);
if (nDist < 0x1a00 && nDist > 0x1400 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderRed, actor->spr.clipdist, 0);
else if (nDist < 0x1400 && nDist > 0xc00 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderBrown, actor->spr.clipdist, 0);
else if (nDist < 0xc00 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
spawned = actSpawnDude(actor, kDudeSpiderBrown, actor->spr.clipdist, 0);
if (spawned)
{
@ -177,14 +177,14 @@ static void spidThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &spidSearch);
aiThinkTarget(actor);
}
@ -197,12 +197,12 @@ static void spidThinkChase(DBloodActor* actor)
aiNewState(actor, &spidGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto target = actor->GetTarget();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = target->spr.pos.X - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -216,14 +216,14 @@ static void spidThinkChase(DBloodActor* actor)
}
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist) {
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
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 (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector())) {
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());
switch (pSprite->type) {
switch (actor->spr.type) {
case kDudeSpiderRed:
if (nDist < 0x399 && abs(nDeltaAngle) < 85)
aiNewState(actor, &spidBite);

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

@ -59,16 +59,16 @@ void sub_71A90(int, DBloodActor* actor)
void sub_71BD4(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = pSprite->yrepeat * pDudeInfo->eyeHeight;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int height = actor->spr.yrepeat * pDudeInfo->eyeHeight;
if (!actor->ValidateTarget(__FUNCTION__)) return;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x100000 };
Aim aim;
aim.dx = bcos(pSprite->ang);
aim.dy = bsin(pSprite->ang);
aim.dx = bcos(actor->spr.ang);
aim.dy = bsin(actor->spr.ang);
aim.dz = actor->dudeSlope;
int nClosest = 0x7fffffff;
BloodStatIterator it(kStatDude);
@ -89,8 +89,8 @@ void sub_71BD4(int, DBloodActor* actor)
y2 += (actor->yvel * t) >> 12;
z2 += (actor->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -104,11 +104,11 @@ void sub_71BD4(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = actor2->spr.pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
int tz = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -129,13 +129,13 @@ void sub_720AC(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = pSprite->yrepeat * pDudeInfo->eyeHeight;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int height = actor->spr.yrepeat * pDudeInfo->eyeHeight;
int ax, ay, az;
ax = bcos(pSprite->ang);
ay = bsin(pSprite->ang);
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
ax = bcos(actor->spr.ang);
ay = bsin(actor->spr.ang);
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x100000 };
Aim aim;
@ -162,8 +162,8 @@ void sub_720AC(int, DBloodActor* actor)
y2 += (actor->yvel * t) >> 12;
z2 += (actor->zvel * t) >> 8;
}
int tx = x + MulScale(Cos(pSprite->ang), nDist, 30);
int ty = y + MulScale(Sin(pSprite->ang), nDist, 30);
int tx = x + MulScale(Cos(actor->spr.ang), nDist, 30);
int ty = y + MulScale(Sin(actor->spr.ang), nDist, 30);
int tz = z + MulScale(actor->dudeSlope, nDist, 10);
int tsr = MulScale(9460, nDist, 10);
int top, bottom;
@ -177,11 +177,11 @@ void sub_720AC(int, DBloodActor* actor)
if (nDist2 < nClosest)
{
int nAngle = getangle(x2 - x, y2 - y);
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
int nDeltaAngle = ((nAngle - actor->spr.ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = actor2->spr.pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, actor2->spr.sector()))
int tz = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -208,12 +208,12 @@ static void sub_725A4(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
if (pDudeExtraE->active && pDudeExtraE->thinkTime < 10)
pDudeExtraE->thinkTime++;
@ -232,18 +232,18 @@ static void sub_725A4(DBloodActor* actor)
PLAYER* pPlayer = &gPlayer[p];
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
pDudeExtraE->thinkTime = 0;
@ -267,18 +267,18 @@ static void sub_72850(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = pXSprite->targetX - actor->spr.pos.X;
int dy = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &tchernobogSearch);
aiThinkTarget(actor);
}
@ -291,17 +291,17 @@ static void sub_72934(DBloodActor* actor)
aiNewState(actor, &tcherno13A9B8);
return;
}
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
///assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) {
Printf(PRINT_HIGH, "actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -316,9 +316,9 @@ static void sub_72934(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -64,12 +64,12 @@ void HackSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->pos.Y;
int tx = pXSprite->targetX - actor->spr.pos.X;
int ty = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(tx, ty);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height = (actor->spr.yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (target->spr.yrepeat * pDudeInfoT->eyeHeight) << 2;
int dz = height - height2;
int dx = bcos(nAngle);
@ -94,14 +94,14 @@ static void zombaThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 921 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 921 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &zombieASearch);
aiThinkTarget(actor);
}
@ -114,13 +114,13 @@ static void zombaThinkChase(DBloodActor* actor)
aiNewState(actor, &zombieASearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -133,15 +133,15 @@ static void zombaThinkChase(DBloodActor* actor)
return;
}
// If the zombie gets whacked while rising from the grave it never executes this change and if it isn't done here at the very latest, will just aimlessly run around.
if (!VanillaMode() && pSprite->type == kDudeZombieAxeBuried)
pSprite->type = kDudeZombieAxeNormal;
if (!VanillaMode() && actor->spr.type == kDudeZombieAxeBuried)
actor->spr.type = kDudeZombieAxeNormal;
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -165,13 +165,13 @@ static void zombaThinkPonder(DBloodActor* actor)
aiNewState(actor, &zombieASearch);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -186,9 +186,9 @@ static void zombaThinkPonder(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -212,26 +212,26 @@ static void zombaThinkPonder(DBloodActor* actor)
static void myThinkTarget(DBloodActor* actor)
{
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
auto owneractor = actor->GetOwner();
if (owneractor == nullptr || owneractor == pPlayer->actor || pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, pPlayer->actor);
@ -264,8 +264,8 @@ static void myThinkSearch(DBloodActor* actor)
static void entryEZombie(DBloodActor* actor)
{
auto pSprite = &actor->s();
pSprite->type = kDudeZombieAxeNormal;
pSprite->flags |= 1;
actor->spr.type = kDudeZombieAxeNormal;
actor->spr.flags |= 1;
}
static void entryAIdle(DBloodActor* actor)
@ -278,7 +278,7 @@ static void entryEStand(DBloodActor* actor)
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
sfxPlay3DSound(actor, 1100, -1, 0);
pSprite->ang = getangle(pXSprite->targetX - pSprite->pos.X, pXSprite->targetY - pSprite->pos.Y);
actor->spr.ang = getangle(pXSprite->targetX - actor->spr.pos.X, pXSprite->targetY - actor->spr.pos.Y);
}
END_BLD_NS

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

@ -48,15 +48,15 @@ AISTATE zombieFTeslaRecoil = { kAiStateRecoil, 4, -1, 0, NULL, NULL, NULL, &zomb
void zombfHackSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
if (pSprite->type != kDudeZombieButcher)
if (actor->spr.type != kDudeZombieButcher)
return;
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int height = (pDudeInfo->eyeHeight * actor->spr.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);
actFireVector(actor, 0, 0, bcos(actor->spr.ang), bsin(actor->spr.ang), height - height2, kVectorCleaver);
}
void PukeSeqCallback(int, DBloodActor* actor)
@ -65,12 +65,12 @@ void PukeSeqCallback(int, DBloodActor* actor)
spritetype* pSprite = &actor->s();
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
DUDEINFO* pDudeInfoT = getDudeInfo(target->spr.type);
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat);
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat);
int height2 = (pDudeInfoT->eyeHeight * target->spr.yrepeat);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->pos.Y;
int tx = pXSprite->targetX - actor->spr.pos.X;
int ty = pXSprite->targetY - actor->spr.pos.Y;
int nAngle = getangle(tx, ty);
int dx = bcos(nAngle);
int dy = bsin(nAngle);
@ -81,7 +81,7 @@ void PukeSeqCallback(int, DBloodActor* actor)
void ThrowSeqCallback(int, DBloodActor* actor)
{
spritetype* pSprite = &actor->s();
actFireMissile(actor, 0, -getDudeInfo(pSprite->type)->eyeHeight, bcos(pSprite->ang), bsin(pSprite->ang), 0, kMissileButcherKnife);
actFireMissile(actor, 0, -getDudeInfo(actor->spr.type)->eyeHeight, bcos(actor->spr.ang), bsin(actor->spr.ang), 0, kMissileButcherKnife);
}
static void zombfThinkSearch(DBloodActor* actor)
@ -95,14 +95,14 @@ static void zombfThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->pos.Y;
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 nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
if (nDist < 512 && abs(pSprite->ang - nAngle) < pDudeInfo->periphery)
if (nDist < 512 && abs(actor->spr.ang - nAngle) < pDudeInfo->periphery)
aiNewState(actor, &zombieFSearch);
aiThinkTarget(actor);
}
@ -115,13 +115,13 @@ static void zombfThinkChase(DBloodActor* actor)
aiNewState(actor, &zombieFGoto);
return;
}
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
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 - pSprite->pos.X;
int dy = target->spr.pos.Y - pSprite->pos.Y;
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)
{
@ -136,23 +136,23 @@ static void zombfThinkChase(DBloodActor* actor)
int nDist = approxDist(dx, dy);
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
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()))
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x1400 && nDist > 0xe00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
aiNewState(actor, &zombieFThrow);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
aiNewState(actor, &zombieFThrow);
else
aiNewState(actor, &zombieFDodge);
@ -164,14 +164,14 @@ static void zombfThinkChase(DBloodActor* actor)
}
else if (nDist < 0x1400 && nDist > 0x600 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
aiNewState(actor, &zombieFPuke);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
aiNewState(actor, &zombieFPuke);
else
aiNewState(actor, &zombieFDodge);
@ -183,14 +183,14 @@ static void zombfThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, actor->spr.pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
aiNewState(actor, &zombieFHack);
break;
case 3:
if (pSprite->type != gHitInfo.actor()->spr.type)
if (actor->spr.type != gHitInfo.actor()->spr.type)
aiNewState(actor, &zombieFHack);
else
aiNewState(actor, &zombieFDodge);