teambeef/raze
0
0
Fork 0
mirror of https://github.com/DrBeef/Raze.git synced 2024-11-15 08:52:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

- refactored Blood's AI callback interface to only use a single DBloodActor parameter.

Browse source
This commit is contained in:
Christoph Oelckers 2020-11-06 22:48:22 +01:00
parent 0ac41e0b5a
commit 502d911a95
28 changed files with 797 additions and 542 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
source/blood/src/actor.cpp
View file

@ -54,6 +54,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "nnexts.h" #include "nnexts.h"
#include "player.h" #include "player.h"
#include "misc.h" #include "misc.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
@ -2743,8 +2744,10 @@ void sub_2A620(int nSprite, int x, int y, int z, int nSector, int nDist, int a7,
} }
} }
void sub_2AA94(spritetype *pSprite, XSPRITE *pXSprite) void sub_2AA94(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = actOwnerIdToSpriteId(pSprite->owner); int nSprite = actOwnerIdToSpriteId(pSprite->owner);
actPostSprite(pSprite->index, kStatDecoration); actPostSprite(pSprite->index, kStatDecoration);
seqSpawn(9, 3, pSprite->extra); seqSpawn(9, 3, pSprite->extra);
@ -4093,7 +4096,7 @@ void ProcessTouchObjects(spritetype *pSprite, int nXSprite)
if (!IsPlayerSprite(pSprite)) { if (!IsPlayerSprite(pSprite)) {
actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_0, dmg); actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_0, dmg);
if (xspriRangeIsFine(pSprite->extra) && !isActive(pSprite->index)) if (xspriRangeIsFine(pSprite->extra) && !isActive(pSprite->index))
aiActivateDude(pSprite, &xsprite[pSprite->extra]); aiActivateDude(&bloodActors[pSprite->index]);
} }
else if (powerupCheck(&gPlayer[pSprite->type - kDudePlayer1], kPwUpJumpBoots) > 0) actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_3, dmg); else if (powerupCheck(&gPlayer[pSprite->type - kDudePlayer1], kPwUpJumpBoots) > 0) actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_3, dmg);
else actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_0, dmg); else actDamageSprite(pSprite2->index, pSprite, DAMAGE_TYPE_0, dmg);
@ -4444,7 +4447,7 @@ int MoveThing(spritetype *pSprite)
switch (pSprite->type) { switch (pSprite->type) {
case kThingNapalmBall: case kThingNapalmBall:
if (zvel[nSprite] == 0 || Chance(0xA000)) sub_2AA94(pSprite, pXSprite); if (zvel[nSprite] == 0 || Chance(0xA000)) sub_2AA94(&bloodActors[pXSprite->reference]);
break; break;
case kThingZombieHead: case kThingZombieHead:
if (klabs(zvel[nSprite]) > 0x80000) { if (klabs(zvel[nSprite]) > 0x80000) {
@ -5373,8 +5376,10 @@ void actExplodeSprite(spritetype *pSprite)
xsprite[nXSprite].data3 = pExplodeInfo->flashEffect; xsprite[nXSprite].data3 = pExplodeInfo->flashEffect;
} }
void actActivateGibObject(spritetype *pSprite, XSPRITE *pXSprite) void actActivateGibObject(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int vdx = ClipRange(pXSprite->data1, 0, 31); int vdx = ClipRange(pXSprite->data1, 0, 31);
int vc = ClipRange(pXSprite->data2, 0, 31); int vc = ClipRange(pXSprite->data2, 0, 31);
int v4 = ClipRange(pXSprite->data3, 0, 31); int v4 = ClipRange(pXSprite->data3, 0, 31);
@ -5405,7 +5410,7 @@ bool IsUnderWater(spritetype *pSprite)
return 0; return 0;
} }
void MakeSplash(spritetype *pSprite, XSPRITE *pXSprite); void MakeSplash(DBloodActor *actor);
void actProcessSprites(void) void actProcessSprites(void)
{ {
@ -5588,7 +5593,7 @@ void actProcessSprites(void)
switch (pSprite->type) { switch (pSprite->type) {
case kThingDripWater: case kThingDripWater:
case kThingDripBlood: case kThingDripBlood:
MakeSplash(pSprite, pXSprite); MakeSplash(&bloodActors[pXSprite->reference]);
break; break;
#ifdef NOONE_EXTENSIONS #ifdef NOONE_EXTENSIONS
case kModernThingThrowableRock: case kModernThingThrowableRock:
@ -5907,7 +5912,7 @@ void actProcessSprites(void)
pSprite->type = kDudeCerberusOneHead; pSprite->type = kDudeCerberusOneHead;
if (pXSprite->target != -1) if (pXSprite->target != -1)
aiSetTarget(pXSprite, pXSprite->target); aiSetTarget(pXSprite, pXSprite->target);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
} }
if (pXSprite->Proximity && !pXSprite->isTriggered) if (pXSprite->Proximity && !pXSprite->isTriggered)
@ -6909,9 +6914,10 @@ void actPostProcess(void)
gPostCount = 0; gPostCount = 0;
} }
void MakeSplash(spritetype *pSprite, XSPRITE *pXSprite) void MakeSplash(DBloodActor* actor)
{ {
UNREFERENCED_PARAMETER(pXSprite); auto pXSprite = &actor->x();
auto pSprite = &actor->s();
pSprite->flags &= ~2; pSprite->flags &= ~2;
int nXSprite = pSprite->extra; int nXSprite = pSprite->extra;
pSprite->z -= 4 << 8; pSprite->z -= 4 << 8;

8
source/blood/src/actor.h
View file

@ -30,6 +30,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
BEGIN_BLD_NS BEGIN_BLD_NS
class DBloodActor;
enum DAMAGE_TYPE { enum DAMAGE_TYPE {
DAMAGE_TYPE_0 = 0, DAMAGE_TYPE_0 = 0,
DAMAGE_TYPE_1, // Flame DAMAGE_TYPE_1, // Flame
@ -225,7 +227,7 @@ void ConcussSprite(int a1, spritetype *pSprite, int x, int y, int z, int a6);
int actWallBounceVector(int *x, int *y, int nWall, int a4); int actWallBounceVector(int *x, int *y, int nWall, int a4);
int actFloorBounceVector(int *x, int *y, int *z, int nSector, int a5); int actFloorBounceVector(int *x, int *y, int *z, int nSector, int a5);
void sub_2A620(int nSprite, int x, int y, int z, int nSector, int nDist, int a7, int a8, DAMAGE_TYPE a9, int a10, int a11, int a12, int a13); void sub_2A620(int nSprite, int x, int y, int z, int nSector, int nDist, int a7, int a8, DAMAGE_TYPE a9, int a10, int a11, int a12, int a13);
void sub_2AA94(spritetype *pSprite, XSPRITE *pXSprite); void sub_2AA94(DBloodActor *actor);
spritetype *actSpawnFloor(spritetype *pSprite); spritetype *actSpawnFloor(spritetype *pSprite);
spritetype *actDropAmmo(spritetype *pSprite, int nType); spritetype *actDropAmmo(spritetype *pSprite, int nType);
spritetype *actDropWeapon(spritetype *pSprite, int nType); spritetype *actDropWeapon(spritetype *pSprite, int nType);
@ -246,7 +248,7 @@ int MoveThing(spritetype *pSprite);
void MoveDude(spritetype *pSprite); void MoveDude(spritetype *pSprite);
int MoveMissile(spritetype *pSprite); int MoveMissile(spritetype *pSprite);
void actExplodeSprite(spritetype *pSprite); void actExplodeSprite(spritetype *pSprite);
void actActivateGibObject(spritetype *pSprite, XSPRITE *pXSprite); void actActivateGibObject(DBloodActor *actor);
bool IsUnderWater(spritetype *pSprite); bool IsUnderWater(spritetype *pSprite);
void actProcessSprites(void); void actProcessSprites(void);
spritetype * actSpawnSprite(int nSector, int x, int y, int z, int nStat, char a6); spritetype * actSpawnSprite(int nSector, int x, int y, int z, int nStat, char a6);
@ -261,7 +263,7 @@ bool actCanSplatWall(int nWall);
void actFireVector(spritetype *pShooter, int a2, int a3, int a4, int a5, int a6, VECTOR_TYPE vectorType); void actFireVector(spritetype *pShooter, int a2, int a3, int a4, int a5, int a6, VECTOR_TYPE vectorType);
void actPostSprite(int nSprite, int nStatus); void actPostSprite(int nSprite, int nStatus);
void actPostProcess(void); void actPostProcess(void);
void MakeSplash(spritetype *pSprite, XSPRITE *pXSprite); void MakeSplash(DBloodActor *actor);
void actBuildMissile(spritetype* pMissile, int nXSprite, int nSprite); void actBuildMissile(spritetype* pMissile, int nXSprite, int nSprite);
extern const int DudeDifficulty[]; extern const int DudeDifficulty[];

61
source/blood/src/ai.cpp
View file

@ -47,6 +47,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "triggers.h" #include "triggers.h"
#include "view.h" #include "view.h"
#include "nnexts.h" #include "nnexts.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
@ -98,7 +99,7 @@ void aiNewState(spritetype *pSprite, XSPRITE *pXSprite, AISTATE *pAIState)
} }
if (pAIState->enterFunc) if (pAIState->enterFunc)
pAIState->enterFunc(pSprite, pXSprite); pAIState->enterFunc(&bloodActors[pXSprite->reference]);
} }
bool isImmune(spritetype* pSprite, int dmgType, int minScale) { bool isImmune(spritetype* pSprite, int dmgType, int minScale) {
@ -270,9 +271,10 @@ void aiChooseDirection(spritetype *pSprite, XSPRITE *pXSprite, int a3)
} }
} }
void aiMoveForward(spritetype *pSprite, XSPRITE *pXSprite) void aiMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -280,12 +282,14 @@ void aiMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
if (klabs(nAng) > 341) if (klabs(nAng) > 341)
return; return;
xvel[nSprite] += mulscale30(pDudeInfo->frontSpeed, Cos(pSprite->ang)); actor->xvel() += mulscale30(pDudeInfo->frontSpeed, Cos(pSprite->ang));
yvel[nSprite] += mulscale30(pDudeInfo->frontSpeed, Sin(pSprite->ang)); actor->yvel() += mulscale30(pDudeInfo->frontSpeed, Sin(pSprite->ang));
} }
void aiMoveTurn(spritetype *pSprite, XSPRITE *pXSprite) void aiMoveTurn(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -293,9 +297,10 @@ void aiMoveTurn(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
} }
void aiMoveDodge(spritetype *pSprite, XSPRITE *pXSprite) void aiMoveDodge(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -305,8 +310,8 @@ void aiMoveDodge(spritetype *pSprite, XSPRITE *pXSprite)
{ {
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -314,13 +319,15 @@ void aiMoveDodge(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
} }
void aiActivateDude(spritetype *pSprite, XSPRITE *pXSprite) void aiActivateDude(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!pXSprite->state) { if (!pXSprite->state) {
aiChooseDirection(pSprite, pXSprite, getangle(pXSprite->targetX-pSprite->x, pXSprite->targetY-pSprite->y)); aiChooseDirection(pSprite, pXSprite, getangle(pXSprite->targetX-pSprite->x, pXSprite->targetY-pSprite->y));
@ -905,7 +912,7 @@ int aiDamageSprite(spritetype *pSprite, XSPRITE *pXSprite, int nSource, DAMAGE_T
if (pXSprite->target == -1 || (nSource != pXSprite->target && Chance(pSprite->type == pSource->type ? nDamage*pDudeInfo->changeTargetKin : nDamage*pDudeInfo->changeTarget))) if (pXSprite->target == -1 || (nSource != pXSprite->target && Chance(pSprite->type == pSource->type ? nDamage*pDudeInfo->changeTargetKin : nDamage*pDudeInfo->changeTarget)))
{ {
aiSetTarget(pXSprite, nSource); aiSetTarget(pXSprite, nSource);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
if (nDmgType == DAMAGE_TYPE_6) if (nDmgType == DAMAGE_TYPE_6)
{ {
@ -1091,8 +1098,10 @@ int aiDamageSprite(spritetype *pSprite, XSPRITE *pXSprite, int nSource, DAMAGE_T
return nDamage; return nDamage;
} }
void RecoilDude(spritetype *pSprite, XSPRITE *pXSprite) void RecoilDude(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
char v4 = Chance(0x8000); char v4 = Chance(0x8000);
DUDEEXTRA *pDudeExtra = &gDudeExtra[pSprite->extra]; DUDEEXTRA *pDudeExtra = &gDudeExtra[pSprite->extra];
if (pSprite->statnum == kStatDude && (pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (pSprite->statnum == kStatDude && (pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
@ -1337,8 +1346,10 @@ void RecoilDude(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
void aiThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) void aiThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
if (Chance(pDudeInfo->alertChance)) if (Chance(pDudeInfo->alertChance))
@ -1363,13 +1374,13 @@ void aiThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery) if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery)
{ {
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
} }
@ -1402,13 +1413,13 @@ void sub_5F15C(spritetype *pSprite, XSPRITE *pXSprite)
if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery) if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery)
{ {
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
} }
@ -1431,7 +1442,7 @@ void sub_5F15C(spritetype *pSprite, XSPRITE *pXSprite)
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist) if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue; continue;
aiSetTarget(pXSprite, pSprite2->index); aiSetTarget(pXSprite, pSprite2->index);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
} }
@ -1452,10 +1463,10 @@ void aiProcessDudes(void) {
pXSprite->stateTimer = ClipLow(pXSprite->stateTimer-4, 0); pXSprite->stateTimer = ClipLow(pXSprite->stateTimer-4, 0);
if (pXSprite->aiState->moveFunc) if (pXSprite->aiState->moveFunc)
pXSprite->aiState->moveFunc(pSprite, pXSprite); pXSprite->aiState->moveFunc(&bloodActors[pXSprite->reference]);
if (pXSprite->aiState->thinkFunc && (gFrameCount & 3) == (nSprite & 3)) if (pXSprite->aiState->thinkFunc && (gFrameCount & 3) == (nSprite & 3))
pXSprite->aiState->thinkFunc(pSprite, pXSprite); pXSprite->aiState->thinkFunc(&bloodActors[pXSprite->reference]);
switch (pSprite->type) { switch (pSprite->type) {
#ifdef NOONE_EXTENSIONS #ifdef NOONE_EXTENSIONS
@ -1471,7 +1482,7 @@ void aiProcessDudes(void) {
int hinder = ((pExtra->isMelee) ? 25 : 5) << 4; int hinder = ((pExtra->isMelee) ? 25 : 5) << 4;
if (pXSprite->health <= 0 || hinder > cumulDamage[pSprite->extra]) break; if (pXSprite->health <= 0 || hinder > cumulDamage[pSprite->extra]) break;
pXSprite->data3 = cumulDamage[pSprite->extra]; pXSprite->data3 = cumulDamage[pSprite->extra];
RecoilDude(pSprite, pXSprite); RecoilDude(&bloodActors[pXSprite->reference]);
break; break;
} }
#endif #endif
@ -1485,7 +1496,7 @@ void aiProcessDudes(void) {
if (pXSprite->health > 0 && ((pDudeInfo->hinderDamage << 4) <= cumulDamage[nXSprite])) { if (pXSprite->health > 0 && ((pDudeInfo->hinderDamage << 4) <= cumulDamage[nXSprite])) {
pXSprite->data3 = cumulDamage[nXSprite]; pXSprite->data3 = cumulDamage[nXSprite];
RecoilDude(pSprite, pXSprite); RecoilDude(&bloodActors[pXSprite->reference]);
} }
break; break;
} }

17
source/blood/src/ai.h
View file

@ -35,9 +35,9 @@ struct AISTATE {
int seqId; int seqId;
int funcId; // seq callback int funcId; // seq callback
int stateTicks; int stateTicks;
void(*enterFunc)(spritetype *, XSPRITE *); void(*enterFunc)(DBloodActor *);
void(*moveFunc)(spritetype *, XSPRITE *); void(*moveFunc)(DBloodActor *);
void(*thinkFunc)(spritetype *, XSPRITE *); void(*thinkFunc)(DBloodActor *);
AISTATE *nextState; AISTATE *nextState;
}; };
extern AISTATE aiState[]; extern AISTATE aiState[];
@ -95,18 +95,17 @@ bool dudeIsPlayingSeq(spritetype *pSprite, int nSeq);
void aiPlay3DSound(spritetype *pSprite, int a2, AI_SFX_PRIORITY a3, int a4); void aiPlay3DSound(spritetype *pSprite, int a2, AI_SFX_PRIORITY a3, int a4);
void aiNewState(spritetype *pSprite, XSPRITE *pXSprite, AISTATE *pAIState); void aiNewState(spritetype *pSprite, XSPRITE *pXSprite, AISTATE *pAIState);
void aiChooseDirection(spritetype *pSprite, XSPRITE *pXSprite, int a3); void aiChooseDirection(spritetype *pSprite, XSPRITE *pXSprite, int a3);
void aiMoveForward(spritetype *pSprite, XSPRITE *pXSprite); void aiMoveForward(DBloodActor*pXSprite);
void aiMoveTurn(spritetype *pSprite, XSPRITE *pXSprite); void aiMoveTurn(DBloodActor*pXSprite);
void aiMoveDodge(spritetype *pSprite, XSPRITE *pXSprite); void aiMoveDodge(DBloodActor *actor);
void aiActivateDude(spritetype *pSprite, XSPRITE *pXSprite); void aiActivateDude(DBloodActor *actor);
void aiSetTarget(XSPRITE *pXSprite, int x, int y, int z); void aiSetTarget(XSPRITE *pXSprite, int x, int y, int z);
void aiSetTarget(XSPRITE *pXSprite, int nTarget); void aiSetTarget(XSPRITE *pXSprite, int nTarget);
int aiDamageSprite(spritetype *pSprite, XSPRITE *pXSprite, int nSource, DAMAGE_TYPE nDmgType, int nDamage); int aiDamageSprite(spritetype *pSprite, XSPRITE *pXSprite, int nSource, DAMAGE_TYPE nDmgType, int nDamage);
void aiThinkTarget(spritetype *pSprite, XSPRITE *pXSprite); void aiThinkTarget(DBloodActor* actor);
void sub_5F15C(spritetype *pSprite, XSPRITE *pXSprite); void sub_5F15C(spritetype *pSprite, XSPRITE *pXSprite);
void aiProcessDudes(void); void aiProcessDudes(void);
void aiInit(void); void aiInit(void);
void aiInitSprite(spritetype *pSprite); void aiInitSprite(spritetype *pSprite);
bool CanMove(spritetype* pSprite, int a2, int nAngle, int nRange); bool CanMove(spritetype* pSprite, int a2, int nAngle, int nRange);
void RecoilDude(spritetype* pSprite, XSPRITE* pXSprite);
END_BLD_NS END_BLD_NS

128
source/blood/src/aibat.cpp
View file

@ -36,20 +36,21 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "dude.h" #include "dude.h"
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void batThinkTarget(spritetype *, XSPRITE *); static void batThinkTarget(DBloodActor*);
static void batThinkSearch(spritetype *, XSPRITE *); static void batThinkSearch(DBloodActor*);
static void batThinkGoto(spritetype *, XSPRITE *); static void batThinkGoto(DBloodActor*);
static void batThinkPonder(spritetype *, XSPRITE *); static void batThinkPonder(DBloodActor*);
static void batMoveDodgeUp(spritetype *, XSPRITE *); static void batMoveDodgeUp(DBloodActor*);
static void batMoveDodgeDown(spritetype *, XSPRITE *); static void batMoveDodgeDown(DBloodActor*);
static void batThinkChase(spritetype *, XSPRITE *); static void batThinkChase(DBloodActor*);
static void batMoveForward(spritetype *, XSPRITE *); static void batMoveForward(DBloodActor*);
static void batMoveSwoop(spritetype *, XSPRITE *); static void batMoveSwoop(DBloodActor*);
static void batMoveFly(spritetype *, XSPRITE *); static void batMoveFly(DBloodActor*);
static void batMoveToCeil(spritetype *, XSPRITE *); static void batMoveToCeil(DBloodActor*);
AISTATE batIdle = {kAiStateIdle, 0, -1, 0, NULL, NULL, batThinkTarget, NULL }; AISTATE batIdle = {kAiStateIdle, 0, -1, 0, NULL, NULL, batThinkTarget, NULL };
@ -87,8 +88,10 @@ void batBiteSeqCallback(int, int nXSprite)
actFireVector(pSprite, 0, 0, dx, dy, height2-height, VECTOR_TYPE_6); actFireVector(pSprite, 0, 0, dx, dy, height2-height, VECTOR_TYPE_6);
} }
static void batThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void batThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
DUDEEXTRA_at6_u1 *pDudeExtraE = &gDudeExtra[pSprite->extra].at6.u1; DUDEEXTRA_at6_u1 *pDudeExtraE = &gDudeExtra[pSprite->extra].at6.u1;
@ -125,12 +128,12 @@ static void batThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery) if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery)
{ {
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -139,14 +142,18 @@ static void batThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void batThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void batThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
batThinkTarget(pSprite, pXSprite); batThinkTarget(actor);
} }
static void batThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void batThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -156,11 +163,13 @@ static void batThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &batSearch); aiNewState(pSprite, pXSprite, &batSearch);
batThinkTarget(pSprite, pXSprite); batThinkTarget(actor);
} }
static void batThinkPonder(spritetype *pSprite, XSPRITE *pXSprite) static void batThinkPonder(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &batSearch); aiNewState(pSprite, pXSprite, &batSearch);
@ -213,9 +222,10 @@ static void batThinkPonder(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void batMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite) static void batMoveDodgeUp(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -223,8 +233,8 @@ static void batMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -232,14 +242,15 @@ static void batMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x52aaa; actor->zvel() = -0x52aaa;
} }
static void batMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite) static void batMoveDodgeDown(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -249,8 +260,8 @@ static void batMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -258,13 +269,15 @@ static void batMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
} }
static void batThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void batThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &batGoto); aiNewState(pSprite, pXSprite, &batGoto);
@ -323,9 +336,10 @@ static void batThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
aiNewState(pSprite, pXSprite, &batHide); aiNewState(pSprite, pXSprite, &batHide);
} }
static void batMoveForward(spritetype *pSprite, XSPRITE *pXSprite) static void batMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -343,21 +357,22 @@ static void batMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void batMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite) static void batMoveSwoop(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -376,19 +391,20 @@ static void batMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
} }
static void batMoveFly(spritetype *pSprite, XSPRITE *pXSprite) static void batMoveFly(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -407,18 +423,20 @@ static void batMoveFly(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x2d555; actor->zvel() = -0x2d555;
} }
void batMoveToCeil(spritetype *pSprite, XSPRITE *pXSprite) void batMoveToCeil(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int x = pSprite->x; int x = pSprite->x;
int y = pSprite->y; int y = pSprite->y;
int z = pSprite->z; int z = pSprite->z;

102
source/blood/src/aibeast.cpp
View file

@ -38,19 +38,20 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void MorphToBeast(spritetype *, XSPRITE *); static void MorphToBeast(DBloodActor *);
static void beastThinkSearch(spritetype *, XSPRITE *); static void beastThinkSearch(DBloodActor *);
static void beastThinkGoto(spritetype *, XSPRITE *); static void beastThinkGoto(DBloodActor *);
static void beastThinkChase(spritetype *, XSPRITE *); static void beastThinkChase(DBloodActor *);
static void beastThinkSwimGoto(spritetype *, XSPRITE *); static void beastThinkSwimGoto(DBloodActor *);
static void beastThinkSwimChase(spritetype *, XSPRITE *); static void beastThinkSwimChase(DBloodActor *);
static void beastMoveForward(spritetype *, XSPRITE *); static void beastMoveForward(DBloodActor *);
static void sub_628A0(spritetype *, XSPRITE *); static void sub_628A0(DBloodActor *);
static void sub_62AE0(spritetype *, XSPRITE *); static void sub_62AE0(DBloodActor *);
static void sub_62D7C(spritetype *, XSPRITE *); static void sub_62D7C(DBloodActor *);
AISTATE beastIdle = {kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE beastIdle = {kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE beastChase = {kAiStateChase, 8, -1, 0, NULL, beastMoveForward, beastThinkChase, NULL }; AISTATE beastChase = {kAiStateChase, 8, -1, 0, NULL, beastMoveForward, beastThinkChase, NULL };
@ -186,20 +187,26 @@ void StompSeqCallback(int, int nXSprite)
sfxPlay3DSound(pSprite, 9015+Random(2), -1, 0); sfxPlay3DSound(pSprite, 9015+Random(2), -1, 0);
} }
static void MorphToBeast(spritetype *pSprite, XSPRITE *pXSprite) static void MorphToBeast(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
actHealDude(pXSprite, dudeInfo[51].startHealth, dudeInfo[51].startHealth); actHealDude(pXSprite, dudeInfo[51].startHealth, dudeInfo[51].startHealth);
pSprite->type = kDudeBeast; pSprite->type = kDudeBeast;
} }
static void beastThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void beastThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void beastThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void beastThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
XSECTOR *pXSector; XSECTOR *pXSector;
@ -220,11 +227,13 @@ static void beastThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
else else
aiNewState(pSprite, pXSprite, &beastSearch); aiNewState(pSprite, pXSprite, &beastSearch);
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void beastThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void beastThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
XSECTOR *pXSector; XSECTOR *pXSector;
@ -385,8 +394,10 @@ static void beastThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void beastThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite) static void beastThinkSwimGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -396,11 +407,13 @@ static void beastThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &beastSwimSearch); aiNewState(pSprite, pXSprite, &beastSwimSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void beastThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite) static void beastThinkSwimChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &beastSwimGoto); aiNewState(pSprite, pXSprite, &beastSwimGoto);
@ -453,9 +466,10 @@ static void beastThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void beastMoveForward(spritetype *pSprite, XSPRITE *pXSprite) static void beastMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -468,13 +482,14 @@ static void beastMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
int nDist = approxDist(dx, dy); int nDist = approxDist(dx, dy);
if (nDist <= 0x400 && Random(64) < 32) if (nDist <= 0x400 && Random(64) < 32)
return; return;
xvel[nSprite] += mulscale30(pDudeInfo->frontSpeed, Cos(pSprite->ang)); actor->xvel() += mulscale30(pDudeInfo->frontSpeed, Cos(pSprite->ang));
yvel[nSprite] += mulscale30(pDudeInfo->frontSpeed, Sin(pSprite->ang)); actor->yvel() += mulscale30(pDudeInfo->frontSpeed, Sin(pSprite->ang));
} }
static void sub_628A0(spritetype *pSprite, XSPRITE *pXSprite) static void sub_628A0(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -492,21 +507,22 @@ static void sub_628A0(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>2; t1 += nAccel>>2;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void sub_62AE0(spritetype *pSprite, XSPRITE *pXSprite) static void sub_62AE0(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
spritetype *pTarget = &sprite[pXSprite->target]; spritetype *pTarget = &sprite[pXSprite->target];
@ -529,18 +545,20 @@ static void sub_62AE0(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel; t1 += nAccel;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -dz; actor->zvel() = -dz;
} }
static void sub_62D7C(spritetype *pSprite, XSPRITE *pXSprite) static void sub_62D7C(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
@ -564,14 +582,14 @@ static void sub_62D7C(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = dz; actor->zvel() = dz;
} }
END_BLD_NS END_BLD_NS

128
source/blood/src/aiboneel.cpp
View file

@ -37,20 +37,21 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void eelThinkTarget(spritetype *, XSPRITE *); static void eelThinkTarget(DBloodActor *);
static void eelThinkSearch(spritetype *, XSPRITE *); static void eelThinkSearch(DBloodActor *);
static void eelThinkGoto(spritetype *, XSPRITE *); static void eelThinkGoto(DBloodActor *);
static void eelThinkPonder(spritetype *, XSPRITE *); static void eelThinkPonder(DBloodActor *);
static void eelMoveDodgeUp(spritetype *, XSPRITE *); static void eelMoveDodgeUp(DBloodActor *);
static void eelMoveDodgeDown(spritetype *, XSPRITE *); static void eelMoveDodgeDown(DBloodActor *);
static void eelThinkChase(spritetype *, XSPRITE *); static void eelThinkChase(DBloodActor *);
static void eelMoveForward(spritetype *, XSPRITE *); static void eelMoveForward(DBloodActor *);
static void eelMoveSwoop(spritetype *, XSPRITE *); static void eelMoveSwoop(DBloodActor *);
static void eelMoveAscend(spritetype *pSprite, XSPRITE *pXSprite); static void eelMoveAscend(DBloodActor *actor);
static void eelMoveToCeil(spritetype *, XSPRITE *); static void eelMoveToCeil(DBloodActor *);
AISTATE eelIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, eelThinkTarget, NULL }; AISTATE eelIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, eelThinkTarget, NULL };
@ -100,8 +101,10 @@ void eelBiteSeqCallback(int, int nXSprite)
actFireVector(pSprite, 0, 0, dx, dy, height2-height, VECTOR_TYPE_7); actFireVector(pSprite, 0, 0, dx, dy, height2-height, VECTOR_TYPE_7);
} }
static void eelThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void eelThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
DUDEEXTRA_at6_u1 *pDudeExtraE = &gDudeExtra[pSprite->extra].at6.u1; DUDEEXTRA_at6_u1 *pDudeExtraE = &gDudeExtra[pSprite->extra].at6.u1;
@ -139,13 +142,13 @@ static void eelThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -154,14 +157,18 @@ static void eelThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void eelThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void eelThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
eelThinkTarget(pSprite, pXSprite); eelThinkTarget(actor);
} }
static void eelThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void eelThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -171,11 +178,13 @@ static void eelThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &eelSearch); aiNewState(pSprite, pXSprite, &eelSearch);
eelThinkTarget(pSprite, pXSprite); eelThinkTarget(actor);
} }
static void eelThinkPonder(spritetype *pSprite, XSPRITE *pXSprite) static void eelThinkPonder(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &eelSearch); aiNewState(pSprite, pXSprite, &eelSearch);
@ -228,9 +237,10 @@ static void eelThinkPonder(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void eelMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite) static void eelMoveDodgeUp(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -238,8 +248,8 @@ static void eelMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -247,14 +257,15 @@ static void eelMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x8000; actor->zvel() = -0x8000;
} }
static void eelMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite) static void eelMoveDodgeDown(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -264,8 +275,8 @@ static void eelMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -273,13 +284,15 @@ static void eelMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
} }
static void eelThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void eelThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &eelGoto); aiNewState(pSprite, pXSprite, &eelGoto);
@ -334,9 +347,10 @@ static void eelThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
aiNewState(pSprite, pXSprite, &eelSearch); aiNewState(pSprite, pXSprite, &eelSearch);
} }
static void eelMoveForward(spritetype *pSprite, XSPRITE *pXSprite) static void eelMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -354,21 +368,22 @@ static void eelMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void eelMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite) static void eelMoveSwoop(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -384,19 +399,20 @@ static void eelMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x22222; actor->zvel() = 0x22222;
} }
static void eelMoveAscend(spritetype *pSprite, XSPRITE *pXSprite) static void eelMoveAscend(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024; int nAng = ((pXSprite->goalAng+1024-pSprite->ang)&2047)-1024;
@ -412,18 +428,20 @@ static void eelMoveAscend(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x8000; actor->zvel() = -0x8000;
} }
void eelMoveToCeil(spritetype *pSprite, XSPRITE *pXSprite) void eelMoveToCeil(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int x = pSprite->x; int x = pSprite->x;
int y = pSprite->y; int y = pSprite->y;
int z = pSprite->z; int z = pSprite->z;

23
source/blood/src/aiburn.cpp
View file

@ -40,12 +40,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "nnexts.h" #include "nnexts.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void burnThinkSearch(spritetype*, XSPRITE*); static void burnThinkSearch(DBloodActor*);
static void burnThinkGoto(spritetype*, XSPRITE*); static void burnThinkGoto(DBloodActor*);
static void burnThinkChase(spritetype*, XSPRITE*); static void burnThinkChase(DBloodActor*);
AISTATE cultistBurnIdle = { kAiStateIdle, 3, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE cultistBurnIdle = { kAiStateIdle, 3, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE cultistBurnChase = { kAiStateChase, 3, -1, 0, NULL, aiMoveForward, burnThinkChase, NULL }; AISTATE cultistBurnChase = { kAiStateChase, 3, -1, 0, NULL, aiMoveForward, burnThinkChase, NULL };
@ -88,14 +89,18 @@ void BurnSeqCallback(int, int)
{ {
} }
static void burnThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void burnThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void burnThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void burnThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -132,11 +137,13 @@ static void burnThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
#endif #endif
} }
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void burnThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void burnThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
switch (pSprite->type) switch (pSprite->type)

55
source/blood/src/aicaleb.cpp
View file

@ -38,17 +38,18 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void calebThinkSearch(spritetype *, XSPRITE *); static void calebThinkSearch(DBloodActor *);
static void calebThinkGoto(spritetype *, XSPRITE *); static void calebThinkGoto(DBloodActor *);
static void calebThinkChase(spritetype *, XSPRITE *); static void calebThinkChase(DBloodActor *);
static void calebThinkSwimGoto(spritetype *, XSPRITE *); static void calebThinkSwimGoto(DBloodActor *);
static void calebThinkSwimChase(spritetype *, XSPRITE *); static void calebThinkSwimChase(DBloodActor *);
static void sub_65D04(spritetype *, XSPRITE *); static void sub_65D04(DBloodActor *);
static void sub_65F44(spritetype *, XSPRITE *); static void sub_65F44(DBloodActor *);
static void sub_661E0(spritetype *, XSPRITE *); static void sub_661E0(DBloodActor *);
AISTATE tinycalebIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE tinycalebIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE tinycalebChase = { kAiStateChase, 6, -1, 0, NULL, aiMoveForward, calebThinkChase, NULL }; AISTATE tinycalebChase = { kAiStateChase, 6, -1, 0, NULL, aiMoveForward, calebThinkChase, NULL };
@ -94,14 +95,18 @@ void SeqAttackCallback(int, int nXSprite)
sfxPlay3DSound(pSprite, 1002, -1, 0); sfxPlay3DSound(pSprite, 1002, -1, 0);
} }
static void calebThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void calebThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void calebThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void calebThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
XSECTOR *pXSector; XSECTOR *pXSector;
@ -122,11 +127,13 @@ static void calebThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
else else
aiNewState(pSprite, pXSprite, &tinycalebSearch); aiNewState(pSprite, pXSprite, &tinycalebSearch);
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void calebThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void calebThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
XSECTOR *pXSector; XSECTOR *pXSector;
@ -253,8 +260,10 @@ static void calebThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void calebThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite) static void calebThinkSwimGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -264,11 +273,13 @@ static void calebThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &tinycalebSwimSearch); aiNewState(pSprite, pXSprite, &tinycalebSwimSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void calebThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite) static void calebThinkSwimChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &tinycalebSwimGoto); aiNewState(pSprite, pXSprite, &tinycalebSwimGoto);
@ -316,8 +327,10 @@ static void calebThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void sub_65D04(spritetype *pSprite, XSPRITE *pXSprite) static void sub_65D04(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
@ -348,8 +361,10 @@ static void sub_65D04(spritetype *pSprite, XSPRITE *pXSprite)
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos);
} }
static void sub_65F44(spritetype *pSprite, XSPRITE *pXSprite) static void sub_65F44(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
@ -383,8 +398,10 @@ static void sub_65F44(spritetype *pSprite, XSPRITE *pXSprite)
zvel[nSprite] = -dz; zvel[nSprite] = -dz;
} }
static void sub_661E0(spritetype *pSprite, XSPRITE *pXSprite) static void sub_661E0(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);

33
source/blood/src/aicerber.cpp
View file

@ -38,13 +38,14 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void cerberusThinkSearch(spritetype *pSprite, XSPRITE *pXSprite); static void cerberusThinkSearch(DBloodActor *actor);
static void cerberusThinkTarget(spritetype *pSprite, XSPRITE *pXSprite); static void cerberusThinkTarget(DBloodActor *actor);
static void cerberusThinkGoto(spritetype *pSprite, XSPRITE *pXSprite); static void cerberusThinkGoto(DBloodActor *actor);
static void cerberusThinkChase(spritetype *pSprite, XSPRITE *pXSprite); static void cerberusThinkChase(DBloodActor *actor);
AISTATE cerberusIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, cerberusThinkTarget, NULL }; AISTATE cerberusIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, cerberusThinkTarget, NULL };
@ -262,14 +263,18 @@ void cerberusBurnSeqCallback2(int, int nXSprite)
} }
} }
static void cerberusThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void cerberusThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void cerberusThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void cerberusThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -313,13 +318,13 @@ static void cerberusThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
{ {
pDudeExtraE->xval1 = 0; pDudeExtraE->xval1 = 0;
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
pDudeExtraE->xval1 = 0; pDudeExtraE->xval1 = 0;
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -328,8 +333,10 @@ static void cerberusThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void cerberusThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void cerberusThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -352,11 +359,13 @@ static void cerberusThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
break; break;
} }
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void cerberusThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void cerberusThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) { if (pXSprite->target == -1) {
switch (pSprite->type) { switch (pSprite->type) {
case kDudeCerberusTwoHead: case kDudeCerberusTwoHead:

21
source/blood/src/aicult.cpp
View file

@ -40,12 +40,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void cultThinkSearch(spritetype *, XSPRITE *); static void cultThinkSearch(DBloodActor *);
static void cultThinkGoto(spritetype *, XSPRITE *); static void cultThinkGoto(DBloodActor *);
static void cultThinkChase(spritetype *, XSPRITE *); static void cultThinkChase(DBloodActor *);
AISTATE cultistIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE cultistIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE cultistProneIdle = { kAiStateIdle, 17, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE cultistProneIdle = { kAiStateIdle, 17, -1, 0, NULL, NULL, aiThinkTarget, NULL };
@ -216,14 +217,18 @@ static char TargetNearExplosion(spritetype *pSprite)
return 0; return 0;
} }
static void cultThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void cultThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
sub_5F15C(pSprite, pXSprite); sub_5F15C(pSprite, pXSprite);
} }
static void cultThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void cultThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -244,11 +249,13 @@ static void cultThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
break; break;
} }
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void cultThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void cultThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
switch (pXSprite->medium) switch (pXSprite->medium)

158
source/blood/src/aigarg.cpp
View file

@ -41,22 +41,23 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "nnexts.h" #include "nnexts.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void gargThinkTarget(spritetype *, XSPRITE *); static void gargThinkTarget(DBloodActor *);
static void gargThinkSearch(spritetype *, XSPRITE *); static void gargThinkSearch(DBloodActor *);
static void gargThinkGoto(spritetype *, XSPRITE *); static void gargThinkGoto(DBloodActor *);
static void gargMoveDodgeUp(spritetype *, XSPRITE *); static void gargMoveDodgeUp(DBloodActor *);
static void gargMoveDodgeDown(spritetype *, XSPRITE *); static void gargMoveDodgeDown(DBloodActor *);
static void gargThinkChase(spritetype *, XSPRITE *); static void gargThinkChase(DBloodActor *);
static void entryFStatue(spritetype *, XSPRITE *); static void entryFStatue(DBloodActor *);
static void entrySStatue(spritetype *, XSPRITE *); static void entrySStatue(DBloodActor *);
static void gargMoveForward(spritetype *, XSPRITE *); static void gargMoveForward(DBloodActor *);
static void gargMoveSlow(spritetype *, XSPRITE *); static void gargMoveSlow(DBloodActor *);
static void gargMoveSwoop(spritetype *, XSPRITE *); static void gargMoveSwoop(DBloodActor *);
static void gargMoveFly(spritetype *, XSPRITE *); static void gargMoveFly(DBloodActor *);
static void playStatueBreakSnd(spritetype*,XSPRITE*); static void playStatueBreakSnd(DBloodActor*);
AISTATE gargoyleFIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, gargThinkTarget, NULL }; AISTATE gargoyleFIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, gargThinkTarget, NULL };
AISTATE gargoyleStatueIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, NULL, NULL }; AISTATE gargoyleStatueIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, NULL, NULL };
@ -85,8 +86,9 @@ AISTATE gargoyleFDodgeDownLeft = { kAiStateMove, 0, -1, 90, NULL, gargMoveDodgeD
AISTATE statueFBreakSEQ = { kAiStateOther, 5, -1, 0, entryFStatue, NULL, playStatueBreakSnd, &gargoyleFMorph2}; AISTATE statueFBreakSEQ = { kAiStateOther, 5, -1, 0, entryFStatue, NULL, playStatueBreakSnd, &gargoyleFMorph2};
AISTATE statueSBreakSEQ = { kAiStateOther, 5, -1, 0, entrySStatue, NULL, playStatueBreakSnd, &gargoyleSMorph2}; AISTATE statueSBreakSEQ = { kAiStateOther, 5, -1, 0, entrySStatue, NULL, playStatueBreakSnd, &gargoyleSMorph2};
static void playStatueBreakSnd(spritetype* pSprite, XSPRITE* pXSprite) { static void playStatueBreakSnd(DBloodActor* actor) {
UNREFERENCED_PARAMETER(pXSprite); auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiPlay3DSound(pSprite, 313, AI_SFX_PRIORITY_1, -1); aiPlay3DSound(pSprite, 313, AI_SFX_PRIORITY_1, -1);
} }
@ -222,8 +224,10 @@ void ThrowSSeqCallback(int, int nXSprite)
actFireThing(pSprite, 0, 0, gDudeSlope[nXSprite]-7500, kThingBone, Chance(0x6000) ? 0x133333 : 0x111111); actFireThing(pSprite, 0, 0, gDudeSlope[nXSprite]-7500, kThingBone, Chance(0x6000) ? 0x133333 : 0x111111);
} }
static void gargThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void gargThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -264,13 +268,13 @@ static void gargThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -279,14 +283,18 @@ static void gargThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void gargThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void gargThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
sub_5F15C(pSprite, pXSprite); sub_5F15C(pSprite, pXSprite);
} }
static void gargThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void gargThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -300,12 +308,13 @@ static void gargThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &gargoyleFSearch); aiNewState(pSprite, pXSprite, &gargoyleFSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void gargMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveDodgeUp(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -317,8 +326,8 @@ static void gargMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -326,14 +335,15 @@ static void gargMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x1d555; actor->zvel() = -0x1d555;
} }
static void gargMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveDodgeDown(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -347,8 +357,8 @@ static void gargMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -356,13 +366,15 @@ static void gargMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
} }
static void gargThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void gargThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &gargoyleFGoto); aiNewState(pSprite, pXSprite, &gargoyleFGoto);
@ -541,23 +553,28 @@ static void gargThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void entryFStatue(spritetype *pSprite, XSPRITE *pXSprite) static void entryFStatue(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
DUDEINFO *pDudeInfo = &dudeInfo[6]; DUDEINFO *pDudeInfo = &dudeInfo[6];
actHealDude(pXSprite, pDudeInfo->startHealth, pDudeInfo->startHealth); actHealDude(pXSprite, pDudeInfo->startHealth, pDudeInfo->startHealth);
pSprite->type = kDudeGargoyleFlesh; pSprite->type = kDudeGargoyleFlesh;
} }
static void entrySStatue(spritetype *pSprite, XSPRITE *pXSprite) static void entrySStatue(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
DUDEINFO *pDudeInfo = &dudeInfo[7]; DUDEINFO *pDudeInfo = &dudeInfo[7];
actHealDude(pXSprite, pDudeInfo->startHealth, pDudeInfo->startHealth); actHealDude(pXSprite, pDudeInfo->startHealth, pDudeInfo->startHealth);
pSprite->type = kDudeGargoyleStone; pSprite->type = kDudeGargoyleStone;
} }
static void gargMoveForward(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -579,21 +596,22 @@ static void gargMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void gargMoveSlow(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveSlow(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -616,27 +634,28 @@ static void gargMoveSlow(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 = nAccel>>1; t1 = nAccel>>1;
t2 >>= 1; t2 >>= 1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudeGargoyleFlesh: case kDudeGargoyleFlesh:
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
break; break;
case kDudeGargoyleStone: case kDudeGargoyleStone:
zvel[nSprite] = 0x35555; actor->zvel() = 0x35555;
break; break;
} }
} }
static void gargMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveSwoop(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -659,26 +678,27 @@ static void gargMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudeGargoyleFlesh: case kDudeGargoyleFlesh:
zvel[nSprite] = t1; actor->zvel() = t1;
break; break;
case kDudeGargoyleStone: case kDudeGargoyleStone:
zvel[nSprite] = t1; actor->zvel() = t1;
break; break;
} }
} }
static void gargMoveFly(spritetype *pSprite, XSPRITE *pXSprite) static void gargMoveFly(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -701,22 +721,22 @@ static void gargMoveFly(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudeGargoyleFlesh: case kDudeGargoyleFlesh:
zvel[nSprite] = -t1; actor->zvel() = -t1;
break; break;
case kDudeGargoyleStone: case kDudeGargoyleStone:
zvel[nSprite] = -t1; actor->zvel() = -t1;
break; break;
} }
klabs(zvel[nSprite]); klabs(actor->zvel());
} }
END_BLD_NS END_BLD_NS

131
source/blood/src/aighost.cpp
View file

@ -41,19 +41,20 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "nnexts.h" #include "nnexts.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void ghostThinkTarget(spritetype *, XSPRITE *); static void ghostThinkTarget(DBloodActor *);
static void ghostThinkSearch(spritetype *, XSPRITE *); static void ghostThinkSearch(DBloodActor *);
static void ghostThinkGoto(spritetype *, XSPRITE *); static void ghostThinkGoto(DBloodActor *);
static void ghostMoveDodgeUp(spritetype *, XSPRITE *); static void ghostMoveDodgeUp(DBloodActor *);
static void ghostMoveDodgeDown(spritetype *, XSPRITE *); static void ghostMoveDodgeDown(DBloodActor *);
static void ghostThinkChase(spritetype *, XSPRITE *); static void ghostThinkChase(DBloodActor *);
static void ghostMoveForward(spritetype *, XSPRITE *); static void ghostMoveForward(DBloodActor *);
static void ghostMoveSlow(spritetype *, XSPRITE *); static void ghostMoveSlow(DBloodActor *);
static void ghostMoveSwoop(spritetype *, XSPRITE *); static void ghostMoveSwoop(DBloodActor *);
static void ghostMoveFly(spritetype *, XSPRITE *); static void ghostMoveFly(DBloodActor *);
AISTATE ghostIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, ghostThinkTarget, NULL }; AISTATE ghostIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, ghostThinkTarget, NULL };
@ -199,8 +200,10 @@ void ghostBlastSeqCallback(int, int nXSprite)
#endif #endif
} }
static void ghostThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void ghostThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -241,28 +244,32 @@ static void ghostThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
pDudeExtraE->xval2 = 0; pDudeExtraE->xval2 = 0;
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
} }
} }
} }
static void ghostThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void ghostThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void ghostThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void ghostThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -276,11 +283,13 @@ static void ghostThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &ghostSearch); aiNewState(pSprite, pXSprite, &ghostSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void ghostMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveDodgeUp(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
@ -293,8 +302,8 @@ static void ghostMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047; pSprite->ang = (pSprite->ang+ClipRange(nAng, -nTurnRange, nTurnRange))&2047;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -302,13 +311,15 @@ static void ghostMoveDodgeUp(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -0x1d555; actor->zvel() = -0x1d555;
} }
static void ghostMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveDodgeDown(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
@ -323,8 +334,8 @@ static void ghostMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int dx = xvel[nSprite]; int dx = actor->xvel();
int dy = yvel[nSprite]; int dy = actor->yvel();
int t1 = dmulscale30(dx, nCos, dy, nSin); int t1 = dmulscale30(dx, nCos, dy, nSin);
int t2 = dmulscale30(dx, nSin, -dy, nCos); int t2 = dmulscale30(dx, nSin, -dy, nCos);
if (pXSprite->dodgeDir > 0) if (pXSprite->dodgeDir > 0)
@ -332,13 +343,15 @@ static void ghostMoveDodgeDown(spritetype *pSprite, XSPRITE *pXSprite)
else else
t2 -= pDudeInfo->sideSpeed; t2 -= pDudeInfo->sideSpeed;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
} }
static void ghostThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void ghostThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &ghostGoto); aiNewState(pSprite, pXSprite, &ghostGoto);
@ -449,9 +462,10 @@ static void ghostThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void ghostMoveForward(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveForward(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -473,21 +487,22 @@ static void ghostMoveForward(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void ghostMoveSlow(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveSlow(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -510,24 +525,25 @@ static void ghostMoveSlow(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 = nAccel>>1; t1 = nAccel>>1;
t2 >>= 1; t2 >>= 1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudePhantasm: case kDudePhantasm:
zvel[nSprite] = 0x44444; actor->zvel() = 0x44444;
break; break;
} }
} }
static void ghostMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveSwoop(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -550,23 +566,24 @@ static void ghostMoveSwoop(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudePhantasm: case kDudePhantasm:
zvel[nSprite] = t1; actor->zvel() = t1;
break; break;
} }
} }
static void ghostMoveFly(spritetype *pSprite, XSPRITE *pXSprite) static void ghostMoveFly(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -589,16 +606,16 @@ static void ghostMoveFly(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
switch (pSprite->type) { switch (pSprite->type) {
case kDudePhantasm: case kDudePhantasm:
zvel[nSprite] = -t1; actor->zvel() = -t1;
break; break;
} }
} }

85
source/blood/src/aigilbst.cpp
View file

@ -39,17 +39,18 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void gillThinkSearch(spritetype *, XSPRITE *); static void gillThinkSearch(DBloodActor *);
static void gillThinkGoto(spritetype *, XSPRITE *); static void gillThinkGoto(DBloodActor *);
static void gillThinkChase(spritetype *, XSPRITE *); static void gillThinkChase(DBloodActor *);
static void gillThinkSwimGoto(spritetype *, XSPRITE *); static void gillThinkSwimGoto(DBloodActor *);
static void gillThinkSwimChase(spritetype *, XSPRITE *); static void gillThinkSwimChase(DBloodActor *);
static void sub_6CB00(spritetype *, XSPRITE *); static void sub_6CB00(DBloodActor *);
static void sub_6CD74(spritetype *, XSPRITE *); static void sub_6CD74(DBloodActor *);
static void sub_6D03C(spritetype *, XSPRITE *); static void sub_6D03C(DBloodActor *);
AISTATE gillBeastIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE gillBeastIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
@ -86,14 +87,18 @@ void GillBiteSeqCallback(int, int nXSprite)
actFireVector(pSprite, 0, 0, dx, dy, dz, VECTOR_TYPE_8); actFireVector(pSprite, 0, 0, dx, dy, dz, VECTOR_TYPE_8);
} }
static void gillThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void gillThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void gillThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void gillThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
XSECTOR *pXSector; XSECTOR *pXSector;
@ -114,11 +119,13 @@ static void gillThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
else else
aiNewState(pSprite, pXSprite, &gillBeastSearch); aiNewState(pSprite, pXSprite, &gillBeastSearch);
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void gillThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void gillThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
XSECTOR *pXSector; XSECTOR *pXSector;
@ -241,8 +248,10 @@ static void gillThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void gillThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite) static void gillThinkSwimGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -252,11 +261,13 @@ static void gillThinkSwimGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &gillBeastSwimSearch); aiNewState(pSprite, pXSprite, &gillBeastSwimSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void gillThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite) static void gillThinkSwimChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &gillBeastSwimSearch); aiNewState(pSprite, pXSprite, &gillBeastSwimSearch);
@ -309,8 +320,10 @@ static void gillThinkSwimChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void sub_6CB00(spritetype *pSprite, XSPRITE *pXSprite) static void sub_6CB00(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int nSprite = pSprite->index; int nSprite = pSprite->index;
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
@ -329,21 +342,22 @@ static void sub_6CB00(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
if (pXSprite->target == -1) if (pXSprite->target == -1)
t1 += nAccel; t1 += nAccel;
else else
t1 += nAccel>>2; t1 += nAccel>>2;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
} }
static void sub_6CD74(spritetype *pSprite, XSPRITE *pXSprite) static void sub_6CD74(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
spritetype *pTarget = &sprite[pXSprite->target]; spritetype *pTarget = &sprite[pXSprite->target];
@ -366,19 +380,20 @@ static void sub_6CD74(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel; t1 += nAccel;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = -dz; actor->zvel() = -dz;
} }
static void sub_6D03C(spritetype *pSprite, XSPRITE *pXSprite) static void sub_6D03C(DBloodActor* actor)
{ {
int nSprite = pSprite->index; auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
spritetype *pTarget = &sprite[pXSprite->target]; spritetype *pTarget = &sprite[pXSprite->target];
@ -401,14 +416,14 @@ static void sub_6D03C(spritetype *pSprite, XSPRITE *pXSprite)
return; return;
int nCos = Cos(pSprite->ang); int nCos = Cos(pSprite->ang);
int nSin = Sin(pSprite->ang); int nSin = Sin(pSprite->ang);
int vx = xvel[nSprite]; int vx = actor->xvel();
int vy = yvel[nSprite]; int vy = actor->yvel();
int t1 = dmulscale30(vx, nCos, vy, nSin); int t1 = dmulscale30(vx, nCos, vy, nSin);
int t2 = dmulscale30(vx, nSin, -vy, nCos); int t2 = dmulscale30(vx, nSin, -vy, nCos);
t1 += nAccel>>1; t1 += nAccel>>1;
xvel[nSprite] = dmulscale30(t1, nCos, t2, nSin); actor->xvel() = dmulscale30(t1, nCos, t2, nSin);
yvel[nSprite] = dmulscale30(t1, nSin, -t2, nCos); actor->yvel() = dmulscale30(t1, nSin, -t2, nCos);
zvel[nSprite] = dz; actor->zvel() = dz;
} }
END_BLD_NS END_BLD_NS

23
source/blood/src/aihand.cpp
View file

@ -39,12 +39,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void handThinkSearch(spritetype *, XSPRITE *); static void handThinkSearch(DBloodActor *);
static void handThinkGoto(spritetype *, XSPRITE *); static void handThinkGoto(DBloodActor *);
static void handThinkChase(spritetype *, XSPRITE *); static void handThinkChase(DBloodActor *);
AISTATE handIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE handIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE hand13A3B4 = { kAiStateOther, 0, -1, 0, NULL, NULL, NULL, NULL }; AISTATE hand13A3B4 = { kAiStateOther, 0, -1, 0, NULL, NULL, NULL, NULL };
@ -71,14 +72,18 @@ void HandJumpSeqCallback(int, int nXSprite)
} }
} }
static void handThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void handThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void handThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void handThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -88,11 +93,13 @@ static void handThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &handSearch); aiNewState(pSprite, pXSprite, &handSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void handThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void handThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &handGoto); aiNewState(pSprite, pXSprite, &handGoto);

23
source/blood/src/aihound.cpp
View file

@ -41,12 +41,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "nnexts.h" #include "nnexts.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void houndThinkSearch(spritetype *, XSPRITE *); static void houndThinkSearch(DBloodActor *);
static void houndThinkGoto(spritetype *, XSPRITE *); static void houndThinkGoto(DBloodActor *);
static void houndThinkChase(spritetype *, XSPRITE *); static void houndThinkChase(DBloodActor *);
AISTATE houndIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE houndIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE houndSearch = { kAiStateMove, 8, -1, 1800, NULL, aiMoveForward, houndThinkSearch, &houndIdle }; AISTATE houndSearch = { kAiStateMove, 8, -1, 1800, NULL, aiMoveForward, houndThinkSearch, &houndIdle };
@ -93,14 +94,18 @@ void houndBurnSeqCallback(int, int nXSprite)
actFireMissile(pSprite, 0, 0, CosScale16(pSprite->ang), SinScale16(pSprite->ang), 0, kMissileFlameHound); actFireMissile(pSprite, 0, 0, CosScale16(pSprite->ang), SinScale16(pSprite->ang), 0, kMissileFlameHound);
} }
static void houndThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void houndThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void houndThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void houndThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -115,11 +120,13 @@ static void houndThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &houndSearch); aiNewState(pSprite, pXSprite, &houndSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void houndThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void houndThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &houndGoto); aiNewState(pSprite, pXSprite, &houndGoto);

23
source/blood/src/aiinnoc.cpp
View file

@ -39,12 +39,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void innocThinkSearch(spritetype *, XSPRITE *); static void innocThinkSearch(DBloodActor *);
static void innocThinkGoto(spritetype *, XSPRITE *); static void innocThinkGoto(DBloodActor *);
static void innocThinkChase(spritetype *, XSPRITE *); static void innocThinkChase(DBloodActor *);
AISTATE innocentIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE innocentIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE innocentSearch = { kAiStateSearch, 6, -1, 1800, NULL, aiMoveForward, innocThinkSearch, &innocentIdle }; AISTATE innocentSearch = { kAiStateSearch, 6, -1, 1800, NULL, aiMoveForward, innocThinkSearch, &innocentIdle };
@ -53,14 +54,18 @@ AISTATE innocentRecoil = { kAiStateRecoil, 5, -1, 0, NULL, NULL, NULL, &innocent
AISTATE innocentTeslaRecoil = { kAiStateRecoil, 4, -1, 0, NULL, NULL, NULL, &innocentChase }; AISTATE innocentTeslaRecoil = { kAiStateRecoil, 4, -1, 0, NULL, NULL, NULL, &innocentChase };
AISTATE innocentGoto = { kAiStateMove, 6, -1, 600, NULL, aiMoveForward, innocThinkGoto, &innocentIdle }; AISTATE innocentGoto = { kAiStateMove, 6, -1, 600, NULL, aiMoveForward, innocThinkGoto, &innocentIdle };
static void innocThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void innocThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void innocThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void innocThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -70,11 +75,13 @@ static void innocThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &innocentSearch); aiNewState(pSprite, pXSprite, &innocentSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void innocThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void innocThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &innocentGoto); aiNewState(pSprite, pXSprite, &innocentGoto);

23
source/blood/src/aipod.cpp
View file

@ -41,12 +41,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void aiPodSearch(spritetype *, XSPRITE *); static void aiPodSearch(DBloodActor* actor);
static void aiPodMove(spritetype *, XSPRITE *); static void aiPodMove(DBloodActor* actor);
static void aiPodChase(spritetype *, XSPRITE *); static void aiPodChase(DBloodActor* actor);
AISTATE podIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE podIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE podMove = { kAiStateMove, 7, -1, 3600, NULL, aiMoveTurn, aiPodMove, &podSearch }; AISTATE podMove = { kAiStateMove, 7, -1, 3600, NULL, aiMoveTurn, aiPodMove, &podSearch };
@ -160,14 +161,18 @@ void sub_70284(int, int nXSprite)
sub_2A620(nSprite, pSprite->x, pSprite->y, pSprite->z, pSprite->sectnum, nDist, 1, 5*(1+gGameOptions.nDifficulty), dmgType, 2, nBurn, 0, 0); sub_2A620(nSprite, pSprite->x, pSprite->y, pSprite->z, pSprite->sectnum, nDist, 1, 5*(1+gGameOptions.nDifficulty), dmgType, 2, nBurn, 0, 0);
} }
static void aiPodSearch(spritetype *pSprite, XSPRITE *pXSprite) static void aiPodSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void aiPodMove(spritetype *pSprite, XSPRITE *pXSprite) static void aiPodMove(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -192,11 +197,13 @@ static void aiPodMove(spritetype *pSprite, XSPRITE *pXSprite)
break; break;
} }
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void aiPodChase(spritetype *pSprite, XSPRITE *pXSprite) static void aiPodChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) { if (pXSprite->target == -1) {
switch (pSprite->type) { switch (pSprite->type) {
case kDudePodGreen: case kDudePodGreen:

23
source/blood/src/airat.cpp
View file

@ -39,12 +39,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void ratThinkSearch(spritetype *, XSPRITE *); static void ratThinkSearch(DBloodActor *);
static void ratThinkGoto(spritetype *, XSPRITE *); static void ratThinkGoto(DBloodActor *);
static void ratThinkChase(spritetype *, XSPRITE *); static void ratThinkChase(DBloodActor *);
AISTATE ratIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE ratIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE ratSearch = { kAiStateSearch, 7, -1, 1800, NULL, aiMoveForward, ratThinkSearch, &ratIdle }; AISTATE ratSearch = { kAiStateSearch, 7, -1, 1800, NULL, aiMoveForward, ratThinkSearch, &ratIdle };
@ -68,14 +69,18 @@ void ratBiteSeqCallback(int, int nXSprite)
actFireVector(pSprite, 0, 0, dx, dy, pTarget->z-pSprite->z, VECTOR_TYPE_16); actFireVector(pSprite, 0, 0, dx, dy, pTarget->z-pSprite->z, VECTOR_TYPE_16);
} }
static void ratThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void ratThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void ratThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void ratThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -85,11 +90,13 @@ static void ratThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &ratSearch); aiNewState(pSprite, pXSprite, &ratSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void ratThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void ratThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &ratGoto); aiNewState(pSprite, pXSprite, &ratGoto);

23
source/blood/src/aispid.cpp
View file

@ -40,12 +40,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void spidThinkSearch(spritetype *, XSPRITE *); static void spidThinkSearch(DBloodActor *);
static void spidThinkGoto(spritetype *, XSPRITE *); static void spidThinkGoto(DBloodActor *);
static void spidThinkChase(spritetype *, XSPRITE *); static void spidThinkChase(DBloodActor *);
AISTATE spidIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE spidIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
@ -190,14 +191,18 @@ void sub_71370(int, int nXSprite)
} }
static void spidThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void spidThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void spidThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void spidThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -207,11 +212,13 @@ static void spidThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &spidSearch); aiNewState(pSprite, pXSprite, &spidSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void spidThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void spidThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &spidGoto); aiNewState(pSprite, pXSprite, &spidGoto);

33
source/blood/src/aitchern.cpp
View file

@ -40,13 +40,14 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void sub_72580(spritetype *, XSPRITE *); static void sub_72580(DBloodActor *);
static void sub_725A4(spritetype *, XSPRITE *); static void sub_725A4(DBloodActor *);
static void sub_72850(spritetype *, XSPRITE *); static void sub_72850(DBloodActor *);
static void sub_72934(spritetype *, XSPRITE *); static void sub_72934(DBloodActor *);
AISTATE tchernobogIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, sub_725A4, NULL }; AISTATE tchernobogIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, sub_725A4, NULL };
@ -231,14 +232,18 @@ void sub_720AC(int, int nXSprite)
actFireMissile(pSprite, -350, 0, ax, ay, az, kMissileFireballTchernobog); actFireMissile(pSprite, -350, 0, ax, ay, az, kMissileFireballTchernobog);
} }
static void sub_72580(spritetype *pSprite, XSPRITE *pXSprite) static void sub_72580(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void sub_725A4(spritetype *pSprite, XSPRITE *pXSprite) static void sub_725A4(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -279,13 +284,13 @@ static void sub_725A4(spritetype *pSprite, XSPRITE *pXSprite)
{ {
pDudeExtraE->xval1 = 0; pDudeExtraE->xval1 = 0;
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
pDudeExtraE->xval1 = 0; pDudeExtraE->xval1 = 0;
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -294,8 +299,10 @@ static void sub_725A4(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void sub_72850(spritetype *pSprite, XSPRITE *pXSprite) static void sub_72850(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); ///assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
@ -309,11 +316,13 @@ static void sub_72850(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &tchernobogSearch); aiNewState(pSprite, pXSprite, &tchernobogSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void sub_72934(spritetype *pSprite, XSPRITE *pXSprite) static void sub_72934(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &tcherno13A9B8); aiNewState(pSprite, pXSprite, &tcherno13A9B8);

61
source/blood/src/aiunicult.cpp
View file

@ -50,15 +50,16 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "endgame.h" #include "endgame.h"
#include "view.h" #include "view.h"
#include "raze_sound.h" #include "raze_sound.h"
#include "bloodactor.h"
#include "gib.h" #include "gib.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void ThrowThing(int, bool); static void ThrowThing(int, bool);
static void unicultThinkSearch(spritetype*, XSPRITE*); static void unicultThinkSearch(DBloodActor*);
static void unicultThinkGoto(spritetype*, XSPRITE*); static void unicultThinkGoto(DBloodActor*);
static void unicultThinkChase(spritetype*, XSPRITE*); static void unicultThinkChase(DBloodActor*);
static void forcePunch(spritetype*, XSPRITE*); static void forcePunch(DBloodActor*);
AISTATE genDudeIdleL = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE genDudeIdleL = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
AISTATE genDudeIdleW = { kAiStateIdle, 13, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE genDudeIdleW = { kAiStateIdle, 13, -1, 0, NULL, NULL, aiThinkTarget, NULL };
@ -126,7 +127,10 @@ const GENDUDESND gCustomDudeSnd[] = {
GENDUDEEXTRA gGenDudeExtra[kMaxSprites]; // savegame handling in ai.cpp GENDUDEEXTRA gGenDudeExtra[kMaxSprites]; // savegame handling in ai.cpp
void forcePunch(spritetype* pSprite, XSPRITE*) { static void forcePunch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (gGenDudeExtra[pSprite->index].forcePunch && seqGetStatus(3, pSprite->extra) == -1) if (gGenDudeExtra[pSprite->index].forcePunch && seqGetStatus(3, pSprite->extra) == -1)
punchCallback(0,pSprite->extra); punchCallback(0,pSprite->extra);
} }
@ -242,7 +246,7 @@ void genDudeAttack1(int, int nXIndex) {
if (xspriRangeIsFine(pSpawned->extra)) { if (xspriRangeIsFine(pSpawned->extra)) {
xsprite[pSpawned->extra].target = pXSprite->target; xsprite[pSpawned->extra].target = pXSprite->target;
if (pXSprite->target > -1) if (pXSprite->target > -1)
aiActivateDude(pSpawned, &xsprite[pSpawned->extra]); aiActivateDude(&bloodActors[pSpawned->index]);
} }
gKillMgr.AddNewKill(1); gKillMgr.AddNewKill(1);
@ -377,8 +381,10 @@ static void ThrowThing(int nXIndex, bool impact) {
} }
} }
static void unicultThinkSearch( spritetype* pSprite, XSPRITE* pXSprite ) { static void unicultThinkSearch(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
// TO DO: if can't see the target, but in fireDist range - stop moving and look around // TO DO: if can't see the target, but in fireDist range - stop moving and look around
//viewSetSystemMessage("IN SEARCH"); //viewSetSystemMessage("IN SEARCH");
@ -386,8 +392,10 @@ static void unicultThinkSearch( spritetype* pSprite, XSPRITE* pXSprite ) {
sub_5F15C(pSprite, pXSprite); sub_5F15C(pSprite, pXSprite);
} }
static void unicultThinkGoto(spritetype* pSprite, XSPRITE* pXSprite) { static void unicultThinkGoto(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) { if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax)) {
Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax"); Printf(PRINT_HIGH, "pSprite->type >= kDudeBase && pSprite->type < kDudeMax");
return; return;
@ -404,11 +412,13 @@ static void unicultThinkGoto(spritetype* pSprite, XSPRITE* pXSprite) {
if (spriteIsUnderwater(pSprite, false)) aiGenDudeNewState(pSprite, &genDudeSearchW); if (spriteIsUnderwater(pSprite, false)) aiGenDudeNewState(pSprite, &genDudeSearchW);
else aiGenDudeNewState(pSprite, &genDudeSearchL); else aiGenDudeNewState(pSprite, &genDudeSearchL);
} }
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) { static void unicultThinkChase(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pSprite->type < kDudeBase || pSprite->type >= kDudeMax) return; if (pSprite->type < kDudeBase || pSprite->type >= kDudeMax) return;
else if (pXSprite->target < 0 || pXSprite->target >= kMaxSprites) { else if (pXSprite->target < 0 || pXSprite->target >= kMaxSprites) {
if(spriteIsUnderwater(pSprite,false)) aiGenDudeNewState(pSprite, &genDudeGotoW); if(spriteIsUnderwater(pSprite,false)) aiGenDudeNewState(pSprite, &genDudeGotoW);
@ -564,7 +574,7 @@ static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) {
return; return;
} else { } else {
int state = checkAttackState(pSprite, pXSprite); int state = checkAttackState(&bloodActors[pXSprite->reference]);
if (state == 1) aiGenDudeNewState(pSprite, &genDudeChaseW); if (state == 1) aiGenDudeNewState(pSprite, &genDudeChaseW);
else if (state == 2) { else if (state == 2) {
if (Chance(0x5000)) aiGenDudeNewState(pSprite, &genDudeChaseD); if (Chance(0x5000)) aiGenDudeNewState(pSprite, &genDudeChaseD);
@ -595,7 +605,7 @@ static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) {
aiGenDudeNewState(pSprite, &genDudePunch); aiGenDudeNewState(pSprite, &genDudePunch);
return; return;
} else { } else {
int state = checkAttackState(pSprite, pXSprite); int state = checkAttackState(&bloodActors[pXSprite->reference]);
if (state == 1) aiGenDudeNewState(pSprite, &genDudeChaseW); if (state == 1) aiGenDudeNewState(pSprite, &genDudeChaseW);
else if (state == 2) aiGenDudeNewState(pSprite, &genDudeChaseD); else if (state == 2) aiGenDudeNewState(pSprite, &genDudeChaseD);
else aiGenDudeNewState(pSprite, &genDudeChaseL); else aiGenDudeNewState(pSprite, &genDudeChaseL);
@ -605,7 +615,7 @@ static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) {
} else if (weaponType == kGenDudeWeaponMissile) { } else if (weaponType == kGenDudeWeaponMissile) {
// special handling for flame, explosive and life leech missiles // special handling for flame, explosive and life leech missiles
int state = checkAttackState(pSprite, pXSprite); int state = checkAttackState(&bloodActors[pXSprite->reference]);
switch (curWeapon) { switch (curWeapon) {
case kMissileLifeLeechRegular: case kMissileLifeLeechRegular:
// pickup life leech if it was thrown previously // pickup life leech if it was thrown previously
@ -653,7 +663,7 @@ static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) {
return; return;
} }
int state = checkAttackState(pSprite, pXSprite); int state = checkAttackState(&bloodActors[pXSprite->reference]);
int kAngle = (dudeIsMelee(pXSprite) || dist <= kGenDudeMaxMeleeDist) ? pDudeInfo->periphery : kGenDudeKlabsAng; int kAngle = (dudeIsMelee(pXSprite) || dist <= kGenDudeMaxMeleeDist) ? pDudeInfo->periphery : kGenDudeKlabsAng;
if (dist < vdist && klabs(losAngle) < kAngle) { if (dist < vdist && klabs(losAngle) < kAngle) {
@ -907,8 +917,10 @@ static void unicultThinkChase( spritetype* pSprite, XSPRITE* pXSprite ) {
} }
int checkAttackState(spritetype* pSprite, XSPRITE* pXSprite) { int checkAttackState(DBloodActor* actor)
UNREFERENCED_PARAMETER(pXSprite); {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (dudeIsPlayingSeq(pSprite, 14) || spriteIsUnderwater(pSprite,false)) if (dudeIsPlayingSeq(pSprite, 14) || spriteIsUnderwater(pSprite,false))
{ {
if ( !dudeIsPlayingSeq(pSprite, 14) || spriteIsUnderwater(pSprite,false)) if ( !dudeIsPlayingSeq(pSprite, 14) || spriteIsUnderwater(pSprite,false))
@ -965,7 +977,10 @@ int getGenDudeMoveSpeed(spritetype* pSprite,int which, bool mul, bool shift) {
return speed; return speed;
} }
void aiGenDudeMoveForward(spritetype* pSprite, XSPRITE* pXSprite ) { void aiGenDudeMoveForward(DBloodActor* actor)
{
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
GENDUDEEXTRA* pExtra = &gGenDudeExtra[pSprite->index]; GENDUDEEXTRA* pExtra = &gGenDudeExtra[pSprite->index];
int maxTurn = pDudeInfo->angSpeed * 4 >> 4; int maxTurn = pDudeInfo->angSpeed * 4 >> 4;
@ -1103,7 +1118,7 @@ void aiGenDudeNewState(spritetype* pSprite, AISTATE* pAIState) {
} }
if (pAIState->enterFunc) if (pAIState->enterFunc)
pAIState->enterFunc(pSprite, pXSprite); pAIState->enterFunc(&bloodActors[pXSprite->reference]);
} }
@ -1785,7 +1800,7 @@ void genDudeTransform(spritetype* pSprite) {
else aiSetTarget(pXSprite, target); else aiSetTarget(pXSprite, target);
// finally activate it // finally activate it
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
break; break;
} }
@ -1818,7 +1833,7 @@ void updateTargetOfLeech(spritetype* pSprite) {
if (pXDude->target < 0 && spriRangeIsFine(pXLeech->target)) { if (pXDude->target < 0 && spriRangeIsFine(pXLeech->target)) {
aiSetTarget(pXDude, pXLeech->target); aiSetTarget(pXDude, pXLeech->target);
if (inIdle(pXDude->aiState)) if (inIdle(pXDude->aiState))
aiActivateDude(pSprite, pXDude); aiActivateDude(&bloodActors[pXDude->reference]);
} else { } else {
pXLeech->target = pXDude->target; pXLeech->target = pXDude->target;
} }

4
source/blood/src/aiunicult.h
View file

@ -203,11 +203,11 @@ void removeDudeStuff(spritetype* pSprite);
spritetype* leechIsDropped(spritetype* pSprite); spritetype* leechIsDropped(spritetype* pSprite);
bool spriteIsUnderwater(spritetype* pSprite, bool oldWay = false); bool spriteIsUnderwater(spritetype* pSprite, bool oldWay = false);
bool playGenDudeSound(spritetype* pSprite, int mode); bool playGenDudeSound(spritetype* pSprite, int mode);
void aiGenDudeMoveForward(spritetype* pSprite, XSPRITE* pXSprite); void aiGenDudeMoveForward(DBloodActor* actor);
void aiGenDudeChooseDirection(spritetype* pSprite, XSPRITE* pXSprite, int a3, int aXvel = -1, int aYvel = -1); void aiGenDudeChooseDirection(spritetype* pSprite, XSPRITE* pXSprite, int a3, int aXvel = -1, int aYvel = -1);
void aiGenDudeNewState(spritetype* pSprite, AISTATE* pAIState); void aiGenDudeNewState(spritetype* pSprite, AISTATE* pAIState);
int getGenDudeMoveSpeed(spritetype* pSprite, int which, bool mul, bool shift); int getGenDudeMoveSpeed(spritetype* pSprite, int which, bool mul, bool shift);
int checkAttackState(spritetype* pSprite, XSPRITE* pXSprite); int checkAttackState(DBloodActor* actor);
bool doExplosion(spritetype* pSprite, int nType); bool doExplosion(spritetype* pSprite, int nType);
spritetype* genDudeSpawn(spritetype* pSprite, int nDist); spritetype* genDudeSpawn(spritetype* pSprite, int nDist);
void genDudeTransform(spritetype* pSprite); void genDudeTransform(spritetype* pSprite);

64
source/blood/src/aizomba.cpp
View file

@ -40,18 +40,19 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void zombaThinkSearch(spritetype *, XSPRITE *); static void zombaThinkSearch(DBloodActor *);
static void zombaThinkGoto(spritetype *, XSPRITE *); static void zombaThinkGoto(DBloodActor *);
static void zombaThinkChase(spritetype *, XSPRITE *); static void zombaThinkChase(DBloodActor *);
static void zombaThinkPonder(spritetype *, XSPRITE *); static void zombaThinkPonder(DBloodActor *);
static void myThinkTarget(spritetype *, XSPRITE *); static void myThinkTarget(DBloodActor *);
static void myThinkSearch(spritetype *, XSPRITE *); static void myThinkSearch(DBloodActor *);
static void entryEZombie(spritetype *, XSPRITE *); static void entryEZombie(DBloodActor *);
static void entryAIdle(spritetype *, XSPRITE *); static void entryAIdle(DBloodActor *);
static void entryEStand(spritetype *, XSPRITE *); static void entryEStand(DBloodActor *);
AISTATE zombieAIdle = { kAiStateIdle, 0, -1, 0, entryAIdle, NULL, aiThinkTarget, NULL }; AISTATE zombieAIdle = { kAiStateIdle, 0, -1, 0, entryAIdle, NULL, aiThinkTarget, NULL };
@ -99,14 +100,18 @@ void StandSeqCallback(int, int nXSprite)
sfxPlay3DSound(&sprite[nSprite], 1102, -1, 0); sfxPlay3DSound(&sprite[nSprite], 1102, -1, 0);
} }
static void zombaThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void zombaThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
sub_5F15C(pSprite, pXSprite); sub_5F15C(pSprite, pXSprite);
} }
static void zombaThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void zombaThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -116,11 +121,13 @@ static void zombaThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 921 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 921 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &zombieASearch); aiNewState(pSprite, pXSprite, &zombieASearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void zombaThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void zombaThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &zombieASearch); aiNewState(pSprite, pXSprite, &zombieASearch);
@ -169,8 +176,10 @@ static void zombaThinkChase(spritetype *pSprite, XSPRITE *pXSprite)
pXSprite->target = -1; pXSprite->target = -1;
} }
static void zombaThinkPonder(spritetype *pSprite, XSPRITE *pXSprite) static void zombaThinkPonder(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &zombieASearch); aiNewState(pSprite, pXSprite, &zombieASearch);
@ -220,8 +229,10 @@ static void zombaThinkPonder(spritetype *pSprite, XSPRITE *pXSprite)
aiNewState(pSprite, pXSprite, &zombieAChase); aiNewState(pSprite, pXSprite, &zombieAChase);
} }
static void myThinkTarget(spritetype *pSprite, XSPRITE *pXSprite) static void myThinkTarget(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
@ -245,12 +256,12 @@ static void myThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery) if (nDist < pDudeInfo->seeDist && klabs(nDeltaAngle) <= pDudeInfo->periphery)
{ {
aiSetTarget(pXSprite, pPlayer->nSprite); aiSetTarget(pXSprite, pPlayer->nSprite);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else if (nDist < pDudeInfo->hearDist) else if (nDist < pDudeInfo->hearDist)
{ {
aiSetTarget(pXSprite, x, y, z); aiSetTarget(pXSprite, x, y, z);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
} }
else else
continue; continue;
@ -258,27 +269,32 @@ static void myThinkTarget(spritetype *pSprite, XSPRITE *pXSprite)
} }
} }
static void myThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void myThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
myThinkTarget(pSprite, pXSprite); myThinkTarget(actor);
} }
static void entryEZombie(spritetype *pSprite, XSPRITE *pXSprite) static void entryEZombie(DBloodActor* actor)
{ {
UNREFERENCED_PARAMETER(pXSprite); auto pXSprite = &actor->x();
auto pSprite = &actor->s();
pSprite->type = kDudeZombieAxeNormal; pSprite->type = kDudeZombieAxeNormal;
pSprite->flags |= 1; pSprite->flags |= 1;
} }
static void entryAIdle(spritetype *pSprite, XSPRITE *pXSprite) static void entryAIdle(DBloodActor* actor)
{ {
UNREFERENCED_PARAMETER(pSprite); auto pXSprite = &actor->x();
pXSprite->target = -1; pXSprite->target = -1;
} }
static void entryEStand(spritetype *pSprite, XSPRITE *pXSprite) static void entryEStand(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
sfxPlay3DSound(pSprite, 1100, -1, 0); sfxPlay3DSound(pSprite, 1100, -1, 0);
pSprite->ang = getangle(pXSprite->targetX-pSprite->x, pXSprite->targetY-pSprite->y); pSprite->ang = getangle(pXSprite->targetX-pSprite->x, pXSprite->targetY-pSprite->y);
} }

23
source/blood/src/aizombf.cpp
View file

@ -39,12 +39,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "player.h" #include "player.h"
#include "seq.h" #include "seq.h"
#include "sound.h" #include "sound.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
static void zombfThinkSearch(spritetype *pSprite, XSPRITE *pXSprite); static void zombfThinkSearch(DBloodActor *actor);
static void zombfThinkGoto(spritetype *pSprite, XSPRITE *pXSprite); static void zombfThinkGoto(DBloodActor *actor);
static void zombfThinkChase(spritetype *pSprite, XSPRITE *pXSprite); static void zombfThinkChase(DBloodActor *actor);
AISTATE zombieFIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL }; AISTATE zombieFIdle = { kAiStateIdle, 0, -1, 0, NULL, NULL, aiThinkTarget, NULL };
@ -104,14 +105,18 @@ void ThrowSeqCallback(int, int nXSprite)
actFireMissile(pSprite, 0, -getDudeInfo(pSprite->type)->eyeHeight, CosScale16(pSprite->ang), SinScale16(pSprite->ang), 0, kMissileButcherKnife); actFireMissile(pSprite, 0, -getDudeInfo(pSprite->type)->eyeHeight, CosScale16(pSprite->ang), SinScale16(pSprite->ang), 0, kMissileButcherKnife);
} }
static void zombfThinkSearch(spritetype *pSprite, XSPRITE *pXSprite) static void zombfThinkSearch(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng); aiChooseDirection(pSprite, pXSprite, pXSprite->goalAng);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void zombfThinkGoto(spritetype *pSprite, XSPRITE *pXSprite) static void zombfThinkGoto(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax); assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type); DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX-pSprite->x; int dx = pXSprite->targetX-pSprite->x;
@ -121,11 +126,13 @@ static void zombfThinkGoto(spritetype *pSprite, XSPRITE *pXSprite)
aiChooseDirection(pSprite, pXSprite, nAngle); aiChooseDirection(pSprite, pXSprite, nAngle);
if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery) if (nDist < 512 && klabs(pSprite->ang - nAngle) < pDudeInfo->periphery)
aiNewState(pSprite, pXSprite, &zombieFSearch); aiNewState(pSprite, pXSprite, &zombieFSearch);
aiThinkTarget(pSprite, pXSprite); aiThinkTarget(actor);
} }
static void zombfThinkChase(spritetype *pSprite, XSPRITE *pXSprite) static void zombfThinkChase(DBloodActor* actor)
{ {
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
if (pXSprite->target == -1) if (pXSprite->target == -1)
{ {
aiNewState(pSprite, pXSprite, &zombieFGoto); aiNewState(pSprite, pXSprite, &zombieFGoto);

2
source/blood/src/bloodactor.h
View file

@ -10,7 +10,7 @@
BEGIN_BLD_NS BEGIN_BLD_NS
// Due to the messed up array storage of all the game data we cannot do any direct referenced here yet. We have to access everything via wrapper functions for now. // Due to the messed up array storage of all the game data we cannot do any direct references here yet. We have to access everything via wrapper functions for now.
// Note that the indexing is very inconsistent - partially by sprite index, partially by xsprite index. // Note that the indexing is very inconsistent - partially by sprite index, partially by xsprite index.
class DBloodActor class DBloodActor
{ {

29
source/blood/src/nnexts.cpp
View file

@ -45,6 +45,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "seq.h" #include "seq.h"
#include "ai.h" #include "ai.h"
#include "savegamehelp.h" #include "savegamehelp.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
@ -2123,7 +2124,7 @@ void useTeleportTarget(XSPRITE* pXSource, spritetype* pSprite) {
if (target >= 0) { if (target >= 0) {
pXDude->targetX = x; pXDude->targetY = y; pXDude->targetZ = z; pXDude->targetX = x; pXDude->targetY = y; pXDude->targetZ = z;
pXDude->target = target; aiActivateDude(pSprite, pXDude); pXDude->target = target; aiActivateDude(&bloodActors[pXDude->reference]);
} }
} }
@ -3612,7 +3613,7 @@ void aiFightAlarmDudesInSight(spritetype* pSprite, int max) {
continue; continue;
aiSetTarget(pXDude, pDude->x, pDude->y, pDude->z); aiSetTarget(pXDude, pDude->x, pDude->y, pDude->z);
aiActivateDude(pDude, pXDude); aiActivateDude(&bloodActors[pXDude->reference]);
if (max-- < 1) if (max-- < 1)
break; break;
} }
@ -3696,7 +3697,7 @@ bool modernTypeOperateSprite(int nSprite, spritetype* pSprite, XSPRITE* pXSprite
switch (pXSprite->aiState->stateType) { switch (pXSprite->aiState->stateType) {
case kAiStateIdle: case kAiStateIdle:
case kAiStateGenIdle: case kAiStateGenIdle:
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
break; break;
} }
break; break;
@ -3735,10 +3736,10 @@ bool modernTypeOperateSprite(int nSprite, spritetype* pSprite, XSPRITE* pXSprite
pXSpawn->health = getDudeInfo(pXSprite->data1)->startHealth << 4; pXSpawn->health = getDudeInfo(pXSprite->data1)->startHealth << 4;
pXSpawn->burnTime = 10; pXSpawn->burnTime = 10;
pXSpawn->target = -1; pXSpawn->target = -1;
aiActivateDude(pSpawn, pXSpawn); aiActivateDude(&bloodActors[pXSpawn->reference]);
break; break;
default: default:
if (pSprite->flags & kModernTypeFlag3) aiActivateDude(pSpawn, pXSpawn); if (pSprite->flags & kModernTypeFlag3) aiActivateDude(&bloodActors[pXSpawn->reference]);
break; break;
} }
} }
@ -4635,7 +4636,7 @@ void useTargetChanger(XSPRITE* pXSource, spritetype* pSprite) {
int mDist = 3; if (aiFightIsMeleeUnit(pSprite)) mDist = 2; int mDist = 3; if (aiFightIsMeleeUnit(pSprite)) mDist = 2;
if (pXSprite->target >= 0 && aiFightGetTargetDist(pSprite, pDudeInfo, &sprite[pXSprite->target]) < mDist) { if (pXSprite->target >= 0 && aiFightGetTargetDist(pSprite, pDudeInfo, &sprite[pXSprite->target]) < mDist) {
if (!isActive(pSprite->index)) aiActivateDude(pSprite, pXSprite); if (!isActive(pSprite->index)) aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
// lets try to look for target that fits better by distance // lets try to look for target that fits better by distance
@ -4649,19 +4650,19 @@ void useTargetChanger(XSPRITE* pXSource, spritetype* pSprite) {
spritetype* prvTarget = &sprite[pXSprite->target]; spritetype* prvTarget = &sprite[pXSprite->target];
aiSetTarget(&xsprite[prvTarget->extra], prvTarget->x, prvTarget->y, prvTarget->z); aiSetTarget(&xsprite[prvTarget->extra], prvTarget->x, prvTarget->y, prvTarget->z);
if (!isActive(pTarget->index)) if (!isActive(pTarget->index))
aiActivateDude(pTarget, pXTarget); aiActivateDude(&bloodActors[pXTarget->reference]);
} }
// Change target for dude // Change target for dude
aiSetTarget(pXSprite, pTarget->index); aiSetTarget(pXSprite, pTarget->index);
if (!isActive(pSprite->index)) if (!isActive(pSprite->index))
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
// ...and change target of target to dude to force it fight // ...and change target of target to dude to force it fight
if (pXSource->data3 > 0 && pXTarget->target != pSprite->index) { if (pXSource->data3 > 0 && pXTarget->target != pSprite->index) {
aiSetTarget(pXTarget, pSprite->index); aiSetTarget(pXTarget, pSprite->index);
if (!isActive(pTarget->index)) if (!isActive(pTarget->index))
aiActivateDude(pTarget, pXTarget); aiActivateDude(&bloodActors[pXTarget->reference]);
} }
return; return;
@ -4697,13 +4698,13 @@ void useTargetChanger(XSPRITE* pXSource, spritetype* pSprite) {
// Change target for dude // Change target for dude
aiSetTarget(pXSprite, pTarget->index); aiSetTarget(pXSprite, pTarget->index);
if (!isActive(pSprite->index)) if (!isActive(pSprite->index))
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
// ...and change target of target to dude to force it fight // ...and change target of target to dude to force it fight
if (pXSource->data3 > 0 && pXTarget->target != pSprite->index) { if (pXSource->data3 > 0 && pXTarget->target != pSprite->index) {
aiSetTarget(pXTarget, pSprite->index); aiSetTarget(pXTarget, pSprite->index);
if (pPlayer == NULL && !isActive(pTarget->index)) if (pPlayer == NULL && !isActive(pTarget->index))
aiActivateDude(pTarget, pXTarget); aiActivateDude(&bloodActors[pXTarget->reference]);
if (pXSource->data3 == 2) if (pXSource->data3 == 2)
aiFightAlarmDudesInSight(pTarget, maxAlarmDudes); aiFightAlarmDudesInSight(pTarget, maxAlarmDudes);
@ -4725,12 +4726,12 @@ void useTargetChanger(XSPRITE* pXSource, spritetype* pSprite) {
if (pXMateTarget->target < 0) { if (pXMateTarget->target < 0) {
aiSetTarget(pXMateTarget, pSprite->index); aiSetTarget(pXMateTarget, pSprite->index);
if (IsDudeSprite(pMateTarget) && !isActive(pMateTarget->index)) if (IsDudeSprite(pMateTarget) && !isActive(pMateTarget->index))
aiActivateDude(pMateTarget, pXMateTarget); aiActivateDude(&bloodActors[pXMateTarget->reference]);
} }
aiSetTarget(pXSprite, pMateTarget->index); aiSetTarget(pXSprite, pMateTarget->index);
if (!isActive(pSprite->index)) if (!isActive(pSprite->index))
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
// try walk in mate direction in case if not see the target // try walk in mate direction in case if not see the target
@ -4741,7 +4742,7 @@ void useTargetChanger(XSPRITE* pXSource, spritetype* pSprite) {
pXSprite->targetY = pMate->y; pXSprite->targetY = pMate->y;
pXSprite->targetZ = pMate->z; pXSprite->targetZ = pMate->z;
if (!isActive(pSprite->index)) if (!isActive(pSprite->index))
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
return; return;
} }
} }

11
source/blood/src/triggers.cpp
View file

@ -50,6 +50,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "messages.h" #include "messages.h"
#include "nnexts.h" #include "nnexts.h"
#include "d_net.h" #include "d_net.h"
#include "bloodactor.h"
BEGIN_BLD_NS BEGIN_BLD_NS
@ -349,7 +350,7 @@ void OperateSprite(int nSprite, XSPRITE *pXSprite, EVENT event)
case kCmdSpritePush: case kCmdSpritePush:
case kCmdSpriteTouch: case kCmdSpriteTouch:
if (!pXSprite->state) SetSpriteState(nSprite, pXSprite, 1); if (!pXSprite->state) SetSpriteState(nSprite, pXSprite, 1);
aiActivateDude(pSprite, pXSprite); aiActivateDude(&bloodActors[pXSprite->reference]);
break; break;
} }
@ -507,7 +508,7 @@ void OperateSprite(int nSprite, XSPRITE *pXSprite, EVENT event)
pXSpawn->health = getDudeInfo(pXSprite->data1)->startHealth << 4; pXSpawn->health = getDudeInfo(pXSprite->data1)->startHealth << 4;
pXSpawn->burnTime = 10; pXSpawn->burnTime = 10;
pXSpawn->target = -1; pXSpawn->target = -1;
aiActivateDude(pSpawn, pXSpawn); aiActivateDude(&bloodActors[pXSpawn->reference]);
break; break;
default: default:
break; break;
@ -625,15 +626,15 @@ void OperateSprite(int nSprite, XSPRITE *pXSprite, EVENT event)
switch (event.cmd) { switch (event.cmd) {
case kCmdOff: case kCmdOff:
if (!SetSpriteState(nSprite, pXSprite, 0)) break; if (!SetSpriteState(nSprite, pXSprite, 0)) break;
actActivateGibObject(pSprite, pXSprite); actActivateGibObject(&bloodActors[pXSprite->reference]);
break; break;
case kCmdOn: case kCmdOn:
if (!SetSpriteState(nSprite, pXSprite, 1)) break; if (!SetSpriteState(nSprite, pXSprite, 1)) break;
actActivateGibObject(pSprite, pXSprite); actActivateGibObject(&bloodActors[pXSprite->reference]);
break; break;
default: default:
if (!SetSpriteState(nSprite, pXSprite, pXSprite->state ^ 1)) break; if (!SetSpriteState(nSprite, pXSprite, pXSprite->state ^ 1)) break;
actActivateGibObject(pSprite, pXSprite); actActivateGibObject(&bloodActors[pXSprite->reference]);
break; break;
} }
break; break;