From e123e61f995b4bffa94d28540ffba9a0d2c62401 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 22 Dec 2021 20:22:35 +0100 Subject: [PATCH] - quick replace of 'pSprite->' with 'actor->spr.' in AI files. --- source/games/blood/src/aibeast.cpp | 168 ++++++++++---------- source/games/blood/src/aiboneel.cpp | 152 +++++++++--------- source/games/blood/src/aiburn.cpp | 34 ++-- source/games/blood/src/aicaleb.cpp | 120 +++++++------- source/games/blood/src/aicerber.cpp | 138 ++++++++-------- source/games/blood/src/aicult.cpp | 98 ++++++------ source/games/blood/src/aigarg.cpp | 236 ++++++++++++++-------------- source/games/blood/src/aighost.cpp | 222 +++++++++++++------------- source/games/blood/src/aigilbst.cpp | 122 +++++++------- source/games/blood/src/aihand.cpp | 24 +-- source/games/blood/src/aihound.cpp | 48 +++--- source/games/blood/src/aiinnoc.cpp | 24 +-- source/games/blood/src/aipod.cpp | 56 +++---- source/games/blood/src/airat.cpp | 32 ++-- source/games/blood/src/aispid.cpp | 70 ++++----- source/games/blood/src/aitchern.cpp | 100 ++++++------ source/games/blood/src/aizomba.cpp | 76 ++++----- source/games/blood/src/aizombf.cpp | 54 +++---- 18 files changed, 887 insertions(+), 887 deletions(-) diff --git a/source/games/blood/src/aibeast.cpp b/source/games/blood/src/aibeast.cpp index 05ec6ce66..61a740f11 100644 --- a/source/games/blood/src/aibeast.cpp +++ b/source/games/blood/src/aibeast.cpp @@ -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); diff --git a/source/games/blood/src/aiboneel.cpp b/source/games/blood/src/aiboneel.cpp index e01d34567..7e47fd2b2 100644 --- a/source/games/blood/src/aiboneel.cpp +++ b/source/games/blood/src/aiboneel.cpp @@ -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 diff --git a/source/games/blood/src/aiburn.cpp b/source/games/blood/src/aiburn.cpp index 066750cc2..5dff2de38 100644 --- a/source/games/blood/src/aiburn.cpp +++ b/source/games/blood/src/aiburn.cpp @@ -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); diff --git a/source/games/blood/src/aicaleb.cpp b/source/games/blood/src/aicaleb.cpp index c8a930144..0238b7c32 100644 --- a/source/games/blood/src/aicaleb.cpp +++ b/source/games/blood/src/aicaleb.cpp @@ -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); diff --git a/source/games/blood/src/aicerber.cpp b/source/games/blood/src/aicerber.cpp index cbde237d6..e515c9f97 100644 --- a/source/games/blood/src/aicerber.cpp +++ b/source/games/blood/src/aicerber.cpp @@ -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; diff --git a/source/games/blood/src/aicult.cpp b/source/games/blood/src/aicult.cpp index f4019312c..31aef8fc4 100644 --- a/source/games/blood/src/aicult.cpp +++ b/source/games/blood/src/aicult.cpp @@ -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); diff --git a/source/games/blood/src/aigarg.cpp b/source/games/blood/src/aigarg.cpp index 2c9457ecc..6c2d46575 100644 --- a/source/games/blood/src/aigarg.cpp +++ b/source/games/blood/src/aigarg.cpp @@ -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; diff --git a/source/games/blood/src/aighost.cpp b/source/games/blood/src/aighost.cpp index 515fcc474..412df7af1 100644 --- a/source/games/blood/src/aighost.cpp +++ b/source/games/blood/src/aighost.cpp @@ -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; diff --git a/source/games/blood/src/aigilbst.cpp b/source/games/blood/src/aigilbst.cpp index 18846170a..7bfcaca0b 100644 --- a/source/games/blood/src/aigilbst.cpp +++ b/source/games/blood/src/aigilbst.cpp @@ -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); diff --git a/source/games/blood/src/aihand.cpp b/source/games/blood/src/aihand.cpp index f23bf1f01..c1f3af6e6 100644 --- a/source/games/blood/src/aihand.cpp +++ b/source/games/blood/src/aihand.cpp @@ -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) { diff --git a/source/games/blood/src/aihound.cpp b/source/games/blood/src/aihound.cpp index 68ddcb0de..366dbbeac 100644 --- a/source/games/blood/src/aihound.cpp +++ b/source/games/blood/src/aihound.cpp @@ -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) { diff --git a/source/games/blood/src/aiinnoc.cpp b/source/games/blood/src/aiinnoc.cpp index 558465850..38fbb6cec 100644 --- a/source/games/blood/src/aiinnoc.cpp +++ b/source/games/blood/src/aiinnoc.cpp @@ -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) { diff --git a/source/games/blood/src/aipod.cpp b/source/games/blood/src/aipod.cpp index 6ee9a054a..2c0e07170 100644 --- a/source/games/blood/src/aipod.cpp +++ b/source/games/blood/src/aipod.cpp @@ -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); diff --git a/source/games/blood/src/airat.cpp b/source/games/blood/src/airat.cpp index 6925e1d40..f38f4f88d 100644 --- a/source/games/blood/src/airat.cpp +++ b/source/games/blood/src/airat.cpp @@ -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) { diff --git a/source/games/blood/src/aispid.cpp b/source/games/blood/src/aispid.cpp index 52a053cdf..9bb543a0d 100644 --- a/source/games/blood/src/aispid.cpp +++ b/source/games/blood/src/aispid.cpp @@ -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); diff --git a/source/games/blood/src/aitchern.cpp b/source/games/blood/src/aitchern.cpp index 4a5eae644..e8f05fcbe 100644 --- a/source/games/blood/src/aitchern.cpp +++ b/source/games/blood/src/aitchern.cpp @@ -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) { diff --git a/source/games/blood/src/aizomba.cpp b/source/games/blood/src/aizomba.cpp index 9edac7281..7f90bd295 100644 --- a/source/games/blood/src/aizomba.cpp +++ b/source/games/blood/src/aizomba.cpp @@ -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 diff --git a/source/games/blood/src/aizombf.cpp b/source/games/blood/src/aizombf.cpp index d31fc405e..772eac951 100644 --- a/source/games/blood/src/aizombf.cpp +++ b/source/games/blood/src/aizombf.cpp @@ -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);