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

adapted all AI files

Browse source
This commit is contained in:
Christoph Oelckers 2023-10-09 00:23:00 +02:00
parent 55621e9a38
commit 92eb20e1ad
19 changed files with 238 additions and 350 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
source/games/blood/src/aibat.cpp
View file

@ -35,18 +35,15 @@ void batBiteSeqCallback(DBloodActor* actor)
auto pTarget = actor->GetTarget();
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * pTarget->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (pTarget->eyeHeight() * pTarget->spr.scale.Y);
actFireVector(actor, 0., 0., DVector3(actor->spr.Angles.Yaw.ToVector() * 64, height2 - height), kVectorBatBite);
}
void batThinkTarget(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
@ -58,7 +55,7 @@ void batThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_batTurn);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -70,18 +67,18 @@ void batThinkTarget(DBloodActor* actor)
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvec.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvec.Angle());
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
aiSetTarget(actor, ppos);
aiActivateDude(actor);
@ -102,12 +99,11 @@ void batThinkSearch(DBloodActor* actor)
void batThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.X;
auto nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_batSearch);
batThinkTarget(actor);
}
@ -120,7 +116,6 @@ void batThinkPonder(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto pTarget = actor->GetTarget();
auto dvec = pTarget->spr.pos.XY() - actor->spr.pos.XY();
@ -131,11 +126,11 @@ void batThinkPonder(DBloodActor* actor)
return;
}
double nDist = dvec.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvec.Angle());
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (getDudeInfo(pTarget)->eyeHeight * pTarget->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (pTarget->eyeHeight() * pTarget->spr.scale.Y);
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->spr.pos, pTarget->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
@ -167,15 +162,14 @@ void batThinkPonder(DBloodActor* actor)
void batMoveDodgeUp(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += pDudeInfo->sideSpeed;
t2 += actor->SideSpeed();
else
t2 -= pDudeInfo->sideSpeed;
t2 -= actor->SideSpeed();
});
actor->vel.Z = FixedToFloat(-0x52aaa);
@ -184,17 +178,16 @@ void batMoveDodgeUp(DBloodActor* actor)
void batMoveDodgeDown(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
if (actor->xspr.dodgeDir == 0)
return;
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = 4.26666;
@ -208,7 +201,6 @@ void batThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto pTarget = actor->GetTarget();
auto dvec = pTarget->spr.pos.XY() - actor->spr.pos.XY();
@ -225,17 +217,17 @@ void batThinkChase(DBloodActor* actor)
return;
}
double nDist = dvec.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvec.Angle());
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y;
// Should be dudeInfo[pTarget]
double height2 = pDudeInfo->eyeHeight * pTarget->spr.scale.Y;
double height = actor->eyeHeight() * actor->spr.scale.Y;
// Should check the target...
double height2 = (VanillaMode()? actor->eyeHeight() : pTarget->eyeHeight()) * pTarget->spr.scale.Y;
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->spr.pos, pTarget->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
double floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos);
@ -265,11 +257,10 @@ void batThinkChase(DBloodActor* actor)
void batMoveForward(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -290,11 +281,10 @@ void batMoveForward(DBloodActor* actor)
void batMoveSwoop(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -314,11 +304,10 @@ void batMoveSwoop(DBloodActor* actor)
void batMoveFly(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->spr.Angles.Yaw += DAngle90;

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

@ -126,7 +126,7 @@ void StompSeqCallback(DBloodActor* actor)
void MorphToBeast(DBloodActor* actor)
{
actHealDude(actor, dudeInfo[51].startHealth, dudeInfo[51].startHealth);
actHealDude(actor, actor->startHealth(), actor->startHealth());
actor->ChangeType(kDudeBeast);
}
@ -139,7 +139,6 @@ void beastThinkSearch(DBloodActor* actor)
void beastThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -147,7 +146,7 @@ void beastThinkGoto(DBloodActor* actor)
auto nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, NAME_beastSwimSearch);
@ -171,7 +170,6 @@ void beastThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -198,13 +196,13 @@ void beastThinkChase(DBloodActor* actor)
return;
}
double nDist = dv.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dv.Angle());
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : int(target->spr.pos.Z - actor->spr.pos.Z / nDist);
@ -291,12 +289,11 @@ void beastThinkChase(DBloodActor* actor)
void beastThinkSwimGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
auto nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_beastSwimSearch);
aiThinkTarget(actor);
}
@ -309,7 +306,6 @@ void beastThinkSwimChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -329,13 +325,13 @@ void beastThinkSwimChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 64 && nDeltaAngle < DAngle15)
@ -358,9 +354,8 @@ void beastThinkSwimChase(DBloodActor* actor)
void beastMoveForward(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
if (abs(nAng) > DAngle60)
return;
@ -368,17 +363,16 @@ void beastMoveForward(DBloodActor* actor)
double nDist = dvec.Length();
if (nDist <= 0x40 && Random(64) < 32)
return;
actor->vel.XY() += actor->spr.Angles.Yaw.ToVector() * pDudeInfo->FrontSpeed();
actor->vel.XY() += actor->spr.Angles.Yaw.ToVector() * actor->FrontSpeed();
}
void beastMoveSwim(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -398,14 +392,13 @@ void beastMoveSwim(DBloodActor* actor)
void beastMoveSwimAlt(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
@ -428,14 +421,13 @@ void beastMoveSwimAlt(DBloodActor* actor)
void beastMoveIn(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{

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

@ -47,10 +47,8 @@ void eelBiteSeqCallback(DBloodActor* actor)
auto target = actor->GetTarget();
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(target);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
DVector3 vect(actor->spr.Angles.Yaw.ToVector() * 1024, height2 - height);
actFireVector(actor, 0., 0., vect, kVectorBoneelBite);
@ -59,7 +57,6 @@ void eelBiteSeqCallback(DBloodActor* actor)
void eelThinkTarget(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
@ -71,7 +68,7 @@ void eelThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_eelTurn);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -82,19 +79,19 @@ void eelThinkTarget(DBloodActor* actor)
auto dvect = ppos.XY() - actor->spr.pos;
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvect.Angle());
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, ppos);
@ -116,12 +113,11 @@ void eelThinkSearch(DBloodActor* actor)
void eelThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
auto nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_eelSearch);
eelThinkTarget(actor);
}
@ -134,7 +130,6 @@ void eelThinkPonder(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -147,11 +142,11 @@ void eelThinkPonder(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (getDudeInfo(target)->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
@ -183,15 +178,14 @@ void eelThinkPonder(DBloodActor* actor)
void eelMoveDodgeUp(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = -0.5;
@ -200,17 +194,16 @@ void eelMoveDodgeUp(DBloodActor* actor)
void eelMoveDodgeDown(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
if (actor->xspr.dodgeDir == 0)
return;
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = 4.26666;
@ -224,7 +217,6 @@ void eelThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -242,10 +234,10 @@ void eelThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double top, bottom;
double top2, bottom2;
GetActorExtents(actor, &top, &bottom);
@ -253,7 +245,7 @@ void eelThinkChase(DBloodActor* actor)
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 57.5625 && top2 > top && nDeltaAngle < DAngle15)
@ -276,11 +268,10 @@ void eelThinkChase(DBloodActor* actor)
void eelMoveForward(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -301,11 +292,10 @@ void eelMoveForward(DBloodActor* actor)
void eelMoveSwoop(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
return;
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
@ -322,11 +312,10 @@ void eelMoveSwoop(DBloodActor* actor)
void eelMoveAscend(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 26) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
return;
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();

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

@ -43,12 +43,11 @@ void burnThinkSearch(DBloodActor* actor)
void burnThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
switch (actor->GetType())
{
@ -113,7 +112,6 @@ void burnThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -152,13 +150,13 @@ void burnThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 51.1875 && nDeltaAngle < DAngle15)

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

@ -60,7 +60,6 @@ void calebThinkSearch(DBloodActor* actor)
void calebThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -69,7 +68,7 @@ void calebThinkGoto(DBloodActor* actor)
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, NAME_tinycalebSwimSearch);
@ -93,7 +92,6 @@ void calebThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -121,13 +119,13 @@ void calebThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : target->spr.pos.Z - actor->spr.pos.Z / nDist;
@ -183,12 +181,11 @@ void calebThinkChase(DBloodActor* actor)
void calebThinkSwimGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_tinycalebSwimSearch);
aiThinkTarget(actor);
}
@ -201,7 +198,6 @@ void calebThinkSwimChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -220,14 +216,14 @@ void calebThinkSwimChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x40 && abs(nDeltaAngle) < DAngle15)
@ -247,11 +243,10 @@ void calebThinkSwimChase(DBloodActor* actor)
void calebMoveSwimChase(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -272,14 +267,13 @@ void calebMoveSwimChase(DBloodActor* actor)
void calebSwimUnused(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -300,14 +294,13 @@ void calebSwimUnused(DBloodActor* actor)
void calebSwimMoveIn(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->spr.Angles.Yaw += DAngle90;

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

@ -51,8 +51,7 @@ void cerberusBiteSeqCallback(DBloodActor* actor)
void cerberusBurnSeqCallback(DBloodActor* actor)
{
DUDEINFO* pDudeInfo = getDudeInfo(actor);
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y * 0.25;
double height = actor->eyeHeight() * actor->spr.scale.Y * 0.25;
if (!actor->ValidateTarget(__FUNCTION__)) return;
DVector3 pos(actor->spr.pos.XY(), height);
@ -113,8 +112,7 @@ void cerberusBurnSeqCallback(DBloodActor* actor)
void cerberusBurnSeqCallback2(DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
DUDEINFO* pDudeInfo = getDudeInfo(actor);
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y * 0.25;
double height = actor->eyeHeight() * actor->spr.scale.Y * 0.25;
DVector3 pos(actor->spr.pos.XY(), height);
//auto pos = actor->spr.pos.plusZ(height); // what it probably should be
@ -154,8 +152,7 @@ void cerberusBurnSeqCallback2(DBloodActor* actor)
DAngle nDeltaAngle = absangle(nAngle, actor->spr.Angles.Yaw);
if (nDeltaAngle <= DAngle45)
{
DUDEINFO* pDudeInfo2 = getDudeInfo(actor2);
double height1 = (pDudeInfo2->aimHeight * actor2->spr.scale.Y);
double height1 = (actor2->aimHeight() * actor2->spr.scale.Y);
double tz1 = actor2->spr.pos.Z - height - actor->spr.pos.Z;
if (cansee(pos, actor->sector(), pos2, actor2->sector()))
@ -193,7 +190,6 @@ void cerberusThinkTarget(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
@ -207,7 +203,7 @@ void cerberusThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_cerberusTurn2);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -218,19 +214,19 @@ void cerberusThinkTarget(DBloodActor* actor)
auto dvect = ppos.XY() - actor->spr.pos;
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvect.Angle());
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, ppos);
@ -249,12 +245,11 @@ void cerberusThinkGoto(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
switch (actor->GetType()) {
case kDudeCerberusTwoHead:
@ -288,7 +283,6 @@ void cerberusThinkChase(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -323,13 +317,13 @@ void cerberusThinkChase(DBloodActor* actor)
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());

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

@ -140,12 +140,11 @@ void cultThinkSearch(DBloodActor* actor)
void cultThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 320 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 320 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
switch (actor->xspr.medium)
{
@ -178,7 +177,6 @@ void cultThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos - actor->spr.pos;
@ -218,13 +216,13 @@ void cultThinkChase(DBloodActor* actor)
}
return;
}
if (nDist > 0 && nDist <= pDudeInfo->SeeDist())
if (nDist > 0 && nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : (target->spr.pos.Z - actor->spr.pos.Z) / nDist;

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

@ -39,10 +39,8 @@ void SlashFSeqCallback(DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(target);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
DVector3 vec(actor->spr.Angles.Yaw.ToVector() * 64, height - height2);
actFireVector(actor, 0, 0, vec, kVectorGargSlash);
@ -64,7 +62,7 @@ void BlastSSeqCallback(DBloodActor* actor)
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
double height = (actor->spr.scale.Y * getDudeInfo(actor)->eyeHeight);
double height = (actor->spr.scale.Y * actor->eyeHeight());
DVector3 pos(actor->spr.pos.XY(), height);
DVector3 Aim(actor->spr.Angles.Yaw.ToVector(), actor->dudeSlope);
@ -139,8 +137,6 @@ void gargThinkTarget(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
else if (actor->dudeExtra.thinkTime >= 10 && actor->dudeExtra.active)
@ -150,7 +146,7 @@ void gargThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_gargoyleTurn);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -161,19 +157,19 @@ void gargThinkTarget(DBloodActor* actor)
auto dvect = ppos.XY() - actor->spr.pos;
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvect.Angle());
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, ppos);
@ -198,12 +194,11 @@ void gargThinkGoto(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_gargoyleFSearch);
aiThinkTarget(actor);
}
@ -214,15 +209,14 @@ void gargMoveDodgeUp(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = FixedToFloat(-0x1d555);
@ -234,17 +228,16 @@ void gargMoveDodgeDown(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
if (actor->xspr.dodgeDir == 0)
return;
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = 4.26666;
@ -262,7 +255,6 @@ void gargThinkChase(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
DVector2 dxy = target->spr.pos.XY() - actor->spr.pos.XY();
@ -279,17 +271,17 @@ void gargThinkChase(DBloodActor* actor)
return;
}
double nDist = dxy.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dxyAngle);
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y;
// Should be dudeInfo[target]
double height2 = pDudeInfo->eyeHeight * target->spr.scale.Y;
double height = actor->eyeHeight() * actor->spr.scale.Y;
// Should check the target
double height2 = actor->eyeHeight() * target->spr.scale.Y;
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
double floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos);
@ -431,15 +423,13 @@ void gargThinkChase(DBloodActor* actor)
void entryFStatue(DBloodActor* actor)
{
DUDEINFO* pDudeInfo = &dudeInfo[6];
actHealDude(actor, pDudeInfo->startHealth, pDudeInfo->startHealth);
actHealDude(actor, actor->startHealth(), actor->startHealth());
actor->ChangeType(kDudeGargoyleFlesh);
}
void entrySStatue(DBloodActor* actor)
{
DUDEINFO* pDudeInfo = &dudeInfo[7];
actHealDude(actor, pDudeInfo->startHealth, pDudeInfo->startHealth);
actHealDude(actor, actor->startHealth(), actor->startHealth());
actor->ChangeType(kDudeGargoyleStone);
}
@ -449,11 +439,10 @@ void gargMoveForward(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -477,11 +466,10 @@ void gargMoveSlow(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -512,11 +500,10 @@ void gargMoveSwoop(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -547,11 +534,10 @@ void gargMoveFly(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->spr.Angles.Yaw += DAngle90;

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

@ -33,10 +33,8 @@ void ghostSlashSeqCallback(DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(target);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
DVector3 dv(actor->spr.Angles.Yaw.ToVector() * 64, height - height2);
sfxPlay3DSound(actor, 1406, 0, 0);
@ -60,7 +58,7 @@ void ghostBlastSeqCallback(DBloodActor* actor)
wrand(); // ???
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
double height = (actor->spr.scale.Y * getDudeInfo(actor)->eyeHeight);
double height = (actor->spr.scale.Y * actor->eyeHeight());
DVector3 pos(actor->spr.pos.XY(), height);
DVector3 Aim(actor->spr.Angles.Yaw.ToVector(), actor->dudeSlope);
@ -129,8 +127,6 @@ void ghostThinkTarget(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
else if (actor->dudeExtra.thinkTime >= 10 && actor->dudeExtra.active)
@ -140,7 +136,7 @@ void ghostThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_ghostTurn);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -151,20 +147,20 @@ void ghostThinkTarget(DBloodActor* actor)
auto dvect = ppos.XY() - actor->spr.pos;
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvect.Angle());
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
return;
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, ppos);
@ -187,12 +183,11 @@ void ghostThinkGoto(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_ghostSearch);
aiThinkTarget(actor);
}
@ -203,15 +198,14 @@ void ghostMoveDodgeUp(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = FixedToFloat(-0x1d555);
@ -223,17 +217,16 @@ void ghostMoveDodgeDown(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
if (actor->xspr.dodgeDir == 0)
return;
AdjustVelocity(actor, ADJUSTER{
if (actor->xspr.dodgeDir > 0)
t2 += FixedToFloat(pDudeInfo->sideSpeed);
t2 += actor->SideSpeed();
else
t2 -= FixedToFloat(pDudeInfo->sideSpeed);
t2 -= actor->SideSpeed();
});
actor->vel.Z = 4.26666;
}
@ -250,7 +243,6 @@ void ghostThinkChase(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
DVector2 dxy = target->spr.pos.XY() - actor->spr.pos.XY();
@ -267,17 +259,17 @@ void ghostThinkChase(DBloodActor* actor)
return;
}
double nDist = dxy.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dxyAngle);
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y;
// Should be dudeInfo[target->GetType()-kDudeBase]
double height2 = pDudeInfo->eyeHeight * target->spr.scale.Y;
double height = actor->eyeHeight() * actor->spr.scale.Y;
// Should check the target...
double height2 = actor->eyeHeight() * target->spr.scale.Y;
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
double floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos);
@ -354,11 +346,10 @@ void ghostMoveForward(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -381,11 +372,10 @@ void ghostMoveSlow(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -412,11 +402,10 @@ void ghostMoveSwoop(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -442,11 +431,10 @@ void ghostMoveFly(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = pDudeInfo->FrontSpeed() * 4;
double nAccel = actor->FrontSpeed() * 4;
if (abs(nAng) > DAngle60)
{
actor->spr.Angles.Yaw += DAngle90;

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

@ -50,7 +50,6 @@ void gillThinkSearch(DBloodActor* actor)
void gillThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -59,7 +58,7 @@ void gillThinkGoto(DBloodActor* actor)
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
if (pXSector && pXSector->Underwater)
aiNewState(actor, NAME_gillBeastSwimSearch);
@ -83,7 +82,6 @@ void gillThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto dv = target->spr.pos.XY() - actor->spr.pos.XY();
@ -106,13 +104,13 @@ void gillThinkChase(DBloodActor* actor)
return;
}
double nDist = dv.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : (target->spr.pos.Z - actor->spr.pos.Z) / nDist;
@ -167,12 +165,11 @@ void gillThinkChase(DBloodActor* actor)
void gillThinkSwimGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_gillBeastSwimSearch);
aiThinkTarget(actor);
}
@ -185,7 +182,6 @@ void gillThinkSwimChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -204,15 +200,15 @@ void gillThinkSwimChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x40 && nDeltaAngle < DAngle15)
@ -235,11 +231,10 @@ void gillThinkSwimChase(DBloodActor* actor)
void gillMoveSwimChase(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
return;
if (actor->GetTarget() == nullptr)
@ -260,14 +255,13 @@ void gillMoveSwimChase(DBloodActor* actor)
void gillMoveSwimUnused(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
{
actor->xspr.goalAng += DAngle90;
@ -287,14 +281,13 @@ void gillMoveSwimUnused(DBloodActor* actor)
void gillSwimMoveIn(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
auto nAng = deltaangle(actor->spr.Angles.Yaw, actor->xspr.goalAng);
auto nTurnRange = pDudeInfo->TurnRange();
auto nTurnRange = actor->TurnRange();
actor->spr.Angles.Yaw += clamp(nAng, -nTurnRange, nTurnRange);
double nAccel = FixedToFloat((pDudeInfo->frontSpeed - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
double nAccel = FixedToFloat((actor->FrontSpeedFixed() - (((4 - gGameOptions.nDifficulty) << 27) / 120) / 120) << 2);
if (abs(nAng) > DAngle60)
{
actor->spr.Angles.Yaw += DAngle90;

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

@ -53,12 +53,11 @@ void handThinkSearch(DBloodActor* actor)
void handThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_handSearch);
aiThinkTarget(actor);
}
@ -71,7 +70,6 @@ void handThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -89,13 +87,13 @@ void handThinkChase(DBloodActor* actor)
aiNewState(actor, NAME_handSearch);
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 35.1875 && nDeltaAngle < DAngle15 && gGameOptions.nGameType == 0)

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

@ -61,12 +61,11 @@ void houndThinkGoto(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_houndSearch);
aiThinkTarget(actor);
}
@ -82,7 +81,6 @@ void houndThinkChase(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -100,13 +98,13 @@ void houndThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0xb0 && nDist > 0x50 && nDeltaAngle < DAngle15)

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

@ -38,12 +38,11 @@ void innocThinkSearch(DBloodActor* actor)
void innocThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_innocentSearch);
aiThinkTarget(actor);
}
@ -56,7 +55,6 @@ void innocThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -75,13 +73,13 @@ void innocThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 102.375 && nDeltaAngle < DAngle15)

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

@ -44,7 +44,6 @@ void podAttack(DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dv = target->spr.pos - actor->spr.pos;
dv.X += Random2F(1000, 4);
dv.Y += Random2F(1000, 4);
@ -54,7 +53,7 @@ void podAttack(DBloodActor* actor)
{
case kDudePodGreen:
dv.Z += 31.25;
if (pDudeInfo->SeeDist() * 1.6 < nDist)
if (actor->SeeDist() * 1.6 < nDist)
{
if (Chance(0x8000))
sfxPlay3DSound(actor, 2474, -1, 0);
@ -67,7 +66,7 @@ void podAttack(DBloodActor* actor)
break;
case kDudePodFire:
dv.Z += 31.25;
if (pDudeInfo->SeeDist() * 1.6 < nDist)
if (actor->SeeDist() * 1.6 < nDist)
{
sfxPlay3DSound(actor, 2454, -1, 0);
pMissile = actFireThing(actor, 0., -500., dv.Z / 32768 - 0.22125, kThingPodFireBall, nDist * (2048. / 64800));
@ -114,12 +113,11 @@ void aiPodMove(DBloodActor* actor)
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
{
switch (actor->GetType()) {
case kDudePodGreen:
@ -154,7 +152,6 @@ void aiPodChase(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -175,13 +172,13 @@ void aiPodChase(DBloodActor* actor)
}
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDeltaAngle < DAngle15 && target->GetType() != kDudePodGreen && target->GetType() != kDudePodFire) {

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

@ -50,12 +50,11 @@ void ratThinkSearch(DBloodActor* actor)
void ratThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_ratSearch);
aiThinkTarget(actor);
}
@ -68,7 +67,6 @@ void ratThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -86,13 +84,13 @@ void ratThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 57.5625 && nDeltaAngle < DAngle15)

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

@ -118,7 +118,6 @@ void SpidJumpSeqCallback(DBloodActor* actor)
void SpidBirthSeqCallback(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -130,11 +129,11 @@ void SpidBirthSeqCallback(DBloodActor* actor)
if (target->IsPlayerActor() && actor->dudeExtra.birthCounter < 10)
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
if (nDist < 0x1a0 && nDist > 0x140 && nDeltaAngle < pDudeInfo->Periphery())
if (nDist < 0x1a0 && nDist > 0x140 && nDeltaAngle < actor->Periphery())
spawned = actSpawnDude(actor, kDudeSpiderRed, actor->clipdist * 0.25);
else if (nDist < 0x140 && nDist > 0xc0 && nDeltaAngle < pDudeInfo->Periphery())
else if (nDist < 0x140 && nDist > 0xc0 && nDeltaAngle < actor->Periphery())
spawned = actSpawnDude(actor, kDudeSpiderBrown, actor->clipdist * 0.25);
else if (nDist < 0xc0 && nDeltaAngle < pDudeInfo->Periphery())
else if (nDist < 0xc0 && nDeltaAngle < actor->Periphery())
spawned = actSpawnDude(actor, kDudeSpiderBrown, actor->clipdist * 0.25);
if (spawned)
@ -156,12 +155,11 @@ void spidThinkSearch(DBloodActor* actor)
void spidThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_spidSearch);
aiThinkTarget(actor);
}
@ -174,7 +172,6 @@ void spidThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto target = actor->GetTarget();
auto dvec = target->spr.pos.XY() - actor->spr.pos.XY();
@ -192,13 +189,13 @@ void spidThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && nDeltaAngle <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());

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

@ -44,8 +44,7 @@ void tchernobogFire(DBloodActor* actor)
void tchernobogBurnSeqCallback(DBloodActor* actor)
{
DUDEINFO* pDudeInfo = getDudeInfo(actor);
double height = actor->spr.scale.Y * pDudeInfo->eyeHeight * 0.25;
double height = actor->spr.scale.Y * actor->eyeHeight() * 0.25;
if (!actor->ValidateTarget(__FUNCTION__)) return;
DVector3 pos(actor->spr.pos.XY(), height);
@ -103,8 +102,7 @@ void tchernobogBurnSeqCallback2(DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
DUDEINFO* pDudeInfo = getDudeInfo(actor);
double height = actor->spr.scale.Y * pDudeInfo->eyeHeight * 0.25;
double height = actor->spr.scale.Y * actor->eyeHeight() * 0.25;
DVector3 pos(actor->spr.pos.XY(), height);
DVector3 Aim(actor->spr.Angles.Yaw.ToVector(), -actor->dudeSlope);
@ -167,8 +165,6 @@ void tchernobogThinkTarget(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (actor->dudeExtra.active && actor->dudeExtra.thinkTime < 10)
actor->dudeExtra.thinkTime++;
else if (actor->dudeExtra.thinkTime >= 10 && actor->dudeExtra.active)
@ -178,7 +174,7 @@ void tchernobogThinkTarget(DBloodActor* actor)
aiNewState(actor, NAME_tchernobogTurn);
return;
}
if (Chance(pDudeInfo->alertChance))
if (Chance(actor->alertChance()))
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
@ -191,19 +187,19 @@ void tchernobogThinkTarget(DBloodActor* actor)
DAngle nAngle = dvect.Angle();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
actor->dudeExtra.thinkTime = 0;
aiSetTarget(actor, ppos);
@ -222,12 +218,11 @@ void tchernobogThinkGoto(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_tchernobogSearch);
aiThinkTarget(actor);
}
@ -243,7 +238,6 @@ void tchernobogThinkChase(DBloodActor* actor)
Printf(PRINT_HIGH, "actor->IsDudeActor()");
return;
}
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -262,13 +256,13 @@ void tchernobogThinkChase(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x1f0 && nDist > 0xd0 && nDeltaAngle < DAngle15)

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

@ -33,13 +33,11 @@ void HackSeqCallback(DBloodActor* actor)
{
auto target = actor->GetTarget();
if (!target) return;
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(target);
DVector3 dv;
dv.XY() = (actor->xspr.TargetPos.XY() - actor->spr.pos.XY()).Resized(64);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
dv.Z = height - height2;
sfxPlay3DSound(actor, 1101, 1, 0);
@ -60,12 +58,11 @@ void zombaThinkSearch(DBloodActor* actor)
void zombaThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 51.3125 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 51.3125 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_zombieASearch);
aiThinkTarget(actor);
}
@ -78,7 +75,6 @@ void zombaThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -102,13 +98,13 @@ void zombaThinkChase(DBloodActor* actor)
actor->ChangeType(kDudeZombieAxeNormal);
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDeltaAngle <= pDudeInfo->Periphery())
if (nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x40 && nDeltaAngle < DAngle15)
@ -130,7 +126,6 @@ void zombaThinkPonder(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -149,13 +144,13 @@ void zombaThinkPonder(DBloodActor* actor)
return;
}
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDeltaAngle <= pDudeInfo->Periphery())
if (nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x40)
@ -177,7 +172,6 @@ void zombaThinkPonder(DBloodActor* actor)
void myThinkTarget(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
DBloodPlayer* pPlayer = getPlayer(p);
@ -188,18 +182,18 @@ void myThinkTarget(DBloodActor* actor)
auto dvect = ppos.XY() - actor->spr.pos;
auto pSector = pPlayer->GetActor()->sector();
double nDist = dvect.Length();
if (nDist > pDudeInfo->SeeDist() && nDist > pDudeInfo->HearDist())
if (nDist > actor->SeeDist() && nDist > actor->HearDist())
continue;
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (!cansee(ppos, pSector, actor->spr.pos.plusZ(-height), actor->sector()))
continue;
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, dvect.Angle());
if (nDist < pDudeInfo->SeeDist() && abs(nDeltaAngle) <= pDudeInfo->Periphery())
if (nDist < actor->SeeDist() && abs(nDeltaAngle) <= actor->Periphery())
{
aiSetTarget(actor, pPlayer->GetActor());
aiActivateDude(actor);
}
else if (nDist < pDudeInfo->HearDist())
else if (nDist < actor->HearDist())
{
aiSetTarget(actor, ppos);
aiActivateDude(actor);

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

@ -35,10 +35,8 @@ void zombfHackSeqCallback(DBloodActor* actor)
return;
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor);
double height = pDudeInfo->eyeHeight * actor->spr.scale.Y * 0.25;
DUDEINFO* pDudeInfoT = getDudeInfo(target);
double height2 = pDudeInfoT->eyeHeight * target->spr.scale.Y * 0.25;
double height = actor->eyeHeight() * actor->spr.scale.Y * 0.25;
double height2 = target->eyeHeight() * target->spr.scale.Y * 0.25;
actFireVector(actor, 0, 0, DVector3(actor->spr.Angles.Yaw.ToVector() * 64, height - height2), kVectorCleaver);
}
@ -46,13 +44,11 @@ void PukeSeqCallback(DBloodActor* actor)
{
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
DUDEINFO* pDudeInfo = getDudeInfo(actor);
DUDEINFO* pDudeInfoT = getDudeInfo(target);
DVector2 dv = (actor->xspr.TargetPos.XY() - actor->spr.pos.XY()).Resized(64);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height2 = (pDudeInfoT->eyeHeight * target->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
double height2 = (target->eyeHeight() * target->spr.scale.Y);
double z = (height - height2) * 0.25;
sfxPlay3DSound(actor, 1203, 1, 0);
@ -73,12 +69,11 @@ void zombfThinkSearch(DBloodActor* actor)
void zombfThinkGoto(DBloodActor* actor)
{
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
auto dvec = actor->xspr.TargetPos.XY() - actor->spr.pos.XY();
DAngle nAngle = dvec.Angle();
double nDist = dvec.Length();
aiChooseDirection(actor, nAngle);
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < pDudeInfo->Periphery())
if (nDist < 32 && absangle(actor->spr.Angles.Yaw, nAngle) < actor->Periphery())
aiNewState(actor, NAME_zombieFSearch);
aiThinkTarget(actor);
}
@ -91,7 +86,6 @@ void zombfThinkChase(DBloodActor* actor)
return;
}
assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor);
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto target = actor->GetTarget();
@ -109,13 +103,13 @@ void zombfThinkChase(DBloodActor* actor)
return;
}
double nDist = dv.Length();
if (nDist <= pDudeInfo->SeeDist())
if (nDist <= actor->SeeDist())
{
DAngle nDeltaAngle = absangle(actor->spr.Angles.Yaw, nAngle);
double height = (pDudeInfo->eyeHeight * actor->spr.scale.Y);
double height = (actor->eyeHeight() * actor->spr.scale.Y);
if (cansee(target->spr.pos, target->sector(), actor->spr.pos.plusZ(-height), actor->sector()))
{
if (nDeltaAngle <= pDudeInfo->Periphery())
if (nDeltaAngle <= actor->Periphery())
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x100 && nDist > 0xe0 && abs(nDeltaAngle) < DAngle15)