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

- SW: all s() in actor.cpp

Browse source
This commit is contained in:
Christoph Oelckers 2021-12-23 19:20:50 +01:00
parent 2718b3a5e3
commit 92f2182e6e
4 changed files with 108 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
source/games/exhumed/src/snake.cpp
View file

@ -130,17 +130,16 @@ void BuildSnake(int nPlayer, int zVal)
zVal -= 1280; zVal -= 1280;
auto pPlayerActor = PlayerList[nPlayer].Actor(); auto pPlayerActor = PlayerList[nPlayer].Actor();
auto pPlayerSprite = &pPlayerActor->s();
auto pViewSect = PlayerList[nPlayer].pPlayerViewSect; auto pViewSect = PlayerList[nPlayer].pPlayerViewSect;
int nPic = seq_GetSeqPicnum(kSeqSnakBody, 0, 0); int nPic = seq_GetSeqPicnum(kSeqSnakBody, 0, 0);
int x = pPlayerSprite->pos.X; int x = pPlayerActor->spr.pos.X;
int y = pPlayerSprite->pos.Y; int y = pPlayerActor->spr.pos.Y;
int z = (pPlayerSprite->pos.Z + zVal) - 2560; int z = (pPlayerActor->spr.pos.Z + zVal) - 2560;
int nAngle = pPlayerSprite->ang; int nAngle = pPlayerActor->spr.ang;
HitInfo hit{}; HitInfo hit{};
hitscan({ x, y, z }, pPlayerSprite->sector(), { bcos(nAngle), bsin(nAngle), 0 }, hit, CLIPMASK1); hitscan({ x, y, z }, pPlayerActor->spr.sector(), { bcos(nAngle), bsin(nAngle), 0 }, hit, CLIPMASK1);
uint32_t yDiff = abs(hit.hitpos.Y - y); uint32_t yDiff = abs(hit.hitpos.Y - y);
uint32_t xDiff = abs(hit.hitpos.X - x); uint32_t xDiff = abs(hit.hitpos.X - x);
@ -194,9 +193,9 @@ void BuildSnake(int nPlayer, int zVal)
if (i == 0) if (i == 0)
{ {
pActor->spr.pos.X = pPlayerSprite->pos.X; pActor->spr.pos.X = pPlayerActor->spr.pos.X;
pActor->spr.pos.Y = pPlayerSprite->pos.Y; pActor->spr.pos.Y = pPlayerActor->spr.pos.Y;
pActor->spr.pos.Z = pPlayerSprite->pos.Z + zVal; pActor->spr.pos.Z = pPlayerActor->spr.pos.Z + zVal;
pActor->spr.xrepeat = 32; pActor->spr.xrepeat = 32;
pActor->spr.yrepeat = 32; pActor->spr.yrepeat = 32;
pViewSect = pActor->spr.sector(); pViewSect = pActor->spr.sector();
@ -217,7 +216,7 @@ void BuildSnake(int nPlayer, int zVal)
pActor->spr.pal = 0; pActor->spr.pal = 0;
pActor->spr.xoffset = 0; pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0; pActor->spr.yoffset = 0;
pActor->spr.ang = pPlayerSprite->ang; pActor->spr.ang = pPlayerActor->spr.ang;
pActor->spr.xvel = 0; pActor->spr.xvel = 0;
pActor->spr.yvel = 0; pActor->spr.yvel = 0;
pActor->spr.zvel = 0; pActor->spr.zvel = 0;
@ -274,10 +273,9 @@ DExhumedActor* FindSnakeEnemy(int nSnake)
ExhumedSectIterator it(pSector); ExhumedSectIterator it(pSector);
while (auto pAct2 = it.Next()) while (auto pAct2 = it.Next())
{ {
auto pSpr2 = &pAct2->s(); if (pAct2->spr.statnum >= 90 && pAct2->spr.statnum < 150 && (pAct2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL))
if (pSpr2->statnum >= 90 && pSpr2->statnum < 150 && (pSpr2->cstat & CSTAT_SPRITE_BLOCK_ALL))
{ {
if (pAct2 != pPlayerActor && !(pSpr2->cstat & CSTAT_SPRITE_INVISIBLE)) if (pAct2 != pPlayerActor && !(pAct2->spr.cstat & CSTAT_SPRITE_INVISIBLE))
{ {
int nAngle2 = (nAngle - GetAngleToSprite(pActor, pAct2)) & kAngleMask; int nAngle2 = (nAngle - GetAngleToSprite(pActor, pAct2)) & kAngleMask;
if (nAngle2 < esi) if (nAngle2 < esi)
@ -381,12 +379,11 @@ void AISnake::Tick(RunListEvent* ev)
{ {
DExhumedActor* pActor2 = SnakeList[nSnake].pSprites[i]; DExhumedActor* pActor2 = SnakeList[nSnake].pSprites[i];
if (!pActor2) continue; if (!pActor2) continue;
auto pSprite2 = &pActor2->s();
pSprite2->ang = nAngle; pActor2->spr.ang = nAngle;
pSprite2->pos.X = x; pActor2->spr.pos.X = x;
pSprite2->pos.Y = y; pActor2->spr.pos.Y = y;
pSprite2->pos.Z = z; pActor2->spr.pos.Z = z;
ChangeActorSect(pActor2, pSector); ChangeActorSect(pActor2, pSector);

193
source/games/sw/src/actor.cpp
View file

@ -58,7 +58,6 @@ extern STATEp sg_NinjaGrabThroat[];
int DoScaleSprite(DSWActor* actor) int DoScaleSprite(DSWActor* actor)
{ {
auto u = actor->u(); auto u = actor->u();
auto sp = &actor->s();
int scale_value; int scale_value;
if (u->scale_speed) if (u->scale_speed)
@ -72,14 +71,14 @@ int DoScaleSprite(DSWActor* actor)
if (scale_value > u->scale_tgt) if (scale_value > u->scale_tgt)
u->scale_speed = 0; u->scale_speed = 0;
else else
sp->xrepeat = sp->yrepeat = scale_value; actor->spr.xrepeat = actor->spr.yrepeat = scale_value;
} }
else else
{ {
if (scale_value < u->scale_tgt) if (scale_value < u->scale_tgt)
u->scale_speed = 0; u->scale_speed = 0;
else else
sp->xrepeat = sp->yrepeat = scale_value; actor->spr.xrepeat = actor->spr.yrepeat = scale_value;
} }
} }
@ -90,8 +89,6 @@ int DoScaleSprite(DSWActor* actor)
int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath) int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
{ {
auto u = actor->u(); auto u = actor->u();
auto sp = &actor->s();
change_actor_stat(actor, STAT_DEAD_ACTOR); change_actor_stat(actor, STAT_DEAD_ACTOR);
SET(u->Flags, SPR_DEAD); SET(u->Flags, SPR_DEAD);
@ -99,8 +96,8 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
u->floor_dist = Z(40); u->floor_dist = Z(40);
// test for gibable dead bodies // test for gibable dead bodies
SET(sp->extra, SPRX_BREAKABLE); SET(actor->spr.extra, SPRX_BREAKABLE);
SET(sp->cstat, CSTAT_SPRITE_BREAKABLE); SET(actor->spr.cstat, CSTAT_SPRITE_BREAKABLE);
if (weapActor == nullptr) if (weapActor == nullptr)
{ {
@ -123,7 +120,6 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
if (!weapActor->hasU()) return 0; if (!weapActor->hasU()) return 0;
auto wu = weapActor->u(); auto wu = weapActor->u();
auto wp = &weapActor->s();
// killed by one of these sprites // killed by one of these sprites
switch (wu->ID) switch (wu->ID)
@ -133,9 +129,9 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
case COOLIE_RUN_R0: case COOLIE_RUN_R0:
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
u->RotNum = 0; u->RotNum = 0;
sp->xvel <<= 1; actor->spr.xvel <<= 1;
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
sp->ang = NORM_ANGLE(sp->ang + 1024); actor->spr.ang = NORM_ANGLE(actor->spr.ang + 1024);
break; break;
case NINJA_RUN_R0: case NINJA_RUN_R0:
@ -163,19 +159,19 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
u->RotNum = 0; u->RotNum = 0;
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
sp->xvel = 200 + RandomRange(200); actor->spr.xvel = 200 + RandomRange(200);
u->jump_speed = -200 - RandomRange(250); u->jump_speed = -200 - RandomRange(250);
DoActorBeginJump(actor); DoActorBeginJump(actor);
sp->ang = wp->ang; actor->spr.ang = weapActor->spr.ang;
} }
} }
else else
{ {
// test for gibable dead bodies // test for gibable dead bodies
if (RandomRange(1000) > 500) if (RandomRange(1000) > 500)
SET(sp->cstat, CSTAT_SPRITE_YFLIP); SET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
sp->xvel = 0; actor->spr.xvel = 0;
u->jump_speed = 0; u->jump_speed = 0;
DoActorBeginJump(actor); DoActorBeginJump(actor);
} }
@ -185,7 +181,7 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
//u->ActorActionFunc = NullAnimator; //u->ActorActionFunc = NullAnimator;
if (!sw_ninjahack) if (!sw_ninjahack)
sp->ang = wp->ang; actor->spr.ang = weapActor->spr.ang;
break; break;
case COOLG_RUN_R0: case COOLG_RUN_R0:
@ -201,48 +197,48 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
case UZI_SMOKE: case UZI_SMOKE:
if (RandomRange(1000) > 500) if (RandomRange(1000) > 500)
SET(sp->cstat, CSTAT_SPRITE_YFLIP); SET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
u->RotNum = 0; u->RotNum = 0;
// Rippers still gotta jump or they fall off walls weird // Rippers still gotta jump or they fall off walls weird
if (u->ID == RIPPER_RUN_R0 || u->ID == RIPPER2_RUN_R0) if (u->ID == RIPPER_RUN_R0 || u->ID == RIPPER2_RUN_R0)
{ {
sp->xvel <<= 1; actor->spr.xvel <<= 1;
u->jump_speed = -100 - RandomRange(250); u->jump_speed = -100 - RandomRange(250);
DoActorBeginJump(actor); DoActorBeginJump(actor);
} }
else else
{ {
sp->xvel = 0; actor->spr.xvel = 0;
u->jump_speed = -10 - RandomRange(25); u->jump_speed = -10 - RandomRange(25);
DoActorBeginJump(actor); DoActorBeginJump(actor);
} }
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
// Get angle to player // Get angle to player
sp->ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - sp->pos.X, u->targetActor->spr.pos.Y - sp->pos.Y) + 1024); actor->spr.ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - actor->spr.pos.X, u->targetActor->spr.pos.Y - actor->spr.pos.Y) + 1024);
break; break;
case UZI_SMOKE+1: // Shotgun case UZI_SMOKE+1: // Shotgun
if (RandomRange(1000) > 500) if (RandomRange(1000) > 500)
SET(sp->cstat, CSTAT_SPRITE_YFLIP); SET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
u->RotNum = 0; u->RotNum = 0;
// Rippers still gotta jump or they fall off walls weird // Rippers still gotta jump or they fall off walls weird
if (u->ID == RIPPER_RUN_R0 || u->ID == RIPPER2_RUN_R0) if (u->ID == RIPPER_RUN_R0 || u->ID == RIPPER2_RUN_R0)
{ {
sp->xvel = 75 + RandomRange(100); actor->spr.xvel = 75 + RandomRange(100);
u->jump_speed = -100 - RandomRange(150); u->jump_speed = -100 - RandomRange(150);
} }
else else
{ {
sp->xvel = 100 + RandomRange(200); actor->spr.xvel = 100 + RandomRange(200);
u->jump_speed = -100 - RandomRange(250); u->jump_speed = -100 - RandomRange(250);
} }
DoActorBeginJump(actor); DoActorBeginJump(actor);
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
// Get angle to player // Get angle to player
sp->ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - sp->pos.X, u->targetActor->spr.pos.Y - sp->pos.Y) + 1024); actor->spr.ang = NORM_ANGLE(getangle(u->targetActor->spr.pos.X - actor->spr.pos.X, u->targetActor->spr.pos.Y - actor->spr.pos.Y) + 1024);
break; break;
default: default:
@ -260,14 +256,14 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
} }
if (RandomRange(1000) > 500) if (RandomRange(1000) > 500)
SET(sp->cstat, CSTAT_SPRITE_YFLIP); SET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
ChangeState(actor, u->StateEnd); ChangeState(actor, u->StateEnd);
u->RotNum = 0; u->RotNum = 0;
u->ActorActionFunc = nullptr; u->ActorActionFunc = nullptr;
sp->xvel = 300 + RandomRange(400); actor->spr.xvel = 300 + RandomRange(400);
u->jump_speed = -300 - RandomRange(350); u->jump_speed = -300 - RandomRange(350);
DoActorBeginJump(actor); DoActorBeginJump(actor);
sp->ang = wp->ang; actor->spr.ang = weapActor->spr.ang;
break; break;
} }
break; break;
@ -280,7 +276,7 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
case COOLIE_RUN_R0: case COOLIE_RUN_R0:
case SUMO_RUN_R0: case SUMO_RUN_R0:
case ZILLA_RUN_R0: case ZILLA_RUN_R0:
RESET(sp->cstat, CSTAT_SPRITE_YFLIP); RESET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
break; break;
} }
@ -293,10 +289,9 @@ void DoDebrisCurrent(DSWActor* actor)
{ {
int nx, ny; int nx, ny;
USERp u = actor->u(); USERp u = actor->u();
auto sp = &actor->s(); auto sectp = actor->spr.sector();
auto sectp = sp->sector();
//sp->clipdist = (256+128)>>2; //actor->spr.clipdist = (256+128)>>2;
nx = MulScale((sectp->speed >> 2), bcos(sectp->ang), 14); nx = MulScale((sectp->speed >> 2), bcos(sectp->ang), 14);
ny = MulScale((sectp->speed >> 2), bsin(sectp->ang), 14); ny = MulScale((sectp->speed >> 2), bsin(sectp->ang), 14);
@ -314,14 +309,13 @@ void DoDebrisCurrent(DSWActor* actor)
move_sprite(actor, nx, ny, 0, u->ceiling_dist, u->floor_dist, 0, ACTORMOVETICS); move_sprite(actor, nx, ny, 0, u->ceiling_dist, u->floor_dist, 0, ACTORMOVETICS);
} }
sp->pos.Z = u->loz; actor->spr.pos.Z = u->loz;
} }
int DoActorSectorDamage(DSWActor* actor) int DoActorSectorDamage(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s(); SECTORp sectp = actor->spr.sector();
SECTORp sectp = sp->sector();
if (u->Health <= 0) if (u->Health <= 0)
return false; return false;
@ -343,7 +337,7 @@ int DoActorSectorDamage(DSWActor* actor)
} }
} }
} }
else if (SPRITEp_BOS(sp) >= sectp->floorz) else if (SPRITEp_BOS(&actor->spr) >= sectp->floorz)
{ {
if ((u->DamageTics -= synctics) < 0) if ((u->DamageTics -= synctics) < 0)
{ {
@ -361,8 +355,7 @@ int DoActorSectorDamage(DSWActor* actor)
} }
// note that most squishing is done in vator.c // note that most squishing is done in vator.c
if (u->lo_sectp && u->hi_sectp && labs(u->loz - u->hiz) < DIV2(SPRITEp_SIZE_Z(sp))) if (u->lo_sectp && u->hi_sectp && labs(u->loz - u->hiz) < (SPRITEp_SIZE_Z(actor) >> 1))
//if (u->lo_sectp && u->hi_sectp && labs(u->loz - u->hiz) < SPRITEp_SIZE_Z(sp))
{ {
u->Health = 0; u->Health = 0;
if (SpawnShrap(actor, nullptr, WPN_NM_SECTOR_SQUISH)) if (SpawnShrap(actor, nullptr, WPN_NM_SECTOR_SQUISH))
@ -399,12 +392,11 @@ bool move_debris(DSWActor* actor, int xchange, int ychange, int zchange)
int DoActorDebris(DSWActor* actor) int DoActorDebris(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s(); SECTORp sectp = actor->spr.sector();
SECTORp sectp = sp->sector();
int nx, ny; int nx, ny;
// This was move from DoActorDie so actor's can't be walked through until they are on the floor // This was move from DoActorDie so actor's can't be walked through until they are on the floor
RESET(sp->cstat, CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN); RESET(actor->spr.cstat, CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
// Don't let some actors float // Don't let some actors float
switch (u->ID) switch (u->ID)
@ -414,9 +406,9 @@ int DoActorDebris(DSWActor* actor)
KillActor(actor); KillActor(actor);
return 0; return 0;
case ZILLA_RUN_R0: case ZILLA_RUN_R0:
getzsofslopeptr(sp->sector(), sp->pos.X, sp->pos.Y, &u->hiz, &u->loz); getzsofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, &u->hiz, &u->loz);
u->lo_sectp = sp->sector(); u->lo_sectp = actor->spr.sector();
u->hi_sectp = sp->sector(); u->hi_sectp = actor->spr.sector();
u->lowActor = nullptr; u->lowActor = nullptr;
u->highActor = nullptr; u->highActor = nullptr;
break; break;
@ -430,29 +422,29 @@ int DoActorDebris(DSWActor* actor)
} }
else else
{ {
//nx = sp->xvel * ACTORMOVETICS * bcos(sp->ang) >> 14; //nx = actor->spr.xvel * ACTORMOVETICS * bcos(actor->spr.ang) >> 14;
//ny = sp->xvel * ACTORMOVETICS * bsin(sp->ang) >> 14; //ny = actor->spr.xvel * ACTORMOVETICS * bsin(actor->spr.ang) >> 14;
nx = MulScale(ACTORMOVETICS, bcos(sp->ang), 14); nx = MulScale(ACTORMOVETICS, bcos(actor->spr.ang), 14);
ny = MulScale(ACTORMOVETICS, bsin(sp->ang), 14); ny = MulScale(ACTORMOVETICS, bsin(actor->spr.ang), 14);
//sp->clipdist = (256+128)>>2; //actor->spr.clipdist = (256+128)>>2;
if (!move_debris(actor, nx, ny, 0L)) if (!move_debris(actor, nx, ny, 0L))
{ {
sp->ang = RANDOM_P2(2048); actor->spr.ang = RANDOM_P2(2048);
} }
} }
if (sp->sector()->hasU() && FixedToInt(sp->sector()->depth_fixed) > 10) // JBF: added null check if (actor->spr.sector()->hasU() && FixedToInt(actor->spr.sector()->depth_fixed) > 10) // JBF: added null check
{ {
u->WaitTics = (u->WaitTics + (ACTORMOVETICS << 3)) & 1023; u->WaitTics = (u->WaitTics + (ACTORMOVETICS << 3)) & 1023;
//sp->z = Z(2) + u->loz + ((Z(4) * (int) bsin(u->WaitTics)) >> 14); //actor->spr.z = Z(2) + u->loz + ((Z(4) * (int) bsin(u->WaitTics)) >> 14);
sp->pos.Z = u->loz - MulScale(Z(2), bsin(u->WaitTics), 14); actor->spr.pos.Z = u->loz - MulScale(Z(2), bsin(u->WaitTics), 14);
} }
} }
else else
{ {
sp->pos.Z = u->loz; actor->spr.pos.Z = u->loz;
} }
return 0; return 0;
@ -462,27 +454,25 @@ int DoActorDebris(DSWActor* actor)
int DoFireFly(DSWActor* actor) int DoFireFly(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int nx, ny; int nx, ny;
nx = 4 * ACTORMOVETICS * bcos(sp->ang) >> 14; nx = 4 * ACTORMOVETICS * bcos(actor->spr.ang) >> 14;
ny = 4 * ACTORMOVETICS * bsin(sp->ang) >> 14; ny = 4 * ACTORMOVETICS * bsin(actor->spr.ang) >> 14;
sp->clipdist = 256>>2; actor->spr.clipdist = 256>>2;
if (!move_actor(actor, nx, ny, 0L)) if (!move_actor(actor, nx, ny, 0L))
{ {
sp->ang = NORM_ANGLE(sp->ang + 1024); actor->spr.ang = NORM_ANGLE(actor->spr.ang + 1024);
} }
u->WaitTics = (u->WaitTics + (ACTORMOVETICS << 1)) & 2047; u->WaitTics = (u->WaitTics + (ACTORMOVETICS << 1)) & 2047;
sp->pos.Z = u->sz + MulScale(Z(32), bsin(u->WaitTics), 14); actor->spr.pos.Z = u->sz + MulScale(Z(32), bsin(u->WaitTics), 14);
return 0; return 0;
} }
int DoGenerateSewerDebris(DSWActor* actor) int DoGenerateSewerDebris(DSWActor* actor)
{ {
SPRITEp sp = &actor->s();
USERp u = actor->u(); USERp u = actor->u();
static STATEp Debris[] = static STATEp Debris[] =
@ -499,7 +489,7 @@ int DoGenerateSewerDebris(DSWActor* actor)
{ {
u->Tics = u->WaitTics; u->Tics = u->WaitTics;
auto spawned = SpawnActor(STAT_DEAD_ACTOR, 0, Debris[RANDOM_P2(4<<8)>>8], sp->sector(), sp->pos.X, sp->pos.Y, sp->pos.Z, sp->ang, 200); auto spawned = SpawnActor(STAT_DEAD_ACTOR, 0, Debris[RANDOM_P2(4<<8)>>8], actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang, 200);
SetOwner(actor, spawned); SetOwner(actor, spawned);
} }
@ -512,13 +502,12 @@ int DoGenerateSewerDebris(DSWActor* actor)
void KeepActorOnFloor(DSWActor* actor) void KeepActorOnFloor(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
SECTORp sectp; SECTORp sectp;
int depth; int depth;
sectp = sp->sector(); sectp = actor->spr.sector();
RESET(sp->cstat, CSTAT_SPRITE_YFLIP); // If upside down, reset it RESET(actor->spr.cstat, CSTAT_SPRITE_YFLIP); // If upside down, reset it
if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING))
return; return;
@ -538,9 +527,9 @@ void KeepActorOnFloor(DSWActor* actor)
{ {
// was swimming but have now stopped // was swimming but have now stopped
RESET(u->Flags, SPR_SWIMMING); RESET(u->Flags, SPR_SWIMMING);
RESET(sp->cstat, CSTAT_SPRITE_YCENTER); RESET(actor->spr.cstat, CSTAT_SPRITE_YCENTER);
u->oz = sp->pos.Z = u->loz; u->oz = actor->spr.pos.Z = u->loz;
sp->backupz(); actor->spr.backupz();
return; return;
} }
@ -550,8 +539,8 @@ void KeepActorOnFloor(DSWActor* actor)
} }
// are swimming // are swimming
u->oz = sp->pos.Z = u->loz - Z(depth); u->oz = actor->spr.pos.Z = u->loz - Z(depth);
sp->backupz(); actor->spr.backupz();
} }
else else
{ {
@ -559,17 +548,17 @@ void KeepActorOnFloor(DSWActor* actor)
if (u->Rot == u->ActorActionSet->Run || u->Rot == u->ActorActionSet->Swim) if (u->Rot == u->ActorActionSet->Run || u->Rot == u->ActorActionSet->Swim)
{ {
NewStateGroup(actor, u->ActorActionSet->Swim); NewStateGroup(actor, u->ActorActionSet->Swim);
u->oz = sp->pos.Z = u->loz - Z(depth); u->oz = actor->spr.pos.Z = u->loz - Z(depth);
sp->backupz(); actor->spr.backupz();
SET(u->Flags, SPR_SWIMMING); SET(u->Flags, SPR_SWIMMING);
SET(sp->cstat, CSTAT_SPRITE_YCENTER); SET(actor->spr.cstat, CSTAT_SPRITE_YCENTER);
} }
else else
{ {
RESET(u->Flags, SPR_SWIMMING); RESET(u->Flags, SPR_SWIMMING);
RESET(sp->cstat, CSTAT_SPRITE_YCENTER); RESET(actor->spr.cstat, CSTAT_SPRITE_YCENTER);
u->oz = sp->pos.Z = u->loz; u->oz = actor->spr.pos.Z = u->loz;
sp->backupz(); actor->spr.backupz();
} }
} }
@ -578,23 +567,23 @@ void KeepActorOnFloor(DSWActor* actor)
// NOT in a swimming situation // NOT in a swimming situation
RESET(u->Flags, SPR_SWIMMING); RESET(u->Flags, SPR_SWIMMING);
RESET(sp->cstat, CSTAT_SPRITE_YCENTER); RESET(actor->spr.cstat, CSTAT_SPRITE_YCENTER);
#if 1 #if 1
if (TEST(u->Flags, SPR_MOVED)) if (TEST(u->Flags, SPR_MOVED))
{ {
u->oz = sp->pos.Z = u->loz; u->oz = actor->spr.pos.Z = u->loz;
sp->backupz(); actor->spr.backupz();
} }
else else
{ {
int ceilz, florz; int ceilz, florz;
Collision ctrash, ftrash; Collision ctrash, ftrash;
FAFgetzrangepoint(sp->pos.X, sp->pos.Y, sp->pos.Z, sp->sector(), FAFgetzrangepoint(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(),
&ceilz, &ctrash, &florz, &ftrash); &ceilz, &ctrash, &florz, &ftrash);
u->oz = sp->pos.Z = florz; u->oz = actor->spr.pos.Z = florz;
sp->backupz(); actor->spr.backupz();
} }
#endif #endif
@ -677,7 +666,6 @@ int DoActorBeginJump(DSWActor* actor)
int DoActorJump(DSWActor* actor) int DoActorJump(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int jump_adj; int jump_adj;
@ -694,13 +682,14 @@ int DoActorJump(DSWActor* actor)
} }
// adjust height by jump speed // adjust height by jump speed
sp->pos.Z += u->jump_speed * ACTORMOVETICS; actor->spr.pos.Z += u->jump_speed * ACTORMOVETICS;
// if player gets to close the ceiling while jumping // if player gets to close the ceiling while jumping
if (sp->pos.Z < u->hiz + Z(PIC_SIZY(sp))) int minh = u->hiz + (tileHeight(actor->spr.picnum) << 8);
if (actor->spr.pos.Z < minh)
{ {
// put player at the ceiling // put player at the ceiling
sp->pos.Z = u->hiz + Z(PIC_SIZY(sp)); actor->spr.pos.Z = minh;
// reverse your speed to falling // reverse your speed to falling
u->jump_speed = -u->jump_speed; u->jump_speed = -u->jump_speed;
@ -746,16 +735,15 @@ int DoActorBeginFall(DSWActor* actor)
int DoActorFall(DSWActor* actor) int DoActorFall(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
// adjust jump speed by gravity // adjust jump speed by gravity
u->jump_speed += u->jump_grav * ACTORMOVETICS; u->jump_speed += u->jump_grav * ACTORMOVETICS;
// adjust player height by jump speed // adjust player height by jump speed
sp->pos.Z += u->jump_speed * ACTORMOVETICS; actor->spr.pos.Z += u->jump_speed * ACTORMOVETICS;
// Stick like glue when you hit the ground // Stick like glue when you hit the ground
if (sp->pos.Z > u->loz) if (actor->spr.pos.Z > u->loz)
{ {
DoActorStopFall(actor); DoActorStopFall(actor);
} }
@ -766,19 +754,18 @@ int DoActorFall(DSWActor* actor)
int DoActorStopFall(DSWActor* actor) int DoActorStopFall(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
sp->pos.Z = u->loz; actor->spr.pos.Z = u->loz;
RESET(u->Flags, SPR_FALLING | SPR_JUMPING); RESET(u->Flags, SPR_FALLING | SPR_JUMPING);
RESET(sp->cstat, CSTAT_SPRITE_YFLIP); RESET(actor->spr.cstat, CSTAT_SPRITE_YFLIP);
// don't stand on face or wall sprites - jump again // don't stand on face or wall sprites - jump again
if (u->lowActor && !TEST(u->lowActor->spr.cstat, CSTAT_SPRITE_ALIGNMENT_FLOOR)) if (u->lowActor && !TEST(u->lowActor->spr.cstat, CSTAT_SPRITE_ALIGNMENT_FLOOR))
{ {
//sp->ang = NORM_ANGLE(sp->ang + (RANDOM_P2(64<<8)>>8) - 32); //actor->spr.ang = NORM_ANGLE(actor->spr.ang + (RANDOM_P2(64<<8)>>8) - 32);
sp->ang = NORM_ANGLE(sp->ang + 1024 + (RANDOM_P2(512<<8)>>8)); actor->spr.ang = NORM_ANGLE(actor->spr.ang + 1024 + (RANDOM_P2(512<<8)>>8));
u->jump_speed = -350; u->jump_speed = -350;
DoActorBeginJump(actor); DoActorBeginJump(actor);
@ -814,7 +801,6 @@ int DoActorDeathMove(DSWActor* actor)
{ {
USER* u = actor->u(); USER* u = actor->u();
SPRITEp sp = &actor->s();
int nx, ny; int nx, ny;
if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING))
@ -825,10 +811,10 @@ int DoActorDeathMove(DSWActor* actor)
DoActorFall(actor); DoActorFall(actor);
} }
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);
sp->clipdist = (128+64)>>2; actor->spr.clipdist = (128+64)>>2;
move_actor(actor, nx, ny, 0); move_actor(actor, nx, ny, 0);
// only fall on top of floor sprite or sector // only fall on top of floor sprite or sector
@ -857,7 +843,6 @@ int DoBeginJump(DSWActor* actor)
int DoJump(DSWActor* actor) int DoJump(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
int jump_adj; int jump_adj;
@ -874,13 +859,14 @@ int DoJump(DSWActor* actor)
} }
// adjust height by jump speed // adjust height by jump speed
sp->pos.Z += u->jump_speed * ACTORMOVETICS; actor->spr.pos.Z += u->jump_speed * ACTORMOVETICS;
// if player gets to close the ceiling while jumping // if player gets to close the ceiling while jumping
if (sp->pos.Z < u->hiz + Z(PIC_SIZY(sp))) int minh = u->hiz + (tileHeight(actor->spr.picnum) << 8);
if (actor->spr.pos.Z < minh)
{ {
// put player at the ceiling // put player at the ceiling
sp->pos.Z = u->hiz + Z(PIC_SIZY(sp)); actor->spr.pos.Z = minh;
// reverse your speed to falling // reverse your speed to falling
u->jump_speed = -u->jump_speed; u->jump_speed = -u->jump_speed;
@ -910,18 +896,17 @@ int DoBeginFall(DSWActor* actor)
int DoFall(DSWActor* actor) int DoFall(DSWActor* actor)
{ {
USERp u = actor->u(); USERp u = actor->u();
SPRITEp sp = &actor->s();
// adjust jump speed by gravity // adjust jump speed by gravity
u->jump_speed += u->jump_grav * ACTORMOVETICS; u->jump_speed += u->jump_grav * ACTORMOVETICS;
// adjust player height by jump speed // adjust player height by jump speed
sp->pos.Z += u->jump_speed * ACTORMOVETICS; actor->spr.pos.Z += u->jump_speed * ACTORMOVETICS;
// Stick like glue when you hit the ground // Stick like glue when you hit the ground
if (sp->pos.Z > u->loz - u->floor_dist) if (actor->spr.pos.Z > u->loz - u->floor_dist)
{ {
sp->pos.Z = u->loz - u->floor_dist; actor->spr.pos.Z = u->loz - u->floor_dist;
RESET(u->Flags, SPR_FALLING); RESET(u->Flags, SPR_FALLING);
} }

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

@ -224,11 +224,6 @@ int StdRandomRange(int range);
#define DIST(x1, y1, x2, y2) ksqrt( SQ((x1) - (x2)) + SQ((y1) - (y2)) ) #define DIST(x1, y1, x2, y2) ksqrt( SQ((x1) - (x2)) + SQ((y1) - (y2)) )
inline int PIC_SIZY(spritetype* sp)
{
return tileHeight(sp->picnum);
}
// Distance macro - tx, ty, tmin are holding vars that must be declared in the routine // Distance macro - tx, ty, tmin are holding vars that must be declared in the routine
// that uses this macro // that uses this macro
inline void DISTANCE(int x1, int y1, int x2, int y2, int& dist, int& tx, int& ty, int& tmin) inline void DISTANCE(int x1, int y1, int x2, int y2, int& dist, int& tx, int& ty, int& tmin)
@ -254,6 +249,10 @@ inline int SPRITEp_SIZE_Z(const spritetypebase* sp)
return (tileHeight(sp->picnum) * sp->yrepeat) << 2; return (tileHeight(sp->picnum) * sp->yrepeat) << 2;
} }
inline int SPRITEp_SIZE_Z(DSWActor* sp)
{
return (tileHeight(sp->spr.picnum) * sp->spr.yrepeat) << 2;
}
// Given a z height and sprite return the correct y repeat value // Given a z height and sprite return the correct y repeat value

2
source/games/sw/src/names2.h
View file

@ -224,8 +224,6 @@ enum STAT_ENUMS
#define BLADE2 361 #define BLADE2 361
#define BLADE3 362 #define BLADE3 362
#define HORIZ_BLADES BLADE1 : BLADE2 : BLADE3
////////////////////// //////////////////////
// //
// WEAPON RELATED // WEAPON RELATED