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

- SW: replace s() in ai.cpp.

Browse source 
Also a bit of inline cleanup to make it compile again.
This commit is contained in:
Christoph Oelckers 2021-12-23 23:31:28 +01:00
parent 8d5bffc280
commit ed8b4100f6
2 changed files with 85 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

176
source/games/sw/src/ai.cpp
View file

@ -98,14 +98,13 @@ bool ActorMoveHitReact(DSWActor* actor)
bool ActorFlaming(DSWActor* actor) bool ActorFlaming(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
auto flame = u->flameActor; auto flame = u->flameActor;
if (flame != nullptr) if (flame != nullptr)
{ {
int size; int size;
size = GetSpriteSizeZ(sp) - (GetSpriteSizeZ(sp) >> 2); size = ActorSizeZ(actor) - (ActorSizeZ(actor) >> 2);
if (GetSpriteSizeZ(flame) > size) if (GetSpriteSizeZ(flame) > size)
return true; return true;
@ -117,9 +116,8 @@ bool ActorFlaming(DSWActor* actor)
void DoActorSetSpeed(DSWActor* actor, uint8_t speed) void DoActorSetSpeed(DSWActor* actor, uint8_t speed)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
if (TEST(sp->cstat, CSTAT_SPRITE_RESTORE)) if (TEST(actor->spr.cstat, CSTAT_SPRITE_RESTORE))
return; return;
ASSERT(u->Attrib); ASSERT(u->Attrib);
@ -127,9 +125,9 @@ void DoActorSetSpeed(DSWActor* actor, uint8_t speed)
u->speed = speed; u->speed = speed;
if (ActorFlaming(actor)) if (ActorFlaming(actor))
sp->xvel = u->Attrib->Speed[speed] + DIV2(u->Attrib->Speed[speed]); actor->spr.xvel = u->Attrib->Speed[speed] + DIV2(u->Attrib->Speed[speed]);
else else
sp->xvel = u->Attrib->Speed[speed]; actor->spr.xvel = u->Attrib->Speed[speed];
} }
/* /*
@ -227,12 +225,11 @@ int DoActorNoise(ANIMATORp Action, DSWActor* actor)
bool CanSeePlayer(DSWActor* actor) bool CanSeePlayer(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
// if actor can still see the player // if actor can still see the player
int look_height = GetSpriteZOfTop(sp); int look_height = ActorZOfTop(actor);
if (u->targetActor && FAFcansee(sp->pos.X, sp->pos.Y, look_height, sp->sector(), u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y, ActorUpperZ(u->targetActor), u->targetActor->spr.sector())) if (u->targetActor && FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, look_height, actor->spr.sector(), u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y, ActorUpperZ(u->targetActor), u->targetActor->spr.sector()))
return true; return true;
else else
return false; return false;
@ -241,20 +238,19 @@ bool CanSeePlayer(DSWActor* actor)
int CanHitPlayer(DSWActor* actor) int CanHitPlayer(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
HitInfo hit{}; HitInfo hit{};
int xvect,yvect,zvect; int xvect,yvect,zvect;
int ang; int ang;
// if actor can still see the player // if actor can still see the player
int zhs, zhh; int zhs, zhh;
zhs = sp->pos.Z - DIV2(GetSpriteSizeZ(sp)); zhs = actor->spr.pos.Z - DIV2(ActorSizeZ(actor));
auto targ = u->targetActor; auto targ = u->targetActor;
// get angle to target // get angle to target
ang = getangle(targ->spr.pos.X - sp->pos.X, targ->spr.pos.Y - sp->pos.Y); ang = getangle(targ->spr.pos.X - actor->spr.pos.X, targ->spr.pos.Y - actor->spr.pos.Y);
// get x,yvect // get x,yvect
xvect = bcos(ang); xvect = bcos(ang);
@ -262,20 +258,20 @@ int CanHitPlayer(DSWActor* actor)
// get zvect // get zvect
zhh = targ->spr.pos.Z - (GetSpriteSizeZ(targ) >> 1); zhh = targ->spr.pos.Z - (GetSpriteSizeZ(targ) >> 1);
if (targ->spr.pos.X - sp->pos.X != 0) if (targ->spr.pos.X - actor->spr.pos.X != 0)
zvect = xvect * ((zhh - zhs) / (targ->spr.pos.X - sp->pos.X)); zvect = xvect * ((zhh - zhs) / (targ->spr.pos.X - actor->spr.pos.X));
else if (targ->spr.pos.Y - sp->pos.Y != 0) else if (targ->spr.pos.Y - actor->spr.pos.Y != 0)
zvect = yvect * ((zhh - zhs) / (targ->spr.pos.Y - sp->pos.Y)); zvect = yvect * ((zhh - zhs) / (targ->spr.pos.Y - actor->spr.pos.Y));
else else
return false; return false;
// so actors won't shoot straight up at you // so actors won't shoot straight up at you
// need to be a bit of a distance away // need to be a bit of a distance away
// before they have a valid shot // before they have a valid shot
// if (labs(zvect / FindDistance2D(targ->spr.x - sp->x, targ->spr.y - sp->y)) > 200) // if (labs(zvect / FindDistance2D(targ->spr.x - actor->spr.x, targ->spr.y - actor->spr.y)) > 200)
// return(false); // return(false);
FAFhitscan(sp->pos.X, sp->pos.Y, zhs, sp->sector(), FAFhitscan(actor->spr.pos.X, actor->spr.pos.Y, zhs, actor->spr.sector(),
xvect, xvect,
yvect, yvect,
zvect, zvect,
@ -297,12 +293,11 @@ int CanHitPlayer(DSWActor* actor)
int DoActorPickClosePlayer(DSWActor* actor) int DoActorPickClosePlayer(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
int dist, near_dist = MAX_ACTIVE_RANGE, a,b,c; int dist, near_dist = MAX_ACTIVE_RANGE, a,b,c;
int pnum; int pnum;
PLAYERp pp; PLAYERp pp;
// if actor can still see the player // if actor can still see the player
int look_height = GetSpriteZOfTop(sp); int look_height = ActorZOfTop(actor);
bool found = false; bool found = false;
int i; int i;
@ -347,7 +342,7 @@ int DoActorPickClosePlayer(DSWActor* actor)
// continue; // continue;
} }
DISTANCE(sp->pos.X, sp->pos.Y, pp->pos.X, pp->pos.Y, dist, a, b, c); DISTANCE(actor->spr.pos.X, actor->spr.pos.Y, pp->pos.X, pp->pos.Y, dist, a, b, c);
if (dist < near_dist) if (dist < near_dist)
{ {
@ -373,10 +368,10 @@ int DoActorPickClosePlayer(DSWActor* actor)
continue; continue;
} }
DISTANCE(sp->pos.X, sp->pos.Y, pp->pos.X, pp->pos.Y, dist, a, b, c); DISTANCE(actor->spr.pos.X, actor->spr.pos.Y, pp->pos.X, pp->pos.Y, dist, a, b, c);
auto plActor = pp->actor; auto plActor = pp->actor;
if (dist < near_dist && FAFcansee(sp->pos.X, sp->pos.Y, look_height, sp->sector(), plActor->spr.pos.X, plActor->spr.pos.Y, ActorUpperZ(plActor), plActor->spr.sector())) if (dist < near_dist && FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, look_height, actor->spr.sector(), plActor->spr.pos.X, plActor->spr.pos.Y, ActorUpperZ(plActor), plActor->spr.sector()))
{ {
near_dist = dist; near_dist = dist;
u->targetActor = pp->actor; u->targetActor = pp->actor;
@ -400,9 +395,9 @@ TARGETACTOR:
if (TEST(itActor->u()->Flags, SPR_SUICIDE | SPR_DEAD)) if (TEST(itActor->u()->Flags, SPR_SUICIDE | SPR_DEAD))
continue; continue;
DISTANCE(sp->pos.X, sp->pos.Y, itActor->spr.pos.X, itActor->spr.pos.Y, dist, a, b, c); DISTANCE(actor->spr.pos.X, actor->spr.pos.Y, itActor->spr.pos.X, itActor->spr.pos.Y, dist, a, b, c);
if (dist < near_dist && FAFcansee(sp->pos.X, sp->pos.Y, look_height, sp->sector(), itActor->spr.pos.X, itActor->spr.pos.Y, ActorUpperZ(itActor), itActor->spr.sector())) if (dist < near_dist && FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, look_height, actor->spr.sector(), itActor->spr.pos.X, itActor->spr.pos.Y, ActorUpperZ(itActor), itActor->spr.sector()))
{ {
near_dist = dist; near_dist = dist;
u->targetActor = itActor; u->targetActor = itActor;
@ -444,7 +439,6 @@ int CloseRangeDist(DSWActor* actor1, DSWActor* actor2)
int DoActorOperate(DSWActor* actor) int DoActorOperate(DSWActor* actor)
{ {
SPRITEp sp = &actor->s();
USERp u = actor->u(); USERp u = actor->u();
HitInfo near{}; HitInfo near{};
int z[2]; int z[2];
@ -459,12 +453,12 @@ int DoActorOperate(DSWActor* actor)
if ((u->WaitTics -= ACTORMOVETICS) > 0) if ((u->WaitTics -= ACTORMOVETICS) > 0)
return false; return false;
z[0] = sp->pos.Z - GetSpriteSizeZ(sp) + Z(5); z[0] = actor->spr.pos.Z - ActorSizeZ(actor) + Z(5);
z[1] = sp->pos.Z - DIV2(GetSpriteSizeZ(sp)); z[1] = actor->spr.pos.Z - DIV2(ActorSizeZ(actor));
for (i = 0; i < SIZ(z); i++) for (i = 0; i < SIZ(z); i++)
{ {
neartag({ sp->pos.X, sp->pos.Y, z[i] }, sp->sector(), sp->ang, near, 1024, NTAG_SEARCH_LO_HI); neartag({ actor->spr.pos.X, actor->spr.pos.Y, z[i] }, actor->spr.sector(), actor->spr.ang, near, 1024, NTAG_SEARCH_LO_HI);
} }
if (near.hitSector != nullptr && near.hitpos.X < 1024) if (near.hitSector != nullptr && near.hitpos.X < 1024)
@ -502,7 +496,6 @@ DECISION GenericFlaming[] =
ANIMATORp DoActorActionDecide(DSWActor* actor) ANIMATORp DoActorActionDecide(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
int dist; int dist;
ANIMATORp action; ANIMATORp action;
bool ICanSee=false; bool ICanSee=false;
@ -546,7 +539,7 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
DoActorOperate(actor); DoActorOperate(actor);
// if far enough away and cannot see the player // if far enough away and cannot see the player
dist = Distance(sp->pos.X, sp->pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y); dist = Distance(actor->spr.pos.X, actor->spr.pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y);
if (dist > 30000 && !ICanSee) if (dist > 30000 && !ICanSee)
{ {
@ -567,7 +560,7 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
if ((dist < CloseRangeDist(actor, u->targetActor) && ICanSee) || if ((dist < CloseRangeDist(actor, u->targetActor) && ICanSee) ||
(pActor && pActor->hasU() && pActor->u()->WeaponNum == WPN_FIST && u->ID != RIPPER2_RUN_R0 && u->ID != RIPPER_RUN_R0)) (pActor && pActor->hasU() && pActor->u()->WeaponNum == WPN_FIST && u->ID != RIPPER2_RUN_R0 && u->ID != RIPPER_RUN_R0))
{ {
if ((u->ID == COOLG_RUN_R0 && TEST(sp->cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(sp->cstat, CSTAT_SPRITE_INVISIBLE)) if ((u->ID == COOLG_RUN_R0 && TEST(actor->spr.cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(actor->spr.cstat, CSTAT_SPRITE_INVISIBLE))
action = ChooseAction(u->Personality->Evasive); action = ChooseAction(u->Personality->Evasive);
else else
action = ChooseAction(u->Personality->CloseRange); action = ChooseAction(u->Personality->CloseRange);
@ -589,7 +582,7 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
action = InitActorDuck; action = InitActorDuck;
else else
{ {
if ((u->ID == COOLG_RUN_R0 && TEST(sp->cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(sp->cstat, CSTAT_SPRITE_INVISIBLE)) if ((u->ID == COOLG_RUN_R0 && TEST(actor->spr.cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(actor->spr.cstat, CSTAT_SPRITE_INVISIBLE))
action = ChooseAction(u->Personality->Evasive); action = ChooseAction(u->Personality->Evasive);
else else
action = ChooseAction(u->Personality->Battle); action = ChooseAction(u->Personality->Battle);
@ -601,7 +594,7 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
// fighting // fighting
else else
{ {
if ((u->ID == COOLG_RUN_R0 && TEST(sp->cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(sp->cstat, CSTAT_SPRITE_INVISIBLE)) if ((u->ID == COOLG_RUN_R0 && TEST(actor->spr.cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(actor->spr.cstat, CSTAT_SPRITE_INVISIBLE))
action = ChooseAction(u->Personality->Evasive); action = ChooseAction(u->Personality->Evasive);
else else
action = ChooseAction(u->Personality->Battle); action = ChooseAction(u->Personality->Battle);
@ -613,7 +606,7 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
// if player is NOT facing me he is running or unaware of actor // if player is NOT facing me he is running or unaware of actor
else if (ICanSee) else if (ICanSee)
{ {
if ((u->ID == COOLG_RUN_R0 && TEST(sp->cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(sp->cstat, CSTAT_SPRITE_INVISIBLE)) if ((u->ID == COOLG_RUN_R0 && TEST(actor->spr.cstat, CSTAT_SPRITE_TRANSLUCENT)) || TEST(actor->spr.cstat, CSTAT_SPRITE_INVISIBLE))
action = ChooseAction(u->Personality->Evasive); action = ChooseAction(u->Personality->Evasive);
else else
action = ChooseAction(u->Personality->Offense); action = ChooseAction(u->Personality->Offense);
@ -633,11 +626,11 @@ ANIMATORp DoActorActionDecide(DSWActor* actor)
{ {
// try and find another player // try and find another player
// pick a closeby player as the (new) target // pick a closeby player as the (new) target
if (sp->hitag != TAG_SWARMSPOT) if (actor->spr.hitag != TAG_SWARMSPOT)
DoActorPickClosePlayer(actor); DoActorPickClosePlayer(actor);
// if close by // if close by
dist = Distance(sp->pos.X, sp->pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y); dist = Distance(actor->spr.pos.X, actor->spr.pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y);
if (dist < 15000 || ICanSee) if (dist < 15000 || ICanSee)
{ {
if ((Facing(actor, u->targetActor) && dist < 10000) || ICanSee) if ((Facing(actor, u->targetActor) && dist < 10000) || ICanSee)
@ -868,13 +861,12 @@ int InitActorMoveCloser(DSWActor* actor)
int DoActorCantMoveCloser(DSWActor* actor) int DoActorCantMoveCloser(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
u->track = FindTrackToPlayer(actor); u->track = FindTrackToPlayer(actor);
if (u->track >= 0) if (u->track >= 0)
{ {
sp->ang = getangle((Track[u->track].TrackPoint + u->point)->x - sp->pos.X, (Track[u->track].TrackPoint + u->point)->y - sp->pos.Y); actor->spr.ang = getangle((Track[u->track].TrackPoint + u->point)->x - actor->spr.pos.X, (Track[u->track].TrackPoint + u->point)->y - actor->spr.pos.Y);
DoActorSetSpeed(actor, MID_SPEED); DoActorSetSpeed(actor, MID_SPEED);
SET(u->Flags, SPR_FIND_PLAYER); SET(u->Flags, SPR_FIND_PLAYER);
@ -896,11 +888,10 @@ int DoActorCantMoveCloser(DSWActor* actor)
int DoActorMoveCloser(DSWActor* actor) int DoActorMoveCloser(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int nx, ny; int nx, ny;
nx = MulScale(sp->xvel, bcos(sp->ang), 14); nx = MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
ny = MulScale(sp->xvel, bsin(sp->ang), 14); ny = MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
// if cannot move the sprite // if cannot move the sprite
if (!move_actor(actor, nx, ny, 0L)) if (!move_actor(actor, nx, ny, 0L))
@ -947,7 +938,7 @@ int DoActorMoveCloser(DSWActor* actor)
else else
{ {
// turn to face player // turn to face player
sp->ang = getangle(u->targetActor->spr.pos.X - sp->pos.X, u->targetActor->spr.pos.Y - sp->pos.Y); actor->spr.ang = getangle(u->targetActor->spr.pos.X - actor->spr.pos.X, u->targetActor->spr.pos.Y - actor->spr.pos.Y);
} }
} }
@ -969,7 +960,6 @@ int DoActorMoveCloser(DSWActor* actor)
int FindTrackToPlayer(DSWActor* actor) int FindTrackToPlayer(DSWActor* actor)
{ {
auto u = actor->u(); auto u = actor->u();
SPRITEp sp = &actor->s();
int point, track_dir, track; int point, track_dir, track;
int i, size; int i, size;
@ -1005,7 +995,7 @@ int FindTrackToPlayer(DSWActor* actor)
BIT(TT_SCAN) BIT(TT_SCAN)
}; };
zdiff = ActorUpperZ(u->targetActor) - (sp->pos.Z - GetSpriteSizeZ(sp) + Z(8)); zdiff = ActorUpperZ(u->targetActor) - (actor->spr.pos.Z - ActorSizeZ(actor) + Z(8));
if (labs(zdiff) <= Z(20)) if (labs(zdiff) <= Z(20))
{ {
@ -1129,7 +1119,6 @@ int FindWanderTrack(DSWActor* actor)
int InitActorRunAway(DSWActor* actor) int InitActorRunAway(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
//MONO_PRINT("Init Actor RunAway\n"); //MONO_PRINT("Init Actor RunAway\n");
@ -1140,7 +1129,7 @@ int InitActorRunAway(DSWActor* actor)
if (u->track >= 0) if (u->track >= 0)
{ {
sp->ang = NORM_ANGLE(getangle((Track[u->track].TrackPoint + u->point)->x - sp->pos.X, (Track[u->track].TrackPoint + u->point)->y - sp->pos.Y)); actor->spr.ang = NORM_ANGLE(getangle((Track[u->track].TrackPoint + u->point)->x - actor->spr.pos.X, (Track[u->track].TrackPoint + u->point)->y - actor->spr.pos.Y));
DoActorSetSpeed(actor, FAST_SPEED); DoActorSetSpeed(actor, FAST_SPEED);
SET(u->Flags, SPR_RUN_AWAY); SET(u->Flags, SPR_RUN_AWAY);
//MONO_PRINT("Actor running away on track\n"); //MONO_PRINT("Actor running away on track\n");
@ -1181,7 +1170,6 @@ int InitActorRunToward(DSWActor* actor)
int InitActorAttack(DSWActor* actor) int InitActorAttack(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
// zombie is attacking a player // zombie is attacking a player
if (u->ID == ZOMBIE_RUN_R0 && u->targetActor->hasU() && u->targetActor->u()->PlayerP) if (u->ID == ZOMBIE_RUN_R0 && u->targetActor->hasU() && u->targetActor->u()->PlayerP)
@ -1230,7 +1218,7 @@ int InitActorAttack(DSWActor* actor)
//NewStateGroup(actor, u->ActorActionSet->Stand); //NewStateGroup(actor, u->ActorActionSet->Stand);
// face player when attacking // face player when attacking
sp->ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - sp->pos.X, u->targetActor->spr.pos.Y - sp->pos.Y)); actor->spr.ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - actor->spr.pos.X, u->targetActor->spr.pos.Y - actor->spr.pos.Y));
// If it's your own kind, lay off! // If it's your own kind, lay off!
if (u->ID == u->targetActor->u()->ID && !u->targetActor->u()->PlayerP) if (u->ID == u->targetActor->u()->ID && !u->targetActor->u()->PlayerP)
@ -1267,13 +1255,12 @@ int InitActorAttack(DSWActor* actor)
int DoActorAttack(DSWActor* actor) int DoActorAttack(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int rand_num; int rand_num;
int dist,a,b,c; int dist,a,b,c;
DoActorNoise(ChooseAction(u->Personality->Broadcast),actor); DoActorNoise(ChooseAction(u->Personality->Broadcast),actor);
DISTANCE(sp->pos.X, sp->pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y, dist, a, b, c); DISTANCE(actor->spr.pos.X, actor->spr.pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y, dist, a, b, c);
auto pActor = GetPlayerSpriteNum(actor); auto pActor = GetPlayerSpriteNum(actor);
if ((u->ActorActionSet->CloseAttack[0] && dist < CloseRangeDist(actor, u->targetActor)) || if ((u->ActorActionSet->CloseAttack[0] && dist < CloseRangeDist(actor, u->targetActor)) ||
@ -1303,7 +1290,6 @@ int DoActorAttack(DSWActor* actor)
int InitActorEvade(DSWActor* actor) int InitActorEvade(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
// Evade is same thing as run away except when you get to the end of the // Evade is same thing as run away except when you get to the end of the
// track // track
@ -1316,7 +1302,7 @@ int InitActorEvade(DSWActor* actor)
if (u->track >= 0) if (u->track >= 0)
{ {
sp->ang = NORM_ANGLE(getangle((Track[u->track].TrackPoint + u->point)->x - sp->pos.X, (Track[u->track].TrackPoint + u->point)->y - sp->pos.Y)); actor->spr.ang = NORM_ANGLE(getangle((Track[u->track].TrackPoint + u->point)->x - actor->spr.pos.X, (Track[u->track].TrackPoint + u->point)->y - actor->spr.pos.Y));
DoActorSetSpeed(actor, FAST_SPEED); DoActorSetSpeed(actor, FAST_SPEED);
// NOT doing a RUN_AWAY // NOT doing a RUN_AWAY
RESET(u->Flags, SPR_RUN_AWAY); RESET(u->Flags, SPR_RUN_AWAY);
@ -1328,7 +1314,6 @@ int InitActorEvade(DSWActor* actor)
int InitActorWanderAround(DSWActor* actor) int InitActorWanderAround(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
u->ActorActionFunc = DoActorDecide; u->ActorActionFunc = DoActorDecide;
NewStateGroup(actor, u->ActorActionSet->Run); NewStateGroup(actor, u->ActorActionSet->Run);
@ -1339,7 +1324,7 @@ int InitActorWanderAround(DSWActor* actor)
if (u->track >= 0) if (u->track >= 0)
{ {
sp->ang = getangle((Track[u->track].TrackPoint + u->point)->x - sp->pos.X, (Track[u->track].TrackPoint + u->point)->y - sp->pos.Y); actor->spr.ang = getangle((Track[u->track].TrackPoint + u->point)->x - actor->spr.pos.X, (Track[u->track].TrackPoint + u->point)->y - actor->spr.pos.Y);
DoActorSetSpeed(actor, NORM_SPEED); DoActorSetSpeed(actor, NORM_SPEED);
} }
@ -1349,7 +1334,6 @@ int InitActorWanderAround(DSWActor* actor)
int InitActorFindPlayer(DSWActor* actor) int InitActorFindPlayer(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
u->ActorActionFunc = DoActorDecide; u->ActorActionFunc = DoActorDecide;
NewStateGroup(actor, u->ActorActionSet->Run); NewStateGroup(actor, u->ActorActionSet->Run);
@ -1358,7 +1342,7 @@ int InitActorFindPlayer(DSWActor* actor)
if (u->track >= 0) if (u->track >= 0)
{ {
sp->ang = getangle((Track[u->track].TrackPoint + u->point)->x - sp->pos.X, (Track[u->track].TrackPoint + u->point)->y - sp->pos.Y); actor->spr.ang = getangle((Track[u->track].TrackPoint + u->point)->x - actor->spr.pos.X, (Track[u->track].TrackPoint + u->point)->y - actor->spr.pos.Y);
DoActorSetSpeed(actor, MID_SPEED); DoActorSetSpeed(actor, MID_SPEED);
SET(u->Flags, SPR_FIND_PLAYER); SET(u->Flags, SPR_FIND_PLAYER);
@ -1377,7 +1361,6 @@ int InitActorFindPlayer(DSWActor* actor)
int InitActorDuck(DSWActor* actor) int InitActorDuck(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int dist; int dist;
if (!u->ActorActionSet->Duck) if (!u->ActorActionSet->Duck)
@ -1389,7 +1372,7 @@ int InitActorDuck(DSWActor* actor)
u->ActorActionFunc = DoActorDuck; u->ActorActionFunc = DoActorDuck;
NewStateGroup(actor, u->ActorActionSet->Duck); NewStateGroup(actor, u->ActorActionSet->Duck);
dist = Distance(sp->pos.X, sp->pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y); dist = Distance(actor->spr.pos.X, actor->spr.pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y);
if (dist > 8000) if (dist > 8000)
{ {
@ -1424,13 +1407,12 @@ int DoActorDuck(DSWActor* actor)
int DoActorMoveJump(DSWActor* actor) int DoActorMoveJump(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int nx, ny; int nx, ny;
// Move while jumping // Move while jumping
nx = MulScale(sp->xvel, bcos(sp->ang), 14); nx = MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
ny = MulScale(sp->xvel, bsin(sp->ang), 14); ny = MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
move_actor(actor, nx, ny, 0L); move_actor(actor, nx, ny, 0L);
@ -1446,7 +1428,6 @@ int DoActorMoveJump(DSWActor* actor)
Collision move_scan(DSWActor* actor, int ang, int dist, int *stopx, int *stopy, int *stopz) Collision move_scan(DSWActor* actor, int ang, int dist, int *stopx, int *stopy, int *stopz)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
int nx,ny; int nx,ny;
uint32_t cliptype = CLIPMASK_ACTOR; uint32_t cliptype = CLIPMASK_ACTOR;
@ -1461,22 +1442,22 @@ Collision move_scan(DSWActor* actor, int ang, int dist, int *stopx, int *stopy,
// moves out a bit but keeps the sprites original postion/sector. // moves out a bit but keeps the sprites original postion/sector.
// save off position info // save off position info
x = sp->pos.X; x = actor->spr.pos.X;
y = sp->pos.Y; y = actor->spr.pos.Y;
z = sp->pos.Z; z = actor->spr.pos.Z;
sang = sp->ang; sang = actor->spr.ang;
loz = u->loz; loz = u->loz;
hiz = u->hiz; hiz = u->hiz;
lowActor = u->lowActor; lowActor = u->lowActor;
highActor = u->highActor; highActor = u->highActor;
lo_sectp = u->lo_sectp; lo_sectp = u->lo_sectp;
hi_sectp = u->hi_sectp; hi_sectp = u->hi_sectp;
ssp = sp->sector(); ssp = actor->spr.sector();
// do the move // do the move
sp->ang = ang; actor->spr.ang = ang;
nx = MulScale(dist, bcos(sp->ang), 14); nx = MulScale(dist, bcos(actor->spr.ang), 14);
ny = MulScale(dist, bsin(sp->ang), 14); ny = MulScale(dist, bsin(actor->spr.ang), 14);
Collision ret = move_sprite(actor, nx, ny, 0, u->ceiling_dist, u->floor_dist, cliptype, 1); Collision ret = move_sprite(actor, nx, ny, 0, u->ceiling_dist, u->floor_dist, cliptype, 1);
// move_sprite DOES do a getzrange point? // move_sprite DOES do a getzrange point?
@ -1484,15 +1465,15 @@ Collision move_scan(DSWActor* actor, int ang, int dist, int *stopx, int *stopy,
// should I look down with a FAFgetzrange to see where I am? // should I look down with a FAFgetzrange to see where I am?
// remember where it stopped // remember where it stopped
*stopx = sp->pos.X; *stopx = actor->spr.pos.X;
*stopy = sp->pos.Y; *stopy = actor->spr.pos.Y;
*stopz = sp->pos.Z; *stopz = actor->spr.pos.Z;
// reset position information // reset position information
sp->pos.X = x; actor->spr.pos.X = x;
sp->pos.Y = y; actor->spr.pos.Y = y;
sp->pos.Z = z; actor->spr.pos.Z = z;
sp->ang = sang; actor->spr.ang = sang;
u->loz = loz; u->loz = loz;
u->hiz = hiz; u->hiz = hiz;
u->lowActor = lowActor; u->lowActor = lowActor;
@ -1513,7 +1494,6 @@ enum
int FindNewAngle(DSWActor* actor, int dir, int DistToMove) int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
static const int16_t toward_angle_delta[4][9] = static const int16_t toward_angle_delta[4][9] =
{ {
@ -1547,7 +1527,7 @@ int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
DistToMove = (DistToMove >> 2) + (DistToMove >> 3); DistToMove = (DistToMove >> 2) + (DistToMove >> 3);
// Find angle to from the player // Find angle to from the player
oang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - sp->pos.X, u->targetActor->spr.pos.Y - sp->pos.Y)); oang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - actor->spr.pos.X, u->targetActor->spr.pos.Y - actor->spr.pos.Y));
// choose a random angle array // choose a random angle array
switch (dir) switch (dir)
@ -1580,13 +1560,13 @@ int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
// look directly ahead for a ledge // look directly ahead for a ledge
if (!TEST(u->Flags, SPR_NO_SCAREDZ | SPR_JUMPING | SPR_FALLING | SPR_SWIMMING | SPR_DEAD)) if (!TEST(u->Flags, SPR_NO_SCAREDZ | SPR_JUMPING | SPR_FALLING | SPR_SWIMMING | SPR_DEAD))
{ {
sp->ang = new_ang; actor->spr.ang = new_ang;
if (DropAhead(actor, u->lo_step)) if (DropAhead(actor, u->lo_step))
{ {
sp->ang = oang; actor->spr.ang = oang;
continue; continue;
} }
sp->ang = oang; actor->spr.ang = oang;
} }
#endif #endif
@ -1596,13 +1576,13 @@ int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
if (ret.type == kHitNone) if (ret.type == kHitNone)
{ {
// cleanly moved in new direction without hitting something // cleanly moved in new direction without hitting something
u->TargetDist = Distance(sp->pos.X, sp->pos.Y, stopx, stopy); u->TargetDist = Distance(actor->spr.pos.X, actor->spr.pos.Y, stopx, stopy);
return new_ang; return new_ang;
} }
else else
{ {
// hit something // hit something
dist = Distance(sp->pos.X, sp->pos.Y, stopx, stopy); dist = Distance(actor->spr.pos.X, actor->spr.pos.Y, stopx, stopy);
if (dist > save_dist) if (dist > save_dist)
{ {
@ -1625,7 +1605,7 @@ int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
if (u->TargetDist > 4000) if (u->TargetDist > 4000)
u->TargetDist -= 3500; u->TargetDist -= 3500;
sp->ang = save_ang; actor->spr.ang = save_ang;
return save_ang; return save_ang;
} }
@ -1649,12 +1629,11 @@ int FindNewAngle(DSWActor* actor, int dir, int DistToMove)
int InitActorReposition(DSWActor* actor) int InitActorReposition(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int ang; int ang;
int rnum; int rnum;
int dist; int dist;
static int AwayDist[8] = static const int AwayDist[8] =
{ {
17000, 17000,
20000, 20000,
@ -1666,7 +1645,7 @@ int InitActorReposition(DSWActor* actor)
42000 42000
}; };
static int TowardDist[8] = static const int TowardDist[8] =
{ {
10000, 10000,
15000, 15000,
@ -1678,7 +1657,7 @@ int InitActorReposition(DSWActor* actor)
40000 40000
}; };
static int PlayerDist[8] = static const int16_t PlayerDist[8] =
{ {
2000, 2000,
3000, 3000,
@ -1690,12 +1669,10 @@ int InitActorReposition(DSWActor* actor)
9000 9000
}; };
//MONO_PRINT("InitActorReposition\n");
u->Dist = 0; u->Dist = 0;
rnum = RANDOM_P2(8<<8)>>8; rnum = RANDOM_P2(8<<8)>>8;
dist = Distance(sp->pos.X, sp->pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y); dist = Distance(actor->spr.pos.X, actor->spr.pos.Y, u->targetActor->spr.pos.X, u->targetActor->spr.pos.Y);
if (dist < PlayerDist[rnum] || TEST(u->Flags, SPR_RUN_AWAY)) if (dist < PlayerDist[rnum] || TEST(u->Flags, SPR_RUN_AWAY))
{ {
@ -1708,7 +1685,7 @@ int InitActorReposition(DSWActor* actor)
return 0; return 0;
} }
sp->ang = ang; actor->spr.ang = ang;
DoActorSetSpeed(actor, FAST_SPEED); DoActorSetSpeed(actor, FAST_SPEED);
RESET(u->Flags, SPR_RUN_AWAY); RESET(u->Flags, SPR_RUN_AWAY);
} }
@ -1738,7 +1715,7 @@ int InitActorReposition(DSWActor* actor)
DoActorSetSpeed(actor, MID_SPEED); DoActorSetSpeed(actor, MID_SPEED);
} }
sp->ang = ang; actor->spr.ang = ang;
} }
@ -1754,11 +1731,10 @@ int InitActorReposition(DSWActor* actor)
int DoActorReposition(DSWActor* actor) int DoActorReposition(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int nx, ny; int nx, ny;
nx = MulScale(sp->xvel, bcos(sp->ang), 14); nx = MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
ny = MulScale(sp->xvel, bsin(sp->ang), 14); ny = MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
// still might hit something and have to handle it. // still might hit something and have to handle it.
if (!move_actor(actor, nx, ny, 0L)) if (!move_actor(actor, nx, ny, 0L))
@ -1787,10 +1763,6 @@ int InitActorPause(DSWActor* actor)
u->ActorActionFunc = DoActorPause; u->ActorActionFunc = DoActorPause;
// !JIM! This makes actors not animate
//if (!TEST(u->Flags, SPR_SWIMMING))
//NewStateGroup(actor, u->ActorActionSet->Stand);
(*u->ActorActionFunc)(actor); (*u->ActorActionFunc)(actor);
return 0; return 0;

11
source/games/sw/src/game.h
View file

@ -2119,6 +2119,17 @@ END_SW_NS
BEGIN_SW_NS BEGIN_SW_NS
// actual Z for TOS and BOS - handles both WYSIWYG and old style
inline int ActorZOfTop(DSWActor* actor)
{
return GetSpriteZOfTop(&actor->spr);
}
inline int ActorSizeZ(DSWActor* actor)
{
return (tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 2;
}
inline int ActorUpperZ(DSWActor* actor) inline int ActorUpperZ(DSWActor* actor)
{ {
return (GetSpriteZOfTop(&actor->spr) + (GetSpriteSizeZ(&actor->spr) >> 2)); return (GetSpriteZOfTop(&actor->spr) + (GetSpriteSizeZ(&actor->spr) >> 2));