teambeef/raze
0
0
Fork 0
mirror of https://github.com/DrBeef/Raze.git synced 2025-02-21 03:01:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

- more CanMove fixes, plus salvaging the rest of the old commit.

Browse source 
CanMove twice uses the texel-based nRange as a Build-unit value, this caused strange problems with the initial floatification.
This commit is contained in:
Christoph Oelckers 2022-09-27 17:33:18 +02:00
parent 138ba53ace
commit 5e2e53d684
4 changed files with 13 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
source/core/gamefuncs.cpp
View file

@ -821,8 +821,9 @@ int hitscan(const DVector3& start, const sectortype* startsect, const DVector3&
if (maxrange > 0)
{
hitfactor = maxrange / vect.Length();
hitinfo.hitpos = start + hitfactor * vect;
}
hitinfo.hitpos.X = hitinfo.hitpos.Y = DBL_MAX;
else hitinfo.hitpos.X = hitinfo.hitpos.Y = DBL_MAX;
BFSSectorSearch search(startsect);
while (auto sec = search.GetNext())

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

@ -127,24 +127,24 @@ static bool isImmune(DBloodActor* actor, int dmgType, int minScale)
//
//---------------------------------------------------------------------------
bool CanMove(DBloodActor* actor, DBloodActor* target, int nAngle_, int nRange)
bool CanMove(DBloodActor* actor, DBloodActor* target, DAngle nAngle, double nRange)
{
DAngle nAngle = DAngle::fromBuild(nAngle_);
double top, bottom;
GetActorExtents(actor, &top, &bottom);
DVector3 pos = actor->spr.pos;
DVector2 nAngVect = nAngle.ToVector();
HitScan(actor, pos.Z, DVector3(nAngVect, 0) * 1024, CLIPMASK0, nRange);
double nDist = (actor->spr.pos.XY() - gHitInfo.hitpos.XY()).Length();
if (nDist - (actor->fClipdist()) < nRange)
if (nDist - (actor->fClipdist()) < nRange / 16.) // this was actually comparing a Build unit value with a texel unit value!
{
if (gHitInfo.actor() == nullptr || target == nullptr || target != gHitInfo.actor())
return false;
return true;
}
pos.XY() += nRange * nAngVect;
pos.XY() += nRange / 16 * nAngVect; // see above - same weird mixup.
auto pSector = actor->sector();
assert(pSector);
auto ps2 = pSector;
updatesectorz(pos, &pSector);
if (!pSector) return false;
double floorZ = getflorzofslopeptr(pSector, pos);
@ -250,14 +250,11 @@ void aiChooseDirection(DBloodActor* actor, DAngle direction)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DAngle vc = deltaangle(actor->spr.angle, direction);
double nCos = actor->spr.angle.Cos();
double nSin = actor->spr.angle.Sin();
double t1 = actor->vel.X * nCos + actor->vel.Y * nSin;
auto almost60deg = DAngle::fromBuild(341); // 60° does not work correctly - this is a little bit less, actually.
int range = FloatToFixed(t1 * (15 / 8192.));
DAngle v8 = vc.Sgn() == -1 ? -almost60deg : almost60deg;
double range = actor->vel.XY().dot(actor->spr.angle.ToVector()) * 120;
if (CanMove(actor, actor->GetTarget(), actor->spr.angle + vc, range))
actor->xspr.goalAng = actor->spr.angle + vc;
else if (CanMove(actor, actor->GetTarget(), actor->spr.angle + vc / 2, range))

6
source/games/blood/src/ai.h
View file

@ -97,10 +97,12 @@ void aiLookForTarget(DBloodActor* actor);
void aiProcessDudes(void);
void aiInit(void);
void aiInitSprite(DBloodActor* pSprite);
bool CanMove(DBloodActor* pSprite, DBloodActor* target, int nAngle, int nRange);
inline bool CanMove(DBloodActor* pSprite, DBloodActor* target, DAngle nAngle, int nRange)
bool CanMove(DBloodActor* pSprite, DBloodActor* target, DAngle nAngle, double nRange);
/*
inline bool CanMove(DBloodActor* pSprite, DBloodActor* target, DAngle nAngle, double nRange)
{
return CanMove(pSprite, target, nAngle.Buildang(), nRange);
}
*/
END_BLD_NS

3
source/games/blood/src/aiunicult.cpp
View file

@ -1166,8 +1166,7 @@ void aiGenDudeChooseDirection(DBloodActor* actor, DAngle direction, const DVecto
// TO-DO: Take in account if sprite is flip-x, so enemy select correct angle
DAngle vc = deltaangle(actor->spr.angle, direction);
double t1 = vel.X * actor->spr.angle.Cos() + vel.Y * actor->spr.angle.Sin();
int range = FloatToFixed(t1 * (15 / 8192.));
double range = vel.dot(actor->spr.angle.ToVector()) * 120;
DAngle v8 = vc > nullAngle ? DAngle180 / 3 : -DAngle180 / 3;
if (CanMove(actor, actor->GetTarget(), actor->spr.angle + vc, range))