zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-06-01 17:52:13 +00:00
Code Issues Projects Releases Packages Wiki Activity

turn players into DObjects and fix several bugs with bad memory access.

Browse source 
* DObjects may not be memset to 0.
* There was still code trying to retrieve the player index with pointer artithmetic. With an array of pointers this does not work.
This commit is contained in:
Christoph Oelckers 2023-10-02 21:03:59 +02:00
parent 1ce8ceac5d
commit 5448f6ec2c
126 changed files with 1709 additions and 1585 deletions
Download patch file Download diff file Expand all files Collapse all files

21
source/core/coreplayer.h
View file

@ -4,15 +4,30 @@
#include "packet.h" #include "packet.h"
#include "gameinput.h" #include "gameinput.h"
struct CorePlayer class DCorePlayer : public DObject
{ {
DECLARE_CLASS(DCorePlayer, DObject)
HAS_OBJECT_POINTERS
protected:
DCorePlayer() = default;
void Clear()
{
memset(&lastcmd, 0, sizeof(lastcmd));
memset(&cmd, 0, sizeof(cmd));
memset(&Angles, 0, sizeof(Angles));
actor = nullptr;
pnum = 0;
}
public:
ticcmd_t lastcmd, cmd; ticcmd_t lastcmd, cmd;
PlayerAngles Angles; PlayerAngles Angles;
DCoreActor* actor; DCoreActor* actor;
uint8_t pnum; uint8_t pnum;
virtual ~CorePlayer() { if (actor) actor->Destroy(); }; DCorePlayer(uint8_t p) : pnum(p) {}
void OnDestroy() override { if (actor) actor->Destroy(); actor = nullptr; }
virtual DCoreActor* GetActor() = 0; virtual DCoreActor* GetActor() = 0;
}; };
extern CorePlayer* PlayerArray[MAXPLAYERS]; extern DCorePlayer* PlayerArray[MAXPLAYERS];

4
source/core/gamecontrol.cpp
View file

@ -166,6 +166,7 @@ void HudScaleChanged();
bool M_SetSpecialMenu(FName& menu, int param); bool M_SetSpecialMenu(FName& menu, int param);
void OnMenuOpen(bool makeSound); void OnMenuOpen(bool makeSound);
void DestroyAltHUD(); void DestroyAltHUD();
void MarkPlayers();
DStatusBarCore* StatusBar; DStatusBarCore* StatusBar;
@ -637,7 +638,7 @@ int GameMain()
gi->FreeLevelData(); gi->FreeLevelData();
for (int i = 0; i < MAXPLAYERS; i++) for (int i = 0; i < MAXPLAYERS; i++)
{ {
delete PlayerArray[i]; PlayerArray[i]->Destroy();
PlayerArray[i] = nullptr; PlayerArray[i] = nullptr;
} }
} }
@ -1154,6 +1155,7 @@ int RunGame()
StartWindow->Progress(); StartWindow->Progress();
GC::AddMarkerFunc(MarkMap); GC::AddMarkerFunc(MarkMap);
GC::AddMarkerFunc(MarkPlayers);
gi->app_init(); gi->app_init();
StartWindow->Progress(); StartWindow->Progress();
G_ParseMapInfo(); G_ParseMapInfo();

12
source/core/mainloop.cpp
View file

@ -101,7 +101,17 @@ static uint64_t stabilityticduration = 0;
static uint64_t stabilitystarttime = 0; static uint64_t stabilitystarttime = 0;
static double inputScale; static double inputScale;
CorePlayer* PlayerArray[MAXPLAYERS]; DCorePlayer* PlayerArray[MAXPLAYERS];
IMPLEMENT_CLASS(DCorePlayer, true, true)
IMPLEMENT_POINTERS_START(DCorePlayer)
IMPLEMENT_POINTER(actor)
IMPLEMENT_POINTERS_END
void MarkPlayers()
{
GC::MarkArray(PlayerArray, MAXPLAYERS);
}
bool r_NoInterpolate; bool r_NoInterpolate;
int entertic; int entertic;

3
source/core/vmexports.cpp
View file

@ -39,6 +39,7 @@
#include "raze_sound.h" #include "raze_sound.h"
#include "texturemanager.h" #include "texturemanager.h"
#include "texinfo.h" #include "texinfo.h"
#include "coreplayer.h"
#include "buildtiles.h" #include "buildtiles.h"
@ -816,6 +817,8 @@ DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, setSpritePic, tspritetype_setSpriteP
//============================================================================= //=============================================================================
DEFINE_FIELD(DCorePlayer, pnum)
DEFINE_FIELD_NAMED(DCoreActor, spr.sectp, sector) DEFINE_FIELD_NAMED(DCoreActor, spr.sectp, sector)
DEFINE_FIELD_NAMED(DCoreActor, spr.cstat, cstat) DEFINE_FIELD_NAMED(DCoreActor, spr.cstat, cstat)
DEFINE_FIELD_NAMED(DCoreActor, spr.cstat2, cstat2) DEFINE_FIELD_NAMED(DCoreActor, spr.cstat2, cstat2)

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

@ -3053,7 +3053,7 @@ static void checkAddFrag(DBloodActor* killerActor, DBloodActor* actor)
{ {
if (killerActor->IsPlayerActor()) if (killerActor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(killerActor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(killerActor->spr.type - kDudePlayer1);
if (gGameOptions.nGameType == 1) if (gGameOptions.nGameType == 1)
pPlayer->fragCount++; pPlayer->fragCount++;
} }
@ -3068,7 +3068,7 @@ static void checkAddFrag(DBloodActor* killerActor, DBloodActor* actor)
case kDudeBurningInnocent: case kDudeBurningInnocent:
break; break;
default: default:
BloodPlayer* pKillerPlayer = getPlayer(killerActor->spr.type - kDudePlayer1); DBloodPlayer* pKillerPlayer = getPlayer(killerActor->spr.type - kDudePlayer1);
pKillerPlayer->fragCount++; pKillerPlayer->fragCount++;
break; break;
} }
@ -3616,7 +3616,7 @@ static int actDamageDude(DBloodActor* source, DBloodActor* actor, int damage, DA
} }
else else
{ {
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (actor->xspr.health > 0 || playerSeqPlaying(pPlayer, 16)) if (actor->xspr.health > 0 || playerSeqPlaying(pPlayer, 16))
damage = playerDamageSprite(source, pPlayer, damageType, damage); damage = playerDamageSprite(source, pPlayer, damageType, damage);
@ -3630,7 +3630,7 @@ static int actDamageDude(DBloodActor* source, DBloodActor* actor, int damage, DA
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static int actDamageThing(DBloodActor* source, DBloodActor* actor, int damage, DAMAGE_TYPE damageType, BloodPlayer* pSourcePlayer) static int actDamageThing(DBloodActor* source, DBloodActor* actor, int damage, DAMAGE_TYPE damageType, DBloodPlayer* pSourcePlayer)
{ {
assert(actor->spr.type >= kThingBase && actor->spr.type < kThingMax); assert(actor->spr.type >= kThingBase && actor->spr.type < kThingMax);
int nType = actor->spr.type - kThingBase; int nType = actor->spr.type - kThingBase;
@ -3739,7 +3739,7 @@ int actDamageSprite(DBloodActor* source, DBloodActor* actor, DAMAGE_TYPE damageT
if (source == nullptr) source = actor; if (source == nullptr) source = actor;
BloodPlayer* pSourcePlayer = nullptr; DBloodPlayer* pSourcePlayer = nullptr;
if (source->IsPlayerActor()) pSourcePlayer = getPlayer(source->spr.type - kDudePlayer1); if (source->IsPlayerActor()) pSourcePlayer = getPlayer(source->spr.type - kDudePlayer1);
if (!gGameOptions.bFriendlyFire && IsTargetTeammate(pSourcePlayer, actor)) return 0; if (!gGameOptions.bFriendlyFire && IsTargetTeammate(pSourcePlayer, actor)) return 0;
@ -4334,7 +4334,7 @@ static void checkFloorHit(DBloodActor* actor)
} }
#endif #endif
BloodPlayer* pPlayer = nullptr; DBloodPlayer* pPlayer = nullptr;
if (actor->IsPlayerActor()) pPlayer = getPlayer(actor->spr.type - kDudePlayer1); if (actor->IsPlayerActor()) pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
switch (actor2->spr.type) switch (actor2->spr.type)
@ -4691,7 +4691,7 @@ static Collision MoveThing(DBloodActor* actor)
void MoveDude(DBloodActor* actor) void MoveDude(DBloodActor* actor)
{ {
BloodPlayer* pPlayer = nullptr; DBloodPlayer* pPlayer = nullptr;
if (actor->IsPlayerActor()) pPlayer = getPlayer(actor->spr.type - kDudePlayer1); if (actor->IsPlayerActor()) pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax)) if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax))
{ {
@ -5543,8 +5543,8 @@ static void actCheckProximity()
auto Owner = actor->GetOwner(); auto Owner = actor->GetOwner();
if (!Owner->IsPlayerActor()) continue; if (!Owner->IsPlayerActor()) continue;
BloodPlayer* pPlayer = getPlayer(Owner->spr.type - kDudePlayer1); auto pPlayer = getPlayer(Owner);
BloodPlayer* pPlayer2 = dudeactor->IsPlayerActor() ? getPlayer(dudeactor->spr.type - kDudePlayer1) : nullptr; DBloodPlayer* pPlayer2 = dudeactor->IsPlayerActor() ? getPlayer(dudeactor) : nullptr;
if (dudeactor == Owner || dudeactor->spr.type == kDudeZombieAxeBuried || dudeactor->spr.type == kDudeRat || dudeactor->spr.type == kDudeBat) continue; if (dudeactor == Owner || dudeactor->spr.type == kDudeZombieAxeBuried || dudeactor->spr.type == kDudeRat || dudeactor->spr.type == kDudeBat) continue;
if (gGameOptions.nGameType == 3 && pPlayer2 && pPlayer->teamId == pPlayer2->teamId) continue; if (gGameOptions.nGameType == 3 && pPlayer2 && pPlayer->teamId == pPlayer2->teamId) continue;
@ -5975,7 +5975,7 @@ static void actCheckDudes()
} }
if (actor->IsPlayerActor()) if (actor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (pPlayer->voodooTargets) voodooTarget(pPlayer); if (pPlayer->voodooTargets) voodooTarget(pPlayer);
if (pPlayer->hand && Chance(0x8000)) actDamageSprite(actor, actor, kDamageDrown, 12); if (pPlayer->hand && Chance(0x8000)) actDamageSprite(actor, actor, kDamageDrown, 12);
@ -6049,7 +6049,7 @@ static void actCheckDudes()
if (actor->IsPlayerActor()) if (actor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
double nDrag = FixedToFloat(gDudeDrag); double nDrag = FixedToFloat(gDudeDrag);
if (actor->xspr.height > 0) if (actor->xspr.height > 0)
nDrag -= Scale(nDrag, (double)actor->xspr.height, 256.); nDrag -= Scale(nDrag, (double)actor->xspr.height, 256.);
@ -6624,7 +6624,7 @@ void actFireVector(DBloodActor* shooter, double offset, double zoffset, DVector3
if (!gGameOptions.bFriendlyFire && IsTargetTeammate(shooter, hitactor)) return; if (!gGameOptions.bFriendlyFire && IsTargetTeammate(shooter, hitactor)) return;
if (hitactor->IsPlayerActor()) if (hitactor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(hitactor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(hitactor->spr.type - kDudePlayer1);
if (powerupCheck(pPlayer, kPwUpReflectShots)) if (powerupCheck(pPlayer, kPwUpReflectShots))
{ {
gHitInfo.hitActor = shooter; gHitInfo.hitActor = shooter;

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

@ -971,7 +971,7 @@ int aiDamageSprite(DBloodActor* source, DBloodActor* actor, DAMAGE_TYPE nDmgType
{ {
aiPatrolStop(actor, source, actor->xspr.dudeAmbush); aiPatrolStop(actor, source, actor->xspr.dudeAmbush);
BloodPlayer* pPlayer = getPlayerById(source->spr.type); DBloodPlayer* pPlayer = getPlayerById(source->spr.type);
if (!pPlayer) return nDamage; if (!pPlayer) return nDamage;
//if (powerupCheck(pPlayer, kPwUpShadowCloak)) pPlayer->pwUpTime[kPwUpShadowCloak] = 0; //if (powerupCheck(pPlayer, kPwUpShadowCloak)) pPlayer->pwUpTime[kPwUpShadowCloak] = 0;
if (readyForCrit(source, actor)) if (readyForCrit(source, actor))
@ -1491,7 +1491,7 @@ void aiThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;
@ -1536,7 +1536,7 @@ void aiLookForTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -94,7 +94,7 @@ static void batThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -106,7 +106,7 @@ static void eelThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -237,7 +237,7 @@ static void cerberusThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -193,7 +193,7 @@ static void gargThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -174,7 +174,7 @@ static void ghostThinkTarget(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -47,7 +47,7 @@ void HandJumpSeqCallback(int, DBloodActor* actor)
auto target = actor->GetTarget(); auto target = actor->GetTarget();
if (target->IsPlayerActor()) if (target->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1);
if (!pPlayer->hand) if (!pPlayer->hand)
{ {
pPlayer->hand = 1; pPlayer->hand = 1;

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

@ -49,7 +49,7 @@ static void spidBlindEffect(DBloodActor* actor, int nBlind, int max)
{ {
nBlind <<= 4; nBlind <<= 4;
max <<= 4; max <<= 4;
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (pPlayer->blindEffect < max) if (pPlayer->blindEffect < max)
{ {
pPlayer->blindEffect = ClipHigh(pPlayer->blindEffect + nBlind, max); pPlayer->blindEffect = ClipHigh(pPlayer->blindEffect + nBlind, max);
@ -74,7 +74,7 @@ void SpidBiteSeqCallback(int, DBloodActor* actor)
if (hit == 3 && gHitInfo.actor()->IsPlayerActor()) if (hit == 3 && gHitInfo.actor()->IsPlayerActor())
{ {
vec.Z += target->spr.pos.Z - actor->spr.pos.Z; vec.Z += target->spr.pos.Z - actor->spr.pos.Z;
BloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1);
switch (actor->spr.type) switch (actor->spr.type)
{ {
case kDudeSpiderBrown: case kDudeSpiderBrown:

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

@ -198,7 +198,7 @@ static void sub_725A4(DBloodActor* actor)
{ {
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;
auto ppos = pPlayer->GetActor()->spr.pos; auto ppos = pPlayer->GetActor()->spr.pos;

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

@ -461,7 +461,7 @@ static void unicultThinkChase(DBloodActor* actor)
if (target->xspr.health <= 0) // target is dead if (target->xspr.health <= 0) // target is dead
{ {
BloodPlayer* pPlayer = NULL; DBloodPlayer* pPlayer = NULL;
if ((!target->IsPlayerActor()) || ((pPlayer = getPlayerById(target->spr.type)) != NULL && pPlayer->fragger == actor)) if ((!target->IsPlayerActor()) || ((pPlayer = getPlayerById(target->spr.type)) != NULL && pPlayer->fragger == actor))
{ {
playGenDudeSound(actor, kGenDudeSndTargetDead); playGenDudeSound(actor, kGenDudeSndTargetDead);
@ -498,7 +498,7 @@ static void unicultThinkChase(DBloodActor* actor)
} }
else if (target->IsPlayerActor()) else if (target->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(target->spr.type - kDudePlayer1);
if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
{ {
if (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchShortW); if (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchShortW);
@ -1758,7 +1758,7 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
{ {
if (actTarget->IsPlayerActor()) if (actTarget->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(actTarget->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actTarget->spr.type - kDudePlayer1);
if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0) return; if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0) return;
} }
double top, bottom; double top, bottom;

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

@ -209,7 +209,7 @@ static void myThinkTarget(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
for (int p = connecthead; p >= 0; p = connectpoint2[p]) for (int p = connecthead; p >= 0; p = connectpoint2[p])
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
auto owneractor = actor->GetOwner(); auto owneractor = actor->GetOwner();
if (owneractor == nullptr || owneractor == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0) if (owneractor == nullptr || owneractor == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue; continue;

6
source/games/blood/src/animatesprite.cpp
View file

@ -490,7 +490,7 @@ static tspritetype* viewAddEffect(tspriteArray& tsprites, int nTSprite, VIEW_EFF
case kViewEffectShowWeapon: case kViewEffectShowWeapon:
{ {
assert(pTSprite->type >= kDudePlayer1 && pTSprite->type <= kDudePlayer8); assert(pTSprite->type >= kDudePlayer1 && pTSprite->type <= kDudePlayer8);
BloodPlayer* pPlayer = getPlayer(pTSprite->type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(pTSprite->type - kDudePlayer1);
WEAPONICON weaponIcon = gWeaponIcon[pPlayer->curWeapon]; WEAPONICON weaponIcon = gWeaponIcon[pPlayer->curWeapon];
auto nTex = weaponIcon.textureID(); auto nTex = weaponIcon.textureID();
if (!nTex.isValid()) break; if (!nTex.isValid()) break;
@ -555,7 +555,7 @@ static int GetOctant(const DVector2& dPos)
void viewProcessSprites(tspriteArray& tsprites, const DVector3& cPos, DAngle cA, double interpfrac) void viewProcessSprites(tspriteArray& tsprites, const DVector3& cPos, DAngle cA, double interpfrac)
{ {
BloodPlayer* pPlayer = getPlayer(gViewIndex); DBloodPlayer* pPlayer = getPlayer(gViewIndex);
int nViewSprites = tsprites.Size(); int nViewSprites = tsprites.Size();
// shift before interpolating to increase precision. // shift before interpolating to increase precision.
DAngle myclock = DAngle::fromBuild((PlayClock << 3) + (4 << 3) * interpfrac); DAngle myclock = DAngle::fromBuild((PlayClock << 3) + (4 << 3) * interpfrac);
@ -841,7 +841,7 @@ void viewProcessSprites(tspriteArray& tsprites, const DVector3& cPos, DAngle cA,
if (powerupCheck(pPlayer, kPwUpBeastVision) > 0) pTSprite->shade = -128; if (powerupCheck(pPlayer, kPwUpBeastVision) > 0) pTSprite->shade = -128;
if (IsPlayerSprite(pTSprite)) { if (IsPlayerSprite(pTSprite)) {
BloodPlayer* thisPlayer = getPlayer(pTSprite->type - kDudePlayer1); DBloodPlayer* thisPlayer = getPlayer(pTSprite->type - kDudePlayer1);
if (powerupCheck(thisPlayer, kPwUpShadowCloak) && !powerupCheck(pPlayer, kPwUpBeastVision)) { if (powerupCheck(thisPlayer, kPwUpShadowCloak) && !powerupCheck(pPlayer, kPwUpBeastVision)) {
pTSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT; pTSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pTSprite->pal = 5; pTSprite->pal = 5;

2
source/games/blood/src/asound.cpp
View file

@ -43,7 +43,7 @@ int nAmbChannels = 0;
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ambProcess(BloodPlayer* pPlayer) void ambProcess(DBloodPlayer* pPlayer)
{ {
if (!SoundEnabled()) if (!SoundEnabled())
return; return;

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

@ -70,6 +70,31 @@ IMPLEMENT_POINTER(xspr.burnSource)
IMPLEMENT_POINTER(xspr.target) IMPLEMENT_POINTER(xspr.target)
IMPLEMENT_POINTERS_END IMPLEMENT_POINTERS_END
IMPLEMENT_CLASS(DBloodPlayer, false, true)
IMPLEMENT_POINTERS_START(DBloodPlayer)
IMPLEMENT_POINTER(ctfFlagState[0])
IMPLEMENT_POINTER(ctfFlagState[1])
IMPLEMENT_POINTER(aimTarget)
IMPLEMENT_POINTER(fragger)
IMPLEMENT_POINTER(voodooTarget)
IMPLEMENT_POINTER(aimTargets[0])
IMPLEMENT_POINTER(aimTargets[1])
IMPLEMENT_POINTER(aimTargets[2])
IMPLEMENT_POINTER(aimTargets[3])
IMPLEMENT_POINTER(aimTargets[4])
IMPLEMENT_POINTER(aimTargets[5])
IMPLEMENT_POINTER(aimTargets[6])
IMPLEMENT_POINTER(aimTargets[7])
IMPLEMENT_POINTER(aimTargets[8])
IMPLEMENT_POINTER(aimTargets[9])
IMPLEMENT_POINTER(aimTargets[10])
IMPLEMENT_POINTER(aimTargets[11])
IMPLEMENT_POINTER(aimTargets[12])
IMPLEMENT_POINTER(aimTargets[13])
IMPLEMENT_POINTER(aimTargets[14])
IMPLEMENT_POINTER(aimTargets[15])
IMPLEMENT_POINTERS_END
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
// //
@ -96,19 +121,6 @@ static void markgcroots()
GC::MarkArray(gPhysSpritesList, gPhysSpritesCount); GC::MarkArray(gPhysSpritesList, gPhysSpritesCount);
GC::MarkArray(gImpactSpritesList, gImpactSpritesCount); GC::MarkArray(gImpactSpritesList, gImpactSpritesCount);
MarkSprInSect(); MarkSprInSect();
for (int i = 0; i < MAXPLAYERS; i++)
{
auto plr = getPlayer(i);
if (plr)
{
GC::Mark(plr->actor);
GC::MarkArray(plr->ctfFlagState, 2);
GC::Mark(plr->aimTarget);
GC::MarkArray(plr->aimTargets, 16);
GC::Mark(plr->fragger);
GC::Mark(plr->voodooTarget);
}
}
for (auto& evobj : rxBucket) for (auto& evobj : rxBucket)
{ {
evobj.Mark(); evobj.Mark();
@ -127,7 +139,7 @@ bool bNoDemo = false;
int gNetPlayers; int gNetPlayers;
int gChokeCounter = 0; int gChokeCounter = 0;
int blood_globalflags; int blood_globalflags;
BloodPlayer gPlayerTemp[kMaxPlayers]; PlayerSave gPlayerTemp[kMaxPlayers];
int gHealthTemp[kMaxPlayers]; int gHealthTemp[kMaxPlayers];
int16_t startang; int16_t startang;
sectortype* startsector; sectortype* startsector;
@ -343,19 +355,10 @@ void StartLevel(MapRecord* level, bool newgame)
{ {
for (int i = connecthead; i >= 0; i = connectpoint2[i]) for (int i = connecthead; i >= 0; i = connectpoint2[i])
{ {
BloodPlayer* pPlayer = getPlayer(i); DBloodPlayer* pPlayer = getPlayer(i);
pPlayer->GetActor()->xspr.health &= 0xf000; pPlayer->GetActor()->xspr.health &= 0xf000;
pPlayer->GetActor()->xspr.health |= gHealthTemp[i]; pPlayer->GetActor()->xspr.health |= gHealthTemp[i];
pPlayer->weaponQav = gPlayerTemp[i].weaponQav; gPlayerTemp[i].CopyToPlayer(pPlayer);
pPlayer->curWeapon = gPlayerTemp[i].curWeapon;
pPlayer->weaponState = gPlayerTemp[i].weaponState;
pPlayer->weaponAmmo = gPlayerTemp[i].weaponAmmo;
pPlayer->qavCallback = gPlayerTemp[i].qavCallback;
pPlayer->qavLoop = gPlayerTemp[i].qavLoop;
pPlayer->weaponTimer = gPlayerTemp[i].weaponTimer;
pPlayer->nextWeapon = gPlayerTemp[i].nextWeapon;
pPlayer->qavLastTick = gPlayerTemp[i].qavLastTick;
pPlayer->qavTimer = gPlayerTemp[i].qavTimer;
} }
} }
PreloadCache(); PreloadCache();
@ -425,7 +428,7 @@ void GameInterface::Ticker()
thinktime.Reset(); thinktime.Reset();
thinktime.Clock(); thinktime.Clock();
BloodPlayer* pPlayer = getPlayer(myconnectindex); DBloodPlayer* pPlayer = getPlayer(myconnectindex);
// disable synchronised input if set by game. // disable synchronised input if set by game.
resetForcedSyncInput(); resetForcedSyncInput();
@ -592,8 +595,8 @@ void GameInterface::app_init()
// Initialise player array. // Initialise player array.
for (unsigned i = 0; i < MAXPLAYERS; i++) for (unsigned i = 0; i < MAXPLAYERS; i++)
{ {
PlayerArray[i] = new BloodPlayer; PlayerArray[i] = Create<DBloodPlayer>(i);
*getPlayer(i) = {}; GC::WriteBarrier(PlayerArray[i]);
} }
mirrortile = tileGetTextureID(504); mirrortile = tileGetTextureID(504);
@ -772,13 +775,13 @@ DEFINE_ACTION_FUNCTION(_Blood, GetViewPlayer)
DEFINE_ACTION_FUNCTION(_BloodPlayer, GetHealth) DEFINE_ACTION_FUNCTION(_BloodPlayer, GetHealth)
{ {
PARAM_SELF_STRUCT_PROLOGUE(BloodPlayer); PARAM_SELF_STRUCT_PROLOGUE(DBloodPlayer);
ACTION_RETURN_INT(self->GetActor()->xspr.health); ACTION_RETURN_INT(self->GetActor()->xspr.health);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_BloodPlayer, powerupCheck, powerupCheck) DEFINE_ACTION_FUNCTION_NATIVE(_BloodPlayer, powerupCheck, powerupCheck)
{ {
PARAM_SELF_STRUCT_PROLOGUE(BloodPlayer); PARAM_SELF_STRUCT_PROLOGUE(DBloodPlayer);
PARAM_INT(pwup); PARAM_INT(pwup);
ACTION_RETURN_INT(powerupCheck(self, pwup)); ACTION_RETURN_INT(powerupCheck(self, pwup));
} }

74
source/games/blood/src/bloodactor.h
View file

@ -159,13 +159,27 @@ public:
}; };
struct BloodPlayer final : public CorePlayer class DBloodPlayer final : public DCorePlayer
{ {
DUDEINFO* pDudeInfo; DECLARE_CLASS(DBloodPlayer, DCorePlayer)
HAS_OBJECT_POINTERS
DBloodPlayer() = default;
public:
DBloodPlayer(uint8_t p) : DCorePlayer(p) {}
void Clear()
{
Super::Clear();
// Quick'n dirty clear
memset(&startOfMem, 0, sizeof(DBloodPlayer) - myoffsetof(DBloodPlayer, startOfMem));
}
uint8_t startOfMem; // only for Clear
uint8_t newWeapon; uint8_t newWeapon;
bool isRunning;
DUDEINFO* pDudeInfo;
int weaponQav; int weaponQav;
int qavCallback; int qavCallback;
bool isRunning;
int posture; // stand, crouch, swim int posture; // stand, crouch, swim
int sceneQav; // by NoOne: used to keep qav id int sceneQav; // by NoOne: used to keep qav id
double bobPhase; double bobPhase;
@ -258,11 +272,59 @@ struct BloodPlayer final : public CorePlayer
} }
}; };
inline BloodPlayer* getPlayer(int index) inline DBloodPlayer* getPlayer(int index)
{ {
return static_cast<BloodPlayer*>(PlayerArray[index]); return static_cast<DBloodPlayer*>(PlayerArray[index]);
} }
inline DBloodPlayer* getPlayer(DBloodActor* ac)
{
return static_cast<DBloodPlayer*>(PlayerArray[ac->spr.type - kDudePlayer1]);
}
struct PlayerSave
{
int weaponQav;
int8_t curWeapon;
int weaponState;
int weaponAmmo;
int qavCallback;
bool qavLoop;
int weaponTimer;
int8_t nextWeapon;
int qavLastTick;
int qavTimer;
void CopyFromPlayer(DBloodPlayer* p)
{
weaponQav = p->weaponQav;
curWeapon = p->curWeapon;
weaponState = p->weaponState;
weaponAmmo = p->weaponAmmo;
qavCallback = p->qavCallback;
qavLoop = p->qavLoop;
weaponTimer = p->weaponTimer;
nextWeapon = p->nextWeapon;
qavLastTick = p->qavLastTick;
qavTimer = p->qavTimer;
}
void CopyToPlayer(DBloodPlayer* p)
{
p->weaponQav = weaponQav;
p->curWeapon = curWeapon;
p->weaponState = weaponState;
p->weaponAmmo = weaponAmmo;
p->qavCallback = qavCallback;
p->qavLoop = qavLoop;
p->weaponTimer = weaponTimer;
p->nextWeapon = nextWeapon;
p->qavLastTick = qavLastTick;
p->qavTimer = qavTimer;
}
};
// subclassed to add a game specific actor() method // subclassed to add a game specific actor() method
extern HitInfo gHitInfo; extern HitInfo gHitInfo;
@ -288,7 +350,7 @@ inline bool IsTargetTeammate(DBloodActor* pSource, DBloodActor* pTarget)
{ {
if (!pSource->IsPlayerActor()) if (!pSource->IsPlayerActor())
return false; return false;
BloodPlayer* pSourcePlayer = getPlayer(pSource->spr.type - kDudePlayer1); DBloodPlayer* pSourcePlayer = getPlayer(pSource->spr.type - kDudePlayer1);
return IsTargetTeammate(pSourcePlayer, pTarget); return IsTargetTeammate(pSourcePlayer, pTarget);
} }

8
source/games/blood/src/callback.cpp
View file

@ -337,7 +337,7 @@ void PlayerBubble(DBloodActor* actor, sectortype*) // 10
if (!actor) return; if (!actor) return;
if (actor->IsPlayerActor()) if (actor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (!pPlayer->bubbleTime) if (!pPlayer->bubbleTime)
return; return;
double top, bottom; double top, bottom;
@ -694,7 +694,7 @@ void LeechStateTimer(DBloodActor* actor, sectortype*) // 20
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void sub_76A08(DBloodActor* actor, DBloodActor* actor2, BloodPlayer* pPlayer) // ??? void sub_76A08(DBloodActor* actor, DBloodActor* actor2, DBloodPlayer* pPlayer) // ???
{ {
double top, bottom; double top, bottom;
GetActorExtents(actor, &top, &bottom); GetActorExtents(actor, &top, &bottom);
@ -726,7 +726,7 @@ void DropVoodooCb(DBloodActor* actor, sectortype*) // unused
evPostActor(actor, 0, kCallbackRemove); evPostActor(actor, 0, kCallbackRemove);
return; return;
} }
BloodPlayer* pPlayer; DBloodPlayer* pPlayer;
if (Owner->IsPlayerActor()) if (Owner->IsPlayerActor())
pPlayer = getPlayer(Owner->spr.type - kDudePlayer1); pPlayer = getPlayer(Owner->spr.type - kDudePlayer1);
else else
@ -753,7 +753,7 @@ void DropVoodooCb(DBloodActor* actor, sectortype*) // unused
continue; continue;
if (actor2->hasX()) if (actor2->hasX())
{ {
BloodPlayer* pPlayer2; DBloodPlayer* pPlayer2;
if (actor2->IsPlayerActor()) if (actor2->IsPlayerActor())
pPlayer2 = getPlayer(actor2->spr.type - kDudePlayer1); pPlayer2 = getPlayer(actor2->spr.type - kDudePlayer1);
else else

4
source/games/blood/src/choke.cpp
View file

@ -35,7 +35,7 @@ BEGIN_BLD_NS
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void CChoke::init(int a1, void(*a2)(BloodPlayer*)) void CChoke::init(int a1, void(*a2)(DBloodPlayer*))
{ {
callback = a2; callback = a2;
if (!qav && a1 != -1) if (!qav && a1 != -1)
@ -82,7 +82,7 @@ void CChoke::animateChoke(int x, int y, double interpfrac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void chokeCallback(BloodPlayer* pPlayer) void chokeCallback(DBloodPlayer* pPlayer)
{ {
int t = gGameOptions.nDifficulty + 2; int t = gGameOptions.nDifficulty + 2;
if (pPlayer->handTime < 64) if (pPlayer->handTime < 64)

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

@ -40,7 +40,7 @@ public:
x = 0; x = 0;
y = 0; y = 0;
}; };
void init(int a1, void(*a2)(BloodPlayer*)); void init(int a1, void(*a2)(DBloodPlayer*));
void animateChoke(int x, int y, double interpfrac); void animateChoke(int x, int y, double interpfrac);
void reset() { time = 0; } void reset() { time = 0; }
QAV* qav; QAV* qav;
@ -48,10 +48,10 @@ public:
int time; int time;
int x; int x;
int y; int y;
void(*callback)(BloodPlayer*); void(*callback)(DBloodPlayer*);
}; };
void chokeCallback(BloodPlayer*); void chokeCallback(DBloodPlayer*);
extern CChoke gChoke; extern CChoke gChoke;

2
source/games/blood/src/endgame.cpp
View file

@ -37,7 +37,7 @@ void GameInterface::LevelCompleted(MapRecord* map, int skill)
{ {
if (getPlayer(i)->GetActor()) if (getPlayer(i)->GetActor())
{ {
memcpy(&gPlayerTemp[i], getPlayer(i), sizeof(BloodPlayer)); gPlayerTemp[i].CopyFromPlayer(getPlayer(i));
gHealthTemp[i] = getPlayer(i)->GetActor()->xspr.health; gHealthTemp[i] = getPlayer(i)->GetActor()->xspr.health;
} }
} }

2
source/games/blood/src/eventq.cpp
View file

@ -311,7 +311,7 @@ void evSend(EventObject& eob, int rxId, COMMAND_ID command, DBloodActor* initiat
if (gModernMap) if (gModernMap)
{ {
// allow to send commands on player sprites // allow to send commands on player sprites
BloodPlayer* pPlayer = NULL; DBloodPlayer* pPlayer = NULL;
if (playerRXRngIsFine(rxId)) if (playerRXRngIsFine(rxId))
{ {
if ((pPlayer = getPlayerById((rxId - kChannelPlayer7) + kMaxPlayers)) != nullptr) if ((pPlayer = getPlayerById((rxId - kChannelPlayer7) + kMaxPlayers)) != nullptr)

4
source/games/blood/src/hudsprites.cpp
View file

@ -100,7 +100,7 @@ static void viewBurnTime(int gScale)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void hudDraw(BloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac) void hudDraw(DBloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac)
{ {
if (gViewPos == 0) if (gViewPos == 0)
{ {
@ -169,7 +169,7 @@ void hudDraw(BloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby
} }
int zn = int(((pPlayer->zWeapon - pPlayer->zView - 12) * 2.) + 220); int zn = int(((pPlayer->zWeapon - pPlayer->zView - 12) * 2.) + 220);
BloodPlayer* pPSprite = getPlayer(pPlayer->GetActor()->spr.type - kDudePlayer1); DBloodPlayer* pPSprite = getPlayer(pPlayer->GetActor()->spr.type - kDudePlayer1);
if (pPlayer->GetActor()->IsPlayerActor() && pPSprite->hand == 1) if (pPlayer->GetActor()->IsPlayerActor() && pPSprite->hand == 1)
{ {
gChoke.animateChoke(160, zn, interpfrac); gChoke.animateChoke(160, zn, interpfrac);

34
source/games/blood/src/messages.cpp
View file

@ -46,7 +46,7 @@ void sub_5A928(void)
buttonMap.ClearButton(i); buttonMap.ClearButton(i);
} }
const char* SetGodMode(BloodPlayer* pPlayer, bool god) const char* SetGodMode(DBloodPlayer* pPlayer, bool god)
{ {
playerSetGodMode(pPlayer, god); playerSetGodMode(pPlayer, god);
bPlayerCheated = true; bPlayerCheated = true;
@ -60,13 +60,13 @@ const char* SetClipMode(bool noclip)
return gNoClip ? GStrings("TXTB_NOCLIP") : GStrings("TXTB_NOCLIPOFF"); return gNoClip ? GStrings("TXTB_NOCLIP") : GStrings("TXTB_NOCLIPOFF");
} }
void packStuff(BloodPlayer* pPlayer) void packStuff(DBloodPlayer* pPlayer)
{ {
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
packAddItem(pPlayer, i); packAddItem(pPlayer, i);
} }
void packClear(BloodPlayer* pPlayer) void packClear(DBloodPlayer* pPlayer)
{ {
pPlayer->packItemId = 0; pPlayer->packItemId = 0;
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
@ -76,7 +76,7 @@ void packClear(BloodPlayer* pPlayer)
} }
} }
void SetAmmo(BloodPlayer* pPlayer, bool stat) void SetAmmo(DBloodPlayer* pPlayer, bool stat)
{ {
if (stat) if (stat)
{ {
@ -92,7 +92,7 @@ void SetAmmo(BloodPlayer* pPlayer, bool stat)
} }
} }
void SetWeapons(BloodPlayer* pPlayer, bool stat) void SetWeapons(DBloodPlayer* pPlayer, bool stat)
{ {
for (int i = 0; i < 14; i++) for (int i = 0; i < 14; i++)
{ {
@ -114,7 +114,7 @@ void SetWeapons(BloodPlayer* pPlayer, bool stat)
} }
} }
void SetToys(BloodPlayer* pPlayer, bool stat) void SetToys(DBloodPlayer* pPlayer, bool stat)
{ {
if (stat) if (stat)
{ {
@ -128,7 +128,7 @@ void SetToys(BloodPlayer* pPlayer, bool stat)
} }
} }
void SetArmor(BloodPlayer* pPlayer, bool stat) void SetArmor(DBloodPlayer* pPlayer, bool stat)
{ {
int nAmount; int nAmount;
if (stat) if (stat)
@ -145,7 +145,7 @@ void SetArmor(BloodPlayer* pPlayer, bool stat)
pPlayer->armor[i] = nAmount; pPlayer->armor[i] = nAmount;
} }
void SetKeys(BloodPlayer* pPlayer, bool stat) void SetKeys(DBloodPlayer* pPlayer, bool stat)
{ {
for (int i = 1; i <= 7; i++) for (int i = 1; i <= 7; i++)
pPlayer->hasKey[i] = stat; pPlayer->hasKey[i] = stat;
@ -173,7 +173,7 @@ void SetMap(bool stat)
viewSetMessage(GStrings("TXTB_NOALLMAP")); viewSetMessage(GStrings("TXTB_NOALLMAP"));
} }
void SetWooMode(BloodPlayer* pPlayer, bool stat) void SetWooMode(DBloodPlayer* pPlayer, bool stat)
{ {
if (stat) if (stat)
{ {
@ -191,12 +191,12 @@ void SetWooMode(BloodPlayer* pPlayer, bool stat)
} }
} }
void ToggleWooMode(BloodPlayer* pPlayer) void ToggleWooMode(DBloodPlayer* pPlayer)
{ {
SetWooMode(pPlayer, !(powerupCheck(pPlayer, kPwUpTwoGuns) != 0)); SetWooMode(pPlayer, !(powerupCheck(pPlayer, kPwUpTwoGuns) != 0));
} }
void ToggleBoots(BloodPlayer* pPlayer) void ToggleBoots(DBloodPlayer* pPlayer)
{ {
if (powerupCheck(pPlayer, kPwUpJumpBoots)) if (powerupCheck(pPlayer, kPwUpJumpBoots))
{ {
@ -217,7 +217,7 @@ void ToggleBoots(BloodPlayer* pPlayer)
} }
} }
void ToggleInvisibility(BloodPlayer* pPlayer) void ToggleInvisibility(DBloodPlayer* pPlayer)
{ {
if (powerupCheck(pPlayer, kPwUpShadowCloak)) if (powerupCheck(pPlayer, kPwUpShadowCloak))
{ {
@ -233,7 +233,7 @@ void ToggleInvisibility(BloodPlayer* pPlayer)
} }
} }
void ToggleInvulnerability(BloodPlayer* pPlayer) void ToggleInvulnerability(DBloodPlayer* pPlayer)
{ {
if (powerupCheck(pPlayer, kPwUpDeathMask)) if (powerupCheck(pPlayer, kPwUpDeathMask))
{ {
@ -249,7 +249,7 @@ void ToggleInvulnerability(BloodPlayer* pPlayer)
} }
} }
void ToggleDelirium(BloodPlayer* pPlayer) void ToggleDelirium(DBloodPlayer* pPlayer)
{ {
if (powerupCheck(pPlayer, kPwUpDeliriumShroom)) if (powerupCheck(pPlayer, kPwUpDeliriumShroom))
{ {
@ -292,7 +292,7 @@ static int parseArgs(char* pzArgs, int* nArg1, int* nArg2)
const char* GameInterface::GenericCheat(int player, int cheat) const char* GameInterface::GenericCheat(int player, int cheat)
{ {
// message processing is not perfect because many cheats output multiple messages. // message processing is not perfect because many cheats output multiple messages.
BloodPlayer* pPlayer = getPlayer(player); DBloodPlayer* pPlayer = getPlayer(player);
if (gGameOptions.nGameType != 0 || numplayers > 1) // sp only for now. if (gGameOptions.nGameType != 0 || numplayers > 1) // sp only for now.
return nullptr; return nullptr;
@ -512,7 +512,7 @@ static cheatseq_t s_CheatInfo[] = {
void cheatReset(void) void cheatReset(void)
{ {
BloodPlayer* pPlayer = getPlayer(myconnectindex); DBloodPlayer* pPlayer = getPlayer(myconnectindex);
bPlayerCheated = 0; bPlayerCheated = 0;
playerSetGodMode(pPlayer, 0); playerSetGodMode(pPlayer, 0);
gNoClip = 0; gNoClip = 0;
@ -530,7 +530,7 @@ void cheatReset(void)
static void cmd_Give(int player, uint8_t** stream, bool skip) static void cmd_Give(int player, uint8_t** stream, bool skip)
{ {
BloodPlayer* pPlayer = getPlayer(player); DBloodPlayer* pPlayer = getPlayer(player);
int type = ReadByte(stream); int type = ReadByte(stream);
if (skip) return; if (skip) return;

16
source/games/blood/src/misc.h
View file

@ -48,16 +48,16 @@ void processSpritesOnOtherSideOfPortal(int x, int y, int interpolation);
void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int viewPlayer); void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int viewPlayer);
int qanimateoffs(int a1, int a2); int qanimateoffs(int a1, int a2);
struct BloodPlayer; class DBloodPlayer;
bool checkLitSprayOrTNT(BloodPlayer* pPlayer); bool checkLitSprayOrTNT(DBloodPlayer* pPlayer);
void WeaponInit(void); void WeaponInit(void);
void WeaponDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle); void WeaponDraw(DBloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void WeaponRaise(BloodPlayer* pPlayer); void WeaponRaise(DBloodPlayer* pPlayer);
void WeaponLower(BloodPlayer* pPlayer); void WeaponLower(DBloodPlayer* pPlayer);
int WeaponUpgrade(BloodPlayer* pPlayer, int newWeapon); int WeaponUpgrade(DBloodPlayer* pPlayer, int newWeapon);
void WeaponProcess(BloodPlayer* pPlayer); void WeaponProcess(DBloodPlayer* pPlayer);
void WeaponUpdateState(BloodPlayer* pPlayer); void WeaponUpdateState(DBloodPlayer* pPlayer);
void teslaHit(DBloodActor* pMissile, int a2); void teslaHit(DBloodActor* pMissile, int a2);
void WeaponPrecache(); void WeaponPrecache();

72
source/games/blood/src/nnexts.cpp
View file

@ -1175,7 +1175,7 @@ void nnExtProcessSuperSprites()
{ {
for (int a = connecthead; a >= 0; a = connectpoint2[a]) for (int a = connecthead; a >= 0; a = connectpoint2[a])
{ {
BloodPlayer* pPlayer = getPlayer(a); DBloodPlayer* pPlayer = getPlayer(a);
if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0) if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0)
continue; continue;
@ -1213,7 +1213,7 @@ void nnExtProcessSuperSprites()
for (int a = connecthead; a >= 0; a = connectpoint2[a]) for (int a = connecthead; a >= 0; a = connectpoint2[a])
{ {
BloodPlayer* pPlayer = getPlayer(a); DBloodPlayer* pPlayer = getPlayer(a);
if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0) if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0)
continue; continue;
@ -1300,7 +1300,7 @@ void nnExtProcessSuperSprites()
if (debrisactor->xspr.physAttr & kPhysDebrisTouch) if (debrisactor->xspr.physAttr & kPhysDebrisTouch)
{ {
BloodPlayer* pPlayer = NULL; DBloodPlayer* pPlayer = NULL;
for (int a = connecthead; a != -1; a = connectpoint2[a]) for (int a = connecthead; a != -1; a = connectpoint2[a])
{ {
pPlayer = getPlayer(a); pPlayer = getPlayer(a);
@ -1940,7 +1940,7 @@ void windGenStopWindOnSectors(DBloodActor* sourceactor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlStartScene(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool force) void trPlayerCtrlStartScene(DBloodActor* sourceactor, DBloodPlayer* pPlayer, bool force)
{ {
TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->pnum]; TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->pnum];
@ -1982,7 +1982,7 @@ void trPlayerCtrlStartScene(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlStopScene(BloodPlayer* pPlayer) void trPlayerCtrlStopScene(DBloodPlayer* pPlayer)
{ {
TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->pnum]; TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->pnum];
auto initiator = pCtrl->qavScene.initiator; auto initiator = pCtrl->qavScene.initiator;
@ -2014,7 +2014,7 @@ void trPlayerCtrlStopScene(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlLink(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool checkCondition) void trPlayerCtrlLink(DBloodActor* sourceactor, DBloodPlayer* pPlayer, bool checkCondition)
{ {
// save player's sprite index to let the tracking condition know it after savegame loading... // save player's sprite index to let the tracking condition know it after savegame loading...
auto actor = pPlayer->GetActor(); auto actor = pPlayer->GetActor();
@ -2074,7 +2074,7 @@ void trPlayerCtrlLink(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool check
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlSetRace(int value, BloodPlayer* pPlayer) void trPlayerCtrlSetRace(int value, DBloodPlayer* pPlayer)
{ {
playerSetRace(pPlayer, value); playerSetRace(pPlayer, value);
switch (pPlayer->lifeMode) switch (pPlayer->lifeMode)
@ -2098,7 +2098,7 @@ void trPlayerCtrlSetRace(int value, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlSetMoveSpeed(int value, BloodPlayer* pPlayer) void trPlayerCtrlSetMoveSpeed(int value, DBloodPlayer* pPlayer)
{ {
int speed = ClipRange(value, 0, 500); int speed = ClipRange(value, 0, 500);
for (int i = 0; i < kModeMax; i++) for (int i = 0; i < kModeMax; i++)
@ -2119,7 +2119,7 @@ void trPlayerCtrlSetMoveSpeed(int value, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlSetJumpHeight(int value, BloodPlayer* pPlayer) void trPlayerCtrlSetJumpHeight(int value, DBloodPlayer* pPlayer)
{ {
int jump = ClipRange(value, 0, 500); int jump = ClipRange(value, 0, 500);
for (int i = 0; i < kModeMax; i++) for (int i = 0; i < kModeMax; i++)
@ -2136,7 +2136,7 @@ void trPlayerCtrlSetJumpHeight(int value, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlSetScreenEffect(int value, int timeval, BloodPlayer* pPlayer) void trPlayerCtrlSetScreenEffect(int value, int timeval, DBloodPlayer* pPlayer)
{ {
int eff = ClipLow(value, 0); int eff = ClipLow(value, 0);
int time = (eff > 0) ? timeval : 0; int time = (eff > 0) ? timeval : 0;
@ -2179,7 +2179,7 @@ void trPlayerCtrlSetScreenEffect(int value, int timeval, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlSetLookAngle(int value, BloodPlayer* pPlayer) void trPlayerCtrlSetLookAngle(int value, DBloodPlayer* pPlayer)
{ {
static constexpr double upAngle = 289; static constexpr double upAngle = 289;
static constexpr double downAngle = -347; static constexpr double downAngle = -347;
@ -2199,7 +2199,7 @@ void trPlayerCtrlSetLookAngle(int value, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlEraseStuff(int value, BloodPlayer* pPlayer) void trPlayerCtrlEraseStuff(int value, DBloodPlayer* pPlayer)
{ {
switch (value) switch (value)
@ -2251,7 +2251,7 @@ void trPlayerCtrlEraseStuff(int value, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, BloodPlayer* pPlayer, TRPLAYERCTRL* pCtrl) void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, DBloodPlayer* pPlayer, TRPLAYERCTRL* pCtrl)
{ {
switch (data2) switch (data2)
{ {
@ -2321,7 +2321,7 @@ void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, BloodPlayer* pPlaye
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlUsePackItem(int data2, int data3, int data4, BloodPlayer* pPlayer, int evCmd) void trPlayerCtrlUsePackItem(int data2, int data3, int data4, DBloodPlayer* pPlayer, int evCmd)
{ {
unsigned int invItem = data2 - 1; unsigned int invItem = data2 - 1;
switch (evCmd) switch (evCmd)
@ -2357,7 +2357,7 @@ void trPlayerCtrlUsePackItem(int data2, int data3, int data4, BloodPlayer* pPlay
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trPlayerCtrlUsePowerup(DBloodActor* sourceactor, BloodPlayer* pPlayer, int evCmd) void trPlayerCtrlUsePowerup(DBloodActor* sourceactor, DBloodPlayer* pPlayer, int evCmd)
{ {
bool relative = (sourceactor->spr.flags & kModernTypeFlag1); bool relative = (sourceactor->spr.flags & kModernTypeFlag1);
@ -2891,7 +2891,7 @@ void usePropertiesChanger(DBloodActor* sourceactor, int objType, sectortype* pSe
if (iactor->spr.statnum != kStatDude || !iactor->IsDudeActor() || !iactor->hasX()) if (iactor->spr.statnum != kStatDude || !iactor->IsDudeActor() || !iactor->hasX())
continue; continue;
BloodPlayer* pPlayer = getPlayerById(iactor->spr.type); DBloodPlayer* pPlayer = getPlayerById(iactor->spr.type);
if (pXSector->Underwater) if (pXSector->Underwater)
{ {
if (aLower) if (aLower)
@ -3138,7 +3138,7 @@ void useVelocityChanger(DBloodActor* actor, sectortype* sect, DBloodActor* initi
void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor) void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
{ {
BloodPlayer* pPlayer = getPlayerById(actor->spr.type); DBloodPlayer* pPlayer = getPlayerById(actor->spr.type);
XSECTOR* pXSector = (sourceactor->sector()->hasX()) ? &sourceactor->sector()->xs() : nullptr; XSECTOR* pXSector = (sourceactor->sector()->hasX()) ? &sourceactor->sector()->xs() : nullptr;
bool isDude = (!pPlayer && actor->IsDudeActor()); bool isDude = (!pPlayer && actor->IsDudeActor());
@ -3559,7 +3559,7 @@ void damageSprites(DBloodActor* sourceactor, DBloodActor* actor)
int health = 0; int health = 0;
BloodPlayer* pPlayer = getPlayerById(actor->spr.type); DBloodPlayer* pPlayer = getPlayerById(actor->spr.type);
int dmgType = (sourceactor->xspr.data2 >= kDmgFall) ? ClipHigh(sourceactor->xspr.data2, kDmgElectric) : -1; int dmgType = (sourceactor->xspr.data2 >= kDmgFall) ? ClipHigh(sourceactor->xspr.data2, kDmgElectric) : -1;
int dmg = actor->xspr.health << 4; int dmg = actor->xspr.health << 4;
int armor[3]; int armor[3];
@ -4304,7 +4304,7 @@ bool condCheckWall(DBloodActor* aCond, int cmpOp, bool PUSH)
bool condCheckPlayer(DBloodActor* aCond, int cmpOp, bool PUSH) bool condCheckPlayer(DBloodActor* aCond, int cmpOp, bool PUSH)
{ {
int var = -1; int var = -1;
BloodPlayer* pPlayer = NULL; DBloodPlayer* pPlayer = NULL;
int cond = aCond->xspr.data1 - kCondPlayerBase; int cond = aCond->xspr.data1 - kCondPlayerBase;
int arg1 = aCond->xspr.data2; int arg1 = aCond->xspr.data2;
int arg2 = aCond->xspr.data3; int arg2 = aCond->xspr.data3;
@ -4550,7 +4550,7 @@ bool condCheckDude(DBloodActor* aCond, int cmpOp, bool PUSH)
bool condCheckSprite(DBloodActor* aCond, int cmpOp, bool PUSH) bool condCheckSprite(DBloodActor* aCond, int cmpOp, bool PUSH)
{ {
int var = -1, var2 = -1, var3 = -1; BloodPlayer* pPlayer = NULL; bool retn = false; int var = -1, var2 = -1, var3 = -1; DBloodPlayer* pPlayer = NULL; bool retn = false;
int cond = aCond->xspr.data1 - kCondSpriteBase; int arg1 = aCond->xspr.data2; int cond = aCond->xspr.data1 - kCondSpriteBase; int arg1 = aCond->xspr.data2;
int arg2 = aCond->xspr.data3; int arg3 = aCond->xspr.data4; int arg2 = aCond->xspr.data3; int arg3 = aCond->xspr.data4;
@ -5727,7 +5727,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
else if (actor->xspr.data1 >= 666 && actor->xspr.data1 < 669) useSpriteDamager(actor, -1, nullptr, nullptr); else if (actor->xspr.data1 >= 666 && actor->xspr.data1 < 669) useSpriteDamager(actor, -1, nullptr, nullptr);
else else
{ {
BloodPlayer* pPlayer = getPlayerById(actor->xspr.data1); DBloodPlayer* pPlayer = getPlayerById(actor->xspr.data1);
if (pPlayer != NULL) if (pPlayer != NULL)
useSpriteDamager(actor, OBJ_SPRITE, 0, pPlayer->GetActor()); useSpriteDamager(actor, OBJ_SPRITE, 0, pPlayer->GetActor());
} }
@ -5746,7 +5746,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
case kMarkerWarpDest: case kMarkerWarpDest:
if (actor->xspr.txID <= 0) if (actor->xspr.txID <= 0)
{ {
BloodPlayer* pPlayer = getPlayerById(actor->xspr.data1); DBloodPlayer* pPlayer = getPlayerById(actor->xspr.data1);
if (pPlayer != NULL && SetSpriteState(actor, actor->xspr.state ^ 1, initiator) == 1) if (pPlayer != NULL && SetSpriteState(actor, actor->xspr.state ^ 1, initiator) == 1)
useTeleportTarget(actor, pPlayer->GetActor()); useTeleportTarget(actor, pPlayer->GetActor());
return true; return true;
@ -5981,7 +5981,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
return true; return true;
case kModernPlayerControl: case kModernPlayerControl:
{ // WIP { // WIP
BloodPlayer* pPlayer = NULL; DBloodPlayer* pPlayer = NULL;
int cmd = (event.cmd >= kCmdNumberic) ? event.cmd : actor->xspr.command; int cmd = (event.cmd >= kCmdNumberic) ? event.cmd : actor->xspr.command;
@ -7252,7 +7252,7 @@ QAV* playerQavSceneLoad(int qavId)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerQavSceneProcess(BloodPlayer* pPlayer, QAVSCENE* pQavScene) void playerQavSceneProcess(DBloodPlayer* pPlayer, QAVSCENE* pQavScene)
{ {
auto initiator = pQavScene->initiator; auto initiator = pQavScene->initiator;
if (initiator->hasX()) if (initiator->hasX())
@ -7303,7 +7303,7 @@ void playerQavSceneProcess(BloodPlayer* pPlayer, QAVSCENE* pQavScene)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerQavSceneDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle) void playerQavSceneDraw(DBloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle)
{ {
if (pPlayer == NULL || pPlayer->sceneQav == -1) return; if (pPlayer == NULL || pPlayer->sceneQav == -1) return;
@ -7347,7 +7347,7 @@ void playerQavSceneDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypo
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerQavScenePlay(BloodPlayer* pPlayer) void playerQavScenePlay(DBloodPlayer* pPlayer)
{ {
if (pPlayer == NULL) return; if (pPlayer == NULL) return;
@ -7363,7 +7363,7 @@ void playerQavScenePlay(BloodPlayer* pPlayer)
} }
} }
void playerQavSceneReset(BloodPlayer* pPlayer) void playerQavSceneReset(DBloodPlayer* pPlayer)
{ {
QAVSCENE* pQavScene = &gPlayerCtrl[pPlayer->pnum].qavScene; QAVSCENE* pQavScene = &gPlayerCtrl[pPlayer->pnum].qavScene;
pQavScene->initiator = nullptr; pQavScene->initiator = nullptr;
@ -7371,28 +7371,28 @@ void playerQavSceneReset(BloodPlayer* pPlayer)
pQavScene->qavResrc = NULL; pQavScene->qavResrc = NULL;
} }
bool playerSizeShrink(BloodPlayer* pPlayer, int divider) bool playerSizeShrink(DBloodPlayer* pPlayer, int divider)
{ {
pPlayer->GetActor()->xspr.scale = 256 / divider; pPlayer->GetActor()->xspr.scale = 256 / divider;
playerSetRace(pPlayer, kModeHumanShrink); playerSetRace(pPlayer, kModeHumanShrink);
return true; return true;
} }
bool playerSizeGrow(BloodPlayer* pPlayer, int multiplier) bool playerSizeGrow(DBloodPlayer* pPlayer, int multiplier)
{ {
pPlayer->GetActor()->xspr.scale = 256 * multiplier; pPlayer->GetActor()->xspr.scale = 256 * multiplier;
playerSetRace(pPlayer, kModeHumanGrown); playerSetRace(pPlayer, kModeHumanGrown);
return true; return true;
} }
bool playerSizeReset(BloodPlayer* pPlayer) bool playerSizeReset(DBloodPlayer* pPlayer)
{ {
playerSetRace(pPlayer, kModeHuman); playerSetRace(pPlayer, kModeHuman);
pPlayer->GetActor()->xspr.scale = 0; pPlayer->GetActor()->xspr.scale = 0;
return true; return true;
} }
void playerDeactivateShrooms(BloodPlayer* pPlayer) void playerDeactivateShrooms(DBloodPlayer* pPlayer)
{ {
powerupDeactivate(pPlayer, kPwUpGrowShroom); powerupDeactivate(pPlayer, kPwUpGrowShroom);
pPlayer->pwUpTime[kPwUpGrowShroom] = 0; pPlayer->pwUpTime[kPwUpGrowShroom] = 0;
@ -7407,7 +7407,7 @@ void playerDeactivateShrooms(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
BloodPlayer* getPlayerById(int id) DBloodPlayer* getPlayerById(int id)
{ {
// relative to connected players // relative to connected players
if (id >= 1 && id <= kMaxPlayers) if (id >= 1 && id <= kMaxPlayers)
@ -8380,8 +8380,8 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
enum { kMaxPatrolFoundSounds = 256 }; // should be the maximum amount of sound channels the engine can play at the same time. enum { kMaxPatrolFoundSounds = 256 }; // should be the maximum amount of sound channels the engine can play at the same time.
PATROL_FOUND_SOUNDS patrolBonkles[kMaxPatrolFoundSounds]; PATROL_FOUND_SOUNDS patrolBonkles[kMaxPatrolFoundSounds];
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax); assert(actor->IsDudeActor());
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); BloodPlayer* pPlayer = NULL; DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type - kDudeBase); DBloodPlayer* pPlayer = NULL;
for (int i = 0; i < kMaxPatrolFoundSounds; i++) for (int i = 0; i < kMaxPatrolFoundSounds; i++)
{ {
@ -9286,7 +9286,7 @@ void changeSpriteAngle(DBloodActor* pSpr, DAngle nAng)
pSpr->spr.Angles.Yaw = nAng; pSpr->spr.Angles.Yaw = nAng;
else else
{ {
BloodPlayer* pPlayer = getPlayerById(pSpr->spr.type); DBloodPlayer* pPlayer = getPlayerById(pSpr->spr.type);
if (pPlayer) if (pPlayer)
pPlayer->GetActor()->spr.Angles.Yaw = nAng; pPlayer->GetActor()->spr.Angles.Yaw = nAng;
else else
@ -9349,7 +9349,7 @@ void killEffectGenCallbacks(DBloodActor* actor)
else if (actor->xspr.txID >= kChannelPlayer0 && actor->xspr.txID < kChannelPlayer0 + kMaxPlayers) else if (actor->xspr.txID >= kChannelPlayer0 && actor->xspr.txID < kChannelPlayer0 + kMaxPlayers)
{ {
// player sprites // player sprites
BloodPlayer* pPlayer = getPlayerById(actor->xspr.txID - kChannelPlayer0); DBloodPlayer* pPlayer = getPlayerById(actor->xspr.txID - kChannelPlayer0);
if (pPlayer && pPlayer->GetActor() != nullptr) if (pPlayer && pPlayer->GetActor() != nullptr)
dokillEffectGenCallbacks(pPlayer->GetActor()); dokillEffectGenCallbacks(pPlayer->GetActor());
} }

22
source/games/blood/src/nnexts.h
View file

@ -331,8 +331,8 @@ void useCustomDudeSpawn(DBloodActor* pXSource, DBloodActor* pSprite);
void useVelocityChanger(DBloodActor* pXSource, sectortype* sect, DBloodActor* causerID, DBloodActor* pSprite); void useVelocityChanger(DBloodActor* pXSource, sectortype* sect, DBloodActor* causerID, DBloodActor* pSprite);
void seqTxSendCmdAll(DBloodActor* pXSource, DBloodActor* nIndex, COMMAND_ID cmd, bool modernSend, DBloodActor* initiator); void seqTxSendCmdAll(DBloodActor* pXSource, DBloodActor* nIndex, COMMAND_ID cmd, bool modernSend, DBloodActor* initiator);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
void trPlayerCtrlLink(DBloodActor* pXSource, BloodPlayer* pPlayer, bool checkCondition); void trPlayerCtrlLink(DBloodActor* pXSource, DBloodPlayer* pPlayer, bool checkCondition);
void trPlayerCtrlStopScene(BloodPlayer* pPlayer); void trPlayerCtrlStopScene(DBloodPlayer* pPlayer);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
void modernTypeTrigger(int type, sectortype* sect, walltype* wal, DBloodActor* actor, EVENT& event); void modernTypeTrigger(int type, sectortype* sect, walltype* wal, DBloodActor* actor, EVENT& event);
bool modernTypeOperateSector(sectortype* pSector, const EVENT& event); bool modernTypeOperateSector(sectortype* pSector, const EVENT& event);
@ -340,22 +340,22 @@ bool modernTypeOperateSprite(DBloodActor*, EVENT& event);
bool modernTypeOperateWall(walltype* pWall, const EVENT& event); bool modernTypeOperateWall(walltype* pWall, const EVENT& event);
void modernTypeSendCommand(DBloodActor* nSprite, int channel, COMMAND_ID command, DBloodActor* initiator); void modernTypeSendCommand(DBloodActor* nSprite, int channel, COMMAND_ID command, DBloodActor* initiator);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
bool playerSizeShrink(BloodPlayer* pPlayer, int divider); bool playerSizeShrink(DBloodPlayer* pPlayer, int divider);
bool playerSizeGrow(BloodPlayer* pPlayer, int multiplier); bool playerSizeGrow(DBloodPlayer* pPlayer, int multiplier);
bool playerSizeReset(BloodPlayer* pPlayer); bool playerSizeReset(DBloodPlayer* pPlayer);
void playerDeactivateShrooms(BloodPlayer* pPlayer); void playerDeactivateShrooms(DBloodPlayer* pPlayer);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
QAV* playerQavSceneLoad(int qavId); QAV* playerQavSceneLoad(int qavId);
void playerQavSceneProcess(BloodPlayer* pPlayer, QAVSCENE* pQavScene); void playerQavSceneProcess(DBloodPlayer* pPlayer, QAVSCENE* pQavScene);
void playerQavScenePlay(BloodPlayer* pPlayer); void playerQavScenePlay(DBloodPlayer* pPlayer);
void playerQavSceneDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle); void playerQavSceneDraw(DBloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void playerQavSceneReset(BloodPlayer* pPlayer); void playerQavSceneReset(DBloodPlayer* pPlayer);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
void callbackUniMissileBurst(DBloodActor* actor, sectortype* nSprite); void callbackUniMissileBurst(DBloodActor* actor, sectortype* nSprite);
void callbackMakeMissileBlocking(DBloodActor* actor, sectortype* nSprite); void callbackMakeMissileBlocking(DBloodActor* actor, sectortype* nSprite);
void callbackGenDudeUpdate(DBloodActor* actor, sectortype* nSprite); void callbackGenDudeUpdate(DBloodActor* actor, sectortype* nSprite);
// ------------------------------------------------------------------------- // // ------------------------------------------------------------------------- //
BloodPlayer* getPlayerById(int id); DBloodPlayer* getPlayerById(int id);
bool isGrown(DBloodActor* pSprite); bool isGrown(DBloodActor* pSprite);
bool isShrinked(DBloodActor* pSprite); bool isShrinked(DBloodActor* pSprite);
bool IsBurningDude(DBloodActor* pSprite); bool IsBurningDude(DBloodActor* pSprite);

239
source/games/blood/src/player.cpp
View file

@ -228,7 +228,7 @@ DAMAGEINFO damageInfo[7] = {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
inline bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target) inline bool IsTargetTeammate(DBloodPlayer* pSourcePlayer, DBloodActor* target)
{ {
if (pSourcePlayer == nullptr) if (pSourcePlayer == nullptr)
return false; return false;
@ -236,7 +236,7 @@ inline bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target)
return false; return false;
if (gGameOptions.nGameType == 1 || gGameOptions.nGameType == 3) if (gGameOptions.nGameType == 1 || gGameOptions.nGameType == 3)
{ {
BloodPlayer* pTargetPlayer = getPlayer(target->spr.type - kDudePlayer1); DBloodPlayer* pTargetPlayer = getPlayer(target->spr.type - kDudePlayer1);
if (pSourcePlayer != pTargetPlayer) if (pSourcePlayer != pTargetPlayer)
{ {
if (gGameOptions.nGameType == 1) if (gGameOptions.nGameType == 1)
@ -256,7 +256,7 @@ inline bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int powerupCheck(BloodPlayer* pPlayer, int nPowerUp) int powerupCheck(DBloodPlayer* pPlayer, int nPowerUp)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
assert(nPowerUp >= 0 && nPowerUp < kMaxPowerUps); assert(nPowerUp >= 0 && nPowerUp < kMaxPowerUps);
@ -273,7 +273,7 @@ int powerupCheck(BloodPlayer* pPlayer, int nPowerUp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool powerupActivate(BloodPlayer* pPlayer, int nPowerUp) bool powerupActivate(DBloodPlayer* pPlayer, int nPowerUp)
{ {
if (powerupCheck(pPlayer, nPowerUp) > 0 && gPowerUpInfo[nPowerUp].pickupOnce) if (powerupCheck(pPlayer, nPowerUp) > 0 && gPowerUpInfo[nPowerUp].pickupOnce)
return 0; return 0;
@ -346,7 +346,7 @@ bool powerupActivate(BloodPlayer* pPlayer, int nPowerUp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powerupDeactivate(BloodPlayer* pPlayer, int nPowerUp) void powerupDeactivate(DBloodPlayer* pPlayer, int nPowerUp)
{ {
int nPack = powerupToPackItem(nPowerUp); int nPack = powerupToPackItem(nPowerUp);
if (nPack >= 0) if (nPack >= 0)
@ -401,7 +401,7 @@ void powerupDeactivate(BloodPlayer* pPlayer, int nPowerUp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powerupSetState(BloodPlayer* pPlayer, int nPowerUp, bool bState) void powerupSetState(DBloodPlayer* pPlayer, int nPowerUp, bool bState)
{ {
if (!bState) if (!bState)
powerupActivate(pPlayer, nPowerUp); powerupActivate(pPlayer, nPowerUp);
@ -415,7 +415,7 @@ void powerupSetState(BloodPlayer* pPlayer, int nPowerUp, bool bState)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powerupProcess(BloodPlayer* pPlayer) void powerupProcess(DBloodPlayer* pPlayer)
{ {
pPlayer->packItemTime = ClipLow(pPlayer->packItemTime - 4, 0); pPlayer->packItemTime = ClipLow(pPlayer->packItemTime - 4, 0);
for (int i = kMaxPowerUps - 1; i >= 0; i--) for (int i = kMaxPowerUps - 1; i >= 0; i--)
@ -451,7 +451,7 @@ void powerupProcess(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powerupClear(BloodPlayer* pPlayer) void powerupClear(DBloodPlayer* pPlayer)
{ {
for (int i = kMaxPowerUps - 1; i >= 0; i--) for (int i = kMaxPowerUps - 1; i >= 0; i--)
{ {
@ -517,7 +517,7 @@ int powerupToPackItem(int nPowerUp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool packAddItem(BloodPlayer* pPlayer, unsigned int nPack) bool packAddItem(DBloodPlayer* pPlayer, unsigned int nPack)
{ {
if (nPack <= 4) if (nPack <= 4)
{ {
@ -543,12 +543,12 @@ bool packAddItem(BloodPlayer* pPlayer, unsigned int nPack)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int packCheckItem(BloodPlayer* pPlayer, int nPack) int packCheckItem(DBloodPlayer* pPlayer, int nPack)
{ {
return pPlayer->packSlots[nPack].curAmount; return pPlayer->packSlots[nPack].curAmount;
} }
bool packItemActive(BloodPlayer* pPlayer, int nPack) bool packItemActive(DBloodPlayer* pPlayer, int nPack)
{ {
return pPlayer->packSlots[nPack].isActive; return pPlayer->packSlots[nPack].isActive;
} }
@ -559,7 +559,7 @@ bool packItemActive(BloodPlayer* pPlayer, int nPack)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void packUseItem(BloodPlayer* pPlayer, int nPack) void packUseItem(DBloodPlayer* pPlayer, int nPack)
{ {
bool v4 = 0; bool v4 = 0;
int nPowerUp = -1; int nPowerUp = -1;
@ -612,7 +612,7 @@ void packUseItem(BloodPlayer* pPlayer, int nPack)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void packPrevItem(BloodPlayer* pPlayer) void packPrevItem(DBloodPlayer* pPlayer)
{ {
if (pPlayer->packItemTime > 0) if (pPlayer->packItemTime > 0)
{ {
@ -641,7 +641,7 @@ void packPrevItem(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void packNextItem(BloodPlayer* pPlayer) void packNextItem(DBloodPlayer* pPlayer)
{ {
if (pPlayer->packItemTime > 0) if (pPlayer->packItemTime > 0)
{ {
@ -669,7 +669,7 @@ void packNextItem(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool playerSeqPlaying(BloodPlayer* pPlayer, int nSeq) bool playerSeqPlaying(DBloodPlayer* pPlayer, int nSeq)
{ {
int nCurSeq = seqGetID(pPlayer->GetActor()); int nCurSeq = seqGetID(pPlayer->GetActor());
if (pPlayer->pDudeInfo->seqStartID + nSeq == nCurSeq && seqGetStatus(pPlayer->GetActor()) >= 0) if (pPlayer->pDudeInfo->seqStartID + nSeq == nCurSeq && seqGetStatus(pPlayer->GetActor()) >= 0)
@ -683,7 +683,7 @@ bool playerSeqPlaying(BloodPlayer* pPlayer, int nSeq)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerSetRace(BloodPlayer* pPlayer, int nLifeMode) void playerSetRace(DBloodPlayer* pPlayer, int nLifeMode)
{ {
assert(nLifeMode >= kModeHuman && nLifeMode <= kModeHumanGrown); assert(nLifeMode >= kModeHuman && nLifeMode <= kModeHumanGrown);
DUDEINFO* pDudeInfo = pPlayer->pDudeInfo; DUDEINFO* pDudeInfo = pPlayer->pDudeInfo;
@ -703,12 +703,12 @@ void playerSetRace(BloodPlayer* pPlayer, int nLifeMode)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerSetGodMode(BloodPlayer* pPlayer, bool bGodMode) void playerSetGodMode(DBloodPlayer* pPlayer, bool bGodMode)
{ {
pPlayer->godMode = bGodMode; pPlayer->godMode = bGodMode;
} }
void playerResetInertia(BloodPlayer* pPlayer) void playerResetInertia(DBloodPlayer* pPlayer)
{ {
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ; pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ;
@ -717,7 +717,7 @@ void playerResetInertia(BloodPlayer* pPlayer)
viewBackupView(pPlayer->pnum); viewBackupView(pPlayer->pnum);
} }
void playerCorrectInertia(BloodPlayer* pPlayer, const DVector3& oldpos) void playerCorrectInertia(DBloodPlayer* pPlayer, const DVector3& oldpos)
{ {
auto zAdj = pPlayer->GetActor()->spr.pos.Z - oldpos.Z; auto zAdj = pPlayer->GetActor()->spr.pos.Z - oldpos.Z;
pPlayer->zView += zAdj; pPlayer->zView += zAdj;
@ -727,7 +727,7 @@ void playerCorrectInertia(BloodPlayer* pPlayer, const DVector3& oldpos)
pPlayer->GetActor()->opos.Z += zAdj; pPlayer->GetActor()->opos.Z += zAdj;
} }
void playerResetPowerUps(BloodPlayer* pPlayer) void playerResetPowerUps(DBloodPlayer* pPlayer)
{ {
for (int i = 0; i < kMaxPowerUps; i++) { for (int i = 0; i < kMaxPowerUps; i++) {
if (!VanillaMode() && (i == kPwUpJumpBoots || i == kPwUpDivingSuit || i == kPwUpCrystalBall || i == kPwUpBeastVision)) if (!VanillaMode() && (i == kPwUpJumpBoots || i == kPwUpDivingSuit || i == kPwUpCrystalBall || i == kPwUpBeastVision))
@ -736,7 +736,7 @@ void playerResetPowerUps(BloodPlayer* pPlayer)
} }
} }
void playerResetPosture(BloodPlayer* pPlayer) { void playerResetPosture(DBloodPlayer* pPlayer) {
memcpy(pPlayer->pPosture, gPostureDefaults, sizeof(gPostureDefaults)); memcpy(pPlayer->pPosture, gPostureDefaults, sizeof(gPostureDefaults));
if (!VanillaMode()) { if (!VanillaMode()) {
pPlayer->bobPhase = 0; pPlayer->bobPhase = 0;
@ -757,7 +757,7 @@ void playerResetPosture(BloodPlayer* pPlayer) {
void playerStart(int nPlayer, int bNewLevel) void playerStart(int nPlayer, int bNewLevel)
{ {
BloodPlayer* pPlayer = getPlayer(nPlayer); DBloodPlayer* pPlayer = getPlayer(nPlayer);
InputPacket* pInput = &pPlayer->cmd.ucmd; InputPacket* pInput = &pPlayer->cmd.ucmd;
ZONE* pStartZone = NULL; ZONE* pStartZone = NULL;
@ -916,7 +916,7 @@ void playerStart(int nPlayer, int bNewLevel)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerReset(BloodPlayer* pPlayer) void playerReset(DBloodPlayer* pPlayer)
{ {
static int dword_136400[] = { static int dword_136400[] = {
3, 4, 2, 8, 9, 10, 7, 1, 1, 1, 1, 1, 1, 1 3, 4, 2, 8, 9, 10, 7, 1, 1, 1, 1, 1, 1, 1
@ -980,9 +980,9 @@ int team_ticker[8];
void playerInit(int nPlayer, unsigned int a2) void playerInit(int nPlayer, unsigned int a2)
{ {
if (!(a2 & 1)) if (!(a2 & 1))
*getPlayer(nPlayer) = {}; getPlayer(nPlayer)->Clear();
BloodPlayer* pPlayer = getPlayer(nPlayer); DBloodPlayer* pPlayer = getPlayer(nPlayer);
pPlayer->pnum = nPlayer; pPlayer->pnum = nPlayer;
pPlayer->teamId = nPlayer; pPlayer->teamId = nPlayer;
if (gGameOptions.nGameType == 3) if (gGameOptions.nGameType == 3)
@ -1002,7 +1002,7 @@ void playerInit(int nPlayer, unsigned int a2)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool findDroppedLeech(BloodPlayer* a1, DBloodActor* a2) bool findDroppedLeech(DBloodPlayer* a1, DBloodActor* a2)
{ {
BloodStatIterator it(kStatThing); BloodStatIterator it(kStatThing);
while (auto actor = it.Next()) while (auto actor = it.Next())
@ -1021,7 +1021,7 @@ bool findDroppedLeech(BloodPlayer* a1, DBloodActor* a2)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool PickupItem(BloodPlayer* pPlayer, DBloodActor* itemactor) bool PickupItem(DBloodPlayer* pPlayer, DBloodActor* itemactor)
{ {
char buffer[80]; char buffer[80];
int pickupSnd = 775; int pickupSnd = 775;
@ -1254,7 +1254,7 @@ bool PickupItem(BloodPlayer* pPlayer, DBloodActor* itemactor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool PickupAmmo(BloodPlayer* pPlayer, DBloodActor* ammoactor) bool PickupAmmo(DBloodPlayer* pPlayer, DBloodActor* ammoactor)
{ {
const AMMOITEMDATA* pAmmoItemData = &gAmmoItemData[ammoactor->spr.type - kItemAmmoBase]; const AMMOITEMDATA* pAmmoItemData = &gAmmoItemData[ammoactor->spr.type - kItemAmmoBase];
int nAmmoType = pAmmoItemData->type; int nAmmoType = pAmmoItemData->type;
@ -1278,7 +1278,7 @@ bool PickupAmmo(BloodPlayer* pPlayer, DBloodActor* ammoactor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool PickupWeapon(BloodPlayer* pPlayer, DBloodActor* weaponactor) bool PickupWeapon(DBloodPlayer* pPlayer, DBloodActor* weaponactor)
{ {
const WEAPONITEMDATA* pWeaponItemData = &gWeaponItemData[weaponactor->spr.type - kItemWeaponBase]; const WEAPONITEMDATA* pWeaponItemData = &gWeaponItemData[weaponactor->spr.type - kItemWeaponBase];
int nWeaponType = pWeaponItemData->type; int nWeaponType = pWeaponItemData->type;
@ -1323,7 +1323,7 @@ bool PickupWeapon(BloodPlayer* pPlayer, DBloodActor* weaponactor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PickUp(BloodPlayer* pPlayer, DBloodActor* actor) void PickUp(DBloodPlayer* pPlayer, DBloodActor* actor)
{ {
const char* msg = nullptr; const char* msg = nullptr;
int nType = actor->spr.type; int nType = actor->spr.type;
@ -1374,7 +1374,7 @@ void PickUp(BloodPlayer* pPlayer, DBloodActor* actor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void CheckPickUp(BloodPlayer* pPlayer) void CheckPickUp(DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
auto ppos = plActor->spr.pos; auto ppos = plActor->spr.pos;
@ -1415,7 +1415,7 @@ void CheckPickUp(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int ActionScan(BloodPlayer* pPlayer, HitInfo* out) int ActionScan(DBloodPlayer* pPlayer, HitInfo* out)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
*out = {}; *out = {};
@ -1507,7 +1507,7 @@ unsigned GameInterface::getCrouchState()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ProcessInput(BloodPlayer* pPlayer) void ProcessInput(DBloodPlayer* pPlayer)
{ {
enum enum
{ {
@ -1762,7 +1762,7 @@ void ProcessInput(BloodPlayer* pPlayer)
CheckPickUp(pPlayer); CheckPickUp(pPlayer);
} }
void playerProcess(BloodPlayer* pPlayer) void playerProcess(DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
@ -1890,12 +1890,12 @@ void playerProcess(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
DBloodActor* playerFireMissile(BloodPlayer* pPlayer, double xyoff, const DVector3& dv, int nType) DBloodActor* playerFireMissile(DBloodPlayer* pPlayer, double xyoff, const DVector3& dv, int nType)
{ {
return actFireMissile(pPlayer->GetActor(), xyoff, pPlayer->zWeapon - pPlayer->GetActor()->spr.pos.Z, dv, nType); return actFireMissile(pPlayer->GetActor(), xyoff, pPlayer->zWeapon - pPlayer->GetActor()->spr.pos.Z, dv, nType);
} }
DBloodActor* playerFireThing(BloodPlayer* pPlayer, double xyoff, double zvel, int thingType, double nSpeed) DBloodActor* playerFireThing(DBloodPlayer* pPlayer, double xyoff, double zvel, int thingType, double nSpeed)
{ {
return actFireThing(pPlayer->GetActor(), xyoff, pPlayer->zWeapon - pPlayer->GetActor()->spr.pos.Z, pPlayer->slope * 0.25 + zvel, thingType, nSpeed); return actFireThing(pPlayer->GetActor(), xyoff, pPlayer->zWeapon - pPlayer->GetActor()->spr.pos.Z, pPlayer->slope * 0.25 + zvel, thingType, nSpeed);
} }
@ -1906,7 +1906,7 @@ DBloodActor* playerFireThing(BloodPlayer* pPlayer, double xyoff, double zvel, in
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerFrag(BloodPlayer* pKiller, BloodPlayer* pVictim) void playerFrag(DBloodPlayer* pKiller, DBloodPlayer* pVictim)
{ {
assert(pKiller != NULL); assert(pKiller != NULL);
assert(pVictim != NULL); assert(pVictim != NULL);
@ -1972,11 +1972,11 @@ void playerFrag(BloodPlayer* pKiller, BloodPlayer* pVictim)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FragPlayer(BloodPlayer* pPlayer, DBloodActor* killer) void FragPlayer(DBloodPlayer* pPlayer, DBloodActor* killer)
{ {
if (killer && killer->IsPlayerActor()) if (killer && killer->IsPlayerActor())
{ {
BloodPlayer* pKiller = getPlayer(killer->spr.type - kDudePlayer1); DBloodPlayer* pKiller = getPlayer(killer->spr.type - kDudePlayer1);
playerFrag(pKiller, pPlayer); playerFrag(pKiller, pPlayer);
int nTeam1 = pKiller->teamId & 1; int nTeam1 = pKiller->teamId & 1;
int nTeam2 = pPlayer->teamId & 1; int nTeam2 = pPlayer->teamId & 1;
@ -2003,7 +2003,7 @@ void FragPlayer(BloodPlayer* pPlayer, DBloodActor* killer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int playerDamageArmor(BloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage) int playerDamageArmor(DBloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage)
{ {
DAMAGEINFO* pDamageInfo = &damageInfo[nType]; DAMAGEINFO* pDamageInfo = &damageInfo[nType];
int nArmorType = pDamageInfo->armorType; int nArmorType = pDamageInfo->armorType;
@ -2030,7 +2030,7 @@ int playerDamageArmor(BloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void flagDropped(BloodPlayer* pPlayer, int a2) void flagDropped(DBloodPlayer* pPlayer, int a2)
{ {
DBloodActor* playeractor = pPlayer->GetActor(); DBloodActor* playeractor = pPlayer->GetActor();
DBloodActor* actor; DBloodActor* actor;
@ -2064,7 +2064,7 @@ void flagDropped(BloodPlayer* pPlayer, int a2)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int playerDamageSprite(DBloodActor* source, BloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage) int playerDamageSprite(DBloodActor* source, DBloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
if (pPlayer->damageControl[nDamageType] || pPlayer->godMode) if (pPlayer->damageControl[nDamageType] || pPlayer->godMode)
@ -2232,7 +2232,7 @@ int playerDamageSprite(DBloodActor* source, BloodPlayer* pPlayer, DAMAGE_TYPE nD
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int UseAmmo(BloodPlayer* pPlayer, int nAmmoType, int nDec) int UseAmmo(DBloodPlayer* pPlayer, int nAmmoType, int nDec)
{ {
if (gInfiniteAmmo) if (gInfiniteAmmo)
return 9999; return 9999;
@ -2248,7 +2248,7 @@ int UseAmmo(BloodPlayer* pPlayer, int nAmmoType, int nDec)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void voodooTarget(BloodPlayer* pPlayer) void voodooTarget(DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
double aimz = pPlayer->aim.Z; double aimz = pPlayer->aim.Z;
@ -2275,7 +2275,7 @@ void voodooTarget(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerLandingSound(BloodPlayer* pPlayer) void playerLandingSound(DBloodPlayer* pPlayer)
{ {
static int surfaceSound[] = { static int surfaceSound[] = {
-1, -1,
@ -2320,7 +2320,7 @@ void PlayerSurvive(int, DBloodActor* actor)
sfxPlay3DSound(actor, 3009, 0, 6); sfxPlay3DSound(actor, 3009, 0, 6);
if (actor->IsPlayerActor()) if (actor->IsPlayerActor())
{ {
BloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1); DBloodPlayer* pPlayer = getPlayer(actor->spr.type - kDudePlayer1);
if (pPlayer->pnum == myconnectindex) if (pPlayer->pnum == myconnectindex)
viewSetMessage(GStrings("TXT_LIVEAGAIM")); viewSetMessage(GStrings("TXT_LIVEAGAIM"));
else else
@ -2345,7 +2345,7 @@ void PlayerKneelsOver(int, DBloodActor* actor)
{ {
if (getPlayer(p)->GetActor() == actor) if (getPlayer(p)->GetActor() == actor)
{ {
BloodPlayer* pPlayer = getPlayer(p); DBloodPlayer* pPlayer = getPlayer(p);
playerDamageSprite(pPlayer->fragger, pPlayer, kDamageSpirit, 500 << 4); playerDamageSprite(pPlayer->fragger, pPlayer, kDamageSpirit, 500 << 4);
return; return;
} }
@ -2394,7 +2394,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, POSTURE& w, POSTUR
return arc; return arc;
} }
FSerializer& Serialize(FSerializer& arc, const char* keyname, BloodPlayer& w, BloodPlayer* def) FSerializer& Serialize(FSerializer& arc, const char* keyname, DBloodPlayer& w, DBloodPlayer* def)
{ {
if (arc.BeginObject(keyname)) if (arc.BeginObject(keyname))
{ {
@ -2562,76 +2562,77 @@ void SerializePlayers(FSerializer& arc)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, newWeapon) DEFINE_FIELD(DBloodPlayer, actor)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponQav) DEFINE_FIELD(DBloodPlayer, newWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, qavCallback) DEFINE_FIELD(DBloodPlayer, weaponQav)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, isRunning) DEFINE_FIELD(DBloodPlayer, qavCallback)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, posture) // stand, crouch, swim DEFINE_FIELD(DBloodPlayer, isRunning)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, sceneQav) // by NoOne: used to keep qav id DEFINE_FIELD(DBloodPlayer, posture) // stand, crouch, swim
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobPhase) DEFINE_FIELD(DBloodPlayer, sceneQav) // by NoOne: used to keep qav id
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobAmp) DEFINE_FIELD(DBloodPlayer, bobPhase)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobHeight) DEFINE_FIELD(DBloodPlayer, bobAmp)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobWidth) DEFINE_FIELD(DBloodPlayer, bobHeight)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayAmp) DEFINE_FIELD(DBloodPlayer, bobWidth)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayHeight) DEFINE_FIELD(DBloodPlayer, swayAmp)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayWidth) DEFINE_FIELD(DBloodPlayer, swayHeight)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, pnum) // Connect id DEFINE_FIELD(DBloodPlayer, swayWidth)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, lifeMode) DEFINE_FIELD(DBloodPlayer, pnum) // Connect id
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zView) DEFINE_FIELD(DBloodPlayer, lifeMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zViewVel) DEFINE_FIELD(DBloodPlayer, zView)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zWeapon) DEFINE_FIELD(DBloodPlayer, zViewVel)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zWeaponVel) DEFINE_FIELD(DBloodPlayer, zWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, slope) DEFINE_FIELD(DBloodPlayer, zWeaponVel)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, isUnderwater) DEFINE_FIELD(DBloodPlayer, slope)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasKey) DEFINE_FIELD(DBloodPlayer, isUnderwater)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasFlag) DEFINE_FIELD(DBloodPlayer, hasKey)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, damageControl) DEFINE_FIELD(DBloodPlayer, hasFlag)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, curWeapon) DEFINE_FIELD(DBloodPlayer, damageControl)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, nextWeapon) DEFINE_FIELD(DBloodPlayer, curWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponTimer) DEFINE_FIELD(DBloodPlayer, nextWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponState) DEFINE_FIELD(DBloodPlayer, weaponTimer)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponAmmo) //rename DEFINE_FIELD(DBloodPlayer, weaponState)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasWeapon) DEFINE_FIELD(DBloodPlayer, weaponAmmo) //rename
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponMode) DEFINE_FIELD(DBloodPlayer, hasWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponOrder) DEFINE_FIELD(DBloodPlayer, weaponMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, ammoCount) DEFINE_FIELD(DBloodPlayer, weaponOrder)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, qavLoop) DEFINE_FIELD(DBloodPlayer, ammoCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fuseTime) DEFINE_FIELD(DBloodPlayer, qavLoop)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, throwTime) DEFINE_FIELD(DBloodPlayer, fuseTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, throwPower) DEFINE_FIELD(DBloodPlayer, throwTime)
//DEFINE_FIELD_X(BloodPlayer, PLAYER, aim) // world DEFINE_FIELD(DBloodPlayer, throwPower)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, aimTargetsCount) //DEFINE_FIELD(DBloodPlayer, aim) // world
//DEFINE_FIELD_X(BloodPlayer, PLAYER, aimTargets) DEFINE_FIELD(DBloodPlayer, aimTargetsCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, deathTime) //DEFINE_FIELD(DBloodPlayer, aimTargets)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, pwUpTime) DEFINE_FIELD(DBloodPlayer, deathTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, teamId) DEFINE_FIELD(DBloodPlayer, pwUpTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fragCount) DEFINE_FIELD(DBloodPlayer, teamId)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fragInfo) DEFINE_FIELD(DBloodPlayer, fragCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, underwaterTime) DEFINE_FIELD(DBloodPlayer, fragInfo)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bubbleTime) DEFINE_FIELD(DBloodPlayer, underwaterTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, restTime) DEFINE_FIELD(DBloodPlayer, bubbleTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, kickPower) DEFINE_FIELD(DBloodPlayer, restTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, laughCount) DEFINE_FIELD(DBloodPlayer, kickPower)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, godMode) DEFINE_FIELD(DBloodPlayer, laughCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fallScream) DEFINE_FIELD(DBloodPlayer, godMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, cantJump) DEFINE_FIELD(DBloodPlayer, fallScream)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packItemTime) // pack timer DEFINE_FIELD(DBloodPlayer, cantJump)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packItemId) // pack id 1: diving suit, 2: crystal ball, 3: DEFINE_FIELD(DBloodPlayer, packItemTime) // pack timer
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packSlots) // at325 1]: diving suit, [2]: crystal ball, DEFINE_FIELD(DBloodPlayer, packItemId) // pack id 1: diving suit, 2: crystal ball, 3:
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, armor) // armor DEFINE_FIELD(DBloodPlayer, packSlots) // at325 1]: diving suit, [2]: crystal ball,
//DEFINE_FIELD_X(BloodPlayer, PLAYER, voodooTarget) DEFINE_FIELD(DBloodPlayer, armor) // armor
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, flickerEffect) //DEFINE_FIELD(DBloodPlayer, voodooTarget)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, tiltEffect) DEFINE_FIELD(DBloodPlayer, flickerEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, visibility) DEFINE_FIELD(DBloodPlayer, tiltEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, painEffect) DEFINE_FIELD(DBloodPlayer, visibility)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, blindEffect) DEFINE_FIELD(DBloodPlayer, painEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, chokeEffect) DEFINE_FIELD(DBloodPlayer, blindEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, handTime) DEFINE_FIELD(DBloodPlayer, chokeEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hand) // if true, there is hand start choking the player DEFINE_FIELD(DBloodPlayer, handTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, pickupEffect) DEFINE_FIELD(DBloodPlayer, hand) // if true, there is hand start choking the player
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, flashEffect) // if true, reduce pPlayer->visibility counter DEFINE_FIELD(DBloodPlayer, pickupEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, quakeEffect) DEFINE_FIELD(DBloodPlayer, flashEffect) // if true, reduce pPlayer->visibility counter
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, player_par) DEFINE_FIELD(DBloodPlayer, quakeEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, nWaterPal) DEFINE_FIELD(DBloodPlayer, player_par)
DEFINE_FIELD(DBloodPlayer, nWaterPal)
END_BLD_NS END_BLD_NS

64
source/games/blood/src/player.h
View file

@ -78,7 +78,7 @@ struct POSTURE
extern POSTURE gPostureDefaults[kModeMax][kPostureMax]; extern POSTURE gPostureDefaults[kModeMax][kPostureMax];
struct BloodPlayer; class DBloodPlayer;
struct AMMOINFO struct AMMOINFO
{ {
@ -95,7 +95,7 @@ struct POWERUPINFO
FTextureID textureID() const { return tileGetTextureID(picno); } FTextureID textureID() const { return tileGetTextureID(picno); }
}; };
void playerResetPosture(BloodPlayer* pPlayer); void playerResetPosture(DBloodPlayer* pPlayer);
extern bool gBlueFlagDropped; extern bool gBlueFlagDropped;
extern bool gRedFlagDropped; extern bool gRedFlagDropped;
@ -105,40 +105,40 @@ extern int team_ticker[kMaxPlayers];
extern AMMOINFO gAmmoInfo[]; extern AMMOINFO gAmmoInfo[];
extern POWERUPINFO gPowerUpInfo[kMaxPowerUps]; extern POWERUPINFO gPowerUpInfo[kMaxPowerUps];
bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target); bool IsTargetTeammate(DBloodPlayer* pSourcePlayer, DBloodActor* target);
int powerupCheck(BloodPlayer* pPlayer, int nPowerUp); int powerupCheck(DBloodPlayer* pPlayer, int nPowerUp);
bool powerupActivate(BloodPlayer* pPlayer, int nPowerUp); bool powerupActivate(DBloodPlayer* pPlayer, int nPowerUp);
void powerupDeactivate(BloodPlayer* pPlayer, int nPowerUp); void powerupDeactivate(DBloodPlayer* pPlayer, int nPowerUp);
void powerupSetState(BloodPlayer* pPlayer, int nPowerUp, bool bState); void powerupSetState(DBloodPlayer* pPlayer, int nPowerUp, bool bState);
void powerupProcess(BloodPlayer* pPlayer); void powerupProcess(DBloodPlayer* pPlayer);
void powerupClear(BloodPlayer* pPlayer); void powerupClear(DBloodPlayer* pPlayer);
int packItemToPowerup(int nPack); int packItemToPowerup(int nPack);
int powerupToPackItem(int nPowerUp); int powerupToPackItem(int nPowerUp);
bool packAddItem(BloodPlayer* pPlayer, unsigned int nPack); bool packAddItem(DBloodPlayer* pPlayer, unsigned int nPack);
int packCheckItem(BloodPlayer* pPlayer, int nPack); int packCheckItem(DBloodPlayer* pPlayer, int nPack);
bool packItemActive(BloodPlayer* pPlayer, int nPack); bool packItemActive(DBloodPlayer* pPlayer, int nPack);
void packUseItem(BloodPlayer* pPlayer, int nPack); void packUseItem(DBloodPlayer* pPlayer, int nPack);
void packPrevItem(BloodPlayer* pPlayer); void packPrevItem(DBloodPlayer* pPlayer);
void packNextItem(BloodPlayer* pPlayer); void packNextItem(DBloodPlayer* pPlayer);
bool playerSeqPlaying(BloodPlayer* pPlayer, int nSeq); bool playerSeqPlaying(DBloodPlayer* pPlayer, int nSeq);
void playerSetRace(BloodPlayer* pPlayer, int nLifeMode); void playerSetRace(DBloodPlayer* pPlayer, int nLifeMode);
void playerSetGodMode(BloodPlayer* pPlayer, bool bGodMode); void playerSetGodMode(DBloodPlayer* pPlayer, bool bGodMode);
void playerResetInertia(BloodPlayer* pPlayer); void playerResetInertia(DBloodPlayer* pPlayer);
void playerCorrectInertia(BloodPlayer* pPlayer, const DVector3& oldpos); void playerCorrectInertia(DBloodPlayer* pPlayer, const DVector3& oldpos);
void playerStart(int nPlayer, int bNewLevel = 0); void playerStart(int nPlayer, int bNewLevel = 0);
void playerReset(BloodPlayer* pPlayer); void playerReset(DBloodPlayer* pPlayer);
void playerInit(int nPlayer, unsigned int a2); void playerInit(int nPlayer, unsigned int a2);
void CheckPickUp(BloodPlayer* pPlayer); void CheckPickUp(DBloodPlayer* pPlayer);
void ProcessInput(BloodPlayer* pPlayer); void ProcessInput(DBloodPlayer* pPlayer);
void playerProcess(BloodPlayer* pPlayer); void playerProcess(DBloodPlayer* pPlayer);
DBloodActor* playerFireMissile(BloodPlayer* pPlayer, double xyoff, const DVector3& vec, int nType); DBloodActor* playerFireMissile(DBloodPlayer* pPlayer, double xyoff, const DVector3& vec, int nType);
DBloodActor* playerFireThing(BloodPlayer* pPlayer, double xyoff, double zvel, int thingType, double nSpeed); DBloodActor* playerFireThing(DBloodPlayer* pPlayer, double xyoff, double zvel, int thingType, double nSpeed);
void playerFrag(BloodPlayer* pKiller, BloodPlayer* pVictim); void playerFrag(DBloodPlayer* pKiller, DBloodPlayer* pVictim);
int playerDamageArmor(BloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage); int playerDamageArmor(DBloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage);
int playerDamageSprite(DBloodActor* nSource, BloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage); int playerDamageSprite(DBloodActor* nSource, DBloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage);
int UseAmmo(BloodPlayer* pPlayer, int nAmmoType, int nDec); int UseAmmo(DBloodPlayer* pPlayer, int nAmmoType, int nDec);
void voodooTarget(BloodPlayer* pPlayer); void voodooTarget(DBloodPlayer* pPlayer);
void playerLandingSound(BloodPlayer* pPlayer); void playerLandingSound(DBloodPlayer* pPlayer);
void PlayerSurvive(int, DBloodActor*); void PlayerSurvive(int, DBloodActor*);
END_BLD_NS END_BLD_NS

6
source/games/blood/src/prediction.cpp
View file

@ -39,7 +39,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
BEGIN_BLD_NS BEGIN_BLD_NS
void fakePlayerProcess(BloodPlayer* pPlayer, InputPacket* pInput); void fakePlayerProcess(DBloodPlayer* pPlayer, InputPacket* pInput);
void fakeActProcessSprites(void); void fakeActProcessSprites(void);
bool gPrediction = true; bool gPrediction = true;
@ -98,7 +98,7 @@ void viewUpdatePrediction(InputPacket* pInput)
#endif #endif
} }
static void fakeProcessInput(BloodPlayer* pPlayer, InputPacket* pInput) static void fakeProcessInput(DBloodPlayer* pPlayer, InputPacket* pInput)
{ {
#if 0 #if 0
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][predict.posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][predict.posture];
@ -253,7 +253,7 @@ static void fakeProcessInput(BloodPlayer* pPlayer, InputPacket* pInput)
#endif #endif
} }
void fakePlayerProcess(BloodPlayer* pPlayer, InputPacket* pInput) void fakePlayerProcess(DBloodPlayer* pPlayer, InputPacket* pInput)
{ {
#if 0 #if 0
auto pSprite = pPlayer->actor; auto pSprite = pPlayer->actor;

4
source/games/blood/src/qav.cpp
View file

@ -227,7 +227,7 @@ void QAV::Draw(int ticks, int stat, int shade, int palnum, bool to3dview, double
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void QAV::Play(int start, int end, int nCallback, BloodPlayer* pData) void QAV::Play(int start, int end, int nCallback, DBloodPlayer* pData)
{ {
auto pActor = pData ? pData->GetActor() : nullptr; auto pActor = pData ? pData->GetActor() : nullptr;
assert(ticksPerFrame > 0); assert(ticksPerFrame > 0);
@ -326,7 +326,7 @@ void qavProcessTicker(QAV* const pQAV, int* duration, int* lastTick)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void qavProcessTimer(BloodPlayer* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration, bool const ignoreWeaponTimer) void qavProcessTimer(DBloodPlayer* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration, bool const ignoreWeaponTimer)
{ {
// Process clock based on QAV's ticrate and last tick value. // Process clock based on QAV's ticrate and last tick value.
if (!paused) if (!paused)

4
source/games/blood/src/qav.h
View file

@ -230,13 +230,13 @@ struct QAV
uint16_t res_id; uint16_t res_id;
FRAMEINFO frames[1]; // 24 FRAMEINFO frames[1]; // 24
void Draw(int ticks, int stat, int shade, int palnum, bool to3dview, double const interpfrac, DAngle angle = nullAngle); void Draw(int ticks, int stat, int shade, int palnum, bool to3dview, double const interpfrac, DAngle angle = nullAngle);
void Play(int, int, int, BloodPlayer*); void Play(int, int, int, DBloodPlayer*);
void Precache(int palette = 0); void Precache(int palette = 0);
}; };
QAV* getQAV(int res_id); QAV* getQAV(int res_id);
void qavProcessTicker(QAV* const pQAV, int* duration, int* lastTick); void qavProcessTicker(QAV* const pQAV, int* duration, int* lastTick);
void qavProcessTimer(BloodPlayer* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration = false, bool const ignoreWeaponTimer = false); void qavProcessTimer(DBloodPlayer* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration = false, bool const ignoreWeaponTimer = false);
inline bool qavIsOriginal(const int res_id) inline bool qavIsOriginal(const int res_id)
{ {

2
source/games/blood/src/sbar.cpp
View file

@ -73,7 +73,7 @@ static void UpdateFrame(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void UpdateStatusBar(BloodPlayer* pPlayer) void UpdateStatusBar(DBloodPlayer* pPlayer)
{ {
if (automapMode == am_off && hud_size <= Hud_Stbar) if (automapMode == am_off && hud_size <= Hud_Stbar)
{ {

4
source/games/blood/src/sfx.cpp
View file

@ -63,7 +63,7 @@ void BloodSoundEngine::CalcPosVel(int type, const void* source, const float pt[3
{ {
if (pos != nullptr && type != SOURCE_None) if (pos != nullptr && type != SOURCE_None)
{ {
BloodPlayer* pPlayer = getPlayer(myconnectindex); DBloodPlayer* pPlayer = getPlayer(myconnectindex);
FVector3 camera; FVector3 camera;
if (pPlayer && pPlayer->GetActor()) camera = GetSoundPos(pPlayer->GetActor()->spr.pos); if (pPlayer && pPlayer->GetActor()) camera = GetSoundPos(pPlayer->GetActor()->spr.pos);
@ -105,7 +105,7 @@ void BloodSoundEngine::CalcPosVel(int type, const void* source, const float pt[3
void GameInterface::UpdateSounds() void GameInterface::UpdateSounds()
{ {
BloodPlayer* pPlayer = getPlayer(myconnectindex); DBloodPlayer* pPlayer = getPlayer(myconnectindex);
SoundListener listener; SoundListener listener;
if (pPlayer->GetActor()) if (pPlayer->GetActor())

2
source/games/blood/src/sound.h
View file

@ -36,7 +36,7 @@ void sfxKillAllSounds(void);
void sfxSetReverb(bool toggle); void sfxSetReverb(bool toggle);
void sfxSetReverb2(bool toggle); void sfxSetReverb2(bool toggle);
void ambProcess(BloodPlayer* pPlayer); void ambProcess(DBloodPlayer* pPlayer);
void ambKillAll(void); void ambKillAll(void);
void ambInit(void); void ambInit(void);

6
source/games/blood/src/triggers.cpp
View file

@ -237,7 +237,7 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
int nPlayer = actor->xspr.data4; int nPlayer = actor->xspr.data4;
if (nPlayer >= 0 && nPlayer < kMaxPlayers && playeringame[nPlayer]) if (nPlayer >= 0 && nPlayer < kMaxPlayers && playeringame[nPlayer])
{ {
BloodPlayer* pPlayer = getPlayer(nPlayer); DBloodPlayer* pPlayer = getPlayer(nPlayer);
if (pPlayer->GetActor()->xspr.health > 0) if (pPlayer->GetActor()->xspr.health > 0)
{ {
evKillActor(actor); evKillActor(actor);
@ -598,7 +598,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
case kSoundPlayer: case kSoundPlayer:
if (gGameOptions.nGameType == 0) if (gGameOptions.nGameType == 0)
{ {
BloodPlayer* pPlayer = getPlayer(myconnectindex); DBloodPlayer* pPlayer = getPlayer(myconnectindex);
if (pPlayer->GetActor()->xspr.health <= 0) if (pPlayer->GetActor()->xspr.health <= 0)
break; break;
@ -1596,7 +1596,7 @@ void OperateTeleport(sectortype* pSector)
{ {
if (actor->spr.statnum == kStatDude) if (actor->spr.statnum == kStatDude)
{ {
BloodPlayer* pPlayer; DBloodPlayer* pPlayer;
bool bPlayer = actor->IsPlayerActor(); bool bPlayer = actor->IsPlayerActor();
if (bPlayer) if (bPlayer)
pPlayer = getPlayer(actor->spr.type - kDudePlayer1); pPlayer = getPlayer(actor->spr.type - kDudePlayer1);

16
source/games/blood/src/view.cpp
View file

@ -58,7 +58,7 @@ int gViewIndex;
void viewBackupView(int nPlayer) void viewBackupView(int nPlayer)
{ {
BloodPlayer* pPlayer = getPlayer(nPlayer); DBloodPlayer* pPlayer = getPlayer(nPlayer);
pPlayer->ozView = pPlayer->zView; pPlayer->ozView = pPlayer->zView;
pPlayer->ozWeapon = pPlayer->zWeapon - pPlayer->zView - 12; pPlayer->ozWeapon = pPlayer->zWeapon - pPlayer->zView - 12;
pPlayer->obobHeight = pPlayer->bobHeight; pPlayer->obobHeight = pPlayer->bobHeight;
@ -100,7 +100,7 @@ void viewDrawText(FFont* pFont, const char* pString, int x, int y, int nShade, i
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void viewDrawAimedPlayerName(BloodPlayer* pPlayer) void viewDrawAimedPlayerName(DBloodPlayer* pPlayer)
{ {
if (!cl_idplayers || (pPlayer->aim.XY().isZero())) if (!cl_idplayers || (pPlayer->aim.XY().isZero()))
return; return;
@ -280,7 +280,7 @@ void UpdateDacs(int nPalette, bool bNoTint)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void UpdateBlend(BloodPlayer* pPlayer) void UpdateBlend(DBloodPlayer* pPlayer)
{ {
int nRed = 0; int nRed = 0;
int nGreen = 0; int nGreen = 0;
@ -324,7 +324,7 @@ int gShowFrameRate = 1;
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void viewUpdateDelirium(BloodPlayer* pPlayer) void viewUpdateDelirium(DBloodPlayer* pPlayer)
{ {
gScreenTiltO = gScreenTilt; gScreenTiltO = gScreenTilt;
deliriumTurnO = deliriumTurn; deliriumTurnO = deliriumTurn;
@ -371,7 +371,7 @@ void viewUpdateDelirium(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void viewUpdateShake(BloodPlayer* pPlayer, DVector3& cPos, DRotator& cAngles, double& pshakeX, double& pshakeY) void viewUpdateShake(DBloodPlayer* pPlayer, DVector3& cPos, DRotator& cAngles, double& pshakeX, double& pshakeY)
{ {
auto doEffect = [&](const int& effectType) auto doEffect = [&](const int& effectType)
{ {
@ -404,7 +404,7 @@ int32_t g_frameRate;
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void DrawMap(BloodPlayer* pPlayer, const double interpfrac) static void DrawMap(DBloodPlayer* pPlayer, const double interpfrac)
{ {
int tm = 0; int tm = 0;
if (viewport3d.Left() > 0) if (viewport3d.Left() > 0)
@ -423,7 +423,7 @@ static void DrawMap(BloodPlayer* pPlayer, const double interpfrac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void SetupView(BloodPlayer* pPlayer, DVector3& cPos, DRotator& cAngles, sectortype*& pSector, double& zDelta, double& shakeX, double& shakeY, const double interpfrac) static void SetupView(DBloodPlayer* pPlayer, DVector3& cPos, DRotator& cAngles, sectortype*& pSector, double& zDelta, double& shakeX, double& shakeY, const double interpfrac)
{ {
double bobWidth, bobHeight; double bobWidth, bobHeight;
@ -558,7 +558,7 @@ void renderCrystalBall()
void viewDrawScreen(bool sceneonly) void viewDrawScreen(bool sceneonly)
{ {
BloodPlayer* pPlayer = getPlayer(gViewIndex); DBloodPlayer* pPlayer = getPlayer(gViewIndex);
FireProcess(); FireProcess();

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

@ -73,13 +73,13 @@ extern DAngle gScreenTiltO, gScreenTilt;
extern int gShowFrameRate; extern int gShowFrameRate;
extern int gLastPal; extern int gLastPal;
void hudDraw(BloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac); void hudDraw(DBloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac);
void viewInitializePrediction(void); void viewInitializePrediction(void);
void viewUpdatePrediction(InputPacket* pInput); void viewUpdatePrediction(InputPacket* pInput);
void viewCorrectPrediction(void); void viewCorrectPrediction(void);
void viewBackupView(int nPlayer); void viewBackupView(int nPlayer);
void InitStatusBar(void); void InitStatusBar(void);
void UpdateStatusBar(BloodPlayer* pPlayer); void UpdateStatusBar(DBloodPlayer* pPlayer);
void viewInit(void); void viewInit(void);
void viewprocessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smooth); void viewprocessSprites(tspriteArray& tsprites, int32_t cX, int32_t cY, int32_t cZ, int32_t cA, int32_t smooth);
void viewSetMessage(const char* pMessage, const char* color = nullptr, const MESSAGE_PRIORITY priority = MESSAGE_PRIORITY_NORMAL); void viewSetMessage(const char* pMessage, const char* color = nullptr, const MESSAGE_PRIORITY priority = MESSAGE_PRIORITY_NORMAL);
@ -89,7 +89,7 @@ void viewSetErrorMessage(const char* pMessage);
void DoLensEffect(void); void DoLensEffect(void);
void UpdateDacs(int nPalette, bool bNoTint = false); void UpdateDacs(int nPalette, bool bNoTint = false);
void viewDrawScreen(bool sceneonly = false); void viewDrawScreen(bool sceneonly = false);
void viewUpdateDelirium(BloodPlayer* pPlayer); void viewUpdateDelirium(DBloodPlayer* pPlayer);
void viewSetSystemMessage(const char* pMessage, ...); void viewSetSystemMessage(const char* pMessage, ...);
inline void viewInterpolateSector(sectortype* pSector) inline void viewInterpolateSector(sectortype* pSector)

188
source/games/blood/src/weapon.cpp
View file

@ -32,38 +32,38 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
BEGIN_BLD_NS BEGIN_BLD_NS
void FirePitchfork(int, BloodPlayer* pPlayer); void FirePitchfork(int, DBloodPlayer* pPlayer);
void FireSpray(int, BloodPlayer* pPlayer); void FireSpray(int, DBloodPlayer* pPlayer);
void ThrowCan(int, BloodPlayer* pPlayer); void ThrowCan(int, DBloodPlayer* pPlayer);
void DropCan(int, BloodPlayer* pPlayer); void DropCan(int, DBloodPlayer* pPlayer);
void ExplodeCan(int, BloodPlayer* pPlayer); void ExplodeCan(int, DBloodPlayer* pPlayer);
void ThrowBundle(int, BloodPlayer* pPlayer); void ThrowBundle(int, DBloodPlayer* pPlayer);
void DropBundle(int, BloodPlayer* pPlayer); void DropBundle(int, DBloodPlayer* pPlayer);
void ExplodeBundle(int, BloodPlayer* pPlayer); void ExplodeBundle(int, DBloodPlayer* pPlayer);
void ThrowProx(int, BloodPlayer* pPlayer); void ThrowProx(int, DBloodPlayer* pPlayer);
void DropProx(int, BloodPlayer* pPlayer); void DropProx(int, DBloodPlayer* pPlayer);
void ThrowRemote(int, BloodPlayer* pPlayer); void ThrowRemote(int, DBloodPlayer* pPlayer);
void DropRemote(int, BloodPlayer* pPlayer); void DropRemote(int, DBloodPlayer* pPlayer);
void FireRemote(int, BloodPlayer* pPlayer); void FireRemote(int, DBloodPlayer* pPlayer);
void FireShotgun(int nTrigger, BloodPlayer* pPlayer); void FireShotgun(int nTrigger, DBloodPlayer* pPlayer);
void EjectShell(int, BloodPlayer* pPlayer); void EjectShell(int, DBloodPlayer* pPlayer);
void FireTommy(int nTrigger, BloodPlayer* pPlayer); void FireTommy(int nTrigger, DBloodPlayer* pPlayer);
void FireSpread(int nTrigger, BloodPlayer* pPlayer); void FireSpread(int nTrigger, DBloodPlayer* pPlayer);
void AltFireSpread(int nTrigger, BloodPlayer* pPlayer); void AltFireSpread(int nTrigger, DBloodPlayer* pPlayer);
void AltFireSpread2(int nTrigger, BloodPlayer* pPlayer); void AltFireSpread2(int nTrigger, DBloodPlayer* pPlayer);
void FireFlare(int nTrigger, BloodPlayer* pPlayer); void FireFlare(int nTrigger, DBloodPlayer* pPlayer);
void AltFireFlare(int nTrigger, BloodPlayer* pPlayer); void AltFireFlare(int nTrigger, DBloodPlayer* pPlayer);
void FireVoodoo(int nTrigger, BloodPlayer* pPlayer); void FireVoodoo(int nTrigger, DBloodPlayer* pPlayer);
void AltFireVoodoo(int nTrigger, BloodPlayer* pPlayer); void AltFireVoodoo(int nTrigger, DBloodPlayer* pPlayer);
void DropVoodoo(int nTrigger, BloodPlayer* pPlayer); void DropVoodoo(int nTrigger, DBloodPlayer* pPlayer);
void FireTesla(int nTrigger, BloodPlayer* pPlayer); void FireTesla(int nTrigger, DBloodPlayer* pPlayer);
void AltFireTesla(int nTrigger, BloodPlayer* pPlayer); void AltFireTesla(int nTrigger, DBloodPlayer* pPlayer);
void FireNapalm(int nTrigger, BloodPlayer* pPlayer); void FireNapalm(int nTrigger, DBloodPlayer* pPlayer);
void FireNapalm2(int nTrigger, BloodPlayer* pPlayer); void FireNapalm2(int nTrigger, DBloodPlayer* pPlayer);
void AltFireNapalm(int nTrigger, BloodPlayer* pPlayer); void AltFireNapalm(int nTrigger, DBloodPlayer* pPlayer);
void FireLifeLeech(int nTrigger, BloodPlayer* pPlayer); void FireLifeLeech(int nTrigger, DBloodPlayer* pPlayer);
void AltFireLifeLeech(int nTrigger, BloodPlayer* pPlayer); void AltFireLifeLeech(int nTrigger, DBloodPlayer* pPlayer);
void FireBeast(int nTrigger, BloodPlayer* pPlayer); void FireBeast(int nTrigger, DBloodPlayer* pPlayer);
typedef void(*QAVTypeCast)(int, void*); typedef void(*QAVTypeCast)(int, void*);
@ -146,12 +146,12 @@ enum
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
double getThrowPower(BloodPlayer* pPlayer) double getThrowPower(DBloodPlayer* pPlayer)
{ {
return pPlayer->throwPower * 23.46666 + 6.4; return pPlayer->throwPower * 23.46666 + 6.4;
} }
void setThrowPower(BloodPlayer* pPlayer) void setThrowPower(DBloodPlayer* pPlayer)
{ {
pPlayer->throwPower = min((PlayClock - pPlayer->throwTime) / 240., 1.); pPlayer->throwPower = min((PlayClock - pPlayer->throwTime) / 240., 1.);
} }
@ -162,7 +162,7 @@ void setThrowPower(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool checkLitSprayOrTNT(BloodPlayer* pPlayer) bool checkLitSprayOrTNT(DBloodPlayer* pPlayer)
{ {
switch (pPlayer->curWeapon) switch (pPlayer->curWeapon)
{ {
@ -208,7 +208,7 @@ static bool BannedUnderwater(int nWeapon)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool CheckWeaponAmmo(BloodPlayer* pPlayer, int weapon, int ammotype, int count) static bool CheckWeaponAmmo(DBloodPlayer* pPlayer, int weapon, int ammotype, int count)
{ {
if (gInfiniteAmmo) if (gInfiniteAmmo)
return 1; return 1;
@ -227,7 +227,7 @@ static bool CheckWeaponAmmo(BloodPlayer* pPlayer, int weapon, int ammotype, int
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool CheckAmmo(BloodPlayer* pPlayer, int ammotype, int count) static bool CheckAmmo(DBloodPlayer* pPlayer, int ammotype, int count)
{ {
if (gInfiniteAmmo) if (gInfiniteAmmo)
return 1; return 1;
@ -246,7 +246,7 @@ static bool CheckAmmo(BloodPlayer* pPlayer, int ammotype, int count)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool checkAmmo2(const BloodPlayer* pPlayer, int ammotype, int amount) static bool checkAmmo2(const DBloodPlayer* pPlayer, int ammotype, int amount)
{ {
if (gInfiniteAmmo) if (gInfiniteAmmo)
return 1; return 1;
@ -261,7 +261,7 @@ static bool checkAmmo2(const BloodPlayer* pPlayer, int ammotype, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SpawnBulletEject(BloodPlayer* pPlayer, double dist, int rdist) void SpawnBulletEject(DBloodPlayer* pPlayer, double dist, int rdist)
{ {
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ; pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ;
@ -269,7 +269,7 @@ void SpawnBulletEject(BloodPlayer* pPlayer, double dist, int rdist)
fxSpawnEjectingBrass(pPlayer->GetActor(), dz, dist, rdist); fxSpawnEjectingBrass(pPlayer->GetActor(), dz, dist, rdist);
} }
void SpawnShellEject(BloodPlayer* pPlayer, double dist, int rdist) void SpawnShellEject(DBloodPlayer* pPlayer, double dist, int rdist)
{ {
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ; pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ;
@ -328,7 +328,7 @@ void WeaponPrecache()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void WeaponDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle) void WeaponDraw(DBloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
if (pPlayer->weaponQav == kQAVNone) if (pPlayer->weaponQav == kQAVNone)
@ -357,7 +357,7 @@ void WeaponDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int p
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void WeaponPlay(BloodPlayer* pPlayer) void WeaponPlay(DBloodPlayer* pPlayer)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
if (pPlayer->weaponQav == kQAVNone) if (pPlayer->weaponQav == kQAVNone)
@ -373,7 +373,7 @@ void WeaponPlay(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void StartQAV(BloodPlayer* pPlayer, int nWeaponQAV, int callback = -1, bool looped = false) static void StartQAV(DBloodPlayer* pPlayer, int nWeaponQAV, int callback = -1, bool looped = false)
{ {
assert(nWeaponQAV < kQAVEnd); assert(nWeaponQAV < kQAVEnd);
auto res_id = qavGetCorrectID(nWeaponQAV); auto res_id = qavGetCorrectID(nWeaponQAV);
@ -389,7 +389,7 @@ static void StartQAV(BloodPlayer* pPlayer, int nWeaponQAV, int callback = -1, bo
pPlayer->weaponTimer -= 4; pPlayer->weaponTimer -= 4;
} }
static void SetQAV(BloodPlayer* pPlayer, int nWeaponQAV) static void SetQAV(DBloodPlayer* pPlayer, int nWeaponQAV)
{ {
assert(nWeaponQAV < kQAVEnd); assert(nWeaponQAV < kQAVEnd);
pPlayer->weaponQav = qavGetCorrectID(nWeaponQAV); pPlayer->weaponQav = qavGetCorrectID(nWeaponQAV);
@ -436,7 +436,7 @@ WEAPONTRACK gWeaponTrack[] = {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void UpdateAimVector(BloodPlayer* pPlayer) void UpdateAimVector(DBloodPlayer* pPlayer)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
@ -590,7 +590,7 @@ t_WeaponModes weaponModes[] = {
{ 0, -1 }, { 0, -1 },
}; };
void WeaponRaise(BloodPlayer* pPlayer) void WeaponRaise(DBloodPlayer* pPlayer)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
int prevWeapon = pPlayer->curWeapon; int prevWeapon = pPlayer->curWeapon;
@ -746,7 +746,7 @@ void WeaponRaise(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void WeaponLower(BloodPlayer* pPlayer) void WeaponLower(DBloodPlayer* pPlayer)
{ {
assert(pPlayer != NULL); assert(pPlayer != NULL);
if (checkLitSprayOrTNT(pPlayer)) if (checkLitSprayOrTNT(pPlayer))
@ -939,7 +939,7 @@ void WeaponLower(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void WeaponUpdateState(BloodPlayer* pPlayer) void WeaponUpdateState(DBloodPlayer* pPlayer)
{ {
static int lastWeapon = 0; static int lastWeapon = 0;
static int lastState = 0; static int lastState = 0;
@ -1162,7 +1162,7 @@ void WeaponUpdateState(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FirePitchfork(int, BloodPlayer* pPlayer) void FirePitchfork(int, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
double r1 = Random2F(2000, 14); double r1 = Random2F(2000, 14);
@ -1178,7 +1178,7 @@ void FirePitchfork(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireSpray(int, BloodPlayer* pPlayer) void FireSpray(int, DBloodPlayer* pPlayer)
{ {
playerFireMissile(pPlayer, 0, pPlayer->aim, kMissileFlameSpray); playerFireMissile(pPlayer, 0, pPlayer->aim, kMissileFlameSpray);
UseAmmo(pPlayer, 6, 4); UseAmmo(pPlayer, 6, 4);
@ -1194,7 +1194,7 @@ void FireSpray(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ThrowCan(int, BloodPlayer* pPlayer) void ThrowCan(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), -1, 441); sfxKill3DSound(pPlayer->GetActor(), -1, 441);
double nSpeed = getThrowPower(pPlayer); double nSpeed = getThrowPower(pPlayer);
@ -1217,7 +1217,7 @@ void ThrowCan(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DropCan(int, BloodPlayer* pPlayer) void DropCan(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), -1, 441); sfxKill3DSound(pPlayer->GetActor(), -1, 441);
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedSpray, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedSpray, 0);
@ -1234,7 +1234,7 @@ void DropCan(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ExplodeCan(int, BloodPlayer* pPlayer) void ExplodeCan(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), -1, 441); sfxKill3DSound(pPlayer->GetActor(), -1, 441);
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedSpray, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedSpray, 0);
@ -1254,7 +1254,7 @@ void ExplodeCan(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ThrowBundle(int, BloodPlayer* pPlayer) void ThrowBundle(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), 16, -1); sfxKill3DSound(pPlayer->GetActor(), 16, -1);
double nSpeed = getThrowPower(pPlayer); double nSpeed = getThrowPower(pPlayer);
@ -1277,7 +1277,7 @@ void ThrowBundle(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DropBundle(int, BloodPlayer* pPlayer) void DropBundle(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), 16, -1); sfxKill3DSound(pPlayer->GetActor(), 16, -1);
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedTNTBundle, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedTNTBundle, 0);
@ -1294,7 +1294,7 @@ void DropBundle(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ExplodeBundle(int, BloodPlayer* pPlayer) void ExplodeBundle(int, DBloodPlayer* pPlayer)
{ {
sfxKill3DSound(pPlayer->GetActor(), 16, -1); sfxKill3DSound(pPlayer->GetActor(), 16, -1);
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedTNTBundle, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedTNTBundle, 0);
@ -1314,7 +1314,7 @@ void ExplodeBundle(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ThrowProx(int, BloodPlayer* pPlayer) void ThrowProx(int, DBloodPlayer* pPlayer)
{ {
double nSpeed = getThrowPower(pPlayer); double nSpeed = getThrowPower(pPlayer);
sfxPlay3DSound(pPlayer->GetActor(), 455, 1, 0); sfxPlay3DSound(pPlayer->GetActor(), 455, 1, 0);
@ -1333,7 +1333,7 @@ void ThrowProx(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DropProx(int, BloodPlayer* pPlayer) void DropProx(int, DBloodPlayer* pPlayer)
{ {
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedProxBomb, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedProxBomb, 0);
if (spawned) if (spawned)
@ -1349,7 +1349,7 @@ void DropProx(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ThrowRemote(int, BloodPlayer* pPlayer) void ThrowRemote(int, DBloodPlayer* pPlayer)
{ {
double nSpeed = getThrowPower(pPlayer); double nSpeed = getThrowPower(pPlayer);
sfxPlay3DSound(pPlayer->GetActor(), 455, 1, 0); sfxPlay3DSound(pPlayer->GetActor(), 455, 1, 0);
@ -1368,7 +1368,7 @@ void ThrowRemote(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DropRemote(int, BloodPlayer* pPlayer) void DropRemote(int, DBloodPlayer* pPlayer)
{ {
auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedRemoteBomb, 0); auto spawned = playerFireThing(pPlayer, 0, 0, kThingArmedRemoteBomb, 0);
if (spawned) if (spawned)
@ -1378,7 +1378,7 @@ void DropRemote(int, BloodPlayer* pPlayer)
} }
} }
void FireRemote(int, BloodPlayer* pPlayer) void FireRemote(int, DBloodPlayer* pPlayer)
{ {
evSendGame(90 + (pPlayer->GetActor()->spr.type - kDudePlayer1), kCmdOn); evSendGame(90 + (pPlayer->GetActor()->spr.type - kDudePlayer1), kCmdOn);
} }
@ -1391,7 +1391,7 @@ void FireRemote(int, BloodPlayer* pPlayer)
enum { kMaxShotgunBarrels = 4 }; enum { kMaxShotgunBarrels = 4 };
void FireShotgun(int nTrigger, BloodPlayer* pPlayer) void FireShotgun(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
assert(nTrigger > 0 && nTrigger <= kMaxShotgunBarrels); assert(nTrigger > 0 && nTrigger <= kMaxShotgunBarrels);
@ -1438,13 +1438,13 @@ void FireShotgun(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void EjectShell(int, BloodPlayer* pPlayer) void EjectShell(int, DBloodPlayer* pPlayer)
{ {
SpawnShellEject(pPlayer, 25 / 16., 35); SpawnShellEject(pPlayer, 25 / 16., 35);
SpawnShellEject(pPlayer, 3, 35); SpawnShellEject(pPlayer, 3, 35);
} }
void FireTommy(int nTrigger, BloodPlayer* pPlayer) void FireTommy(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
sfxPlay3DSound(pPlayer->GetActor(), 431, -1, 0); sfxPlay3DSound(pPlayer->GetActor(), 431, -1, 0);
@ -1490,7 +1490,7 @@ enum { kMaxSpread = 14 };
static constexpr DAngle DAngle10 = DAngle::fromDeg(10); static constexpr DAngle DAngle10 = DAngle::fromDeg(10);
static constexpr DAngle DAngle20 = DAngle::fromDeg(20); static constexpr DAngle DAngle20 = DAngle::fromDeg(20);
void FireSpread(int nTrigger, BloodPlayer* pPlayer) void FireSpread(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
assert(nTrigger > 0 && nTrigger <= kMaxSpread); assert(nTrigger > 0 && nTrigger <= kMaxSpread);
@ -1518,7 +1518,7 @@ void FireSpread(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireSpread(int nTrigger, BloodPlayer* pPlayer) void AltFireSpread(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
assert(nTrigger > 0 && nTrigger <= kMaxSpread); assert(nTrigger > 0 && nTrigger <= kMaxSpread);
@ -1554,7 +1554,7 @@ void AltFireSpread(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireSpread2(int nTrigger, BloodPlayer* pPlayer) void AltFireSpread2(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
assert(nTrigger > 0 && nTrigger <= kMaxSpread); assert(nTrigger > 0 && nTrigger <= kMaxSpread);
@ -1612,7 +1612,7 @@ void AltFireSpread2(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireFlare(int nTrigger, BloodPlayer* pPlayer) void FireFlare(int nTrigger, DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
double offset = 0; double offset = 0;
@ -1638,7 +1638,7 @@ void FireFlare(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireFlare(int nTrigger, BloodPlayer* pPlayer) void AltFireFlare(int nTrigger, DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
double offset = 0; double offset = 0;
@ -1664,7 +1664,7 @@ void AltFireFlare(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireVoodoo(int nTrigger, BloodPlayer* pPlayer) void FireVoodoo(int nTrigger, DBloodPlayer* pPlayer)
{ {
nTrigger--; nTrigger--;
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
@ -1713,7 +1713,7 @@ void FireVoodoo(int nTrigger, BloodPlayer* pPlayer)
int nDamage = actDamageSprite(actor, targetactor, kDamageSpirit, 11 << 4); int nDamage = actDamageSprite(actor, targetactor, kDamageSpirit, 11 << 4);
if (targetactor->IsPlayerActor()) if (targetactor->IsPlayerActor())
{ {
BloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1); DBloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1);
pOtherPlayer->blindEffect = 128; pOtherPlayer->blindEffect = 128;
} }
UseAmmo(pPlayer, 9, nDamage / 4); UseAmmo(pPlayer, 9, nDamage / 4);
@ -1728,7 +1728,7 @@ void FireVoodoo(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireVoodoo(int nTrigger, BloodPlayer* pPlayer) void AltFireVoodoo(int nTrigger, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
if (nTrigger == 2) { if (nTrigger == 2) {
@ -1756,7 +1756,7 @@ void AltFireVoodoo(int nTrigger, BloodPlayer* pPlayer)
if (targetactor->IsPlayerActor()) if (targetactor->IsPlayerActor())
{ {
BloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1); DBloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1);
if (!pOtherPlayer->godMode || !powerupCheck(pOtherPlayer, kPwUpDeathMask)) if (!pOtherPlayer->godMode || !powerupCheck(pOtherPlayer, kPwUpDeathMask))
powerupActivate(pOtherPlayer, kPwUpDeliriumShroom); powerupActivate(pOtherPlayer, kPwUpDeliriumShroom);
} }
@ -1794,7 +1794,7 @@ void AltFireVoodoo(int nTrigger, BloodPlayer* pPlayer)
UseAmmo(pPlayer, 9, nDamage); UseAmmo(pPlayer, 9, nDamage);
if (targetactor->IsPlayerActor()) if (targetactor->IsPlayerActor())
{ {
BloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1); DBloodPlayer* pOtherPlayer = getPlayer(targetactor->spr.type - kDudePlayer1);
if (!pOtherPlayer->godMode || !powerupCheck(pOtherPlayer, kPwUpDeathMask)) if (!pOtherPlayer->godMode || !powerupCheck(pOtherPlayer, kPwUpDeathMask))
powerupActivate(pOtherPlayer, kPwUpDeliriumShroom); powerupActivate(pOtherPlayer, kPwUpDeliriumShroom);
} }
@ -1814,7 +1814,7 @@ void AltFireVoodoo(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DropVoodoo(int, BloodPlayer* pPlayer) void DropVoodoo(int, DBloodPlayer* pPlayer)
{ {
sfxPlay3DSound(pPlayer->GetActor(), 455, 2, 0); sfxPlay3DSound(pPlayer->GetActor(), 455, 2, 0);
auto spawned = playerFireThing(pPlayer, 0, -4730 / 65536., kThingVoodooHead, 12.8); auto spawned = playerFireThing(pPlayer, 0, -4730 / 65536., kThingVoodooHead, 12.8);
@ -1850,7 +1850,7 @@ struct TeslaMissile
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireTesla(int nTrigger, BloodPlayer* pPlayer) void FireTesla(int nTrigger, DBloodPlayer* pPlayer)
{ {
TeslaMissile teslaMissile[6] = TeslaMissile teslaMissile[6] =
{ {
@ -1891,7 +1891,7 @@ void FireTesla(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireTesla(int, BloodPlayer* pPlayer) void AltFireTesla(int, DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
playerFireMissile(pPlayer, 0., pPlayer->aim, kMissileTeslaAlt); playerFireMissile(pPlayer, 0., pPlayer->aim, kMissileTeslaAlt);
@ -1907,7 +1907,7 @@ void AltFireTesla(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireNapalm(int nTrigger, BloodPlayer* pPlayer) void FireNapalm(int nTrigger, DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
double offset = 0; double offset = 0;
@ -1926,7 +1926,7 @@ void FireNapalm(int nTrigger, BloodPlayer* pPlayer)
pPlayer->flashEffect = 1; pPlayer->flashEffect = 1;
} }
void FireNapalm2(int, BloodPlayer* pPlayer) void FireNapalm2(int, DBloodPlayer* pPlayer)
{ {
auto plActor = pPlayer->GetActor(); auto plActor = pPlayer->GetActor();
playerFireMissile(pPlayer, -7.5, pPlayer->aim, kMissileFireballNapalm); playerFireMissile(pPlayer, -7.5, pPlayer->aim, kMissileFireballNapalm);
@ -1942,7 +1942,7 @@ void FireNapalm2(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireNapalm(int, BloodPlayer* pPlayer) void AltFireNapalm(int, DBloodPlayer* pPlayer)
{ {
auto missile = playerFireThing(pPlayer, 0, -4730 / 65536., kThingNapalmBall, 18.13333); auto missile = playerFireThing(pPlayer, 0, -4730 / 65536., kThingNapalmBall, 18.13333);
if (missile) if (missile)
@ -1964,7 +1964,7 @@ void AltFireNapalm(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireLifeLeech(int nTrigger, BloodPlayer* pPlayer) void FireLifeLeech(int nTrigger, DBloodPlayer* pPlayer)
{ {
if (!CheckAmmo(pPlayer, 8, 1)) if (!CheckAmmo(pPlayer, 8, 1))
return; return;
@ -1991,7 +1991,7 @@ void FireLifeLeech(int nTrigger, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AltFireLifeLeech(int, BloodPlayer* pPlayer) void AltFireLifeLeech(int, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
sfxPlay3DSound(pPlayer->GetActor(), 455, 2, 0); sfxPlay3DSound(pPlayer->GetActor(), 455, 2, 0);
@ -2030,7 +2030,7 @@ void AltFireLifeLeech(int, BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FireBeast(int, BloodPlayer* pPlayer) void FireBeast(int, DBloodPlayer* pPlayer)
{ {
DBloodActor* actor = pPlayer->GetActor(); DBloodActor* actor = pPlayer->GetActor();
double r1 = Random2F(2000, 14); double r1 = Random2F(2000, 14);
@ -2061,9 +2061,9 @@ static const uint8_t gWeaponUpgrade[][13] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
}; };
int WeaponUpgrade(BloodPlayer* pPlayer, int newWeapon) int WeaponUpgrade(DBloodPlayer* pPlayer, int newWeapon)
{ {
int weaponswitch = WeaponSwitch(pPlayer - (BloodPlayer*)PlayerArray); int weaponswitch = WeaponSwitch(pPlayer->pnum);
int weapon = pPlayer->curWeapon; int weapon = pPlayer->curWeapon;
if (!checkLitSprayOrTNT(pPlayer) && (weaponswitch & 1) && (gWeaponUpgrade[pPlayer->curWeapon][newWeapon] || (weaponswitch & 2))) if (!checkLitSprayOrTNT(pPlayer) && (weaponswitch & 1) && (gWeaponUpgrade[pPlayer->curWeapon][newWeapon] || (weaponswitch & 2)))
weapon = newWeapon; weapon = newWeapon;
@ -2079,7 +2079,7 @@ int WeaponUpgrade(BloodPlayer* pPlayer, int newWeapon)
static const int OrderNext[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 1 }; static const int OrderNext[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 1 };
static const int OrderPrev[] = { 12, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1 }; static const int OrderPrev[] = { 12, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1 };
static int WeaponFindNext(BloodPlayer* pPlayer, int* a2, int bDir) static int WeaponFindNext(DBloodPlayer* pPlayer, int* a2, int bDir)
{ {
int weapon = pPlayer->curWeapon; int weapon = pPlayer->curWeapon;
do do
@ -2118,7 +2118,7 @@ static int WeaponFindNext(BloodPlayer* pPlayer, int* a2, int bDir)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static int WeaponFindLoaded(BloodPlayer* pPlayer, int* a2) static int WeaponFindLoaded(DBloodPlayer* pPlayer, int* a2)
{ {
int v4 = 1; int v4 = 1;
int v14 = 0; int v14 = 0;
@ -2165,7 +2165,7 @@ static int WeaponFindLoaded(BloodPlayer* pPlayer, int* a2)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int processSprayCan(BloodPlayer* pPlayer) int processSprayCan(DBloodPlayer* pPlayer)
{ {
const char bUseShootAsThrow = !VanillaMode() && (pPlayer->cmd.ucmd.actions & SB_FIRE); const char bUseShootAsThrow = !VanillaMode() && (pPlayer->cmd.ucmd.actions & SB_FIRE);
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
@ -2210,7 +2210,7 @@ int processSprayCan(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool processTNT(BloodPlayer* pPlayer) static bool processTNT(DBloodPlayer* pPlayer)
{ {
const char bUseShootAsThrow = !VanillaMode() && (pPlayer->cmd.ucmd.actions & SB_FIRE); const char bUseShootAsThrow = !VanillaMode() && (pPlayer->cmd.ucmd.actions & SB_FIRE);
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
@ -2255,7 +2255,7 @@ static bool processTNT(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool processProxy(BloodPlayer* pPlayer) static bool processProxy(DBloodPlayer* pPlayer)
{ {
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
{ {
@ -2279,7 +2279,7 @@ static bool processProxy(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool processRemote(BloodPlayer* pPlayer) static bool processRemote(DBloodPlayer* pPlayer)
{ {
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
{ {
@ -2301,7 +2301,7 @@ static bool processRemote(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool processLeech(BloodPlayer* pPlayer) static bool processLeech(DBloodPlayer* pPlayer)
{ {
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
{ {
@ -2331,7 +2331,7 @@ static bool processLeech(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool processTesla(BloodPlayer* pPlayer) static bool processTesla(DBloodPlayer* pPlayer)
{ {
switch (pPlayer->weaponState) switch (pPlayer->weaponState)
{ {
@ -2370,7 +2370,7 @@ static bool processTesla(BloodPlayer* pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void WeaponProcess(BloodPlayer* pPlayer) { void WeaponProcess(DBloodPlayer* pPlayer) {
pPlayer->flashEffect = ClipLow(pPlayer->flashEffect - 1, 0); pPlayer->flashEffect = ClipLow(pPlayer->flashEffect - 1, 0);

10
source/games/duke/src/actors.cpp
View file

@ -212,7 +212,7 @@ void RANDOMSCRAP(DDukeActor* origin)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void addammo(int weapon, DukePlayer* player, int amount) void addammo(int weapon, DDukePlayer* player, int amount)
{ {
player->ammo_amount[weapon] += amount; player->ammo_amount[weapon] += amount;
@ -226,7 +226,7 @@ void addammo(int weapon, DukePlayer* player, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkavailinven(DukePlayer* player) void checkavailinven(DDukePlayer* player)
{ {
if (player->firstaid_amount > 0) if (player->firstaid_amount > 0)
@ -252,7 +252,7 @@ void checkavailinven(DukePlayer* player)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkavailweapon(DukePlayer* player) void checkavailweapon(DDukePlayer* player)
{ {
int i, snum; int i, snum;
int weap; int weap;
@ -273,7 +273,7 @@ void checkavailweapon(DukePlayer* player)
weap = player->curr_weapon; weap = player->curr_weapon;
if (player->gotweapon[weap]) if (player->gotweapon[weap])
{ {
if (player->ammo_amount[weap] > 0 || (WeaponSwitch(player - (DukePlayer*)PlayerArray) & 2) == 0) if (player->ammo_amount[weap] > 0 || (WeaponSwitch(player->pnum) & 2) == 0)
return; return;
} }
@ -330,7 +330,7 @@ void checkavailweapon(DukePlayer* player)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void clearcamera(DukePlayer* ps) void clearcamera(DDukePlayer* ps)
{ {
const auto pact = ps->GetActor(); const auto pact = ps->GetActor();
ps->newOwner = nullptr; ps->newOwner = nullptr;

2
source/games/duke/src/actors_d.cpp
View file

@ -49,7 +49,7 @@ BEGIN_DUKE_NS
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void addweapon_d(DukePlayer *p, int weapon, bool wswitch) void addweapon_d(DDukePlayer *p, int weapon, bool wswitch)
{ {
if (p->gotweapon[weapon] == 0 ) if (p->gotweapon[weapon] == 0 )
{ {

2
source/games/duke/src/actors_lava.cpp
View file

@ -453,7 +453,7 @@ void moveminecart(void)
void thunder(void) void thunder(void)
{ {
DukePlayer* p; DDukePlayer* p;
int r1, r2; int r1, r2;
int i = 0; int i = 0;
uint8_t shade; uint8_t shade;

4
source/games/duke/src/actors_r.cpp
View file

@ -42,7 +42,7 @@ void moveminecart();
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void addweapon_r(DukePlayer* p, int weapon, bool wswitch) void addweapon_r(DDukePlayer* p, int weapon, bool wswitch)
{ {
int cw = p->curr_weapon; int cw = p->curr_weapon;
if (p->OnMotorcycle || p->OnBoat) if (p->OnMotorcycle || p->OnBoat)
@ -819,7 +819,7 @@ void moveeffectors_r(void) //STATNUM 3
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void fakebubbaspawn(DDukeActor *actor, DukePlayer* p) void fakebubbaspawn(DDukeActor *actor, DDukePlayer* p)
{ {
fakebubba_spawn++; fakebubba_spawn++;
switch (fakebubba_spawn) switch (fakebubba_spawn)

16
source/games/duke/src/dispatch.cpp
View file

@ -39,18 +39,18 @@ void activatebysector_r(sectortype* sect, DDukeActor* j);
void checksectors_d(int snum); void checksectors_d(int snum);
void checksectors_r(int snum); void checksectors_r(int snum);
void addweapon_d(DukePlayer* p, int weapon, bool wswitch); void addweapon_d(DDukePlayer* p, int weapon, bool wswitch);
void addweapon_r(DukePlayer* p, int weapon, bool wswitch); void addweapon_r(DDukePlayer* p, int weapon, bool wswitch);
int ifhitbyweapon_r(DDukeActor* sn); int ifhitbyweapon_r(DDukeActor* sn);
int ifhitbyweapon_d(DDukeActor* sn); int ifhitbyweapon_d(DDukeActor* sn);
void incur_damage_d(DukePlayer* p); void incur_damage_d(DDukePlayer* p);
void incur_damage_r(DukePlayer* p); void incur_damage_r(DDukePlayer* p);
void selectweapon_d(int snum, int j); void selectweapon_d(int snum, int j);
void selectweapon_r(int snum, int j); void selectweapon_r(int snum, int j);
int doincrements_d(DukePlayer* p); int doincrements_d(DDukePlayer* p);
int doincrements_r(DukePlayer* p); int doincrements_r(DDukePlayer* p);
void checkweapons_d(DukePlayer* p); void checkweapons_d(DDukePlayer* p);
void checkweapons_r(DukePlayer* p); void checkweapons_r(DDukePlayer* p);
void processinput_d(int snum); void processinput_d(int snum);
void processinput_r(int snum); void processinput_r(int snum);
void displayweapon_d(int snum, double interpfrac); void displayweapon_d(int snum, double interpfrac);

20
source/games/duke/src/duke3d.h
View file

@ -74,14 +74,14 @@ struct Dispatcher
void (*activatebysector)(sectortype* sect, DDukeActor* j); void (*activatebysector)(sectortype* sect, DDukeActor* j);
void (*checksectors)(int low); void (*checksectors)(int low);
void (*addweapon)(DukePlayer *p, int weapon, bool wswitch); void (*addweapon)(DDukePlayer *p, int weapon, bool wswitch);
int (*ifhitbyweapon)(DDukeActor* sectnum); int (*ifhitbyweapon)(DDukeActor* sectnum);
// player // player
void (*incur_damage)(DukePlayer* p); void (*incur_damage)(DDukePlayer* p);
void (*selectweapon)(int snum, int j); void (*selectweapon)(int snum, int j);
int (*doincrements)(DukePlayer* p); int (*doincrements)(DDukePlayer* p);
void (*checkweapons)(DukePlayer* p); void (*checkweapons)(DDukePlayer* p);
void (*processinput)(int snum); void (*processinput)(int snum);
void (*displayweapon)(int snum, double interpfrac); void (*displayweapon)(int snum, double interpfrac);
void (*displaymasks)(int snum, int p, double interpfrac); void (*displaymasks)(int snum, int p, double interpfrac);
@ -98,18 +98,18 @@ void CallTick(DDukeActor* actor);
bool CallOperate(DDukeActor* actor, int plnum); bool CallOperate(DDukeActor* actor, int plnum);
void CallAction(DDukeActor* actor); void CallAction(DDukeActor* actor);
void checkhitsprite(DDukeActor* actor, DDukeActor* hitter); void checkhitsprite(DDukeActor* actor, DDukeActor* hitter);
void CallOnHurt(DDukeActor* actor, DukePlayer* hitter); void CallOnHurt(DDukeActor* actor, DDukePlayer* hitter);
void CallOnTouch(DDukeActor* actor, DukePlayer* hitter); void CallOnTouch(DDukeActor* actor, DDukePlayer* hitter);
bool CallOnUse(DDukeActor* actor, DukePlayer* user); bool CallOnUse(DDukeActor* actor, DDukePlayer* user);
void CallOnMotoSmash(DDukeActor* actor, DukePlayer* hitter); void CallOnMotoSmash(DDukeActor* actor, DDukePlayer* hitter);
void CallOnRespawn(DDukeActor* actor, int low); void CallOnRespawn(DDukeActor* actor, int low);
bool CallAnimate(DDukeActor* actor, tspritetype* hitter); bool CallAnimate(DDukeActor* actor, tspritetype* hitter);
bool CallShootThis(DDukeActor* clsdef, DDukeActor* actor, int pn, const DVector3& spos, DAngle sang); bool CallShootThis(DDukeActor* clsdef, DDukeActor* actor, int pn, const DVector3& spos, DAngle sang);
void CallStaticSetup(DDukeActor* actor); void CallStaticSetup(DDukeActor* actor);
void CallPlayFTASound(DDukeActor* actor, int mode = 0); void CallPlayFTASound(DDukeActor* actor, int mode = 0);
void CallStandingOn(DDukeActor* actor, DukePlayer* p); void CallStandingOn(DDukeActor* actor, DDukePlayer* p);
void CallRunState(DDukeActor* actor); void CallRunState(DDukeActor* actor);
int CallTriggerSwitch(DDukeActor* actor, DukePlayer* p); int CallTriggerSwitch(DDukeActor* actor, DDukePlayer* p);
PClassActor* CallGetRadiusDamageType(DDukeActor* actor, int targhealth); PClassActor* CallGetRadiusDamageType(DDukeActor* actor, int targhealth);

4
source/games/duke/src/dukeactor.h
View file

@ -9,12 +9,12 @@ using DukeStatIterator = TStatIterator<DDukeActor>;
using DukeSectIterator = TSectIterator<DDukeActor>; using DukeSectIterator = TSectIterator<DDukeActor>;
using DukeSpriteIterator = TSpriteIterator<DDukeActor>; using DukeSpriteIterator = TSpriteIterator<DDukeActor>;
inline DDukeActor* DukePlayer::GetActor() inline DDukeActor* DDukePlayer::GetActor()
{ {
return static_cast<DDukeActor*>(actor); return static_cast<DDukeActor*>(actor);
} }
inline int DukePlayer::GetPlayerNum() inline int DDukePlayer::GetPlayerNum()
{ {
return GetActor()->PlayerIndex(); return GetActor()->PlayerIndex();
} }

70
source/games/duke/src/funct.h
View file

@ -39,7 +39,7 @@ void operaterespawns(int low);
void moveclouds(double interpfrac); void moveclouds(double interpfrac);
void movefta(); void movefta();
void clearcameras(DukePlayer* p); void clearcameras(DDukePlayer* p);
void RANDOMSCRAP(DDukeActor* i); void RANDOMSCRAP(DDukeActor* i);
void detonate(DDukeActor* i, PClassActor* explosion); void detonate(DDukeActor* i, PClassActor* explosion);
void hitradius(DDukeActor* i, int r, int hp1, int hp2, int hp3, int hp4); void hitradius(DDukeActor* i, int r, int hp1, int hp2, int hp3, int hp4);
@ -88,8 +88,8 @@ void handle_se130(DDukeActor* i, int countmax);
int dodge(DDukeActor*); int dodge(DDukeActor*);
void alterang(int ang, DDukeActor* actor, int g_p); void alterang(int ang, DDukeActor* actor, int g_p);
void checkavailweapon(DukePlayer* p); void checkavailweapon(DDukePlayer* p);
void addammo(int weapon, DukePlayer* p, int amount); void addammo(int weapon, DDukePlayer* p, int amount);
int ssp(DDukeActor* i, unsigned int cliptype); //The set sprite function int ssp(DDukeActor* i, unsigned int cliptype); //The set sprite function
void insertspriteq(DDukeActor *i); void insertspriteq(DDukeActor *i);
@ -114,35 +114,35 @@ void playerAimDown(int snum, ESyncBits actions);
DDukeActor* aim(DDukeActor* s, int aang, bool force = true, bool* b = nullptr); DDukeActor* aim(DDukeActor* s, int aang, bool force = true, bool* b = nullptr);
DDukeActor* aim_(DDukeActor* actor, DDukeActor* weapon, double aimangle, bool* b = nullptr); DDukeActor* aim_(DDukeActor* actor, DDukeActor* weapon, double aimangle, bool* b = nullptr);
void shoot(DDukeActor* actor, PClass* cls); void shoot(DDukeActor* actor, PClass* cls);
void checkweapons(DukePlayer* const p); void checkweapons(DDukePlayer* const p);
int findotherplayer(int p, double* d); int findotherplayer(int p, double* d);
void quickkill(DukePlayer* p); void quickkill(DDukePlayer* p);
int setpal(DukePlayer* p); int setpal(DDukePlayer* p);
int madenoise(int playerNum); int madenoise(int playerNum);
int haslock(sectortype* sect, int snum); int haslock(sectortype* sect, int snum);
void purplelavacheck(DukePlayer* p); void purplelavacheck(DDukePlayer* p);
void addphealth(DukePlayer* p, int amount, bool bigitem); void addphealth(DDukePlayer* p, int amount, bool bigitem);
int playereat(DukePlayer* p, int amount, bool bigitem); int playereat(DDukePlayer* p, int amount, bool bigitem);
void playerdrink(DukePlayer* p, int amount); void playerdrink(DDukePlayer* p, int amount);
int playeraddammo(DukePlayer* p, int weaponindex, int amount); int playeraddammo(DDukePlayer* p, int weaponindex, int amount);
int playeraddweapon(DukePlayer* p, int weaponindex, int amount); int playeraddweapon(DDukePlayer* p, int weaponindex, int amount);
void playeraddinventory(DukePlayer* p, DDukeActor* item, int type, int amount); void playeraddinventory(DDukePlayer* p, DDukeActor* item, int type, int amount);
void actorsizeto(DDukeActor* actor, double x, double y); void actorsizeto(DDukeActor* actor, double x, double y);
void spawndebris(DDukeActor* g_ac, int dnum, int count); void spawndebris(DDukeActor* g_ac, int dnum, int count);
int checkp(DDukeActor* self, DukePlayer* p, int flags); int checkp(DDukeActor* self, DDukePlayer* p, int flags);
int playercheckinventory(DukePlayer* p, DDukeActor* item, int type, int amount); int playercheckinventory(DDukePlayer* p, DDukeActor* item, int type, int amount);
void playerstomp(DukePlayer* p, DDukeActor* stomped); void playerstomp(DDukePlayer* p, DDukeActor* stomped);
void playerreset(DukePlayer* p, DDukeActor* g_ac); void playerreset(DDukePlayer* p, DDukeActor* g_ac);
void wackplayer(DukePlayer* p); void wackplayer(DDukePlayer* p);
void actoroperate(DDukeActor* g_ac); void actoroperate(DDukeActor* g_ac);
void playerkick(DukePlayer* p, DDukeActor* g_ac); void playerkick(DDukePlayer* p, DDukeActor* g_ac);
void garybanjo(DDukeActor* g_ac); void garybanjo(DDukeActor* g_ac);
int ifsquished(DDukeActor* i, int p); int ifsquished(DDukeActor* i, int p);
void fakebubbaspawn(DDukeActor* actor, DukePlayer* p); void fakebubbaspawn(DDukeActor* actor, DDukePlayer* p);
void tearitup(sectortype* sect); void tearitup(sectortype* sect);
void destroyit(DDukeActor* actor); void destroyit(DDukeActor* actor);
void mamaspawn(DDukeActor* actor); void mamaspawn(DDukeActor* actor);
void forceplayerangle(DukePlayer* snum); void forceplayerangle(DDukePlayer* snum);
bool checkhitceiling(sectortype* sectp); bool checkhitceiling(sectortype* sectp);
@ -156,7 +156,7 @@ void allignwarpelevators(void);
bool isablockdoor(int tileNum); bool isablockdoor(int tileNum);
bool activatewarpelevators(DDukeActor* s, int w); bool activatewarpelevators(DDukeActor* s, int w);
int check_activator_motion(int lotag); int check_activator_motion(int lotag);
void operateactivators(int l, DukePlayer* w); void operateactivators(int l, DDukePlayer* w);
void operateforcefields(DDukeActor* s, int low); void operateforcefields(DDukeActor* s, int low);
void operatemasterswitches(int lotag); void operatemasterswitches(int lotag);
void operatesectors(sectortype* s, DDukeActor* i); void operatesectors(sectortype* s, DDukeActor* i);
@ -168,11 +168,11 @@ int setanimation(sectortype* animsect, int animtype, walltype* animtarget, doubl
int setanimation(sectortype* animsect, int animtype, sectortype* animtarget, double thegoal, double thevel); int setanimation(sectortype* animsect, int animtype, sectortype* animtarget, double thegoal, double thevel);
void dofurniture(walltype* wallNum, sectortype* sectnum, int playerNum); void dofurniture(walltype* wallNum, sectortype* sectnum, int playerNum);
void dotorch(); void dotorch();
double hitawall(DukePlayer* pl, walltype** hitWall); double hitawall(DDukePlayer* pl, walltype** hitWall);
double hits(DDukeActor* snum); double hits(DDukeActor* snum);
DDukeActor* LocateTheLocator(int n, sectortype* sectnum); DDukeActor* LocateTheLocator(int n, sectortype* sectnum);
void clearcamera(DukePlayer* ps); void clearcamera(DDukePlayer* ps);
void LoadActor(DDukeActor* i, int p, int x); void LoadActor(DDukeActor* i, int p, int x);
bool execute(DDukeActor* s, int p, double d, int* killit_flag = nullptr); bool execute(DDukeActor* s, int p, double d, int* killit_flag = nullptr);
@ -189,14 +189,14 @@ void ceilingglass(DDukeActor* snum, sectortype* sectnum, int cnt);
void spriteglass(DDukeActor* snum, int cnt); void spriteglass(DDukeActor* snum, int cnt);
void lotsofcolourglass(DDukeActor* snum, walltype* wallNum, int cnt); void lotsofcolourglass(DDukeActor* snum, walltype* wallNum, int cnt);
void lotsofglass(DDukeActor* snum, walltype* wal, int cnt); void lotsofglass(DDukeActor* snum, walltype* wal, int cnt);
void checkplayerhurt_d(DukePlayer* p, const Collision& coll); void checkplayerhurt_d(DDukePlayer* p, const Collision& coll);
void checkplayerhurt_r(DukePlayer* p, const Collision& coll); void checkplayerhurt_r(DDukePlayer* p, const Collision& coll);
DDukeActor* dospawnsprite(DDukeActor* actj, int pn); DDukeActor* dospawnsprite(DDukeActor* actj, int pn);
void spriteinit(DDukeActor*, TArray<DDukeActor*>& actors); void spriteinit(DDukeActor*, TArray<DDukeActor*>& actors);
DDukeActor* spawninit(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors); DDukeActor* spawninit(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors);
void checkavailinven(DukePlayer* p); void checkavailinven(DDukePlayer* p);
bool initspriteforspawn(DDukeActor* spn); bool initspriteforspawn(DDukeActor* spn);
void initshell(DDukeActor* actj, DDukeActor* acti, bool isshell); void initshell(DDukeActor* actj, DDukeActor* acti, bool isshell);
void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors); void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors);
@ -204,18 +204,18 @@ int startrts(int lumpNum, int localPlayer);
void pickrandomspot(int pn); void pickrandomspot(int pn);
void premapcontroller(DDukeActor* ac); void premapcontroller(DDukeActor* ac);
void resetinventory(DukePlayer* pn); void resetinventory(DDukePlayer* pn);
void resetplayerstats(int pn); void resetplayerstats(int pn);
void resetweapons(DukePlayer* pn); void resetweapons(DDukePlayer* pn);
void resetprestat(int snum, int g); void resetprestat(int snum, int g);
void prelevel_common(int g); void prelevel_common(int g);
void cacheit(); void cacheit();
void FTA(int q, DukePlayer* p); void FTA(int q, DDukePlayer* p);
void OnMotorcycle(DukePlayer *pl); void OnMotorcycle(DDukePlayer *pl);
void OffMotorcycle(DukePlayer *pl); void OffMotorcycle(DDukePlayer *pl);
void OnBoat(DukePlayer *pl); void OnBoat(DDukePlayer *pl);
void OffBoat(DukePlayer *pl); void OffBoat(DDukePlayer *pl);
void cameratext(DDukeActor* i); void cameratext(DDukeActor* i);
void dobonus(int bonusonly, const CompletionFunc& completion); void dobonus(int bonusonly, const CompletionFunc& completion);
@ -236,7 +236,7 @@ void enterlevel(MapRecord* mi, int gm);
void donewgame(MapRecord* map, int sk); void donewgame(MapRecord* map, int sk);
int playercolor2lookup(int color); int playercolor2lookup(int color);
void PlayerColorChanged(void); void PlayerColorChanged(void);
bool movementBlocked(DukePlayer *p); bool movementBlocked(DDukePlayer *p);
void underwater(int snum, ESyncBits actions, double floorz, double ceilingz); void underwater(int snum, ESyncBits actions, double floorz, double ceilingz);
void loadcons(); void loadcons();
void DrawStatusBar(); void DrawStatusBar();

57
source/games/duke/src/game.cpp
View file

@ -68,6 +68,27 @@ IMPLEMENT_POINTER(temp_actor)
IMPLEMENT_POINTER(seek_actor) IMPLEMENT_POINTER(seek_actor)
IMPLEMENT_POINTERS_END IMPLEMENT_POINTERS_END
IMPLEMENT_CLASS(DDukePlayer, false, true)
IMPLEMENT_POINTERS_START(DDukePlayer)
IMPLEMENT_POINTER(actorsqu)
IMPLEMENT_POINTER(wackedbyactor)
IMPLEMENT_POINTER(on_crane)
IMPLEMENT_POINTER(holoduke_on)
IMPLEMENT_POINTER(somethingonplayer)
IMPLEMENT_POINTER(access_spritenum)
IMPLEMENT_POINTER(dummyplayersprite)
IMPLEMENT_POINTER(newOwner)
IMPLEMENT_POINTERS_END
size_t DDukePlayer::PropagateMark()
{
for (auto& var : uservars)
{
var.Mark();
}
return Super::PropagateMark();
}
size_t DDukeActor::PropagateMark() size_t DDukeActor::PropagateMark()
{ {
for (auto& var : uservars) for (auto& var : uservars)
@ -83,26 +104,6 @@ static void markgcroots()
GC::MarkArray(spriteq, 1024); GC::MarkArray(spriteq, 1024);
GC::Mark(currentCommentarySprite); GC::Mark(currentCommentarySprite);
GC::Mark(ud.cameraactor); GC::Mark(ud.cameraactor);
for (int i = 0; i < MAXPLAYERS; i++)
{
auto plr = getPlayer(i);
if (plr)
{
GC::Mark(plr->actor);
GC::Mark(plr->actorsqu);
GC::Mark(plr->wackedbyactor);
GC::Mark(plr->on_crane);
GC::Mark(plr->holoduke_on);
GC::Mark(plr->somethingonplayer);
GC::Mark(plr->access_spritenum);
GC::Mark(plr->dummyplayersprite);
GC::Mark(plr->newOwner);
for (auto& var : plr->uservars)
{
var.Mark();
}
}
}
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -393,8 +394,8 @@ void GameInterface::app_init()
// Initialise player array. // Initialise player array.
for (unsigned i = 0; i < MAXPLAYERS; i++) for (unsigned i = 0; i < MAXPLAYERS; i++)
{ {
PlayerArray[i] = new DukePlayer; PlayerArray[i] = Create<DDukePlayer>(i);
*getPlayer(i) = {}; GC::WriteBarrier(PlayerArray[i]);
} }
RegisterClasses(); RegisterClasses();
@ -645,7 +646,7 @@ void checkhitsprite(DDukeActor* actor, DDukeActor* hitter)
} }
} }
void CallOnHurt(DDukeActor* actor, DukePlayer* hitter) void CallOnHurt(DDukeActor* actor, DDukePlayer* hitter)
{ {
IFVIRTUALPTR(actor, DDukeActor, onHurt) IFVIRTUALPTR(actor, DDukeActor, onHurt)
{ {
@ -654,7 +655,7 @@ void CallOnHurt(DDukeActor* actor, DukePlayer* hitter)
} }
} }
void CallOnTouch(DDukeActor* actor, DukePlayer* hitter) void CallOnTouch(DDukeActor* actor, DDukePlayer* hitter)
{ {
IFVIRTUALPTR(actor, DDukeActor, onTouch) IFVIRTUALPTR(actor, DDukeActor, onTouch)
{ {
@ -664,7 +665,7 @@ void CallOnTouch(DDukeActor* actor, DukePlayer* hitter)
} }
bool CallOnUse(DDukeActor* actor, DukePlayer* user) bool CallOnUse(DDukeActor* actor, DDukePlayer* user)
{ {
int nval = false; int nval = false;
IFVIRTUALPTR(actor, DDukeActor, onUse) IFVIRTUALPTR(actor, DDukeActor, onUse)
@ -676,7 +677,7 @@ bool CallOnUse(DDukeActor* actor, DukePlayer* user)
return nval; return nval;
} }
void CallOnMotoSmash(DDukeActor* actor, DukePlayer* hitter) void CallOnMotoSmash(DDukeActor* actor, DDukePlayer* hitter)
{ {
IFVIRTUALPTR(actor, DDukeActor, onMotoSmash) IFVIRTUALPTR(actor, DDukeActor, onMotoSmash)
{ {
@ -737,7 +738,7 @@ void CallPlayFTASound(DDukeActor* actor, int mode)
} }
} }
void CallStandingOn(DDukeActor* actor, DukePlayer* p) void CallStandingOn(DDukeActor* actor, DDukePlayer* p)
{ {
IFVIRTUALPTR(actor, DDukeActor, StandingOn) IFVIRTUALPTR(actor, DDukeActor, StandingOn)
{ {
@ -746,7 +747,7 @@ void CallStandingOn(DDukeActor* actor, DukePlayer* p)
} }
} }
int CallTriggerSwitch(DDukeActor* actor, DukePlayer* p) int CallTriggerSwitch(DDukeActor* actor, DDukePlayer* p)
{ {
int nval = false; int nval = false;
IFVIRTUALPTR(actor, DDukeActor, TriggerSwitch) IFVIRTUALPTR(actor, DDukeActor, TriggerSwitch)

4
source/games/duke/src/game_misc.cpp
View file

@ -96,7 +96,7 @@ void GameInterface::ExitFromMenu()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void FTA(int q, DukePlayer* p) void FTA(int q, DDukePlayer* p)
{ {
if (q < 0 || gamestate != GS_LEVEL) if (q < 0 || gamestate != GS_LEVEL)
return; return;
@ -211,7 +211,7 @@ void V_AddBlend (float r, float g, float b, float a, float v_blend[4])
void drawoverlays(double interpfrac) void drawoverlays(double interpfrac)
{ {
DukePlayer* pp; DDukePlayer* pp;
DVector2 cposxy; DVector2 cposxy;
DAngle cang; DAngle cang;

4
source/games/duke/src/gameexec.cpp
View file

@ -1298,7 +1298,7 @@ void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int CheckWeapRec(DukePlayer* p, DDukeActor* g_ac, int testonly) int CheckWeapRec(DDukePlayer* p, DDukeActor* g_ac, int testonly)
{ {
int j; int j;
for (j = 0; j < p->weapreccnt; j++) for (j = 0; j < p->weapreccnt; j++)
@ -1416,7 +1416,7 @@ static int ifcanshoottarget(DDukeActor *actor, int g_p, int g_x)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int ifcansee(DDukeActor* actor, DukePlayer* p) int ifcansee(DDukeActor* actor, DDukePlayer* p)
{ {
int j; int j;
DDukeActor* tosee; DDukeActor* tosee;

16
source/games/duke/src/hudweapon_d.cpp
View file

@ -61,7 +61,7 @@ inline static void hud_drawpal(double x, double y, const char* tilenum, int shad
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void displayloogie(DukePlayer* p, double const interpfrac) static void displayloogie(DDukePlayer* p, double const interpfrac)
{ {
if (p->loogcnt == 0) return; if (p->loogcnt == 0) return;
@ -84,7 +84,7 @@ static void displayloogie(DukePlayer* p, double const interpfrac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool animatefist(int gs, DukePlayer* p, double xoffset, double yoffset, int fistpal, double const interpfrac) static bool animatefist(int gs, DDukePlayer* p, double xoffset, double yoffset, int fistpal, double const interpfrac)
{ {
const double fisti = min(interpolatedvalue<double>(p->ofist_incs, p->fist_incs, interpfrac), 32.); const double fisti = min(interpolatedvalue<double>(p->ofist_incs, p->fist_incs, interpfrac), 32.);
if (fisti <= 0) return false; if (fisti <= 0) return false;
@ -103,7 +103,7 @@ static bool animatefist(int gs, DukePlayer* p, double xoffset, double yoffset, i
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool animateknee(int gs, DukePlayer* p, double xoffset, double yoffset, int pal, double const interpfrac, DAngle angle) static bool animateknee(int gs, DDukePlayer* p, double xoffset, double yoffset, int pal, double const interpfrac, DAngle angle)
{ {
if (p->knee_incs > 11 || p->knee_incs == 0 || p->GetActor()->spr.extra <= 0) return false; if (p->knee_incs > 11 || p->knee_incs == 0 || p->GetActor()->spr.extra <= 0) return false;
@ -121,7 +121,7 @@ static bool animateknee(int gs, DukePlayer* p, double xoffset, double yoffset, i
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool animateknuckles(int gs, DukePlayer* p, double xoffset, double yoffset, int pal, DAngle angle) static bool animateknuckles(int gs, DDukePlayer* p, double xoffset, double yoffset, int pal, DAngle angle)
{ {
if (isWW2GI() || p->over_shoulder_on != 0 || p->knuckle_incs == 0 || p->GetActor()->spr.extra <= 0) return false; if (isWW2GI() || p->over_shoulder_on != 0 || p->knuckle_incs == 0 || p->GetActor()->spr.extra <= 0) return false;
static const char* const frames[] = { "CRACKKNUCKLES0", "CRACKKNUCKLES1", "CRACKKNUCKLES2", "CRACKKNUCKLES3" }; static const char* const frames[] = { "CRACKKNUCKLES0", "CRACKKNUCKLES1", "CRACKKNUCKLES2", "CRACKKNUCKLES3" };
@ -158,7 +158,7 @@ void displaymasks_d(int snum, int p, double interpfrac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool animatetip(int gs, DukePlayer* p, double xoffset, double yoffset, int pal, double const interpfrac, DAngle angle) static bool animatetip(int gs, DDukePlayer* p, double xoffset, double yoffset, int pal, double const interpfrac, DAngle angle)
{ {
if (p->tipincs == 0) return false; if (p->tipincs == 0) return false;
@ -177,7 +177,7 @@ static bool animatetip(int gs, DukePlayer* p, double xoffset, double yoffset, in
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool animateaccess(int gs, DukePlayer* p, double xoffset, double yoffset, double const interpfrac, DAngle angle) static bool animateaccess(int gs, DDukePlayer* p, double xoffset, double yoffset, double const interpfrac, DAngle angle)
{ {
if (p->access_incs == 0 || p->GetActor()->spr.extra <= 0) return false; if (p->access_incs == 0 || p->GetActor()->spr.extra <= 0) return false;
@ -201,7 +201,7 @@ static bool animateaccess(int gs, DukePlayer* p, double xoffset, double yoffset,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void animateshrunken(DukePlayer* p, double xoffset, double yoffset, int8_t shade, int o, double interpfrac) void animateshrunken(DDukePlayer* p, double xoffset, double yoffset, int8_t shade, int o, double interpfrac)
{ {
const double fistsign = BobVal(interpolatedvalue<double>(p->ofistsign, p->fistsign, interpfrac)) * 16; const double fistsign = BobVal(interpolatedvalue<double>(p->ofistsign, p->fistsign, interpfrac)) * 16;
int pal = getPlayer(screenpeek)->cursector->floorpal; int pal = getPlayer(screenpeek)->cursector->floorpal;
@ -220,7 +220,7 @@ void animateshrunken(DukePlayer* p, double xoffset, double yoffset, int8_t shade
void displayweapon_d(int snum, double interpfrac) void displayweapon_d(int snum, double interpfrac)
{ {
int pal, pal2; int pal, pal2;
DukePlayer* p = getPlayer(snum); DDukePlayer* p = getPlayer(snum);
if (p->newOwner != nullptr || ud.cameraactor != nullptr || p->over_shoulder_on > 0 || (p->GetActor()->spr.pal != 1 && p->GetActor()->spr.extra <= 0)) if (p->newOwner != nullptr || ud.cameraactor != nullptr || p->over_shoulder_on > 0 || (p->GetActor()->spr.pal != 1 && p->GetActor()->spr.extra <= 0))
return; return;

2
source/games/duke/src/hudweapon_r.cpp
View file

@ -208,7 +208,7 @@ void DrawBoat(int const kb, const DVector2& offsets, DAngle angle, int shade, in
// //
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void animateshrunken(DukePlayer* p, double xoffset, double yoffset, int8_t shade, int o, double interpfrac); void animateshrunken(DDukePlayer* p, double xoffset, double yoffset, int8_t shade, int o, double interpfrac);
void displayweapon_r(int snum, double interpfrac) void displayweapon_r(int snum, double interpfrac)
{ {

10
source/games/duke/src/inlines.h
View file

@ -10,9 +10,9 @@
// all inline functions. // all inline functions.
BEGIN_DUKE_NS BEGIN_DUKE_NS
inline DukePlayer* getPlayer(int index) inline DDukePlayer* getPlayer(int index)
{ {
return static_cast<DukePlayer*>(PlayerArray[index]); return static_cast<DDukePlayer*>(PlayerArray[index]);
} }
inline int rnd(int X) inline int rnd(int X)
@ -165,7 +165,7 @@ inline void clearfriction()
} }
} }
inline void SetPlayerPal(DukePlayer* p, PalEntry pe) inline void SetPlayerPal(DDukePlayer* p, PalEntry pe)
{ {
p->pals = pe; p->pals = pe;
} }
@ -175,7 +175,7 @@ inline bool playrunning()
return (paused == 0 || (paused == 1 && (ud.recstat == 2 || ud.multimode > 1))); return (paused == 0 || (paused == 1 && (ud.recstat == 2 || ud.multimode > 1)));
} }
inline void doslopetilting(DukePlayer* p) inline void doslopetilting(DDukePlayer* p)
{ {
p->Angles.doViewPitch(p->aim_mode == 0 && p->on_ground && p->cursector->lotag != ST_2_UNDERWATER); p->Angles.doViewPitch(p->aim_mode == 0 && p->on_ground && p->cursector->lotag != ST_2_UNDERWATER);
} }
@ -343,7 +343,7 @@ inline void subkill(DDukeActor* actor)
} }
} }
inline void dokill(DukePlayer* p, DDukeActor* g_ac, int amount) inline void dokill(DDukePlayer* p, DDukeActor* g_ac, int amount)
{ {
if (g_ac->spriteextra < 1 || g_ac->spriteextra == 128 || !isRR()) if (g_ac->spriteextra < 1 || g_ac->spriteextra == 128 || !isRR())
{ {

2
source/games/duke/src/input.cpp
View file

@ -54,7 +54,7 @@ void hud_input(int plnum)
{ {
int i, k; int i, k;
uint8_t dainv; uint8_t dainv;
DukePlayer* p; DDukePlayer* p;
p = getPlayer(plnum); p = getPlayer(plnum);
auto pact = p->GetActor(); auto pact = p->GetActor();

2
source/games/duke/src/noise.cpp
View file

@ -32,7 +32,7 @@ BEGIN_DUKE_NS
int madenoise(int snum) int madenoise(int snum)
{ {
DukePlayer *p; DDukePlayer *p;
p = getPlayer(snum); p = getPlayer(snum);
p->donoise = 1; p->donoise = 1;
p->noise = p->GetActor()->spr.pos.XY(); p->noise = p->GetActor()->spr.pos.XY();

58
source/games/duke/src/player.cpp
View file

@ -78,7 +78,7 @@ void PlayerColorChanged(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int setpal(DukePlayer* p) int setpal(DDukePlayer* p)
{ {
int palette; int palette;
if (p->DrugMode) palette = DRUGPAL; if (p->DrugMode) palette = DRUGPAL;
@ -96,7 +96,7 @@ int setpal(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void quickkill(DukePlayer* p) void quickkill(DDukePlayer* p)
{ {
SetPlayerPal(p, PalEntry(48, 48, 48, 48)); SetPlayerPal(p, PalEntry(48, 48, 48, 48));
@ -113,7 +113,7 @@ void quickkill(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void forceplayerangle(DukePlayer* p) void forceplayerangle(DDukePlayer* p)
{ {
const auto ang = (DAngle22_5 - randomAngle(45)) / 2.; const auto ang = (DAngle22_5 - randomAngle(45)) / 2.;
@ -174,7 +174,7 @@ double hitasprite(DDukeActor* actor, DDukeActor** hitsp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
double hitawall(DukePlayer* p, walltype** hitw) double hitawall(DDukePlayer* p, walltype** hitw)
{ {
HitInfo hit{}; HitInfo hit{};
@ -708,7 +708,7 @@ void playerJump(int snum, double floorz, double ceilingz)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DukePlayer::apply_seasick() void DDukePlayer::apply_seasick()
{ {
if (isRRRA() && SeaSick && (dead_flag == 0)) if (isRRRA() && SeaSick && (dead_flag == 0))
{ {
@ -736,7 +736,7 @@ void DukePlayer::apply_seasick()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DukePlayer::backuppos(bool noclipping) void DDukePlayer::backuppos(bool noclipping)
{ {
if (!noclipping) if (!noclipping)
{ {
@ -758,7 +758,7 @@ void DukePlayer::backuppos(bool noclipping)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DukePlayer::backupweapon() void DDukePlayer::backupweapon()
{ {
oweapon_sway = weapon_sway; oweapon_sway = weapon_sway;
oweapon_pos = weapon_pos; oweapon_pos = weapon_pos;
@ -779,7 +779,7 @@ void DukePlayer::backupweapon()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DukePlayer::checkhardlanding() void DDukePlayer::checkhardlanding()
{ {
if (hard_landing > 0) if (hard_landing > 0)
{ {
@ -788,7 +788,7 @@ void DukePlayer::checkhardlanding()
} }
} }
void DukePlayer::playerweaponsway(double xvel) void DDukePlayer::playerweaponsway(double xvel)
{ {
if (cl_weaponsway) if (cl_weaponsway)
{ {
@ -966,7 +966,7 @@ void shoot(DDukeActor* actor, PClass* cls)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool movementBlocked(DukePlayer *p) bool movementBlocked(DDukePlayer *p)
{ {
auto blockingweapon = [=]() auto blockingweapon = [=]()
{ {
@ -1026,7 +1026,7 @@ int haslock(sectortype* sectp, int snum)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void purplelavacheck(DukePlayer* p) void purplelavacheck(DDukePlayer* p)
{ {
auto pact = p->GetActor(); auto pact = p->GetActor();
if (p->spritebridge == 0 && pact->insector()) if (p->spritebridge == 0 && pact->insector())
@ -1060,7 +1060,7 @@ void purplelavacheck(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void addphealth(DukePlayer* p, int amount, bool bigitem) void addphealth(DDukePlayer* p, int amount, bool bigitem)
{ {
if (p->newOwner != nullptr) if (p->newOwner != nullptr)
{ {
@ -1124,7 +1124,7 @@ void addphealth(DukePlayer* p, int amount, bool bigitem)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int playereat(DukePlayer* p, int amount, bool bigitem) int playereat(DDukePlayer* p, int amount, bool bigitem)
{ {
p->eat += amount; p->eat += amount;
if (p->eat > 100) if (p->eat > 100)
@ -1181,7 +1181,7 @@ int playereat(DukePlayer* p, int amount, bool bigitem)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerdrink(DukePlayer* p, int amount) void playerdrink(DDukePlayer* p, int amount)
{ {
p->drink_amt += amount; p->drink_amt += amount;
int curhealth = p->GetActor()->spr.extra; int curhealth = p->GetActor()->spr.extra;
@ -1221,7 +1221,7 @@ void playerdrink(DukePlayer* p, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int playeraddammo(DukePlayer* p, int weaponindex, int amount) int playeraddammo(DDukePlayer* p, int weaponindex, int amount)
{ {
if (p->ammo_amount[weaponindex] >= gs.max_ammo_amount[weaponindex]) if (p->ammo_amount[weaponindex] >= gs.max_ammo_amount[weaponindex])
{ {
@ -1229,21 +1229,21 @@ int playeraddammo(DukePlayer* p, int weaponindex, int amount)
} }
addammo(weaponindex, p, amount); addammo(weaponindex, p, amount);
if (p->curr_weapon == KNEE_WEAPON) if (p->curr_weapon == KNEE_WEAPON)
if (p->gotweapon[weaponindex] && (WeaponSwitch(p - (DukePlayer*)PlayerArray) & 1)) if (p->gotweapon[weaponindex] && (WeaponSwitch(p->pnum) & 1))
fi.addweapon(p, weaponindex, true); fi.addweapon(p, weaponindex, true);
return true; return true;
} }
int playeraddweapon(DukePlayer* p, int weaponindex, int amount) int playeraddweapon(DDukePlayer* p, int weaponindex, int amount)
{ {
if (p->gotweapon[weaponindex] == 0) fi.addweapon(p, weaponindex, !!(WeaponSwitch(p - (DukePlayer*)PlayerArray) & 1)); if (p->gotweapon[weaponindex] == 0) fi.addweapon(p, weaponindex, !!(WeaponSwitch(p->pnum) & 1));
else if (p->ammo_amount[weaponindex] >= gs.max_ammo_amount[weaponindex]) else if (p->ammo_amount[weaponindex] >= gs.max_ammo_amount[weaponindex])
{ {
return false; return false;
} }
addammo(weaponindex, p, amount); addammo(weaponindex, p, amount);
if (p->curr_weapon == KNEE_WEAPON) if (p->curr_weapon == KNEE_WEAPON)
if (p->gotweapon[weaponindex] && (WeaponSwitch(p - (DukePlayer*)PlayerArray) & 1)) if (p->gotweapon[weaponindex] && (WeaponSwitch(p->pnum) & 1))
fi.addweapon(p, weaponindex, true); fi.addweapon(p, weaponindex, true);
return true; return true;
@ -1255,7 +1255,7 @@ int playeraddweapon(DukePlayer* p, int weaponindex, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playeraddinventory(DukePlayer* p, DDukeActor* item, int type, int amount) void playeraddinventory(DDukePlayer* p, DDukeActor* item, int type, int amount)
{ {
switch (type) switch (type)
{ {
@ -1322,12 +1322,12 @@ void playeraddinventory(DukePlayer* p, DDukeActor* item, int type, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int checkp(DDukeActor* self, DukePlayer* p, int flags) int checkp(DDukeActor* self, DDukePlayer* p, int flags)
{ {
bool j = 0; bool j = 0;
double vel = self->vel.X; double vel = self->vel.X;
unsigned plindex = unsigned(p - (DukePlayer*)PlayerArray); unsigned plindex = unsigned(p->pnum);
// sigh.. this was yet another place where number literals were used as bit masks for every single value, making the code totally unreadable. // sigh.. this was yet another place where number literals were used as bit masks for every single value, making the code totally unreadable.
if ((flags & pducking) && p->on_ground && PlayerInput(plindex, SB_CROUCH)) if ((flags & pducking) && p->on_ground && PlayerInput(plindex, SB_CROUCH))
@ -1381,7 +1381,7 @@ int checkp(DDukeActor* self, DukePlayer* p, int flags)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int playercheckinventory(DukePlayer* p, DDukeActor* item, int type, int amount) int playercheckinventory(DDukePlayer* p, DDukeActor* item, int type, int amount)
{ {
bool j = 0; bool j = 0;
switch (type) switch (type)
@ -1457,7 +1457,7 @@ int playercheckinventory(DukePlayer* p, DDukeActor* item, int type, int amount)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerstomp(DukePlayer* p, DDukeActor* stomped) void playerstomp(DDukePlayer* p, DDukeActor* stomped)
{ {
if (p->knee_incs == 0 && p->GetActor()->spr.scale.X >= (isRR() ? 0.140625 : 0.625)) if (p->knee_incs == 0 && p->GetActor()->spr.scale.X >= (isRR() ? 0.140625 : 0.625))
if (cansee(stomped->spr.pos.plusZ(-4), stomped->sector(), p->GetActor()->getPosWithOffsetZ().plusZ(16), p->GetActor()->sector())) if (cansee(stomped->spr.pos.plusZ(-4), stomped->sector(), p->GetActor()->getPosWithOffsetZ().plusZ(16), p->GetActor()->sector()))
@ -1475,7 +1475,7 @@ void playerstomp(DukePlayer* p, DDukeActor* stomped)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerreset(DukePlayer* p, DDukeActor* g_ac) void playerreset(DDukePlayer* p, DDukeActor* g_ac)
{ {
if (ud.multimode < 2) if (ud.multimode < 2)
{ {
@ -1484,7 +1484,7 @@ void playerreset(DukePlayer* p, DDukeActor* g_ac)
else else
{ {
// I am not convinced this is even remotely smart to be executed from here.. // I am not convinced this is even remotely smart to be executed from here..
pickrandomspot(int(p - (DukePlayer*)PlayerArray)); pickrandomspot(p->pnum);
g_ac->spr.pos = p->GetActor()->getPosWithOffsetZ(); g_ac->spr.pos = p->GetActor()->getPosWithOffsetZ();
p->GetActor()->backuppos(); p->GetActor()->backuppos();
p->setbobpos(); p->setbobpos();
@ -1504,7 +1504,7 @@ void playerreset(DukePlayer* p, DDukeActor* g_ac)
p->wantweaponfire = -1; p->wantweaponfire = -1;
p->GetActor()->PrevAngles.Pitch = p->GetActor()->spr.Angles.Pitch = nullAngle; p->GetActor()->PrevAngles.Pitch = p->GetActor()->spr.Angles.Pitch = nullAngle;
p->on_crane = nullptr; p->on_crane = nullptr;
p->frag_ps = int(p - (DukePlayer*)PlayerArray); p->frag_ps = p->pnum;
p->Angles.PrevViewAngles.Pitch = p->Angles.ViewAngles.Pitch = nullAngle; p->Angles.PrevViewAngles.Pitch = p->Angles.ViewAngles.Pitch = nullAngle;
p->opyoff = 0; p->opyoff = 0;
p->wackedbyactor = nullptr; p->wackedbyactor = nullptr;
@ -1540,7 +1540,7 @@ void playerreset(DukePlayer* p, DDukeActor* g_ac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void wackplayer(DukePlayer* p) void wackplayer(DDukePlayer* p)
{ {
if (!isRR()) if (!isRR())
forceplayerangle(p); forceplayerangle(p);
@ -1559,7 +1559,7 @@ void wackplayer(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void playerkick(DukePlayer* p, DDukeActor* g_ac) void playerkick(DDukePlayer* p, DDukeActor* g_ac)
{ {
if (ud.multimode > 1 && g_ac->isPlayer()) if (ud.multimode > 1 && g_ac->isPlayer())
{ {

10
source/games/duke/src/player_d.cpp
View file

@ -49,7 +49,7 @@ void operateweapon_ww(int snum, ESyncBits actions);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void incur_damage_d(DukePlayer* p) void incur_damage_d(DDukePlayer* p)
{ {
int damage = 0L, shield_damage = 0L; int damage = 0L, shield_damage = 0L;
@ -337,7 +337,7 @@ void selectweapon_d(int snum, int weap) // playernum, weaponnum
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int doincrements_d(DukePlayer* p) int doincrements_d(DDukePlayer* p)
{ {
int snum; int snum;
@ -536,7 +536,7 @@ int doincrements_d(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkweapons_d(DukePlayer* p) void checkweapons_d(DDukePlayer* p)
{ {
static PClassActor* const * const weapon_sprites[MAX_WEAPONS] = { &DukeMeleeAttackClass, &DukeFirstgunSpriteClass, &DukeShotgunSpriteClass, static PClassActor* const * const weapon_sprites[MAX_WEAPONS] = { &DukeMeleeAttackClass, &DukeFirstgunSpriteClass, &DukeShotgunSpriteClass,
&DukeChaingunSpriteClass, &DukeRPGSpriteClass, &DukePipeBombClass, &DukeShrinkerSpriteClass, &DukeDevastatorSpriteClass, &DukeChaingunSpriteClass, &DukeRPGSpriteClass, &DukePipeBombClass, &DukeShrinkerSpriteClass, &DukeDevastatorSpriteClass,
@ -1536,7 +1536,7 @@ void processinput_d(int snum)
Collision chz, clz; Collision chz, clz;
bool shrunk; bool shrunk;
int psectlotag; int psectlotag;
DukePlayer* p; DDukePlayer* p;
p = getPlayer(snum); p = getPlayer(snum);
auto pact = p->GetActor(); auto pact = p->GetActor();
@ -1952,7 +1952,7 @@ HORIZONLY:
if (p->show_empty_weapon > 0) if (p->show_empty_weapon > 0)
{ {
p->show_empty_weapon--; p->show_empty_weapon--;
if (p->show_empty_weapon == 0 && (WeaponSwitch(p - (DukePlayer*)PlayerArray) & 2)) if (p->show_empty_weapon == 0 && (WeaponSwitch(p->pnum) & 2))
{ {
if (p->last_full_weapon == GROW_WEAPON) if (p->last_full_weapon == GROW_WEAPON)
p->subweapon |= (1 << GROW_WEAPON); p->subweapon |= (1 << GROW_WEAPON);

28
source/games/duke/src/player_r.cpp
View file

@ -43,7 +43,7 @@ BEGIN_DUKE_NS
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void incur_damage_r(DukePlayer* p) void incur_damage_r(DDukePlayer* p)
{ {
int damage = 0, shield_damage = 0; int damage = 0, shield_damage = 0;
int gut = 0; int gut = 0;
@ -343,7 +343,7 @@ void selectweapon_r(int snum, int weap)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int doincrements_r(DukePlayer* p) int doincrements_r(DDukePlayer* p)
{ {
int snum; int snum;
auto pact = p->GetActor(); auto pact = p->GetActor();
@ -600,7 +600,7 @@ int doincrements_r(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkweapons_r(DukePlayer* p) void checkweapons_r(DDukePlayer* p)
{ {
static PClassActor* const* const weapon_sprites[MAX_WEAPONS] = { &DukeMeleeAttackClass, &RedneckRevolverClass, &RedneckShotgunClass, static PClassActor* const* const weapon_sprites[MAX_WEAPONS] = { &DukeMeleeAttackClass, &RedneckRevolverClass, &RedneckShotgunClass,
&RedneckRiflegunClass, &RedneckDynamiteClass, &RedneckCrossbowClass, &RedneckRipsawClass, &RedneckBlasterClass, &RedneckRiflegunClass, &RedneckDynamiteClass, &RedneckCrossbowClass, &RedneckRipsawClass, &RedneckBlasterClass,
@ -709,7 +709,7 @@ enum : unsigned
VEH_FWDBRAKING = VEH_FORWARD|VEH_BRAKING, VEH_FWDBRAKING = VEH_FORWARD|VEH_BRAKING,
}; };
static unsigned outVehicleFlags(DukePlayer* p, ESyncBits& actions) static unsigned outVehicleFlags(DDukePlayer* p, ESyncBits& actions)
{ {
unsigned flags = 0; unsigned flags = 0;
flags += VEH_FORWARD * (p->cmd.ucmd.fvel > 0); flags += VEH_FORWARD * (p->cmd.ucmd.fvel > 0);
@ -727,7 +727,7 @@ static unsigned outVehicleFlags(DukePlayer* p, ESyncBits& actions)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doVehicleTilting(DukePlayer* const p, const bool canTilt) static void doVehicleTilting(DDukePlayer* const p, const bool canTilt)
{ {
auto adj = DAngle::fromDeg(p->cmd.ucmd.avel * (545943. / 3200000.) * canTilt); auto adj = DAngle::fromDeg(p->cmd.ucmd.avel * (545943. / 3200000.) * canTilt);
if (p->OnMotorcycle) adj *= 5 * Sgn(p->MotoSpeed); if (p->OnMotorcycle) adj *= 5 * Sgn(p->MotoSpeed);
@ -744,7 +744,7 @@ static void doVehicleTilting(DukePlayer* const p, const bool canTilt)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doVehicleBumping(DukePlayer* p, DDukeActor* pact, unsigned flags, bool bumptest, int bumpscale) static void doVehicleBumping(DDukePlayer* p, DDukeActor* pact, unsigned flags, bool bumptest, int bumpscale)
{ {
if (p->MotoSpeed != 0 && p->on_ground == 1) if (p->MotoSpeed != 0 && p->on_ground == 1)
{ {
@ -805,7 +805,7 @@ static void doVehicleBumping(DukePlayer* p, DDukeActor* pact, unsigned flags, bo
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doVehicleDrunk(DukePlayer* const p) static void doVehicleDrunk(DDukePlayer* const p)
{ {
if (p->drink_amt > 88 && p->moto_drink == 0) if (p->drink_amt > 88 && p->moto_drink == 0)
{ {
@ -831,7 +831,7 @@ static void doVehicleDrunk(DukePlayer* const p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doVehicleSounds(DukePlayer* p, DDukeActor* pact, unsigned flags, unsigned sound1, unsigned sound2, unsigned sound3, unsigned sound4) static void doVehicleSounds(DDukePlayer* p, DDukeActor* pact, unsigned flags, unsigned sound1, unsigned sound2, unsigned sound3, unsigned sound4)
{ {
if ((p->OnBoat && (flags & VEH_FWDBRAKING) == VEH_FORWARD) || flags & VEH_FORWARD) if ((p->OnBoat && (flags & VEH_FWDBRAKING) == VEH_FORWARD) || flags & VEH_FORWARD)
{ {
@ -883,7 +883,7 @@ static void doVehicleSounds(DukePlayer* p, DDukeActor* pact, unsigned flags, uns
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doVehicleThrottling(DukePlayer* p, DDukeActor* pact, unsigned& flags, int fwdSpeed, int revSpeed, int brakeSpeed, int vBmpFwd, int vBmpBrake) static void doVehicleThrottling(DDukePlayer* p, DDukeActor* pact, unsigned& flags, int fwdSpeed, int revSpeed, int brakeSpeed, int vBmpFwd, int vBmpBrake)
{ {
if (p->on_ground == 1) if (p->on_ground == 1)
{ {
@ -2910,7 +2910,7 @@ HORIZONLY:
{ {
p->show_empty_weapon--; p->show_empty_weapon--;
if (p->show_empty_weapon == 0 && (WeaponSwitch(p - (DukePlayer*)PlayerArray) & 2)) if (p->show_empty_weapon == 0 && (WeaponSwitch(p->pnum) & 2))
{ {
fi.addweapon(p, p->last_full_weapon, true); fi.addweapon(p, p->last_full_weapon, true);
return; return;
@ -2946,7 +2946,7 @@ HORIZONLY:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void OnMotorcycle(DukePlayer *p) void OnMotorcycle(DDukePlayer *p)
{ {
if (!p->OnMotorcycle && p->cursector->lotag != ST_2_UNDERWATER) if (!p->OnMotorcycle && p->cursector->lotag != ST_2_UNDERWATER)
{ {
@ -2969,7 +2969,7 @@ void OnMotorcycle(DukePlayer *p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void OffMotorcycle(DukePlayer *p) void OffMotorcycle(DDukePlayer *p)
{ {
auto pact = p->GetActor(); auto pact = p->GetActor();
if (p->OnMotorcycle) if (p->OnMotorcycle)
@ -3013,7 +3013,7 @@ void OffMotorcycle(DukePlayer *p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void OnBoat(DukePlayer *p) void OnBoat(DDukePlayer *p)
{ {
if (!p->OnBoat) if (!p->OnBoat)
{ {
@ -3034,7 +3034,7 @@ void OnBoat(DukePlayer *p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void OffBoat(DukePlayer *p) void OffBoat(DDukePlayer *p)
{ {
if (p->OnBoat) if (p->OnBoat)
{ {

4
source/games/duke/src/player_w.cpp
View file

@ -48,7 +48,7 @@ int operateTripbomb(int snum);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DoFire(DukePlayer* p, int snum) void DoFire(DDukePlayer* p, int snum)
{ {
int i; int i;
@ -105,7 +105,7 @@ void DoFire(DukePlayer* p, int snum)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DoSpawn(DukePlayer *p, int snum) void DoSpawn(DDukePlayer *p, int snum)
{ {
if(!aplWeaponSpawn(p->curr_weapon, snum)) if(!aplWeaponSpawn(p->curr_weapon, snum))
return; return;

16
source/games/duke/src/premap.cpp
View file

@ -60,7 +60,7 @@ void premapcontroller(DDukeActor* ac)
void pickrandomspot(int snum) void pickrandomspot(int snum)
{ {
DukePlayer* p; DDukePlayer* p;
int i; int i;
p = getPlayer(snum); p = getPlayer(snum);
@ -85,7 +85,7 @@ void pickrandomspot(int snum)
void resetplayerstats(int snum) void resetplayerstats(int snum)
{ {
DukePlayer* p; DDukePlayer* p;
p = getPlayer(snum); p = getPlayer(snum);
@ -259,7 +259,7 @@ void resetplayerstats(int snum)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void resetweapons(DukePlayer* p) void resetweapons(DDukePlayer* p)
{ {
for (int weapon = PISTOL_WEAPON; weapon < MAX_WEAPONS; weapon++) for (int weapon = PISTOL_WEAPON; weapon < MAX_WEAPONS; weapon++)
{ {
@ -293,7 +293,7 @@ void resetweapons(DukePlayer* p)
p->gotweapon[SLINGBLADE_WEAPON] = true; p->gotweapon[SLINGBLADE_WEAPON] = true;
p->ammo_amount[SLINGBLADE_WEAPON] = 1; p->ammo_amount[SLINGBLADE_WEAPON] = 1;
} }
OnEvent(EVENT_RESETWEAPONS, int(p - (DukePlayer*)PlayerArray), nullptr, -1); OnEvent(EVENT_RESETWEAPONS, p->pnum, nullptr, -1);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -302,7 +302,7 @@ void resetweapons(DukePlayer* p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void resetinventory(DukePlayer* p) void resetinventory(DDukePlayer* p)
{ {
p->inven_icon = 0; p->inven_icon = 0;
p->boot_amount = 0; p->boot_amount = 0;
@ -362,7 +362,7 @@ void resetinventory(DukePlayer* p)
ufocnt = 0; ufocnt = 0;
hulkspawn = 2; hulkspawn = 2;
} }
OnEvent(EVENT_RESETINVENTORY, int(p - (DukePlayer*)PlayerArray), p->GetActor()); OnEvent(EVENT_RESETINVENTORY, p->pnum, p->GetActor());
} }
@ -374,7 +374,7 @@ void resetinventory(DukePlayer* p)
void resetprestat(int snum,int g) void resetprestat(int snum,int g)
{ {
DukePlayer* p; DDukePlayer* p;
p = getPlayer(snum); p = getPlayer(snum);
@ -1058,7 +1058,7 @@ void cacheit(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static int LoadTheMap(MapRecord *mi, DukePlayer*p, int gamemode) static int LoadTheMap(MapRecord *mi, DDukePlayer*p, int gamemode)
{ {
int16_t lbang; int16_t lbang;
if (isShareware() && (mi->flags & MI_USERMAP)) if (isShareware() && (mi->flags & MI_USERMAP))

2
source/games/duke/src/premap_r.cpp
View file

@ -42,7 +42,7 @@ BEGIN_DUKE_NS
void prelevel_r(int g, TArray<DDukeActor*>& actors) void prelevel_r(int g, TArray<DDukeActor*>& actors)
{ {
DukePlayer* p; DDukePlayer* p;
int j; int j;
int lotaglist; int lotaglist;
TArray<short> lotags; TArray<short> lotags;

4
source/games/duke/src/render.cpp
View file

@ -129,7 +129,7 @@ bool GameInterface::GetGeoEffect(GeoEffect* eff, sectortype* viewsector)
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int DrugTimer; int DrugTimer;
static int getdrugmode(DukePlayer *p, int oyrepeat) static int getdrugmode(DDukePlayer *p, int oyrepeat)
{ {
int now = I_GetBuildTime() >> 1; // this function works on a 60 fps setup. int now = I_GetBuildTime() >> 1; // this function works on a 60 fps setup.
if (playrunning() && p->DrugMode > 0) if (playrunning() && p->DrugMode > 0)
@ -218,7 +218,7 @@ void displayrooms(int snum, double interpfrac, bool sceneonly)
DVector3 cpos; DVector3 cpos;
DRotator cangles; DRotator cangles;
DukePlayer* p = getPlayer(snum); DDukePlayer* p = getPlayer(snum);
// update render angles. // update render angles.
p->Angles.updateCameraAngles(interpfrac); p->Angles.updateCameraAngles(interpfrac);

2
source/games/duke/src/savegame.cpp
View file

@ -103,7 +103,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, player_orig& w, pl
return arc; return arc;
} }
FSerializer& Serialize(FSerializer& arc, const char* keyname, DukePlayer& w, DukePlayer* def) FSerializer& Serialize(FSerializer& arc, const char* keyname, DDukePlayer& w, DDukePlayer* def)
{ {
if (arc.BeginObject(keyname)) if (arc.BeginObject(keyname))
{ {

2
source/games/duke/src/sectors.cpp
View file

@ -1126,7 +1126,7 @@ void operatesectors(sectortype* sptr, DDukeActor *actor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void operateactivators(int low, DukePlayer* plr) void operateactivators(int low, DDukePlayer* plr)
{ {
int i, j, k; int i, j, k;
Cycler * p; Cycler * p;

6
source/games/duke/src/sectors_d.cpp
View file

@ -117,7 +117,7 @@ void activatebysector_d(sectortype* sect, DDukeActor* activator)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkplayerhurt_d(DukePlayer* p, const Collision& coll) void checkplayerhurt_d(DDukePlayer* p, const Collision& coll)
{ {
if (coll.type == kHitSprite) if (coll.type == kHitSprite)
{ {
@ -158,7 +158,7 @@ void checkplayerhurt_d(DukePlayer* p, const Collision& coll)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void clearcameras(DukePlayer* p) void clearcameras(DDukePlayer* p)
{ {
p->GetActor()->restorepos(); p->GetActor()->restorepos();
p->newOwner = nullptr; p->newOwner = nullptr;
@ -181,7 +181,7 @@ void clearcameras(DukePlayer* p)
void checksectors_d(int snum) void checksectors_d(int snum)
{ {
int i = -1; int i = -1;
DukePlayer* p; DDukePlayer* p;
walltype* hitscanwall; walltype* hitscanwall;
HitInfo near; HitInfo near;

4
source/games/duke/src/sectors_r.cpp
View file

@ -127,7 +127,7 @@ void activatebysector_r(sectortype* sect, DDukeActor* activator)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void checkplayerhurt_r(DukePlayer* p, const Collision &coll) void checkplayerhurt_r(DDukePlayer* p, const Collision &coll)
{ {
if (coll.type == kHitSprite) if (coll.type == kHitSprite)
{ {
@ -160,7 +160,7 @@ void checkplayerhurt_r(DukePlayer* p, const Collision &coll)
void checksectors_r(int snum) void checksectors_r(int snum)
{ {
DukePlayer* p; DDukePlayer* p;
walltype* hitscanwall; walltype* hitscanwall;
HitInfo near; HitInfo near;

8
source/games/duke/src/types.h
View file

@ -224,8 +224,14 @@ struct player_orig
sectortype* os; sectortype* os;
}; };
struct DukePlayer final : public CorePlayer class DDukePlayer final : public DCorePlayer
{ {
DECLARE_CLASS(DDukePlayer, DCorePlayer)
HAS_OBJECT_POINTERS
size_t PropagateMark() override;
DDukePlayer() = default;
public:
DDukePlayer(uint8_t p) : DCorePlayer(p) {}
DVector3 vel; DVector3 vel;
DVector2 bobpos; DVector2 bobpos;
DVector2 fric; DVector2 fric;

448
source/games/duke/src/vmexports.cpp
View file

@ -33,7 +33,7 @@ void resetswitch(int tag);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
DukePlayer* duke_getviewplayer() DDukePlayer* duke_getviewplayer()
{ {
return getPlayer(screenpeek); return getPlayer(screenpeek);
} }
@ -44,7 +44,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_Duke, getviewplayer, duke_getviewplayer)
ACTION_RETURN_POINTER(duke_getviewplayer()); ACTION_RETURN_POINTER(duke_getviewplayer());
} }
DukePlayer* duke_getlocalplayer() DDukePlayer* duke_getlocalplayer()
{ {
return getPlayer(myconnectindex); return getPlayer(myconnectindex);
} }
@ -117,7 +117,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_Duke, CheckSoundPlaying, duke_CheckSoundPlaying)
ACTION_RETURN_INT(duke_CheckSoundPlaying(snd)); ACTION_RETURN_INT(duke_CheckSoundPlaying(snd));
} }
DukePlayer* duke_checkcursectnums(sectortype* sector) DDukePlayer* duke_checkcursectnums(sectortype* sector)
{ {
if (!sector) return nullptr; if (!sector) return nullptr;
int pp = checkcursectnums(sector); int pp = checkcursectnums(sector);
@ -196,16 +196,16 @@ DEFINE_ACTION_FUNCTION_NATIVE(_Duke, StopCommentary, StopCommentary)
return 0; return 0;
} }
int getPlayerIndex(DukePlayer* p) int getPlayerIndex(DDukePlayer* p)
{ {
if (!p) return -1; if (!p) return -1;
return int(p - (DukePlayer*)PlayerArray); return p->pnum;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_Duke, getPlayerIndex, getPlayerIndex) DEFINE_ACTION_FUNCTION_NATIVE(_Duke, getPlayerIndex, getPlayerIndex)
{ {
PARAM_PROLOGUE; PARAM_PROLOGUE;
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
ACTION_RETURN_INT(getPlayerIndex(p)); ACTION_RETURN_INT(getPlayerIndex(p));
} }
@ -355,7 +355,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, getglobalz, getglobalz)
return 0; return 0;
} }
DukePlayer* DukeActor_findplayer(DDukeActor* self, double* dist) DDukePlayer* DukeActor_findplayer(DDukeActor* self, double* dist)
{ {
double a; double a;
return getPlayer(findplayer(self, dist? dist : &a)); return getPlayer(findplayer(self, dist? dist : &a));
@ -371,7 +371,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, findplayer, DukeActor_findplayer)
return min(numret, 2); return min(numret, 2);
} }
DukePlayer* DukeActor_getplayer(DDukeActor* self) DDukePlayer* DukeActor_getplayer(DDukeActor* self)
{ {
return self->isPlayer() ? getPlayer(self->PlayerIndex()) : nullptr; return self->isPlayer() ? getPlayer(self->PlayerIndex()) : nullptr;
} }
@ -713,7 +713,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, restoreloc, DukeActor_restoreloc)
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, fakebubbaspawn, fakebubbaspawn) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, fakebubbaspawn, fakebubbaspawn)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
fakebubbaspawn(self, p); fakebubbaspawn(self, p);
return 0; return 0;
} }
@ -790,7 +790,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, SetAI, Duke_SetAI)
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, checkp, checkp) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, checkp, checkp)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
PARAM_INT(n); PARAM_INT(n);
ACTION_RETURN_INT(checkp(self, p, n)); ACTION_RETURN_INT(checkp(self, p, n));
} }
@ -798,7 +798,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, checkp, checkp)
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, cansee, ifcansee) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, cansee, ifcansee)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
PARAM_INT(n); PARAM_INT(n);
ACTION_RETURN_INT(ifcansee(self, p)); ACTION_RETURN_INT(ifcansee(self, p));
} }
@ -813,7 +813,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, actoroperate, actoroperate)
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ifsquished, ifsquished) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ifsquished, ifsquished)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
ACTION_RETURN_INT(ifcansee(self, p)); ACTION_RETURN_INT(ifcansee(self, p));
} }
@ -830,7 +830,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ChangeType, Duke_ChangeType)
return 0; return 0;
} }
void Duke_fall(DDukeActor* self, DukePlayer* p) void Duke_fall(DDukeActor* self, DDukePlayer* p)
{ {
fall(self, p->GetPlayerNum()); fall(self, p->GetPlayerNum());
} }
@ -838,7 +838,7 @@ void Duke_fall(DDukeActor* self, DukePlayer* p)
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, fall, Duke_fall) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, fall, Duke_fall)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
Duke_fall(self, p); Duke_fall(self, p);
return 0; return 0;
} }
@ -858,14 +858,14 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, dodge, dodge)
ACTION_RETURN_INT(dodge(self)); ACTION_RETURN_INT(dodge(self));
} }
int Duke_ifcanshoottarget(DDukeActor* self, DukePlayer* p, double dist) int Duke_ifcanshoottarget(DDukeActor* self, DDukePlayer* p, double dist)
{ {
return ifcanshoottarget(self, p->GetPlayerNum(), int(dist * worldtoint)); return ifcanshoottarget(self, p->GetPlayerNum(), int(dist * worldtoint));
} }
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ifcanshoottarget, Duke_ifcanshoottarget) DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ifcanshoottarget, Duke_ifcanshoottarget)
{ {
PARAM_SELF_PROLOGUE(DDukeActor); PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
PARAM_FLOAT(x); PARAM_FLOAT(x);
ACTION_RETURN_INT(Duke_ifcanshoottarget(self, p, x)); ACTION_RETURN_INT(Duke_ifcanshoottarget(self, p, x));
} }
@ -972,208 +972,208 @@ DEFINE_ACTION_FUNCTION(DDukeActor, killit)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
DEFINE_FIELD_X(DukePlayer, DukePlayer, gotweapon) DEFINE_FIELD(DDukePlayer, actor)
DEFINE_FIELD_X(DukePlayer, DukePlayer, pals) DEFINE_FIELD(DDukePlayer, gotweapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, weapon_sway) DEFINE_FIELD(DDukePlayer, pals)
DEFINE_FIELD_X(DukePlayer, DukePlayer, oweapon_sway) DEFINE_FIELD(DDukePlayer, weapon_sway)
DEFINE_FIELD_X(DukePlayer, DukePlayer, weapon_pos) DEFINE_FIELD(DDukePlayer, oweapon_sway)
DEFINE_FIELD_X(DukePlayer, DukePlayer, kickback_pic) DEFINE_FIELD(DDukePlayer, weapon_pos)
DEFINE_FIELD_X(DukePlayer, DukePlayer, random_club_frame) DEFINE_FIELD(DDukePlayer, kickback_pic)
DEFINE_FIELD_X(DukePlayer, DukePlayer, oweapon_pos) DEFINE_FIELD(DDukePlayer, random_club_frame)
DEFINE_FIELD_X(DukePlayer, DukePlayer, okickback_pic) DEFINE_FIELD(DDukePlayer, oweapon_pos)
DEFINE_FIELD_X(DukePlayer, DukePlayer, orandom_club_frame) DEFINE_FIELD(DDukePlayer, okickback_pic)
DEFINE_FIELD_X(DukePlayer, DukePlayer, hard_landing) DEFINE_FIELD(DDukePlayer, orandom_club_frame)
DEFINE_FIELD_X(DukePlayer, DukePlayer, ohard_landing) DEFINE_FIELD(DDukePlayer, hard_landing)
DEFINE_FIELD_X(DukePlayer, DukePlayer, psectlotag) DEFINE_FIELD(DDukePlayer, ohard_landing)
//DEFINE_FIELD_X(DukePlayer, player_struct, exitx) DEFINE_FIELD(DDukePlayer, psectlotag)
//DEFINE_FIELD_X(DukePlayer, player_struct, exity) DEFINE_FIELD(DDukePlayer, loogie)
DEFINE_FIELD_UNSIZED(DukePlayer, DukePlayer, loogie) DEFINE_FIELD(DDukePlayer, numloogs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, numloogs) DEFINE_FIELD(DDukePlayer, loogcnt)
DEFINE_FIELD_X(DukePlayer, DukePlayer, loogcnt) DEFINE_FIELD(DDukePlayer, invdisptime)
DEFINE_FIELD_X(DukePlayer, DukePlayer, invdisptime) //DEFINE_FIELD(DukePlayer, exitx)
//DEFINE_FIELD_X(DukePlayer, player_struct, bobposx) //DEFINE_FIELD(DukePlayer, exity)
//DEFINE_FIELD_X(DukePlayer, player_struct, bobposy) //DEFINE_FIELD(DukePlayer, bobposx)
DEFINE_FIELD_X(DukePlayer, DukePlayer, pyoff) //DEFINE_FIELD(DukePlayer, bobposy)
DEFINE_FIELD_X(DukePlayer, DukePlayer, opyoff) DEFINE_FIELD(DDukePlayer, pyoff)
DEFINE_FIELD_X(DukePlayer, DukePlayer, vel) DEFINE_FIELD(DDukePlayer, opyoff)
DEFINE_FIELD_X(DukePlayer, DukePlayer, last_pissed_time) DEFINE_FIELD(DDukePlayer, vel)
DEFINE_FIELD_X(DukePlayer, DukePlayer, truefz) DEFINE_FIELD(DDukePlayer, last_pissed_time)
DEFINE_FIELD_X(DukePlayer, DukePlayer, truecz) DEFINE_FIELD(DDukePlayer, truefz)
DEFINE_FIELD_X(DukePlayer, DukePlayer, player_par) DEFINE_FIELD(DDukePlayer, truecz)
DEFINE_FIELD_X(DukePlayer, DukePlayer, visibility) DEFINE_FIELD(DDukePlayer, player_par)
DEFINE_FIELD_X(DukePlayer, DukePlayer, bobcounter) DEFINE_FIELD(DDukePlayer, visibility)
DEFINE_FIELD_X(DukePlayer, DukePlayer, randomflamex) DEFINE_FIELD(DDukePlayer, bobcounter)
DEFINE_FIELD_X(DukePlayer, DukePlayer, crack_time) DEFINE_FIELD(DDukePlayer, randomflamex)
DEFINE_FIELD_X(DukePlayer, DukePlayer, aim_mode) DEFINE_FIELD(DDukePlayer, crack_time)
DEFINE_FIELD_X(DukePlayer, DukePlayer, ftt) DEFINE_FIELD(DDukePlayer, aim_mode)
DEFINE_FIELD_X(DukePlayer, DukePlayer, cursector) DEFINE_FIELD(DDukePlayer, ftt)
DEFINE_FIELD_X(DukePlayer, DukePlayer, last_extra) DEFINE_FIELD(DDukePlayer, cursector)
DEFINE_FIELD_X(DukePlayer, DukePlayer, subweapon) DEFINE_FIELD(DDukePlayer, last_extra)
DEFINE_FIELD_X(DukePlayer, DukePlayer, ammo_amount) DEFINE_FIELD(DDukePlayer, subweapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, frag) DEFINE_FIELD(DDukePlayer, ammo_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, fraggedself) DEFINE_FIELD(DDukePlayer, frag)
DEFINE_FIELD_X(DukePlayer, DukePlayer, curr_weapon) DEFINE_FIELD(DDukePlayer, fraggedself)
DEFINE_FIELD_X(DukePlayer, DukePlayer, last_weapon) DEFINE_FIELD(DDukePlayer, curr_weapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, tipincs) DEFINE_FIELD(DDukePlayer, last_weapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, wantweaponfire) DEFINE_FIELD(DDukePlayer, tipincs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, holoduke_amount) DEFINE_FIELD(DDukePlayer, wantweaponfire)
DEFINE_FIELD_X(DukePlayer, DukePlayer, hurt_delay) DEFINE_FIELD(DDukePlayer, holoduke_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, hbomb_hold_delay) DEFINE_FIELD(DDukePlayer, hurt_delay)
DEFINE_FIELD_X(DukePlayer, DukePlayer, jumping_counter) DEFINE_FIELD(DDukePlayer, hbomb_hold_delay)
DEFINE_FIELD_X(DukePlayer, DukePlayer, airleft) DEFINE_FIELD(DDukePlayer, jumping_counter)
DEFINE_FIELD_X(DukePlayer, DukePlayer, knee_incs) DEFINE_FIELD(DDukePlayer, airleft)
DEFINE_FIELD_X(DukePlayer, DukePlayer, access_incs) DEFINE_FIELD(DDukePlayer, knee_incs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, ftq) DEFINE_FIELD(DDukePlayer, access_incs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, access_wall) DEFINE_FIELD(DDukePlayer, ftq)
DEFINE_FIELD_X(DukePlayer, DukePlayer, got_access) DEFINE_FIELD(DDukePlayer, access_wall)
DEFINE_FIELD_X(DukePlayer, DukePlayer, weapon_ang) DEFINE_FIELD(DDukePlayer, got_access)
DEFINE_FIELD_X(DukePlayer, DukePlayer, firstaid_amount) DEFINE_FIELD(DDukePlayer, weapon_ang)
DEFINE_FIELD_X(DukePlayer, DukePlayer, actor) DEFINE_FIELD(DDukePlayer, firstaid_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, one_parallax_sectnum) DEFINE_FIELD(DDukePlayer, one_parallax_sectnum)
DEFINE_FIELD_X(DukePlayer, DukePlayer, over_shoulder_on) DEFINE_FIELD(DDukePlayer, over_shoulder_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, fist_incs) DEFINE_FIELD(DDukePlayer, fist_incs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, cheat_phase) DEFINE_FIELD(DDukePlayer, cheat_phase)
DEFINE_FIELD_X(DukePlayer, DukePlayer, extra_extra8) DEFINE_FIELD(DDukePlayer, extra_extra8)
DEFINE_FIELD_X(DukePlayer, DukePlayer, quick_kick) DEFINE_FIELD(DDukePlayer, quick_kick)
DEFINE_FIELD_X(DukePlayer, DukePlayer, last_quick_kick) DEFINE_FIELD(DDukePlayer, last_quick_kick)
DEFINE_FIELD_X(DukePlayer, DukePlayer, heat_amount) DEFINE_FIELD(DDukePlayer, heat_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, timebeforeexit) DEFINE_FIELD(DDukePlayer, timebeforeexit)
DEFINE_FIELD_X(DukePlayer, DukePlayer, customexitsound) DEFINE_FIELD(DDukePlayer, customexitsound)
DEFINE_FIELD_X(DukePlayer, DukePlayer, interface_toggle_flag) DEFINE_FIELD(DDukePlayer, interface_toggle_flag)
DEFINE_FIELD_X(DukePlayer, DukePlayer, dead_flag) DEFINE_FIELD(DDukePlayer, dead_flag)
DEFINE_FIELD_X(DukePlayer, DukePlayer, show_empty_weapon) DEFINE_FIELD(DDukePlayer, show_empty_weapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, scuba_amount) DEFINE_FIELD(DDukePlayer, scuba_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, jetpack_amount) DEFINE_FIELD(DDukePlayer, jetpack_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, steroids_amount) DEFINE_FIELD(DDukePlayer, steroids_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, shield_amount) DEFINE_FIELD(DDukePlayer, shield_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, pycount) DEFINE_FIELD(DDukePlayer, pycount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, frag_ps) DEFINE_FIELD(DDukePlayer, frag_ps)
DEFINE_FIELD_X(DukePlayer, DukePlayer, transporter_hold) DEFINE_FIELD(DDukePlayer, transporter_hold)
DEFINE_FIELD_X(DukePlayer, DukePlayer, last_full_weapon) DEFINE_FIELD(DDukePlayer, last_full_weapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, footprintshade) DEFINE_FIELD(DDukePlayer, footprintshade)
DEFINE_FIELD_X(DukePlayer, DukePlayer, boot_amount) DEFINE_FIELD(DDukePlayer, boot_amount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, on_warping_sector) DEFINE_FIELD(DDukePlayer, on_warping_sector)
DEFINE_FIELD_X(DukePlayer, DukePlayer, footprintcount) DEFINE_FIELD(DDukePlayer, footprintcount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, hbomb_on) DEFINE_FIELD(DDukePlayer, hbomb_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, jumping_toggle) DEFINE_FIELD(DDukePlayer, jumping_toggle)
DEFINE_FIELD_X(DukePlayer, DukePlayer, rapid_fire_hold) DEFINE_FIELD(DDukePlayer, rapid_fire_hold)
DEFINE_FIELD_X(DukePlayer, DukePlayer, on_ground) DEFINE_FIELD(DDukePlayer, on_ground)
DEFINE_FIELD_X(DukePlayer, DukePlayer, inven_icon) DEFINE_FIELD(DDukePlayer, inven_icon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, buttonpalette) DEFINE_FIELD(DDukePlayer, buttonpalette)
DEFINE_FIELD_X(DukePlayer, DukePlayer, jetpack_on) DEFINE_FIELD(DDukePlayer, jetpack_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, spritebridge) DEFINE_FIELD(DDukePlayer, spritebridge)
DEFINE_FIELD_X(DukePlayer, DukePlayer, lastrandomspot) DEFINE_FIELD(DDukePlayer, lastrandomspot)
DEFINE_FIELD_X(DukePlayer, DukePlayer, scuba_on) DEFINE_FIELD(DDukePlayer, scuba_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, footprintpal) DEFINE_FIELD(DDukePlayer, footprintpal)
DEFINE_FIELD_X(DukePlayer, DukePlayer, heat_on) DEFINE_FIELD(DDukePlayer, heat_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, holster_weapon) DEFINE_FIELD(DDukePlayer, holster_weapon)
DEFINE_FIELD_X(DukePlayer, DukePlayer, falling_counter) DEFINE_FIELD(DDukePlayer, falling_counter)
DEFINE_FIELD_X(DukePlayer, DukePlayer, refresh_inventory) DEFINE_FIELD(DDukePlayer, refresh_inventory)
DEFINE_FIELD_X(DukePlayer, DukePlayer, toggle_key_flag) DEFINE_FIELD(DDukePlayer, toggle_key_flag)
DEFINE_FIELD_X(DukePlayer, DukePlayer, knuckle_incs) DEFINE_FIELD(DDukePlayer, knuckle_incs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, walking_snd_toggle) DEFINE_FIELD(DDukePlayer, walking_snd_toggle)
DEFINE_FIELD_X(DukePlayer, DukePlayer, palookup) DEFINE_FIELD(DDukePlayer, palookup)
DEFINE_FIELD_X(DukePlayer, DukePlayer, quick_kick_msg) DEFINE_FIELD(DDukePlayer, quick_kick_msg)
DEFINE_FIELD_X(DukePlayer, DukePlayer, stairs) DEFINE_FIELD(DDukePlayer, stairs)
DEFINE_FIELD_X(DukePlayer, DukePlayer, detonate_count) DEFINE_FIELD(DDukePlayer, detonate_count)
//DEFINE_FIELD_X(DukePlayer, player_struct, noise.X) //DEFINE_FIELD(DukePlayer, noise.X)
//DEFINE_FIELD_X(DukePlayer, player_struct, noise.Y) //DEFINE_FIELD(DukePlayer, noise.Y)
DEFINE_FIELD_X(DukePlayer, DukePlayer, noise_radius) DEFINE_FIELD(DDukePlayer, noise_radius)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drink_timer) DEFINE_FIELD(DDukePlayer, drink_timer)
DEFINE_FIELD_X(DukePlayer, DukePlayer, eat_timer) DEFINE_FIELD(DDukePlayer, eat_timer)
DEFINE_FIELD_X(DukePlayer, DukePlayer, SlotWin) DEFINE_FIELD(DDukePlayer, SlotWin)
DEFINE_FIELD_X(DukePlayer, DukePlayer, recoil) DEFINE_FIELD(DDukePlayer, recoil)
DEFINE_FIELD_X(DukePlayer, DukePlayer, detonate_time) DEFINE_FIELD(DDukePlayer, detonate_time)
DEFINE_FIELD_X(DukePlayer, DukePlayer, yehaa_timer) DEFINE_FIELD(DDukePlayer, yehaa_timer)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drink_amt) DEFINE_FIELD(DDukePlayer, drink_amt)
DEFINE_FIELD_X(DukePlayer, DukePlayer, eat) DEFINE_FIELD(DDukePlayer, eat)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drunkang) DEFINE_FIELD(DDukePlayer, drunkang)
DEFINE_FIELD_X(DukePlayer, DukePlayer, eatang) DEFINE_FIELD(DDukePlayer, eatang)
DEFINE_FIELD_X(DukePlayer, DukePlayer, shotgun_state) DEFINE_FIELD(DDukePlayer, shotgun_state)
DEFINE_FIELD_X(DukePlayer, DukePlayer, donoise) DEFINE_FIELD(DDukePlayer, donoise)
DEFINE_FIELD_X(DukePlayer, DukePlayer, keys) DEFINE_FIELD(DDukePlayer, keys)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drug_aspect) DEFINE_FIELD(DDukePlayer, drug_aspect)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drug_timer) DEFINE_FIELD(DDukePlayer, drug_timer)
DEFINE_FIELD_X(DukePlayer, DukePlayer, SeaSick) DEFINE_FIELD(DDukePlayer, SeaSick)
DEFINE_FIELD_X(DukePlayer, DukePlayer, MamaEnd) DEFINE_FIELD(DDukePlayer, MamaEnd)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_drink) DEFINE_FIELD(DDukePlayer, moto_drink)
DEFINE_FIELD_X(DukePlayer, DukePlayer, TiltStatus) DEFINE_FIELD(DDukePlayer, TiltStatus)
DEFINE_FIELD_X(DukePlayer, DukePlayer, oTiltStatus) DEFINE_FIELD(DDukePlayer, oTiltStatus)
DEFINE_FIELD_X(DukePlayer, DukePlayer, VBumpNow) DEFINE_FIELD(DDukePlayer, VBumpNow)
DEFINE_FIELD_X(DukePlayer, DukePlayer, VBumpTarget) DEFINE_FIELD(DDukePlayer, VBumpTarget)
DEFINE_FIELD_X(DukePlayer, DukePlayer, TurbCount) DEFINE_FIELD(DDukePlayer, TurbCount)
DEFINE_FIELD_X(DukePlayer, DukePlayer, drug_stat) DEFINE_FIELD(DDukePlayer, drug_stat)
DEFINE_FIELD_X(DukePlayer, DukePlayer, DrugMode) DEFINE_FIELD(DDukePlayer, DrugMode)
DEFINE_FIELD_X(DukePlayer, DukePlayer, lotag800kill) DEFINE_FIELD(DDukePlayer, lotag800kill)
DEFINE_FIELD_X(DukePlayer, DukePlayer, sea_sick_stat) DEFINE_FIELD(DDukePlayer, sea_sick_stat)
DEFINE_FIELD_X(DukePlayer, DukePlayer, hurt_delay2) DEFINE_FIELD(DDukePlayer, hurt_delay2)
DEFINE_FIELD_X(DukePlayer, DukePlayer, nocheat) DEFINE_FIELD(DDukePlayer, nocheat)
DEFINE_FIELD_X(DukePlayer, DukePlayer, OnMotorcycle) DEFINE_FIELD(DDukePlayer, OnMotorcycle)
DEFINE_FIELD_X(DukePlayer, DukePlayer, OnBoat) DEFINE_FIELD(DDukePlayer, OnBoat)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_underwater) DEFINE_FIELD(DDukePlayer, moto_underwater)
DEFINE_FIELD_X(DukePlayer, DukePlayer, NotOnWater) DEFINE_FIELD(DDukePlayer, NotOnWater)
DEFINE_FIELD_X(DukePlayer, DukePlayer, MotoOnGround) DEFINE_FIELD(DDukePlayer, MotoOnGround)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_do_bump) DEFINE_FIELD(DDukePlayer, moto_do_bump)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_bump_fast) DEFINE_FIELD(DDukePlayer, moto_bump_fast)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_on_oil) DEFINE_FIELD(DDukePlayer, moto_on_oil)
DEFINE_FIELD_X(DukePlayer, DukePlayer, moto_on_mud) DEFINE_FIELD(DDukePlayer, moto_on_mud)
DEFINE_FIELD_X(DukePlayer, DukePlayer, MotoSpeed) DEFINE_FIELD(DDukePlayer, MotoSpeed)
DEFINE_FIELD_X(DukePlayer, DukePlayer, holoduke_on) DEFINE_FIELD(DDukePlayer, holoduke_on)
DEFINE_FIELD_X(DukePlayer, DukePlayer, actorsqu) DEFINE_FIELD(DDukePlayer, actorsqu)
DEFINE_FIELD_X(DukePlayer, DukePlayer, wackedbyactor) DEFINE_FIELD(DDukePlayer, wackedbyactor)
DEFINE_FIELD_X(DukePlayer, DukePlayer, on_crane) DEFINE_FIELD(DDukePlayer, on_crane)
DEFINE_FIELD_X(DukePlayer, DukePlayer, somethingonplayer) DEFINE_FIELD(DDukePlayer, somethingonplayer)
DEFINE_FIELD_X(DukePlayer, DukePlayer, access_spritenum) DEFINE_FIELD(DDukePlayer, access_spritenum)
DEFINE_FIELD_X(DukePlayer, DukePlayer, dummyplayersprite) DEFINE_FIELD(DDukePlayer, dummyplayersprite)
DEFINE_FIELD_X(DukePlayer, DukePlayer, newOwner) DEFINE_FIELD(DDukePlayer, newOwner)
DEFINE_FIELD_X(DukePlayer, DukePlayer, fric) DEFINE_FIELD(DDukePlayer, fric)
DEFINE_ACTION_FUNCTION(_DukePlayer, IsFrozen) DEFINE_ACTION_FUNCTION(_DukePlayer, IsFrozen)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
ACTION_RETURN_BOOL(self->GetActor()->spr.pal == 1 && self->last_extra < 2); ACTION_RETURN_BOOL(self->GetActor()->spr.pal == 1 && self->last_extra < 2);
} }
DEFINE_ACTION_FUNCTION(_DukePlayer, GetGameVar) DEFINE_ACTION_FUNCTION(_DukePlayer, GetGameVar)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_STRING(name); PARAM_STRING(name);
PARAM_INT(def); PARAM_INT(def);
ACTION_RETURN_INT(GetGameVar(name, def, self->GetActor(), self->GetPlayerNum()).safeValue()); ACTION_RETURN_INT(GetGameVar(name, def, self->GetActor(), self->GetPlayerNum()).safeValue());
} }
void dukeplayer_backuppos(DukePlayer* self) void dukeplayer_backuppos(DDukePlayer* self)
{ {
self->backuppos(); self->backuppos();
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backuppos, dukeplayer_backuppos) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backuppos, dukeplayer_backuppos)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
dukeplayer_backuppos(self); dukeplayer_backuppos(self);
return 0; return 0;
} }
void dukeplayer_backupxyz(DukePlayer* self) void dukeplayer_backupxyz(DDukePlayer* self)
{ {
self->GetActor()->backuppos(); self->GetActor()->backuppos();
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backupxyz, dukeplayer_backupxyz) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backupxyz, dukeplayer_backupxyz)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
dukeplayer_backupxyz(self); dukeplayer_backupxyz(self);
return 0; return 0;
} }
void dukeplayer_setpos(DukePlayer* self, double x, double y, double z) void dukeplayer_setpos(DDukePlayer* self, double x, double y, double z)
{ {
self->GetActor()->spr.pos = { x, y, z + self->GetActor()->viewzoffset }; self->GetActor()->spr.pos = { x, y, z + self->GetActor()->viewzoffset };
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setpos, dukeplayer_setpos) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setpos, dukeplayer_setpos)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_FLOAT(x); PARAM_FLOAT(x);
PARAM_FLOAT(y); PARAM_FLOAT(y);
PARAM_FLOAT(z); PARAM_FLOAT(z);
@ -1181,14 +1181,14 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setpos, dukeplayer_setpos)
return 0; return 0;
} }
void dukeplayer_addpos(DukePlayer* self, double x, double y, double z) void dukeplayer_addpos(DDukePlayer* self, double x, double y, double z)
{ {
self->GetActor()->spr.pos += { x, y, z }; self->GetActor()->spr.pos += { x, y, z };
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpos, dukeplayer_addpos) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpos, dukeplayer_addpos)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_FLOAT(x); PARAM_FLOAT(x);
PARAM_FLOAT(y); PARAM_FLOAT(y);
PARAM_FLOAT(z); PARAM_FLOAT(z);
@ -1196,31 +1196,31 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpos, dukeplayer_addpos)
return 0; return 0;
} }
void dukeplayer_centerview(DukePlayer* self) void dukeplayer_centerview(DDukePlayer* self)
{ {
self->cmd.ucmd.actions |= SB_CENTERVIEW; self->cmd.ucmd.actions |= SB_CENTERVIEW;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, centerview, dukeplayer_centerview) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, centerview, dukeplayer_centerview)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
self->cmd.ucmd.actions |= SB_CENTERVIEW; self->cmd.ucmd.actions |= SB_CENTERVIEW;
return 0; return 0;
} }
inline int DukePlayer_PlayerInput(DukePlayer* pl, int bit) inline int DukePlayer_PlayerInput(DDukePlayer* pl, int bit)
{ {
return (!!((pl->cmd.ucmd.actions) & ESyncBits::FromInt(bit))); return (!!((pl->cmd.ucmd.actions) & ESyncBits::FromInt(bit)));
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerinput, DukePlayer_PlayerInput) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerinput, DukePlayer_PlayerInput)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(bit); PARAM_INT(bit);
ACTION_RETURN_INT(DukePlayer_PlayerInput(self, bit)); ACTION_RETURN_INT(DukePlayer_PlayerInput(self, bit));
} }
void dukeplayer_settargetangle(DukePlayer* self, double a, int backup) void dukeplayer_settargetangle(DDukePlayer* self, double a, int backup)
{ {
self->GetActor()->spr.Angles.Yaw = DAngle::fromDeg(a); self->GetActor()->spr.Angles.Yaw = DAngle::fromDeg(a);
if (backup) self->GetActor()->PrevAngles.Yaw = self->GetActor()->spr.Angles.Yaw; if (backup) self->GetActor()->PrevAngles.Yaw = self->GetActor()->spr.Angles.Yaw;
@ -1228,32 +1228,32 @@ void dukeplayer_settargetangle(DukePlayer* self, double a, int backup)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, settargetangle, dukeplayer_settargetangle) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, settargetangle, dukeplayer_settargetangle)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_FLOAT(a); PARAM_FLOAT(a);
PARAM_BOOL(bak); PARAM_BOOL(bak);
dukeplayer_settargetangle(self, a, bak); dukeplayer_settargetangle(self, a, bak);
return 0; return 0;
} }
double dukeplayer_angle(DukePlayer* self) double dukeplayer_angle(DDukePlayer* self)
{ {
return self->GetActor()->spr.Angles.Yaw.Degrees(); return self->GetActor()->spr.Angles.Yaw.Degrees();
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, angle, dukeplayer_angle) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, angle, dukeplayer_angle)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
ACTION_RETURN_FLOAT(dukeplayer_angle(self)); ACTION_RETURN_FLOAT(dukeplayer_angle(self));
} }
void dukeplayer_addpitch(DukePlayer* self, double a) void dukeplayer_addpitch(DDukePlayer* self, double a)
{ {
self->GetActor()->spr.Angles.Pitch += DAngle::fromDeg(a); self->GetActor()->spr.Angles.Pitch += DAngle::fromDeg(a);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpitch, dukeplayer_addpitch) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpitch, dukeplayer_addpitch)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_FLOAT(a); PARAM_FLOAT(a);
dukeplayer_addpitch(self, a); dukeplayer_addpitch(self, a);
return 0; return 0;
@ -1261,27 +1261,27 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpitch, dukeplayer_addpitch)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, clearcameras, clearcameras) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, clearcameras, clearcameras)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
clearcameras(self); clearcameras(self);
return 0; return 0;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, quickkill, quickkill) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, quickkill, quickkill)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
quickkill(self); quickkill(self);
return 0; return 0;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, CheckWeapRec, CheckWeapRec) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, CheckWeapRec, CheckWeapRec)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(ac, DDukeActor); PARAM_POINTER(ac, DDukeActor);
PARAM_BOOL(test); PARAM_BOOL(test);
ACTION_RETURN_INT(CheckWeapRec(self, ac, test)); ACTION_RETURN_INT(CheckWeapRec(self, ac, test));
} }
void DukePlayer_addammo(DukePlayer* p, int ammo, int amount) void DukePlayer_addammo(DDukePlayer* p, int ammo, int amount)
{ {
if ((unsigned)ammo >= MAX_WEAPONS) ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Ammo number out of range"); if ((unsigned)ammo >= MAX_WEAPONS) ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Ammo number out of range");
addammo(ammo, p, amount); addammo(ammo, p, amount);
@ -1289,14 +1289,14 @@ void DukePlayer_addammo(DukePlayer* p, int ammo, int amount)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addammo, DukePlayer_addammo) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addammo, DukePlayer_addammo)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(type); PARAM_INT(type);
PARAM_INT(amount); PARAM_INT(amount);
DukePlayer_addammo(self, type, amount); DukePlayer_addammo(self, type, amount);
return 0; return 0;
} }
void DukePlayer_addweapon(DukePlayer* p, int wpn, int switchit) void DukePlayer_addweapon(DDukePlayer* p, int wpn, int switchit)
{ {
if ((unsigned)wpn >= MAX_WEAPONS) ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Weapon number out of range"); if ((unsigned)wpn >= MAX_WEAPONS) ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Weapon number out of range");
fi.addweapon(p, wpn, switchit); fi.addweapon(p, wpn, switchit);
@ -1304,7 +1304,7 @@ void DukePlayer_addweapon(DukePlayer* p, int wpn, int switchit)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addweapon, DukePlayer_addweapon) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addweapon, DukePlayer_addweapon)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(type); PARAM_INT(type);
PARAM_INT(switchit); PARAM_INT(switchit);
DukePlayer_addweapon(self, type, switchit); DukePlayer_addweapon(self, type, switchit);
@ -1314,57 +1314,57 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addweapon, DukePlayer_addweapon)
DEFINE_ACTION_FUNCTION(_DukePlayer, hitablockingwall) DEFINE_ACTION_FUNCTION(_DukePlayer, hitablockingwall)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
walltype* pwal; walltype* pwal;
hitawall(self, &pwal); hitawall(self, &pwal);
ACTION_RETURN_BOOL(pwal && pwal->overtexture.isValid()); ACTION_RETURN_BOOL(pwal && pwal->overtexture.isValid());
} }
inline double DukePlayer_GetPitchwithView(DukePlayer* pl) inline double DukePlayer_GetPitchwithView(DDukePlayer* pl)
{ {
return pl->Angles.getPitchWithView().Degrees(); return pl->Angles.getPitchWithView().Degrees();
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, GetPitchwithView, DukePlayer_GetPitchwithView) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, GetPitchwithView, DukePlayer_GetPitchwithView)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
ACTION_RETURN_FLOAT(DukePlayer_GetPitchwithView(self)); ACTION_RETURN_FLOAT(DukePlayer_GetPitchwithView(self));
} }
inline void DukePlayer_setbobpos(DukePlayer* pl) inline void DukePlayer_setbobpos(DDukePlayer* pl)
{ {
return pl->setbobpos(); return pl->setbobpos();
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setbobpos, DukePlayer_setbobpos) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setbobpos, DukePlayer_setbobpos)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
self->setbobpos(); self->setbobpos();
return 0; return 0;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, StartMotorcycle, OnMotorcycle) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, StartMotorcycle, OnMotorcycle)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
OnMotorcycle(self); OnMotorcycle(self);
return 0; return 0;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, StartBoat, OnBoat) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, StartBoat, OnBoat)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
OnBoat(self); OnBoat(self);
return 0; return 0;
} }
void pl_checkhitswitch(DukePlayer* p, walltype* wal, DDukeActor* act) void pl_checkhitswitch(DDukePlayer* p, walltype* wal, DDukeActor* act)
{ {
checkhitswitch(p->GetPlayerNum(), wal, act); checkhitswitch(p->GetPlayerNum(), wal, act);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, checkhitswitch, pl_checkhitswitch) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, checkhitswitch, pl_checkhitswitch)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(wal, walltype); PARAM_POINTER(wal, walltype);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
pl_checkhitswitch(self, wal, act); pl_checkhitswitch(self, wal, act);
@ -1373,7 +1373,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, checkhitswitch, pl_checkhitswitch)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerkick, playerkick) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerkick, playerkick)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
playerkick(self, act); playerkick(self, act);
return 0; return 0;
@ -1381,7 +1381,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerkick, playerkick)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerstomp, playerstomp) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerstomp, playerstomp)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
playerstomp(self, act); playerstomp(self, act);
return 0; return 0;
@ -1389,7 +1389,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerstomp, playerstomp)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerreset, playerreset) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerreset, playerreset)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
playerreset(self, act); playerreset(self, act);
return 0; return 0;
@ -1397,7 +1397,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerreset, playerreset)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addphealth, addphealth) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addphealth, addphealth)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(amt); PARAM_INT(amt);
PARAM_INT(big); PARAM_INT(big);
addphealth(self, amt, big); addphealth(self, amt, big);
@ -1406,30 +1406,30 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addphealth, addphealth)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, wackplayer, wackplayer) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, wackplayer, wackplayer)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
wackplayer(self); wackplayer(self);
return 0; return 0;
} }
static void duke_checkweapons(DukePlayer* p) static void duke_checkweapons(DDukePlayer* p)
{ {
fi.checkweapons(p); fi.checkweapons(p);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, checkweapons, duke_checkweapons) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, checkweapons, duke_checkweapons)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
duke_checkweapons(self); duke_checkweapons(self);
return 0; return 0;
} }
static void msg(DukePlayer* p, int num) static void msg(DDukePlayer* p, int num)
{ {
FTA(num, p); FTA(num, p);
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, FTA, msg) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, FTA, msg)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(num); PARAM_INT(num);
FTA(num, self); FTA(num, self);
return 0; return 0;
@ -1437,7 +1437,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, FTA, msg)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playercheckinventory, playercheckinventory) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playercheckinventory, playercheckinventory)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
PARAM_INT(num); PARAM_INT(num);
PARAM_INT(amt); PARAM_INT(amt);
@ -1446,7 +1446,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playercheckinventory, playercheckinve
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddinventory, playeraddinventory) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddinventory, playeraddinventory)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_POINTER(act, DDukeActor); PARAM_POINTER(act, DDukeActor);
PARAM_INT(num); PARAM_INT(num);
PARAM_INT(amt); PARAM_INT(amt);
@ -1456,7 +1456,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddinventory, playeraddinventor
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddweapon, playeraddweapon) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddweapon, playeraddweapon)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(num); PARAM_INT(num);
PARAM_INT(amt); PARAM_INT(amt);
ACTION_RETURN_BOOL(playeraddweapon(self, num, amt)); ACTION_RETURN_BOOL(playeraddweapon(self, num, amt));
@ -1464,7 +1464,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddweapon, playeraddweapon)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddammo, playeraddammo) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddammo, playeraddammo)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(num); PARAM_INT(num);
PARAM_INT(amt); PARAM_INT(amt);
ACTION_RETURN_BOOL(playeraddammo(self, num, amt)); ACTION_RETURN_BOOL(playeraddammo(self, num, amt));
@ -1472,14 +1472,14 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playeraddammo, playeraddammo)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, forceplayerangle, forceplayerangle) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, forceplayerangle, forceplayerangle)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
forceplayerangle(self); forceplayerangle(self);
return 0; return 0;
} }
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playereat, playereat) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playereat, playereat)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(amt); PARAM_INT(amt);
PARAM_BOOL(big); PARAM_BOOL(big);
ACTION_RETURN_BOOL(playereat(self, amt, big)); ACTION_RETURN_BOOL(playereat(self, amt, big));
@ -1487,7 +1487,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playereat, playereat)
DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerdrink, playerdrink) DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, playerdrink, playerdrink)
{ {
PARAM_SELF_STRUCT_PROLOGUE(DukePlayer); PARAM_SELF_STRUCT_PROLOGUE(DDukePlayer);
PARAM_INT(amt); PARAM_INT(amt);
playerdrink(self, amt); playerdrink(self, amt);
return 0; return 0;
@ -1609,7 +1609,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, operateactivators, operateactivators)
{ {
PARAM_PROLOGUE; PARAM_PROLOGUE;
PARAM_INT(lotag); PARAM_INT(lotag);
PARAM_POINTER(p, DukePlayer); PARAM_POINTER(p, DDukePlayer);
operateactivators(lotag, p); operateactivators(lotag, p);
return 0; return 0;
} }

2
source/games/exhumed/src/aistuff.h
View file

@ -138,7 +138,7 @@ void SetNewWeaponIfBetter(int nPlayer, int nWeapon);
void SelectNewWeapon(int nPlayer); void SelectNewWeapon(int nPlayer);
void CheckClip(int nPlayer); void CheckClip(int nPlayer);
void MoveWeapons(int nPlayer); void MoveWeapons(int nPlayer);
void DrawWeapons(ExhumedPlayer* const pPlayer, double interpfrac); void DrawWeapons(DExhumedPlayer* const pPlayer, double interpfrac);
// items // items

12
source/games/exhumed/src/exhumed.cpp
View file

@ -58,6 +58,14 @@ IMPLEMENT_POINTERS_START(DExhumedActor)
IMPLEMENT_POINTER(pTarget) IMPLEMENT_POINTER(pTarget)
IMPLEMENT_POINTERS_END IMPLEMENT_POINTERS_END
IMPLEMENT_CLASS(DExhumedPlayer, false, true)
IMPLEMENT_POINTERS_START(DExhumedPlayer)
IMPLEMENT_POINTER(pTarget)
IMPLEMENT_POINTER(pDoppleSprite)
IMPLEMENT_POINTER(pPlayerFloorSprite)
IMPLEMENT_POINTER(pPlayerGrenade)
IMPLEMENT_POINTERS_END
size_t MarkMove(); size_t MarkMove();
size_t MarkBullets(); size_t MarkBullets();
size_t MarkItems(); size_t MarkItems();
@ -419,8 +427,8 @@ void GameInterface::app_init()
// Initialise player array. // Initialise player array.
for (unsigned i = 0; i < MAXPLAYERS; i++) for (unsigned i = 0; i < MAXPLAYERS; i++)
{ {
PlayerArray[i] = new ExhumedPlayer; PlayerArray[i] = Create<DExhumedPlayer>(i);
*getPlayer(i) = {}; GC::WriteBarrier(PlayerArray[i]);
} }
GC::AddMarkerFunc(markgcroots); GC::AddMarkerFunc(markgcroots);

2
source/games/exhumed/src/gun.cpp
View file

@ -902,7 +902,7 @@ loc_flag:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DrawWeapons(ExhumedPlayer* const pPlayer, double interpfrac) void DrawWeapons(DExhumedPlayer* const pPlayer, double interpfrac)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const int nWeapon = pPlayer->nCurrentWeapon; const int nWeapon = pPlayer->nCurrentWeapon;

115
source/games/exhumed/src/player.cpp
View file

@ -83,18 +83,6 @@ int nCurStartSprite;
size_t MarkPlayers() size_t MarkPlayers()
{ {
for (int i = 0; i < MAXPLAYERS; i++)
{
auto plr = getPlayer(i);
if (plr)
{
GC::Mark(plr->actor);
GC::Mark(plr->pDoppleSprite);
GC::Mark(plr->pPlayerFloorSprite);
GC::Mark(plr->pPlayerGrenade);
GC::Mark(plr->pTarget);
}
}
GC::MarkArray(nNetStartSprite, MAXPLAYERS); GC::MarkArray(nNetStartSprite, MAXPLAYERS);
return 6 * MAXPLAYERS; return 6 * MAXPLAYERS;
} }
@ -147,7 +135,7 @@ void InitPlayerKeys(int nPlayer)
void InitPlayerInventory(int nPlayer) void InitPlayerInventory(int nPlayer)
{ {
const auto pPlayer = getPlayer(nPlayer); const auto pPlayer = getPlayer(nPlayer);
memset(pPlayer, 0, sizeof(ExhumedPlayer)); pPlayer->Clear();
ResetPlayerWeapons(nPlayer); ResetPlayerWeapons(nPlayer);
@ -712,7 +700,7 @@ static DExhumedActor* feebtag(const DVector3& pos, sectortype* pSector, int nMag
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPickupNotification(ExhumedPlayer* const pPlayer, const int nItem, const int nSound = -1, const int tintRed = 0, const int tintGreen = 16) static void doPickupNotification(DExhumedPlayer* const pPlayer, const int nItem, const int nSound = -1, const int tintRed = 0, const int tintGreen = 16)
{ {
if (pPlayer->pnum != nLocalPlayer) if (pPlayer->pnum != nLocalPlayer)
return; return;
@ -758,7 +746,7 @@ static void doPickupDestroy(DExhumedActor* const pPickupActor, const int nItem)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPickupWeapon(ExhumedPlayer* pPlayer, DExhumedActor* pPickupActor, int nItem, int nWeapon, int nAmount, int nSound = kSound72) static void doPickupWeapon(DExhumedPlayer* pPlayer, DExhumedActor* pPickupActor, int nItem, int nWeapon, int nAmount, int nSound = kSound72)
{ {
const int weapFlag = 1 << nWeapon; const int weapFlag = 1 << nWeapon;
@ -796,7 +784,7 @@ static void doPickupWeapon(ExhumedPlayer* pPlayer, DExhumedActor* pPickupActor,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPickupHealth(ExhumedPlayer* pPlayer, DExhumedActor* pPickupActor, int nItem, const int nAmount, int nSound) static void doPickupHealth(DExhumedPlayer* pPlayer, DExhumedActor* pPickupActor, int nItem, const int nAmount, int nSound)
{ {
if (!pPickupActor->spr.hitag || nAmount > 0 && pPlayer->nHealth >= 800) if (!pPickupActor->spr.hitag || nAmount > 0 && pPlayer->nHealth >= 800)
return; return;
@ -844,7 +832,7 @@ static void doPickupHealth(ExhumedPlayer* pPlayer, DExhumedActor* pPickupActor,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void doPlayerItemPickups(ExhumedPlayer* const pPlayer) void doPlayerItemPickups(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pPlayerSect = pPlayerActor->sector(); const auto pPlayerSect = pPlayerActor->sector();
@ -1044,7 +1032,7 @@ void doPlayerItemPickups(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void updatePlayerTarget(ExhumedPlayer* const pPlayer) void updatePlayerTarget(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pRa = &Ra[pPlayer->pnum]; const auto pRa = &Ra[pPlayer->pnum];
@ -1107,7 +1095,7 @@ void updatePlayerTarget(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerVelocity(ExhumedPlayer* const pPlayer) static void updatePlayerVelocity(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
@ -1139,7 +1127,7 @@ static void updatePlayerVelocity(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerInventory(ExhumedPlayer* const pPlayer) static void updatePlayerInventory(DExhumedPlayer* const pPlayer)
{ {
if (const auto invDir = !!(pPlayer->cmd.ucmd.actions & SB_INVNEXT) - !!(pPlayer->cmd.ucmd.actions & SB_INVPREV)) if (const auto invDir = !!(pPlayer->cmd.ucmd.actions & SB_INVNEXT) - !!(pPlayer->cmd.ucmd.actions & SB_INVPREV))
{ {
@ -1181,7 +1169,7 @@ static void updatePlayerInventory(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerWeapon(ExhumedPlayer* const pPlayer) static void updatePlayerWeapon(DExhumedPlayer* const pPlayer)
{ {
const bool bIsFiring = pPlayer->cmd.ucmd.actions & SB_FIRE; const bool bIsFiring = pPlayer->cmd.ucmd.actions & SB_FIRE;
@ -1237,7 +1225,7 @@ unsigned GameInterface::getCrouchState()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerAction(ExhumedPlayer* const pPlayer) static void updatePlayerAction(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pInput = &pPlayer->cmd.ucmd; const auto pInput = &pPlayer->cmd.ucmd;
@ -1356,7 +1344,7 @@ static void updatePlayerAction(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerCounters(ExhumedPlayer* const pPlayer) static void doPlayerCounters(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const bool bConsolePlayer = pPlayer->pnum == nLocalPlayer; const bool bConsolePlayer = pPlayer->pnum == nLocalPlayer;
@ -1437,7 +1425,7 @@ static void doPlayerCounters(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerUnderwater(ExhumedPlayer* const pPlayer, const bool oUnderwater) static void doPlayerUnderwater(DExhumedPlayer* const pPlayer, const bool oUnderwater)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const bool bUnderwater = pPlayer->pPlayerViewSect->Flag & kSectUnderwater; const bool bUnderwater = pPlayer->pPlayerViewSect->Flag & kSectUnderwater;
@ -1527,7 +1515,7 @@ static void doPlayerUnderwater(ExhumedPlayer* const pPlayer, const bool oUnderwa
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerRamses(ExhumedPlayer* const pPlayer) static void doPlayerRamses(DExhumedPlayer* const pPlayer)
{ {
setForcedSyncInput(pPlayer->pnum); setForcedSyncInput(pPlayer->pnum);
@ -1571,7 +1559,7 @@ static void doPlayerGravity(DExhumedActor* const pPlayerActor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerCameraEffects(ExhumedPlayer* const pPlayer, const double nDestVertPan) static void doPlayerCameraEffects(DExhumedPlayer* const pPlayer, const double nDestVertPan)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto nUnderwater = !!(pPlayerActor->sector()->Flag & kSectUnderwater); const auto nUnderwater = !!(pPlayerActor->sector()->Flag & kSectUnderwater);
@ -1613,7 +1601,7 @@ static void doPlayerCameraEffects(ExhumedPlayer* const pPlayer, const double nDe
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerFloorActor(ExhumedPlayer* const pPlayer) static void updatePlayerFloorActor(DExhumedPlayer* const pPlayer)
{ {
DExhumedActor* const pFloorActor = pPlayer->pPlayerFloorSprite; DExhumedActor* const pFloorActor = pPlayer->pPlayerFloorSprite;
@ -1635,7 +1623,7 @@ static void updatePlayerFloorActor(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerDoppleActor(ExhumedPlayer* const pPlayer) static void updatePlayerDoppleActor(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pPlayerSect = pPlayerActor->sector(); const auto pPlayerSect = pPlayerActor->sector();
@ -1660,7 +1648,7 @@ static void updatePlayerDoppleActor(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void updatePlayerViewSector(ExhumedPlayer* const pPlayer, const Collision& nMove, const DVector3& spr_vel) static void updatePlayerViewSector(DExhumedPlayer* const pPlayer, const Collision& nMove, const DVector3& spr_vel)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pPlayerSect = pPlayerActor->sector(); const auto pPlayerSect = pPlayerActor->sector();
@ -1699,7 +1687,7 @@ static void updatePlayerViewSector(ExhumedPlayer* const pPlayer, const Collision
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerFloorDamage(ExhumedPlayer* const pPlayer, const double nStartVelZ) static void doPlayerFloorDamage(DExhumedPlayer* const pPlayer, const double nStartVelZ)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
pPlayer->nThrust *= 0.5; pPlayer->nThrust *= 0.5;
@ -1728,7 +1716,7 @@ static void doPlayerFloorDamage(ExhumedPlayer* const pPlayer, const double nStar
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerMovingBlocks(ExhumedPlayer* const pPlayer, const Collision& nMove, const DVector3& spr_vel, sectortype* const spr_sect) static void doPlayerMovingBlocks(DExhumedPlayer* const pPlayer, const Collision& nMove, const DVector3& spr_vel, sectortype* const spr_sect)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
sectortype* sect; sectortype* sect;
@ -1786,7 +1774,7 @@ static void doPlayerMovingBlocks(ExhumedPlayer* const pPlayer, const Collision&
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool doPlayerInput(ExhumedPlayer* const pPlayer) static bool doPlayerInput(DExhumedPlayer* const pPlayer)
{ {
// update the player/actor's velocity before anything. // update the player/actor's velocity before anything.
updatePlayerVelocity(pPlayer); updatePlayerVelocity(pPlayer);
@ -1878,7 +1866,7 @@ static bool doPlayerInput(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerRunlistSignals(ExhumedPlayer* const pPlayer, sectortype* const pStartSect) static void doPlayerRunlistSignals(DExhumedPlayer* const pPlayer, sectortype* const pStartSect)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
const auto pPlayerSect = pPlayerActor->sector(); const auto pPlayerSect = pPlayerActor->sector();
@ -1917,7 +1905,7 @@ static void doPlayerRunlistSignals(ExhumedPlayer* const pPlayer, sectortype* con
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static bool doPlayerDeathRestart(ExhumedPlayer* const pPlayer) static bool doPlayerDeathRestart(DExhumedPlayer* const pPlayer)
{ {
if (!(pPlayer->cmd.ucmd.actions & SB_OPEN) || pPlayer->GetActor()->nAction < 16) if (!(pPlayer->cmd.ucmd.actions & SB_OPEN) || pPlayer->GetActor()->nAction < 16)
return true; return true;
@ -1963,7 +1951,7 @@ static bool doPlayerDeathRestart(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerActionSequence(ExhumedPlayer* const pPlayer) static void doPlayerActionSequence(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
@ -2018,7 +2006,7 @@ static void doPlayerActionSequence(ExhumedPlayer* const pPlayer)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void doPlayerDeathPitch(ExhumedPlayer* const pPlayer) static void doPlayerDeathPitch(DExhumedPlayer* const pPlayer)
{ {
const auto pPlayerActor = pPlayer->GetActor(); const auto pPlayerActor = pPlayer->GetActor();
pPlayer->nThrust.Zero(); pPlayer->nThrust.Zero();
@ -2107,7 +2095,7 @@ void AIPlayer::Tick(RunListEvent* ev)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
FSerializer& Serialize(FSerializer& arc, const char* keyname, ExhumedPlayer& w, ExhumedPlayer* def) FSerializer& Serialize(FSerializer& arc, const char* keyname, DExhumedPlayer& w, DExhumedPlayer* def)
{ {
if (arc.BeginObject(keyname)) if (arc.BeginObject(keyname))
{ {
@ -2199,29 +2187,29 @@ void SerializePlayer(FSerializer& arc)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nHealth); DEFINE_FIELD(DExhumedPlayer, actor)
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nLives); DEFINE_FIELD(DExhumedPlayer, nHealth);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nDouble); DEFINE_FIELD(DExhumedPlayer, nLives);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nInvisible); DEFINE_FIELD(DExhumedPlayer, nDouble);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nTorch); DEFINE_FIELD(DExhumedPlayer, nInvisible);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, actor); DEFINE_FIELD(DExhumedPlayer, nTorch);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, bIsMummified); DEFINE_FIELD(DExhumedPlayer, bIsMummified);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, invincibility); DEFINE_FIELD(DExhumedPlayer, invincibility);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nAir); DEFINE_FIELD(DExhumedPlayer, nAir);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nMaskAmount); DEFINE_FIELD(DExhumedPlayer, nMaskAmount);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, keys); DEFINE_FIELD(DExhumedPlayer, keys);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nMagic); DEFINE_FIELD(DExhumedPlayer, nMagic);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nItem); DEFINE_FIELD(DExhumedPlayer, nItem);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, items); DEFINE_FIELD(DExhumedPlayer, items);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nAmmo); // TODO - kMaxWeapons? DEFINE_FIELD(DExhumedPlayer, nAmmo); // TODO - kMaxWeapons?
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nPlayerWeapons); DEFINE_FIELD(DExhumedPlayer, nPlayerWeapons);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nCurrentWeapon); DEFINE_FIELD(DExhumedPlayer, nCurrentWeapon);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nWeapFrame); DEFINE_FIELD(DExhumedPlayer, nWeapFrame);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, bIsFiring); DEFINE_FIELD(DExhumedPlayer, bIsFiring);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nNextWeapon); DEFINE_FIELD(DExhumedPlayer, nNextWeapon);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nState); DEFINE_FIELD(DExhumedPlayer, nState);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nLastWeapon); DEFINE_FIELD(DExhumedPlayer, nLastWeapon);
DEFINE_FIELD_X(ExhumedPlayer, ExhumedPlayer, nRun); DEFINE_FIELD(DExhumedPlayer, nRun);
DEFINE_ACTION_FUNCTION(_Exhumed, GetViewPlayer) DEFINE_ACTION_FUNCTION(_Exhumed, GetViewPlayer)
{ {
@ -2240,14 +2228,13 @@ DEFINE_ACTION_FUNCTION(_Exhumed, GetPlayerClip)
DEFINE_ACTION_FUNCTION(_ExhumedPlayer, IsUnderwater) DEFINE_ACTION_FUNCTION(_ExhumedPlayer, IsUnderwater)
{ {
PARAM_SELF_STRUCT_PROLOGUE(ExhumedPlayer); PARAM_SELF_STRUCT_PROLOGUE(DExhumedPlayer);
auto nLocalPlayer = self - (ExhumedPlayer*)PlayerArray; ACTION_RETURN_BOOL(self->pPlayerViewSect->Flag & kSectUnderwater);
ACTION_RETURN_BOOL(getPlayer((int)nLocalPlayer)->pPlayerViewSect->Flag & kSectUnderwater);
} }
DEFINE_ACTION_FUNCTION(_ExhumedPlayer, GetAngle) DEFINE_ACTION_FUNCTION(_ExhumedPlayer, GetAngle)
{ {
PARAM_SELF_STRUCT_PROLOGUE(ExhumedPlayer); PARAM_SELF_STRUCT_PROLOGUE(DExhumedPlayer);
ACTION_RETURN_INT(self->GetActor()->spr.Angles.Yaw.Buildang()); ACTION_RETURN_INT(self->GetActor()->spr.Angles.Yaw.Buildang());
} }

22
source/games/exhumed/src/player.h
View file

@ -47,8 +47,20 @@ struct PlayerSave
DAngle nAngle; DAngle nAngle;
}; };
struct ExhumedPlayer final : public CorePlayer class DExhumedPlayer final : public DCorePlayer
{ {
DECLARE_CLASS(DExhumedPlayer, DCorePlayer)
HAS_OBJECT_POINTERS
DExhumedPlayer() = default;
public:
DExhumedPlayer(uint8_t p) : DCorePlayer(p) {}
void Clear()
{
Super::Clear();
// Quick'n dirty clear
memset(&nHealth, 0, sizeof(DExhumedPlayer) - myoffsetof(DExhumedPlayer, nHealth));
}
int16_t nHealth; int16_t nHealth;
int16_t nLives; int16_t nLives;
int16_t nDouble; int16_t nDouble;
@ -116,9 +128,9 @@ struct ExhumedPlayer final : public CorePlayer
extern int PlayerCount; extern int PlayerCount;
inline ExhumedPlayer* getPlayer(int index) inline DExhumedPlayer* getPlayer(int index)
{ {
return static_cast<ExhumedPlayer*>(PlayerArray[index]); return static_cast<DExhumedPlayer*>(PlayerArray[index]);
} }
extern TObjPtr<DExhumedActor*> nNetStartSprite[kMaxPlayers]; extern TObjPtr<DExhumedActor*> nNetStartSprite[kMaxPlayers];
@ -129,9 +141,9 @@ int GetPlayerFromActor(DExhumedActor* actor);
void SetPlayerMummified(int nPlayer, int bIsMummified); void SetPlayerMummified(int nPlayer, int bIsMummified);
int AddAmmo(int nPlayer, int nWeapon, int nAmmoAmount); int AddAmmo(int nPlayer, int nWeapon, int nAmmoAmount);
void ShootStaff(int nPlayer); void ShootStaff(int nPlayer);
void updatePlayerTarget(ExhumedPlayer* const pPlayer); void updatePlayerTarget(DExhumedPlayer* const pPlayer);
inline void doPlayerVertPanning(ExhumedPlayer* const pPlayer, const double nDestVertPan) inline void doPlayerVertPanning(DExhumedPlayer* const pPlayer, const double nDestVertPan)
{ {
const auto nVertPan = (nDestVertPan - pPlayer->Angles.ViewAngles.Pitch.Tan() * 128) * 0.25; const auto nVertPan = (nDestVertPan - pPlayer->Angles.ViewAngles.Pitch.Tan() * 128) * 0.25;
pPlayer->Angles.ViewAngles.Pitch += maphoriz(abs(nVertPan) >= 4 ? Sgn(nVertPan) * 4. : nVertPan * 2.); pPlayer->Angles.ViewAngles.Pitch += maphoriz(abs(nVertPan) >= 4 ? Sgn(nVertPan) * 4. : nVertPan * 2.);

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

@ -238,7 +238,7 @@ int CanHitPlayer(DSWActor* actor)
int DoActorPickClosePlayer(DSWActor* actor) int DoActorPickClosePlayer(DSWActor* actor)
{ {
int pnum; int pnum;
SWPlayer* pp; DSWPlayer* pp;
// if actor can still see the player // if actor can still see the player
bool found = false; bool found = false;
int i; int i;
@ -362,7 +362,7 @@ TARGETACTOR:
DSWActor* GetPlayerSpriteNum(DSWActor* actor) DSWActor* GetPlayerSpriteNum(DSWActor* actor)
{ {
int pnum; int pnum;
SWPlayer* pp; DSWPlayer* pp;
TRAVERSE_CONNECT(pnum) TRAVERSE_CONNECT(pnum)
{ {

2
source/games/sw/src/bunny.cpp
View file

@ -993,7 +993,7 @@ int DoBunnyQuickJump(DSWActor* actor)
{ {
if ((hitActor->spr.extra & SPRX_PLAYER_OR_ENEMY)) if ((hitActor->spr.extra & SPRX_PLAYER_OR_ENEMY))
{ {
SWPlayer* pp = nullptr; DSWPlayer* pp = nullptr;
if (RandomRange(1000) < 995 && hitActor->user.spal != PALETTE_PLAYER0) return false; if (RandomRange(1000) < 995 && hitActor->user.spal != PALETTE_PLAYER0) return false;

8
source/games/sw/src/cheats.cpp
View file

@ -51,7 +51,7 @@ extern bool FAF_DebugView;
extern bool ToggleFlyMode; extern bool ToggleFlyMode;
const char *CheatKeyType; const char *CheatKeyType;
void KeysCheat(SWPlayer* pp, const char *cheat_string); void KeysCheat(DSWPlayer* pp, const char *cheat_string);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -59,7 +59,7 @@ void KeysCheat(SWPlayer* pp, const char *cheat_string);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static SWPlayer* checkCheat(cheatseq_t* c) static DSWPlayer* checkCheat(cheatseq_t* c)
{ {
if (::CheckCheatmode(true, true)) return nullptr; if (::CheckCheatmode(true, true)) return nullptr;
return getPlayer(screenpeek); return getPlayer(screenpeek);
@ -142,7 +142,7 @@ bool PrevCheat(cheatseq_t* c)
bool MapCheat(cheatseq_t* c) bool MapCheat(cheatseq_t* c)
{ {
SWPlayer* pp; DSWPlayer* pp;
if (!(pp=checkCheat(c))) return false; if (!(pp=checkCheat(c))) return false;
gFullMap = !gFullMap; gFullMap = !gFullMap;
// Need to do this differently. The code here was completely broken. // Need to do this differently. The code here was completely broken.
@ -158,7 +158,7 @@ bool MapCheat(cheatseq_t* c)
bool WarpCheat(cheatseq_t* c) bool WarpCheat(cheatseq_t* c)
{ {
SWPlayer* pp; DSWPlayer* pp;
if (!(pp = checkCheat(c))) return false; if (!(pp = checkCheat(c))) return false;
int level_num; int level_num;

2
source/games/sw/src/d_menu.cpp
View file

@ -97,7 +97,7 @@ bool GameInterface::CanSave()
bool GameInterface::StartGame(FNewGameStartup& gs) bool GameInterface::StartGame(FNewGameStartup& gs)
{ {
SWPlayer* pp = getPlayer(screenpeek); DSWPlayer* pp = getPlayer(screenpeek);
int handle = 0; int handle = 0;
int zero = 0; int zero = 0;

16
source/games/sw/src/draw.cpp
View file

@ -608,7 +608,7 @@ static void analyzesprites(tspriteArray& tsprites, const DVector3& viewpos, doub
{ {
int tSpriteNum; int tSpriteNum;
static int ang = 0; static int ang = 0;
SWPlayer* pp = getPlayer(screenpeek); DSWPlayer* pp = getPlayer(screenpeek);
int newshade=0; int newshade=0;
const int DART_PIC = 2526; const int DART_PIC = 2526;
@ -966,7 +966,7 @@ void post_analyzesprites(tspriteArray& tsprites)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PrintSpriteInfo(SWPlayer* pp) void PrintSpriteInfo(DSWPlayer* pp)
{ {
const int Y_STEP = 7; const int Y_STEP = 7;
@ -1010,7 +1010,7 @@ void PrintSpriteInfo(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void DrawCrosshair(SWPlayer* pp, const double interpfrac) static void DrawCrosshair(DSWPlayer* pp, const double interpfrac)
{ {
auto offsets = pp->Angles.getCrosshairOffsets(interpfrac); auto offsets = pp->Angles.getCrosshairOffsets(interpfrac);
::DrawCrosshair(pp->GetActor()->user.Health, offsets.first.X, offsets.first.Y + ((pp->Flags & PF_VIEW_FROM_OUTSIDE) ? 5 : 0), 2, offsets.second, shadeToLight(10)); ::DrawCrosshair(pp->GetActor()->user.Health, offsets.first.X, offsets.first.Y + ((pp->Flags & PF_VIEW_FROM_OUTSIDE) ? 5 : 0), 2, offsets.second, shadeToLight(10));
@ -1111,7 +1111,7 @@ void PreDrawStackedWater(void)
} }
void DoPlayerDiveMeter(SWPlayer* pp); void DoPlayerDiveMeter(DSWPlayer* pp);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -1212,10 +1212,14 @@ void RestorePortalState()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void drawscreen(SWPlayer* pp, double interpfrac, bool sceneonly) void drawscreen(DSWPlayer* pp, double interpfrac, bool sceneonly)
{ {
#if 0
// prediction player if prediction is on, else regular player // prediction player if prediction is on, else regular player
SWPlayer* camerapp = (PredictionOn && CommEnabled && pp == getPlayer(myconnectindex)) ? ppp : pp; DSWPlayer* camerapp = (PredictionOn && CommEnabled && pp == getPlayer(myconnectindex)) ? ppp : pp;
#else
DSWPlayer* camerapp = pp;
#endif
PreDraw(); PreDraw();
PreUpdatePanel(interpfrac); PreUpdatePanel(interpfrac);

37
source/games/sw/src/game.cpp
View file

@ -97,7 +97,6 @@ IMPLEMENT_CLASS(DSWActor, false, true)
IMPLEMENT_POINTERS_START(DSWActor) IMPLEMENT_POINTERS_START(DSWActor)
IMPLEMENT_POINTER(ownerActor) IMPLEMENT_POINTER(ownerActor)
IMPLEMENT_POINTER(user.lowActor) IMPLEMENT_POINTER(user.lowActor)
IMPLEMENT_POINTER(user.lowActor)
IMPLEMENT_POINTER(user.highActor) IMPLEMENT_POINTER(user.highActor)
IMPLEMENT_POINTER(user.targetActor) IMPLEMENT_POINTER(user.targetActor)
IMPLEMENT_POINTER(user.flameActor) IMPLEMENT_POINTER(user.flameActor)
@ -105,6 +104,17 @@ IMPLEMENT_POINTER(user.attachActor)
IMPLEMENT_POINTER(user.WpnGoalActor) IMPLEMENT_POINTER(user.WpnGoalActor)
IMPLEMENT_POINTERS_END IMPLEMENT_POINTERS_END
IMPLEMENT_CLASS(DSWPlayer, false, true)
IMPLEMENT_POINTERS_START(DSWPlayer)
IMPLEMENT_POINTER(remoteActor)
IMPLEMENT_POINTER(lowActor)
IMPLEMENT_POINTER(highActor)
IMPLEMENT_POINTER(PlayerUnderActor)
IMPLEMENT_POINTER(KillerActor)
IMPLEMENT_POINTER(HitBy)
IMPLEMENT_POINTER(last_camera_act)
IMPLEMENT_POINTERS_END
void MarkSOInterp(); void MarkSOInterp();
extern int FinishTimer; extern int FinishTimer;
@ -118,21 +128,6 @@ void markgcroots()
GC::MarkArray(GenericQueue, MAX_GENERIC_QUEUE); GC::MarkArray(GenericQueue, MAX_GENERIC_QUEUE);
GC::MarkArray(LoWangsQueue, MAX_LOWANGS_QUEUE); GC::MarkArray(LoWangsQueue, MAX_LOWANGS_QUEUE);
GC::MarkArray(BossSpriteNum, 3); GC::MarkArray(BossSpriteNum, 3);
for (int i = 0; i < MAXPLAYERS; i++)
{
auto plr = getPlayer(i);
if (plr)
{
GC::Mark(plr->actor);
GC::Mark(plr->lowActor);
GC::Mark(plr->highActor);
GC::Mark(plr->remoteActor);
GC::Mark(plr->PlayerUnderActor);
GC::Mark(plr->KillerActor);
GC::Mark(plr->HitBy);
GC::Mark(plr->last_camera_act);
}
}
for (auto& so : SectorObject) for (auto& so : SectorObject)
{ {
GC::Mark(so.controller); GC::Mark(so.controller);
@ -152,7 +147,7 @@ void markgcroots()
} }
void pClearSpriteList(SWPlayer* pp); void pClearSpriteList(DSWPlayer* pp);
int GameVersion = 20; int GameVersion = 20;
@ -257,8 +252,8 @@ void GameInterface::app_init()
// Initialise player array. // Initialise player array.
for (unsigned i = 0; i < MAXPLAYERS; i++) for (unsigned i = 0; i < MAXPLAYERS; i++)
{ {
PlayerArray[i] = new SWPlayer; PlayerArray[i] = Create<DSWPlayer>(i);
*getPlayer(i) = {}; GC::WriteBarrier(PlayerArray[i]);
} }
// these are frequently checked markers. // these are frequently checked markers.
@ -425,7 +420,7 @@ void InitLevel(MapRecord *maprec)
// don't jack with the playerreadyflag // don't jack with the playerreadyflag
int ready_bak = getPlayer(i)->playerreadyflag; int ready_bak = getPlayer(i)->playerreadyflag;
int ver_bak = getPlayer(i)->PlayerVersion; int ver_bak = getPlayer(i)->PlayerVersion;
*getPlayer(i) = {}; getPlayer(i)->Clear();
getPlayer(i)->playerreadyflag = ready_bak; getPlayer(i)->playerreadyflag = ready_bak;
getPlayer(i)->PlayerVersion = ver_bak; getPlayer(i)->PlayerVersion = ver_bak;
INITLIST(&getPlayer(i)->PanelSpriteList); INITLIST(&getPlayer(i)->PanelSpriteList);
@ -583,7 +578,7 @@ void TerminateLevel(void)
TRAVERSE_CONNECT(pnum) TRAVERSE_CONNECT(pnum)
{ {
SWPlayer* pp = getPlayer(pnum); DSWPlayer* pp = getPlayer(pnum);
if (pp->Flags & PF_DEAD) if (pp->Flags & PF_DEAD)
PlayerDeathReset(pp); PlayerDeathReset(pp);

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

@ -327,7 +327,7 @@ enum dam
// Forward declarations // Forward declarations
struct STATE; struct STATE;
struct PANEL_STATE; struct PANEL_STATE;
struct SWPlayer; class DSWPlayer;
struct PERSONALITY; struct PERSONALITY;
struct ATTRIBUTE; struct ATTRIBUTE;
struct SECTOR_OBJECT; struct SECTOR_OBJECT;
@ -427,7 +427,7 @@ enum
struct DAMAGE_DATA struct DAMAGE_DATA
{ {
void (*Init)(SWPlayer*); void (*Init)(DSWPlayer*);
int16_t damage_lo; int16_t damage_lo;
int16_t damage_hi; int16_t damage_hi;
unsigned int radius; unsigned int radius;
@ -444,24 +444,24 @@ extern DAMAGE_DATA DamageData[];
extern int WeaponHasNoAmmo, WeaponIsAmmo; extern int WeaponHasNoAmmo, WeaponIsAmmo;
void InitWeaponFist(SWPlayer*); void InitWeaponFist(DSWPlayer*);
void InitWeaponStar(SWPlayer*); void InitWeaponStar(DSWPlayer*);
void InitWeaponShotgun(SWPlayer*); void InitWeaponShotgun(DSWPlayer*);
void InitWeaponRocket(SWPlayer*); void InitWeaponRocket(DSWPlayer*);
void InitWeaponRail(SWPlayer*); void InitWeaponRail(DSWPlayer*);
void InitWeaponMicro(SWPlayer*); void InitWeaponMicro(DSWPlayer*);
void InitWeaponUzi(SWPlayer*); void InitWeaponUzi(DSWPlayer*);
void InitWeaponSword(SWPlayer*); void InitWeaponSword(DSWPlayer*);
void InitWeaponHothead(SWPlayer*); void InitWeaponHothead(DSWPlayer*);
void InitWeaponElectro(SWPlayer*); void InitWeaponElectro(DSWPlayer*);
void InitWeaponHeart(SWPlayer*); void InitWeaponHeart(DSWPlayer*);
void InitWeaponGrenade(SWPlayer*); void InitWeaponGrenade(DSWPlayer*);
void InitWeaponMine(SWPlayer*); void InitWeaponMine(DSWPlayer*);
void InitWeaponNapalm(SWPlayer*); void InitWeaponNapalm(DSWPlayer*);
void InitWeaponRing(SWPlayer*); void InitWeaponRing(DSWPlayer*);
extern void (*InitWeapon[MAX_WEAPONS]) (SWPlayer*); extern void (*InitWeapon[MAX_WEAPONS]) (DSWPlayer*);
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// //
@ -525,7 +525,7 @@ enum PlayerDeathTypes
PLAYER_DEATH_FLIP, PLAYER_DEATH_CRUMBLE, PLAYER_DEATH_EXPLODE, PLAYER_DEATH_RIPPER, PLAYER_DEATH_SQUISH, PLAYER_DEATH_DROWN, MAX_PLAYER_DEATHS PLAYER_DEATH_FLIP, PLAYER_DEATH_CRUMBLE, PLAYER_DEATH_EXPLODE, PLAYER_DEATH_RIPPER, PLAYER_DEATH_SQUISH, PLAYER_DEATH_DROWN, MAX_PLAYER_DEATHS
}; };
typedef void (*PLAYER_ACTION_FUNCp)(SWPlayer*); typedef void (*PLAYER_ACTION_FUNCp)(DSWPlayer*);
#include "inv.h" #include "inv.h"
@ -755,7 +755,7 @@ struct USER
// if a player's sprite points to player structure // if a player's sprite points to player structure
SWPlayer* PlayerP; DSWPlayer* PlayerP;
int16_t Sibling; int16_t Sibling;
@ -1413,10 +1413,10 @@ enum
short SoundAngle(int x, int y); short SoundAngle(int x, int y);
//void PlaySound(int num, short angle, short vol); //void PlaySound(int num, short angle, short vol);
int _PlaySound(FSoundID num, DSWActor* sprite, SWPlayer* player, const DVector3 *const pos, int flags, int channel, EChanFlags sndflags); int _PlaySound(FSoundID num, DSWActor* sprite, DSWPlayer* player, const DVector3 *const pos, int flags, int channel, EChanFlags sndflags);
void InitAmbient(int num, DSWActor* actor); void InitAmbient(int num, DSWActor* actor);
inline void PlaySound(int num, SWPlayer* player, int flags, int channel = 8, EChanFlags sndflags = CHANF_NONE) inline void PlaySound(int num, DSWPlayer* player, int flags, int channel = 8, EChanFlags sndflags = CHANF_NONE)
{ {
_PlaySound(soundEngine->FindSoundByResID(num), nullptr, player, nullptr, flags | v3df_follow, channel, sndflags); _PlaySound(soundEngine->FindSoundByResID(num), nullptr, player, nullptr, flags | v3df_follow, channel, sndflags);
} }
@ -1429,20 +1429,20 @@ inline void PlaySound(int num, const DVector3 &pos, int flags, int channel = 8,
_PlaySound(soundEngine->FindSoundByResID(num), nullptr, nullptr, &pos, flags, channel, sndflags); _PlaySound(soundEngine->FindSoundByResID(num), nullptr, nullptr, &pos, flags, channel, sndflags);
} }
int _PlayerSound(int num, SWPlayer* pp); int _PlayerSound(int num, DSWPlayer* pp);
inline int PlayerSound(int num, int flags, SWPlayer* pp) { return _PlayerSound(num, pp); } inline int PlayerSound(int num, int flags, DSWPlayer* pp) { return _PlayerSound(num, pp); }
void StopPlayerSound(SWPlayer* pp, int which = -1); void StopPlayerSound(DSWPlayer* pp, int which = -1);
bool SoundValidAndActive(DSWActor* spr, int channel); bool SoundValidAndActive(DSWActor* spr, int channel);
struct BREAK_INFO; struct BREAK_INFO;
int SpawnShrap(DSWActor*, DSWActor*, int = -1, BREAK_INFO* breakinfo = nullptr); int SpawnShrap(DSWActor*, DSWActor*, int = -1, BREAK_INFO* breakinfo = nullptr);
void PlayerUpdateHealth(SWPlayer* pp, short value); void PlayerUpdateHealth(DSWPlayer* pp, short value);
void PlayerUpdateAmmo(SWPlayer* pp, short WeaponNum, short value); void PlayerUpdateAmmo(DSWPlayer* pp, short WeaponNum, short value);
void PlayerUpdateWeapon(SWPlayer* pp, short WeaponNum); void PlayerUpdateWeapon(DSWPlayer* pp, short WeaponNum);
void PlayerUpdateKills(SWPlayer* pp, short value); void PlayerUpdateKills(DSWPlayer* pp, short value);
void RefreshInfoLine(SWPlayer* pp); void RefreshInfoLine(DSWPlayer* pp);
void DoAnim(int numtics); void DoAnim(int numtics);
void AnimDelete(int animtype, int animindex, DSWActor*); void AnimDelete(int animtype, int animindex, DSWActor*);
@ -1571,8 +1571,8 @@ extern int16_t StatDamageList[STAT_DAMAGE_LIST_SIZE];
// //
/////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////
extern void SetFadeAmt(SWPlayer* pp, short damage, uint8_t startcolor); extern void SetFadeAmt(DSWPlayer* pp, short damage, uint8_t startcolor);
extern void DoPaletteFlash(SWPlayer* pp); extern void DoPaletteFlash(DSWPlayer* pp);
extern bool NightVision; extern bool NightVision;
@ -1608,9 +1608,9 @@ void InitSetup(void); // setup.c
void LoadKVXFromScript(TilesetBuildInfo& info, const char *filename); // scrip2.c void LoadKVXFromScript(TilesetBuildInfo& info, const char *filename); // scrip2.c
void LoadCustomInfoFromScript(const char *filename); // scrip2.c void LoadCustomInfoFromScript(const char *filename); // scrip2.c
int PlayerInitChemBomb(SWPlayer* pp); // jweapon.c int PlayerInitChemBomb(DSWPlayer* pp); // jweapon.c
int PlayerInitFlashBomb(SWPlayer* pp); // jweapon.c int PlayerInitFlashBomb(DSWPlayer* pp); // jweapon.c
int PlayerInitCaltrops(SWPlayer* pp); // jweapon.c int PlayerInitCaltrops(DSWPlayer* pp); // jweapon.c
int InitPhosphorus(DSWActor*); // jweapon.c int InitPhosphorus(DSWActor*); // jweapon.c
void SpawnFloorSplash(DSWActor*); // jweapon.c void SpawnFloorSplash(DSWActor*); // jweapon.c
@ -1676,9 +1676,20 @@ END_SW_NS
BEGIN_SW_NS BEGIN_SW_NS
struct SWPlayer final : public CorePlayer class DSWPlayer final : public DCorePlayer
{ {
DSWActor* actor; // this may not be a TObjPtr! DECLARE_CLASS(DSWPlayer, DCorePlayer)
HAS_OBJECT_POINTERS
DSWPlayer() = default;
public:
void Clear()
{
Super::Clear();
// Quick'n dirty clear
memset(&lowActor, 0, sizeof(DSWPlayer) - myoffsetof(DSWPlayer, lowActor));
}
DSWPlayer(uint8_t p) : DCorePlayer(p) {}
TObjPtr<DSWActor*> lowActor, highActor; TObjPtr<DSWActor*> lowActor, highActor;
TObjPtr<DSWActor*> remoteActor; TObjPtr<DSWActor*> remoteActor;
TObjPtr<DSWActor*> PlayerUnderActor; TObjPtr<DSWActor*> PlayerUnderActor;
@ -1854,9 +1865,9 @@ struct SWPlayer final : public CorePlayer
} }
}; };
inline SWPlayer* getPlayer(int index) inline DSWPlayer* getPlayer(int index)
{ {
return static_cast<SWPlayer*>(PlayerArray[index]); return static_cast<DSWPlayer*>(PlayerArray[index]);
} }
@ -1917,7 +1928,7 @@ inline bool SectorIsUnderwaterArea(sectortype* sect)
return sect && sect->extra & (SECTFX_UNDERWATER | SECTFX_UNDERWATER2); return sect && sect->extra & (SECTFX_UNDERWATER | SECTFX_UNDERWATER2);
} }
inline bool PlayerFacingRange(SWPlayer* pp, DSWActor* a, DAngle range) inline bool PlayerFacingRange(DSWPlayer* pp, DSWActor* a, DAngle range)
{ {
return absangle((a->spr.pos.XY() - pp->GetActor()->spr.pos.XY()).Angle(), pp->GetActor()->spr.Angles.Yaw) < range; return absangle((a->spr.pos.XY() - pp->GetActor()->spr.pos.XY()).Angle(), pp->GetActor()->spr.Angles.Yaw) < range;
} }
@ -2072,7 +2083,7 @@ inline bool SpriteInUnderwaterArea(DSWActor* a)
// just determine if the player is moving // just determine if the player is moving
inline bool PLAYER_MOVING(SWPlayer* pp) inline bool PLAYER_MOVING(DSWPlayer* pp)
{ {
return !pp->vect.isZero(); return !pp->vect.isZero();
} }

2
source/games/sw/src/hornet.cpp
View file

@ -551,7 +551,7 @@ int DoHornetDeath(DSWActor* actor)
int DoCheckSwarm(DSWActor* actor) int DoCheckSwarm(DSWActor* actor)
{ {
double dist, pdist; double dist, pdist;
SWPlayer* pp; DSWPlayer* pp;
if (!MoveSkip8) return 0; // Don't over check if (!MoveSkip8) return 0; // Don't over check

2
source/games/sw/src/input.cpp
View file

@ -70,7 +70,7 @@ enum
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void processWeapon(SWPlayer* const pp) void processWeapon(DSWPlayer* const pp)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
if (plActor == nullptr) return; if (plActor == nullptr) return;

72
source/games/sw/src/inv.cpp
View file

@ -44,28 +44,28 @@ BEGIN_SW_NS
extern short NormalVisibility; extern short NormalVisibility;
void PlayerUpdateInventory(SWPlayer* pp, short InventoryNum); void PlayerUpdateInventory(DSWPlayer* pp, short InventoryNum);
void InventoryUse(SWPlayer* pp); void InventoryUse(DSWPlayer* pp);
void InventoryStop(SWPlayer* pp, short InventoryNum); void InventoryStop(DSWPlayer* pp, short InventoryNum);
void UseInventoryRepairKit(SWPlayer* pp); void UseInventoryRepairKit(DSWPlayer* pp);
void UseInventoryMedkit(SWPlayer* pp); void UseInventoryMedkit(DSWPlayer* pp);
void UseInventoryRepairKit(SWPlayer* pp); void UseInventoryRepairKit(DSWPlayer* pp);
void UseInventoryCloak(SWPlayer* pp); void UseInventoryCloak(DSWPlayer* pp);
void UseInventoryEnvironSuit(SWPlayer* pp); void UseInventoryEnvironSuit(DSWPlayer* pp);
void UseInventoryNightVision(SWPlayer* pp); void UseInventoryNightVision(DSWPlayer* pp);
void UseInventoryChemBomb(SWPlayer* pp); void UseInventoryChemBomb(DSWPlayer* pp);
void UseInventoryFlashBomb(SWPlayer* pp); void UseInventoryFlashBomb(DSWPlayer* pp);
void UseInventoryCaltrops(SWPlayer* pp); void UseInventoryCaltrops(DSWPlayer* pp);
void StopInventoryRepairKit(SWPlayer* pp, short); void StopInventoryRepairKit(DSWPlayer* pp, short);
void StopInventoryMedkit(SWPlayer* pp, short); void StopInventoryMedkit(DSWPlayer* pp, short);
void StopInventoryRepairKit(SWPlayer* pp, short); void StopInventoryRepairKit(DSWPlayer* pp, short);
void StopInventoryCloak(SWPlayer* pp, short); void StopInventoryCloak(DSWPlayer* pp, short);
void StopInventoryEnvironSuit(SWPlayer* pp, short); void StopInventoryEnvironSuit(DSWPlayer* pp, short);
void StopInventoryNightVision(SWPlayer* pp, short); void StopInventoryNightVision(DSWPlayer* pp, short);
extern PANEL_STATE ps_PanelEnvironSuit[]; extern PANEL_STATE ps_PanelEnvironSuit[];
@ -96,14 +96,14 @@ void PanelInvTestSuicide(PANEL_SPRITE* psp)
} }
} }
void KillPanelInv(SWPlayer* pp, short InventoryNum) void KillPanelInv(DSWPlayer* pp, short InventoryNum)
{ {
ASSERT(InventoryNum < MAX_INVENTORY); ASSERT(InventoryNum < MAX_INVENTORY);
pp->InventoryTics[InventoryNum] = 0; pp->InventoryTics[InventoryNum] = 0;
} }
void KillAllPanelInv(SWPlayer* pp) void KillAllPanelInv(DSWPlayer* pp)
{ {
for (int i = 0; i < MAX_INVENTORY; i++) for (int i = 0; i < MAX_INVENTORY; i++)
{ {
@ -117,7 +117,7 @@ void KillAllPanelInv(SWPlayer* pp)
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void AutoPickInventory(SWPlayer* pp) void AutoPickInventory(DSWPlayer* pp)
{ {
int i; int i;
@ -149,7 +149,7 @@ void AutoPickInventory(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void UseInventoryMedkit(SWPlayer* pp) void UseInventoryMedkit(DSWPlayer* pp)
{ {
short diff; short diff;
short inv = INVENTORY_MEDKIT; short inv = INVENTORY_MEDKIT;
@ -196,7 +196,7 @@ void UseInventoryMedkit(SWPlayer* pp)
// CHEMICAL WARFARE CANISTERS // CHEMICAL WARFARE CANISTERS
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void UseInventoryChemBomb(SWPlayer* pp) void UseInventoryChemBomb(DSWPlayer* pp)
{ {
short inv = INVENTORY_CHEMBOMB; short inv = INVENTORY_CHEMBOMB;
@ -219,7 +219,7 @@ void UseInventoryChemBomb(SWPlayer* pp)
// FLASH BOMBS // FLASH BOMBS
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void UseInventoryFlashBomb(SWPlayer* pp) void UseInventoryFlashBomb(DSWPlayer* pp)
{ {
short inv = INVENTORY_FLASHBOMB; short inv = INVENTORY_FLASHBOMB;
@ -242,7 +242,7 @@ void UseInventoryFlashBomb(SWPlayer* pp)
// CALTROPS // CALTROPS
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void UseInventoryCaltrops(SWPlayer* pp) void UseInventoryCaltrops(DSWPlayer* pp)
{ {
short inv = INVENTORY_CALTROPS; short inv = INVENTORY_CALTROPS;
@ -266,7 +266,7 @@ void UseInventoryCaltrops(SWPlayer* pp)
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void UseInventoryRepairKit(SWPlayer* pp) void UseInventoryRepairKit(DSWPlayer* pp)
{ {
short inv = INVENTORY_REPAIR_KIT; short inv = INVENTORY_REPAIR_KIT;
@ -294,7 +294,7 @@ void UseInventoryRepairKit(SWPlayer* pp)
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void UseInventoryCloak(SWPlayer* pp) void UseInventoryCloak(DSWPlayer* pp)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
@ -319,7 +319,7 @@ void UseInventoryCloak(SWPlayer* pp)
PlayerSound(DIGI_IAMSHADOW, v3df_follow|v3df_dontpan,pp); PlayerSound(DIGI_IAMSHADOW, v3df_follow|v3df_dontpan,pp);
} }
void StopInventoryCloak(SWPlayer* pp, short InventoryNum) void StopInventoryCloak(DSWPlayer* pp, short InventoryNum)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
@ -347,7 +347,7 @@ void StopInventoryCloak(SWPlayer* pp, short InventoryNum)
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void DoPlayerNightVisionPalette(SWPlayer* pp) void DoPlayerNightVisionPalette(DSWPlayer* pp)
{ {
if (pp != getPlayer(screenpeek)) return; if (pp != getPlayer(screenpeek)) return;
@ -370,7 +370,7 @@ void DoPlayerNightVisionPalette(SWPlayer* pp)
} }
} }
void UseInventoryNightVision(SWPlayer* pp) void UseInventoryNightVision(DSWPlayer* pp)
{ {
if (pp->InventoryActive[pp->InventoryNum]) if (pp->InventoryActive[pp->InventoryNum])
{ {
@ -387,7 +387,7 @@ void UseInventoryNightVision(SWPlayer* pp)
PlaySound(DIGI_NIGHTON, pp, v3df_dontpan|v3df_follow); PlaySound(DIGI_NIGHTON, pp, v3df_dontpan|v3df_follow);
} }
void StopInventoryNightVision(SWPlayer* pp, short InventoryNum) void StopInventoryNightVision(DSWPlayer* pp, short InventoryNum)
{ {
pp->InventoryActive[InventoryNum] = false; pp->InventoryActive[InventoryNum] = false;
@ -414,7 +414,7 @@ void StopInventoryNightVision(SWPlayer* pp, short InventoryNum)
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void InventoryKeys(SWPlayer* pp) void InventoryKeys(DSWPlayer* pp)
{ {
// scroll SPELLs left // scroll SPELLs left
if (pp->cmd.ucmd.actions & SB_INVPREV) if (pp->cmd.ucmd.actions & SB_INVPREV)
@ -507,7 +507,7 @@ void InventoryKeys(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InventoryTimer(SWPlayer* pp) void InventoryTimer(DSWPlayer* pp)
{ {
// called every time through loop // called every time through loop
short inv = 0; short inv = 0;
@ -591,7 +591,7 @@ void InventoryTimer(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InventoryUse(SWPlayer* pp) void InventoryUse(DSWPlayer* pp)
{ {
INVENTORY_DATA* id = &InventoryData[pp->InventoryNum]; INVENTORY_DATA* id = &InventoryData[pp->InventoryNum];
@ -599,7 +599,7 @@ void InventoryUse(SWPlayer* pp)
(*id->Init)(pp); (*id->Init)(pp);
} }
void InventoryStop(SWPlayer* pp, short InventoryNum) void InventoryStop(DSWPlayer* pp, short InventoryNum)
{ {
INVENTORY_DATA* id = &InventoryData[InventoryNum]; INVENTORY_DATA* id = &InventoryData[InventoryNum];
@ -613,7 +613,7 @@ void InventoryStop(SWPlayer* pp, short InventoryNum)
// //
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
void PlayerUpdateInventory(SWPlayer* pp, short InventoryNum) void PlayerUpdateInventory(DSWPlayer* pp, short InventoryNum)
{ {
pp->InventoryNum = InventoryNum; pp->InventoryNum = InventoryNum;

12
source/games/sw/src/inv.h
View file

@ -39,8 +39,8 @@ enum InventoryNames
struct INVENTORY_DATA struct INVENTORY_DATA
{ {
const char* Name; const char* Name;
void (*Init)(SWPlayer*); void (*Init)(DSWPlayer*);
void (*Stop)(SWPlayer*, short); void (*Stop)(DSWPlayer*, short);
short DecPerSec; short DecPerSec;
short MaxInv; short MaxInv;
int Scale; int Scale;
@ -56,7 +56,7 @@ enum EInvFlags
INVF_COUNT = 4 INVF_COUNT = 4
}; };
void PlayerUpdateInventory(SWPlayer* pp, short InventoryNum); void PlayerUpdateInventory(DSWPlayer* pp, short InventoryNum);
void InventoryKeys(SWPlayer* pp); void InventoryKeys(DSWPlayer* pp);
void UseInventoryRepairKit(SWPlayer* pp); void UseInventoryRepairKit(DSWPlayer* pp);
void InventoryTimer(SWPlayer* pp); void InventoryTimer(DSWPlayer* pp);

10
source/games/sw/src/jsector.cpp
View file

@ -376,7 +376,7 @@ void drawroomstotile(const DVector3& pos, DAngle ang, DAngle horiz, sectortype*
void JS_ProcessEchoSpot() void JS_ProcessEchoSpot()
{ {
SWPlayer* pp = getPlayer(screenpeek); DSWPlayer* pp = getPlayer(screenpeek);
int16_t reverb; int16_t reverb;
bool reverb_set = false; bool reverb_set = false;
@ -417,7 +417,7 @@ short camplayerview = 1; // Don't show yourself!
// Hack job alert! // Hack job alert!
// Mirrors and cameras are maintained in the same data structure, but for hardware rendering they cannot be interleaved. // Mirrors and cameras are maintained in the same data structure, but for hardware rendering they cannot be interleaved.
// So this function replicates JS_DrawMirrors to only process the camera textures but not change any global state. // So this function replicates JS_DrawMirrors to only process the camera textures but not change any global state.
void JS_DrawCameras(SWPlayer* pp, const DVector3& campos, double smoothratio) void JS_DrawCameras(DSWPlayer* pp, const DVector3& campos, double smoothratio)
{ {
int cnt; int cnt;
double dist; double dist;
@ -557,7 +557,7 @@ void JS_DrawCameras(SWPlayer* pp, const DVector3& campos, double smoothratio)
{ {
if (dist < MAXCAMDIST) if (dist < MAXCAMDIST)
{ {
SWPlayer* cp = getPlayer(camplayerview); DSWPlayer* cp = getPlayer(camplayerview);
if (TEST_BOOL11(camactor) && numplayers > 1) if (TEST_BOOL11(camactor) && numplayers > 1)
{ {
@ -577,11 +577,11 @@ void JS_DrawCameras(SWPlayer* pp, const DVector3& campos, double smoothratio)
// Workaround until the camera code can be refactored to process all camera textures that were visible last frame. // Workaround until the camera code can be refactored to process all camera textures that were visible last frame.
// Need to stash the parameters for later use. This is only used to find the nearest camera. // Need to stash the parameters for later use. This is only used to find the nearest camera.
static SWPlayer* cam_pp; static DSWPlayer* cam_pp;
DVector3 cam_pos; DVector3 cam_pos;
static int oldstat; static int oldstat;
void JS_CameraParms(SWPlayer* pp, const DVector3& tpos) void JS_CameraParms(DSWPlayer* pp, const DVector3& tpos)
{ {
cam_pp = pp; cam_pp = pp;
cam_pos = tpos; cam_pos = tpos;

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

@ -64,7 +64,7 @@ extern bool mirrorinview;
extern short NormalVisibility; extern short NormalVisibility;
void JAnalyzeSprites(tspritetype* tspr); void JAnalyzeSprites(tspritetype* tspr);
void JS_CameraParms(SWPlayer* pp, const DVector3& tpos); void JS_CameraParms(DSWPlayer* pp, const DVector3& tpos);
void JS_InitMirrors(void); void JS_InitMirrors(void);
void JS_ProcessEchoSpot(void); void JS_ProcessEchoSpot(void);
void JS_SpriteSetup(void); void JS_SpriteSetup(void);

8
source/games/sw/src/jweapon.cpp
View file

@ -1231,7 +1231,7 @@ int DoRadiationCloud(DSWActor* actor)
// Inventory Chemical Bombs // Inventory Chemical Bombs
// //
////////////////////////////////////////////// //////////////////////////////////////////////
int PlayerInitChemBomb(SWPlayer* pp) int PlayerInitChemBomb(DSWPlayer* pp)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
@ -1398,7 +1398,7 @@ int InitChemBomb(DSWActor* actor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int PlayerInitFlashBomb(SWPlayer* pp) int PlayerInitFlashBomb(DSWPlayer* pp)
{ {
unsigned int stat; unsigned int stat;
@ -1473,7 +1473,7 @@ int InitFlashBomb(DSWActor* actor)
int i; int i;
unsigned int stat; unsigned int stat;
short damage; short damage;
SWPlayer* pp = getPlayer(screenpeek); DSWPlayer* pp = getPlayer(screenpeek);
PlaySound(DIGI_GASPOP, actor, v3df_dontpan | v3df_doppler); PlaySound(DIGI_GASPOP, actor, v3df_dontpan | v3df_doppler);
@ -1605,7 +1605,7 @@ void SpawnFlashBombOnActor(DSWActor* actor)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int PlayerInitCaltrops(SWPlayer* pp) int PlayerInitCaltrops(DSWPlayer* pp)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();

8
source/games/sw/src/mclip.cpp
View file

@ -43,7 +43,7 @@ BEGIN_SW_NS
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
Collision MultiClipMove(SWPlayer* pp, double zz, double floordist) Collision MultiClipMove(DSWPlayer* pp, double zz, double floordist)
{ {
int i; int i;
DVector3 opos[MAX_CLIPBOX], pos[MAX_CLIPBOX]; DVector3 opos[MAX_CLIPBOX], pos[MAX_CLIPBOX];
@ -122,7 +122,7 @@ Collision MultiClipMove(SWPlayer* pp, double zz, double floordist)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int MultiClipTurn(SWPlayer* pp, DAngle new_ang, double zz, double floordist) int MultiClipTurn(DSWPlayer* pp, DAngle new_ang, double zz, double floordist)
{ {
int i; int i;
SECTOR_OBJECT* sop = pp->sop; SECTOR_OBJECT* sop = pp->sop;
@ -192,7 +192,7 @@ int testquadinsect(int *point_num, DVector2 const * qp, sectortype* sect)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int RectClipMove(SWPlayer* pp, DVector2* qpos) int RectClipMove(DSWPlayer* pp, DVector2* qpos)
{ {
int i; int i;
DVector2 xy[4]; DVector2 xy[4];
@ -253,7 +253,7 @@ int RectClipMove(SWPlayer* pp, DVector2* qpos)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
short RectClipTurn(SWPlayer* pp, DAngle new_angl, DVector2* qpos, DVector2* opos) short RectClipTurn(DSWPlayer* pp, DAngle new_angl, DVector2* qpos, DVector2* opos)
{ {
int i; int i;
DVector2 xy[4]; DVector2 xy[4];

8
source/games/sw/src/mclip.h
View file

@ -27,9 +27,9 @@ BEGIN_SW_NS
#define RECT_CLIP 1 #define RECT_CLIP 1
Collision MultiClipMove(SWPlayer* pp, double z, double floor_dist); Collision MultiClipMove(DSWPlayer* pp, double z, double floor_dist);
int MultiClipTurn(SWPlayer* pp, DAngle new_ang, double zz, double floordist); int MultiClipTurn(DSWPlayer* pp, DAngle new_ang, double zz, double floordist);
int RectClipMove(SWPlayer* pp, DVector2* qpos); int RectClipMove(DSWPlayer* pp, DVector2* qpos);
//short RectClipTurn(PLAYER* pp, short new_ang, int z, int floor_dist, int *qx, int *qy); //short RectClipTurn(PLAYER* pp, short new_ang, int z, int floor_dist, int *qx, int *qy);
short RectClipTurn(SWPlayer* pp, short new_ang, int *qx, int *qy, int *ox, int *oy); short RectClipTurn(DSWPlayer* pp, short new_ang, int *qx, int *qy, int *ox, int *oy);
END_SW_NS END_SW_NS

4
source/games/sw/src/menus.cpp
View file

@ -80,7 +80,7 @@ static int faderamp[32] =
// Set the amount of redness for damage // Set the amount of redness for damage
// the player just took // the player just took
////////////////////////////////////////// //////////////////////////////////////////
void SetFadeAmt(SWPlayer* pp, short damage, uint8_t startcolor) void SetFadeAmt(DSWPlayer* pp, short damage, uint8_t startcolor)
{ {
const int FADE_DAMAGE_FACTOR = 3; // 100 health / 32 shade cycles = 3.125 const int FADE_DAMAGE_FACTOR = 3; // 100 health / 32 shade cycles = 3.125
@ -143,7 +143,7 @@ void SetFadeAmt(SWPlayer* pp, short damage, uint8_t startcolor)
////////////////////////////////////////// //////////////////////////////////////////
// Do the screen reddness based on damage // Do the screen reddness based on damage
////////////////////////////////////////// //////////////////////////////////////////
void DoPaletteFlash(SWPlayer* pp) void DoPaletteFlash(DSWPlayer* pp)
{ {
const int MAXFADETICS = 5; const int MAXFADETICS = 5;

20
source/games/sw/src/misc.h
View file

@ -25,7 +25,7 @@ DSWActor* WarpPlane(DVector3& pos, sectortype** sect, double testz = DBL_MAX);
void ProcessVisOn(void); void ProcessVisOn(void);
void VisViewChange(SWPlayer* pp, int* vis); void VisViewChange(DSWPlayer* pp, int* vis);
void SpawnVis(DSWActor* Parent, sectortype* sect, const DVector3& pos, int amt); void SpawnVis(DSWActor* Parent, sectortype* sect, const DVector3& pos, int amt);
enum TriggerType { TRIGGER_TYPE_REMOTE_SO }; enum TriggerType { TRIGGER_TYPE_REMOTE_SO };
@ -53,10 +53,10 @@ int DoActorFall(DSWActor* actor);
#define TEXT_INFO_YOFF (10) #define TEXT_INFO_YOFF (10)
inline constexpr int TEXT_INFO_LINE(int line) { return (TEXT_INFO_Y + ((line)*TEXT_INFO_YOFF)); } inline constexpr int TEXT_INFO_LINE(int line) { return (TEXT_INFO_Y + ((line)*TEXT_INFO_YOFF)); }
void PutStringInfo(SWPlayer* pp, const char* string); void PutStringInfo(DSWPlayer* pp, const char* string);
void DoSlidorMatch(SWPlayer* pp, short match, bool); void DoSlidorMatch(DSWPlayer* pp, short match, bool);
bool TestSlidorMatchActive(short match); bool TestSlidorMatchActive(short match);
void InterpSectorSprites(sectortype* sect, bool state); void InterpSectorSprites(sectortype* sect, bool state);
@ -75,21 +75,21 @@ int DoActorSectorDamage(DSWActor* actor);
int DoScaleSprite(DSWActor* actor); int DoScaleSprite(DSWActor* actor);
int DoActorStopFall(DSWActor* actor); int DoActorStopFall(DSWActor* actor);
void InitPlayerSprite(SWPlayer* pp, const DVector3& spawnpos, const DAngle startang); void InitPlayerSprite(DSWPlayer* pp, const DVector3& spawnpos, const DAngle startang);
void InitAllPlayerSprites(const DVector3& spawnpos, const DAngle startang); void InitAllPlayerSprites(const DVector3& spawnpos, const DAngle startang);
void PlayerPanelSetup(void); void PlayerPanelSetup(void);
void PlayerDeathReset(SWPlayer* pp); void PlayerDeathReset(DSWPlayer* pp);
void SpawnPlayerUnderSprite(SWPlayer* pp); void SpawnPlayerUnderSprite(DSWPlayer* pp);
void DoQuakeMatch(short match); void DoQuakeMatch(short match);
void ProcessQuakeOn(void); void ProcessQuakeOn(void);
void ProcessQuakeSpot(void); void ProcessQuakeSpot(void);
void QuakeViewChange(SWPlayer* pp, DVector3& tpos, DAngle& tang); void QuakeViewChange(DSWPlayer* pp, DVector3& tpos, DAngle& tang);
void DoQuake(SWPlayer* pp); void DoQuake(DSWPlayer* pp);
bool SetQuake(SWPlayer* pp, short tics, short amt); bool SetQuake(DSWPlayer* pp, short tics, short amt);
int SetExpQuake(DSWActor*); int SetExpQuake(DSWActor*);
int SetGunQuake(DSWActor*); int SetGunQuake(DSWActor*);
int SetPlayerQuake(SWPlayer* mpp); int SetPlayerQuake(DSWPlayer* mpp);
int SetNuclearQuake(DSWActor*); int SetNuclearQuake(DSWActor*);
int SetSumoQuake(DSWActor*); int SetSumoQuake(DSWActor*);
int SetSumoFartQuake(DSWActor*); int SetSumoFartQuake(DSWActor*);

2
source/games/sw/src/network.cpp
View file

@ -60,7 +60,7 @@ uint8_t CommPlayers = 0;
void InitNetPlayerOptions(void) void InitNetPlayerOptions(void)
{ {
// short pnum; // short pnum;
SWPlayer* pp = getPlayer(myconnectindex); DSWPlayer* pp = getPlayer(myconnectindex);
strncpy(pp->PlayerName, playername, 31); strncpy(pp->PlayerName, playername, 31);

8
source/games/sw/src/network.h
View file

@ -32,14 +32,14 @@ enum
MAXSYNCBYTES = 16 MAXSYNCBYTES = 16
}; };
extern bool PredictionOn; extern bool PredictionOn;
extern SWPlayer PredictPlayer; extern DSWPlayer PredictPlayer;
extern SWPlayer* ppp; extern DSWPlayer* ppp;
extern short predictangpos[]; extern short predictangpos[];
extern int predictmovefifoplc; extern int predictmovefifoplc;
extern bool Prediction; extern bool Prediction;
void InitPrediction(SWPlayer* pp); void InitPrediction(DSWPlayer* pp);
void DoPrediction(SWPlayer* ppp); void DoPrediction(DSWPlayer* ppp);
void CorrectPrediction(int actualfifoplc); void CorrectPrediction(int actualfifoplc);

14
source/games/sw/src/ninja.cpp
View file

@ -2120,7 +2120,7 @@ void InitAllPlayerSprites(const DVector3& spawnpos, const DAngle startang)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerLevelReset(SWPlayer* pp) void PlayerLevelReset(DSWPlayer* pp)
{ {
DSWActor* actor = pp->GetActor(); DSWActor* actor = pp->GetActor();
@ -2163,7 +2163,7 @@ void PlayerLevelReset(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerDeathReset(SWPlayer* pp) void PlayerDeathReset(DSWPlayer* pp)
{ {
DSWActor* actor = pp->GetActor(); DSWActor* actor = pp->GetActor();
@ -2255,7 +2255,7 @@ void PlayerPanelSetup(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerGameReset(SWPlayer* pp) void PlayerGameReset(DSWPlayer* pp)
{ {
DSWActor* actor = pp->GetActor(); DSWActor* actor = pp->GetActor();
@ -2319,9 +2319,9 @@ extern ACTOR_ACTION_SET PlayerNinjaActionSet;
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitPlayerSprite(SWPlayer* pp, const DVector3& spawnpos, const DAngle startang) void InitPlayerSprite(DSWPlayer* pp, const DVector3& spawnpos, const DAngle startang)
{ {
int pnum = int(pp - (SWPlayer*)PlayerArray); int pnum = int(pp->pnum);
double fz,cz; double fz,cz;
extern bool NewGame; extern bool NewGame;
@ -2404,11 +2404,11 @@ void InitPlayerSprite(SWPlayer* pp, const DVector3& spawnpos, const DAngle start
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SpawnPlayerUnderSprite(SWPlayer* pp) void SpawnPlayerUnderSprite(DSWPlayer* pp)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
int pnum = int(pp - (SWPlayer*)PlayerArray); int pnum = int(pp->pnum);
pp->PlayerUnderActor = SpawnActor(STAT_PLAYER_UNDER0 + pnum, pp->PlayerUnderActor = SpawnActor(STAT_PLAYER_UNDER0 + pnum,
NINJA_RUN_R0, nullptr, pp->cursector, pp->GetActor()->getPosWithOffsetZ(), pp->GetActor()->spr.Angles.Yaw); NINJA_RUN_R0, nullptr, pp->cursector, pp->GetActor()->getPosWithOffsetZ(), pp->GetActor()->spr.Angles.Yaw);

2
source/games/sw/src/osdcmds.cpp
View file

@ -131,7 +131,7 @@ void GameInterface::SwitchCoopView()
} }
else else
{ {
SWPlayer* tp = getPlayer(screenpeek); DSWPlayer* tp = getPlayer(screenpeek);
DoPlayerDivePalette(tp); DoPlayerDivePalette(tp);
DoPlayerNightVisionPalette(tp); DoPlayerNightVisionPalette(tp);
} }

124
source/games/sw/src/panel.cpp
View file

@ -46,17 +46,17 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
BEGIN_SW_NS BEGIN_SW_NS
int InitSwordAttack(SWPlayer* pp); int InitSwordAttack(DSWPlayer* pp);
PANEL_SPRITE* InitWeaponUziSecondaryReload(PANEL_SPRITE*); PANEL_SPRITE* InitWeaponUziSecondaryReload(PANEL_SPRITE*);
PANEL_SPRITE* InitWeaponUzi2(PANEL_SPRITE*); PANEL_SPRITE* InitWeaponUzi2(PANEL_SPRITE*);
int InitShotgun(SWPlayer* pp); int InitShotgun(DSWPlayer* pp);
int InitRail(SWPlayer* pp); int InitRail(DSWPlayer* pp);
int InitMicro(SWPlayer* pp); int InitMicro(DSWPlayer* pp);
int InitRocket(SWPlayer* pp); int InitRocket(DSWPlayer* pp);
int InitNuke(SWPlayer* pp); int InitNuke(DSWPlayer* pp);
int InitGrenade(SWPlayer* pp); int InitGrenade(DSWPlayer* pp);
int InitMine(SWPlayer* pp); int InitMine(DSWPlayer* pp);
int InitFistAttack(SWPlayer* pp); int InitFistAttack(DSWPlayer* pp);
struct PANEL_SHRAP struct PANEL_SHRAP
{ {
@ -67,7 +67,7 @@ struct PANEL_SHRAP
void PanelInvTestSuicide(PANEL_SPRITE* psp); void PanelInvTestSuicide(PANEL_SPRITE* psp);
void InsertPanelSprite(SWPlayer* pp, PANEL_SPRITE* psp); void InsertPanelSprite(DSWPlayer* pp, PANEL_SPRITE* psp);
void pKillSprite(PANEL_SPRITE* psp); void pKillSprite(PANEL_SPRITE* psp);
void pWeaponBob(PANEL_SPRITE* psp, short condition); void pWeaponBob(PANEL_SPRITE* psp, short condition);
void pSuicide(PANEL_SPRITE* psp); void pSuicide(PANEL_SPRITE* psp);
@ -92,8 +92,8 @@ uint8_t UziRecoilYadj = 0;
extern short screenpeek; extern short screenpeek;
pANIMATOR pNullAnimator; pANIMATOR pNullAnimator;
int InitStar(SWPlayer*); int InitStar(DSWPlayer*);
int ChangeWeapon(SWPlayer*); int ChangeWeapon(DSWPlayer*);
int NullAnimator(DSWActor*) int NullAnimator(DSWActor*)
{ {
@ -117,7 +117,7 @@ inline int pspheight(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
PANEL_SPRITE* pFindMatchingSprite(SWPlayer* pp, int x, int y, short pri) PANEL_SPRITE* pFindMatchingSprite(DSWPlayer* pp, int x, int y, short pri)
{ {
PANEL_SPRITE* next; PANEL_SPRITE* next;
@ -143,7 +143,7 @@ PANEL_SPRITE* pFindMatchingSprite(SWPlayer* pp, int x, int y, short pri)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
PANEL_SPRITE* pFindMatchingSpriteID(SWPlayer* pp, short id, int x, int y, short pri) PANEL_SPRITE* pFindMatchingSpriteID(DSWPlayer* pp, short id, int x, int y, short pri)
{ {
PANEL_SPRITE* next; PANEL_SPRITE* next;
@ -169,7 +169,7 @@ PANEL_SPRITE* pFindMatchingSpriteID(SWPlayer* pp, short id, int x, int y, short
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool pKillScreenSpiteIDs(SWPlayer* pp, short id) bool pKillScreenSpiteIDs(DSWPlayer* pp, short id)
{ {
PANEL_SPRITE* next; PANEL_SPRITE* next;
bool found = false; bool found = false;
@ -213,7 +213,7 @@ void pToggleCrosshair(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DoPlayerChooseYell(SWPlayer* pp) void DoPlayerChooseYell(DSWPlayer* pp)
{ {
int choose_snd = 0; int choose_snd = 0;
@ -257,7 +257,7 @@ void ArmorCalc(int damage_amt, int *armor_damage, int *player_damage)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerUpdateHealth(SWPlayer* pp, short value) void PlayerUpdateHealth(DSWPlayer* pp, short value)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
short x,y; short x,y;
@ -367,7 +367,7 @@ void PlayerUpdateHealth(SWPlayer* pp, short value)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerUpdateAmmo(SWPlayer* pp, short UpdateWeaponNum, short value) void PlayerUpdateAmmo(DSWPlayer* pp, short UpdateWeaponNum, short value)
{ {
short x,y; short x,y;
short WeaponNum; short WeaponNum;
@ -411,7 +411,7 @@ void PlayerUpdateAmmo(SWPlayer* pp, short UpdateWeaponNum, short value)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerUpdateWeapon(SWPlayer* pp, short WeaponNum) void PlayerUpdateWeapon(DSWPlayer* pp, short WeaponNum)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
@ -428,7 +428,7 @@ void PlayerUpdateWeapon(SWPlayer* pp, short WeaponNum)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerUpdateKills(SWPlayer* pp, short value) void PlayerUpdateKills(DSWPlayer* pp, short value)
{ {
if (Prediction) if (Prediction)
return; return;
@ -440,7 +440,7 @@ void PlayerUpdateKills(SWPlayer* pp, short value)
if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.TeamPlay) if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.TeamPlay)
{ {
short pnum; short pnum;
SWPlayer* opp; DSWPlayer* opp;
TRAVERSE_CONNECT(pnum) TRAVERSE_CONNECT(pnum)
{ {
@ -463,7 +463,7 @@ void PlayerUpdateKills(SWPlayer* pp, short value)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PlayerUpdateArmor(SWPlayer* pp, short value) void PlayerUpdateArmor(DSWPlayer* pp, short value)
{ {
if (Prediction) if (Prediction)
return; return;
@ -486,7 +486,7 @@ void PlayerUpdateArmor(SWPlayer* pp, short value)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int WeaponOperate(SWPlayer* pp) int WeaponOperate(DSWPlayer* pp)
{ {
short weapon; short weapon;
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
@ -710,7 +710,7 @@ int WeaponOperate(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool WeaponOK(SWPlayer* pp) bool WeaponOK(DSWPlayer* pp)
{ {
short min_ammo, WeaponNum, FindWeaponNum; short min_ammo, WeaponNum, FindWeaponNum;
static const uint8_t wpn_order[] = {2,3,4,5,6,7,8,9,1,0}; static const uint8_t wpn_order[] = {2,3,4,5,6,7,8,9,1,0};
@ -990,7 +990,7 @@ void SpecialUziRetractFunc(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void RetractCurWpn(SWPlayer* pp) void RetractCurWpn(DSWPlayer* pp)
{ {
// Retract old weapon // Retract old weapon
if (pp->CurWpn) if (pp->CurWpn)
@ -1033,7 +1033,7 @@ void RetractCurWpn(SWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponSword(SWPlayer* pp) void InitWeaponSword(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
short rnd_num; short rnd_num;
@ -1485,7 +1485,7 @@ void pStarRestTest(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponStar(SWPlayer* pp) void InitWeaponStar(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr; PANEL_SPRITE* psp = nullptr;
@ -2093,7 +2093,7 @@ void pUziReloadRetract(PANEL_SPRITE* nclip)
void pUziDoneReload(PANEL_SPRITE* psp) void pUziDoneReload(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
if (psp->flags & (PANF_PRIMARY) && pp->WpnUziType == 3) if (psp->flags & (PANF_PRIMARY) && pp->WpnUziType == 3)
@ -2180,7 +2180,7 @@ void pUziClip(PANEL_SPRITE* oclip)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponUzi(SWPlayer* pp) void InitWeaponUzi(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr; PANEL_SPRITE* psp = nullptr;
@ -2269,7 +2269,7 @@ void InitWeaponUzi(SWPlayer* pp)
PANEL_SPRITE* InitWeaponUzi2(PANEL_SPRITE* uzi_orig) PANEL_SPRITE* InitWeaponUzi2(PANEL_SPRITE* uzi_orig)
{ {
PANEL_SPRITE* New; PANEL_SPRITE* New;
SWPlayer* pp = uzi_orig->PlayerP; DSWPlayer* pp = uzi_orig->PlayerP;
// There is already a second uzi, or it's retracting // There is already a second uzi, or it's retracting
@ -2310,7 +2310,7 @@ PANEL_SPRITE* InitWeaponUzi2(PANEL_SPRITE* uzi_orig)
PANEL_SPRITE* InitWeaponUziSecondaryReload(PANEL_SPRITE* uzi_orig) PANEL_SPRITE* InitWeaponUziSecondaryReload(PANEL_SPRITE* uzi_orig)
{ {
PANEL_SPRITE* New; PANEL_SPRITE* New;
SWPlayer* pp = uzi_orig->PlayerP; DSWPlayer* pp = uzi_orig->PlayerP;
New = pSpawnSprite(pp, ps_PresentUzi, PRI_MID, 160 - UZI_XOFF, UZI_YOFF); New = pSpawnSprite(pp, ps_PresentUzi, PRI_MID, 160 - UZI_XOFF, UZI_YOFF);
New->pos.Y += pspheight(New); New->pos.Y += pspheight(New);
@ -2567,7 +2567,7 @@ void pUziAction(PANEL_SPRITE* psp)
void pUziFire(PANEL_SPRITE* psp) void pUziFire(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
if (!WeaponOK(psp->PlayerP)) if (!WeaponOK(psp->PlayerP))
return; return;
@ -2698,7 +2698,7 @@ PANEL_STATE ps_Uzi2Shell[] =
void SpawnUziShell(PANEL_SPRITE* psp) void SpawnUziShell(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
if (psp->State && (psp->State->flags & psf_Xflip)) if (psp->State && (psp->State->flags & psf_Xflip))
{ {
@ -2773,7 +2773,7 @@ PANEL_STATE ps_ShotgunShell[] =
void SpawnShotgunShell(PANEL_SPRITE* psp) void SpawnShotgunShell(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
SpawnShell(pp->GetActor(),-4); SpawnShell(pp->GetActor(),-4);
} }
@ -2920,7 +2920,7 @@ PANEL_STATE ps_RetractShotgun[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponShotgun(SWPlayer* pp) void InitWeaponShotgun(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr; PANEL_SPRITE* psp = nullptr;
@ -3468,7 +3468,7 @@ PANEL_STATE ps_RetractRail[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponRail(SWPlayer* pp) void InitWeaponRail(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr; PANEL_SPRITE* psp = nullptr;
@ -3971,7 +3971,7 @@ void pHotHeadOverlays(PANEL_SPRITE* psp, short mode)
#define HOTHEAD_XOFF (200 + HOTHEAD_BOB_X_AMT + 6) #define HOTHEAD_XOFF (200 + HOTHEAD_BOB_X_AMT + 6)
#define HOTHEAD_YOFF 200 #define HOTHEAD_YOFF 200
void InitWeaponHothead(SWPlayer* pp) void InitWeaponHothead(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr; PANEL_SPRITE* psp = nullptr;
@ -4272,7 +4272,7 @@ PANEL_STATE ps_OnFire[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SpawnOnFire(SWPlayer* pp) void SpawnOnFire(DSWPlayer* pp)
{ {
PANEL_SPRITE* fire; PANEL_SPRITE* fire;
int x = 50; int x = 50;
@ -4451,7 +4451,7 @@ void pMicroSetRecoil(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponMicro(SWPlayer* pp) void InitWeaponMicro(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -4565,7 +4565,7 @@ void pMicroRecoilUp(PANEL_SPRITE* psp)
void pMicroPresent(PANEL_SPRITE* psp) void pMicroPresent(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
if (psp->PlayerP->Flags & (PF_WEAPON_RETRACT)) if (psp->PlayerP->Flags & (PF_WEAPON_RETRACT))
return; return;
@ -4743,7 +4743,7 @@ PANEL_STATE ps_MicroNukeFlash[] =
void pMicroRest(PANEL_SPRITE* psp) void pMicroRest(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
bool force = !!(psp->flags & PANF_UNHIDE_SHOOT); bool force = !!(psp->flags & PANF_UNHIDE_SHOOT);
if (pWeaponHideKeys(psp, ps_MicroHide)) if (pWeaponHideKeys(psp, ps_MicroHide))
@ -4877,7 +4877,7 @@ void pMicroRetract(PANEL_SPRITE* psp)
void pNukeAction(PANEL_SPRITE* psp) void pNukeAction(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
#if 0 // Code commented out as it's causing interpolation issues when initialising a nuke. #if 0 // Code commented out as it's causing interpolation issues when initialising a nuke.
psp->backupy(); psp->backupy();
@ -4904,7 +4904,7 @@ void pNukeAction(PANEL_SPRITE* psp)
void pMicroStandBy(PANEL_SPRITE* psp) void pMicroStandBy(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
pMicroOverlays(psp); pMicroOverlays(psp);
PlaySound(DIGI_NUKESTDBY, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON); PlaySound(DIGI_NUKESTDBY, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON);
@ -4912,14 +4912,14 @@ void pMicroStandBy(PANEL_SPRITE* psp)
void pMicroCount(PANEL_SPRITE* psp) void pMicroCount(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
PlaySound(DIGI_NUKECDOWN, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON); PlaySound(DIGI_NUKECDOWN, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON);
} }
void pMicroReady(PANEL_SPRITE* psp) void pMicroReady(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
PlaySound(DIGI_NUKEREADY, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON); PlaySound(DIGI_NUKEREADY, pp, v3df_follow|v3df_dontpan, CHAN_WEAPON);
pp->NukeInitialized = true; pp->NukeInitialized = true;
@ -4997,7 +4997,7 @@ PANEL_STATE ps_RetractHeart[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponHeart(SWPlayer* pp) void InitWeaponHeart(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -5188,7 +5188,7 @@ void pHeartActionBlood(PANEL_SPRITE* psp)
SpawnHeartBlood(psp); SpawnHeartBlood(psp);
} }
void InitHeartAttack(SWPlayer* pp); void InitHeartAttack(DSWPlayer* pp);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -5198,7 +5198,7 @@ void InitHeartAttack(SWPlayer* pp);
void pHeartAttack(PANEL_SPRITE* psp) void pHeartAttack(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
// CTW MODIFICATION // CTW MODIFICATION
//int InitHeartAttack(PLAYER* pp); //int InitHeartAttack(PLAYER* pp);
// CTW MODIFICATION END // CTW MODIFICATION END
@ -5270,7 +5270,7 @@ PANEL_STATE ps_HeartBloodSmall[] =
void SpawnHeartBlood(PANEL_SPRITE* psp) void SpawnHeartBlood(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
PANEL_SPRITE* blood; PANEL_SPRITE* blood;
PANEL_SHRAP* hsp; PANEL_SHRAP* hsp;
@ -5315,7 +5315,7 @@ void SpawnHeartBlood(PANEL_SPRITE* psp)
void SpawnSmallHeartBlood(PANEL_SPRITE* psp) void SpawnSmallHeartBlood(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
PANEL_SPRITE* blood; PANEL_SPRITE* blood;
PANEL_SHRAP* hsp; PANEL_SHRAP* hsp;
@ -5553,7 +5553,7 @@ void pGrenadePresentSetup(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponGrenade(SWPlayer* pp) void InitWeaponGrenade(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -5857,7 +5857,7 @@ PANEL_STATE ps_RetractMine[] =
//#define MINE_XOFF (160+20) //#define MINE_XOFF (160+20)
#define MINE_XOFF (160+50) #define MINE_XOFF (160+50)
void InitWeaponMine(SWPlayer* pp) void InitWeaponMine(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -5911,7 +5911,7 @@ void InitWeaponMine(SWPlayer* pp)
void pMineUpSound(PANEL_SPRITE* psp) void pMineUpSound(PANEL_SPRITE* psp)
{ {
SWPlayer* pp = psp->PlayerP; DSWPlayer* pp = psp->PlayerP;
PlaySound(DIGI_MINE_UP, pp, v3df_follow); PlaySound(DIGI_MINE_UP, pp, v3df_follow);
} }
@ -6190,7 +6190,7 @@ PANEL_STATE ps_ChopsRetract[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitChops(SWPlayer* pp) void InitChops(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -6339,7 +6339,7 @@ void pChopsWait(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void ChopsSetRetract(SWPlayer* pp) void ChopsSetRetract(DSWPlayer* pp)
{ {
if (pp == nullptr || pp->Chops == nullptr) if (pp == nullptr || pp->Chops == nullptr)
return; return;
@ -6615,7 +6615,7 @@ PANEL_STATE ps_RetractFist[] =
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InitWeaponFist(SWPlayer* pp) void InitWeaponFist(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
short rnd_num; short rnd_num;
@ -7066,7 +7066,7 @@ void pFistBlock(PANEL_SPRITE* psp)
void pWeaponForceRest(SWPlayer* pp) void pWeaponForceRest(DSWPlayer* pp)
{ {
pSetState(pp->CurWpn, pp->CurWpn->RestState); pSetState(pp->CurWpn, pp->CurWpn->RestState);
} }
@ -7171,7 +7171,7 @@ bool pWeaponHideKeys(PANEL_SPRITE* psp, PANEL_STATE* state)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void InsertPanelSprite(SWPlayer* pp, PANEL_SPRITE* psp) void InsertPanelSprite(DSWPlayer* pp, PANEL_SPRITE* psp)
{ {
PANEL_SPRITE* cur,* nxt; PANEL_SPRITE* cur,* nxt;
@ -7219,7 +7219,7 @@ void InsertPanelSprite(SWPlayer* pp, PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
PANEL_SPRITE* pSpawnSprite(SWPlayer* pp, PANEL_STATE* state, uint8_t priority, double x, double y) PANEL_SPRITE* pSpawnSprite(DSWPlayer* pp, PANEL_STATE* state, uint8_t priority, double x, double y)
{ {
unsigned i; unsigned i;
PANEL_SPRITE* psp; PANEL_SPRITE* psp;
@ -7287,7 +7287,7 @@ void pKillSprite(PANEL_SPRITE* psp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void pClearSpriteList(SWPlayer* pp) void pClearSpriteList(DSWPlayer* pp)
{ {
PANEL_SPRITE* psp = nullptr, * next_psp = nullptr; PANEL_SPRITE* psp = nullptr, * next_psp = nullptr;
auto l = &pp->PanelSpriteList; auto l = &pp->PanelSpriteList;
@ -7363,7 +7363,7 @@ void pWeaponBob(PANEL_SPRITE* psp, short condition)
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
bool DrawBeforeView = false; bool DrawBeforeView = false;
void pDisplaySprites(SWPlayer* pp, double interpfrac) void pDisplaySprites(DSWPlayer* pp, double interpfrac)
{ {
DSWActor* plActor = pp->GetActor(); DSWActor* plActor = pp->GetActor();
PANEL_SPRITE* next=nullptr; PANEL_SPRITE* next=nullptr;
@ -7656,7 +7656,7 @@ void pDisplaySprites(SWPlayer* pp, double interpfrac)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void pSpriteControl(SWPlayer* pp) void pSpriteControl(DSWPlayer* pp)
{ {
PANEL_SPRITE* next=nullptr; PANEL_SPRITE* next=nullptr;

12
source/games/sw/src/panel.h
View file

@ -109,7 +109,7 @@ struct PANEL_SPRITE
PANEL_SPRITE* Next, * Prev; PANEL_SPRITE* Next, * Prev;
PANEL_SPRITE* sibling; PANEL_SPRITE* sibling;
PANEL_STATE* State, *RetractState, *PresentState, *ActionState, *RestState; PANEL_STATE* State, *RetractState, *PresentState, *ActionState, *RestState;
SWPlayer* PlayerP; DSWPlayer* PlayerP;
DVector2 pos, opos, bobpos; DVector2 pos, opos, bobpos;
PANEL_SPRITE_OVERLAY over[8]; PANEL_SPRITE_OVERLAY over[8];
@ -177,16 +177,16 @@ enum
}; };
PANEL_SPRITE* pSpawnSprite(SWPlayer* pp, PANEL_STATE* state, uint8_t priority, double x, double y); PANEL_SPRITE* pSpawnSprite(DSWPlayer* pp, PANEL_STATE* state, uint8_t priority, double x, double y);
void pSetSuicide(PANEL_SPRITE* psp); void pSetSuicide(PANEL_SPRITE* psp);
bool pKillScreenSpiteIDs(SWPlayer* pp, short id); bool pKillScreenSpiteIDs(DSWPlayer* pp, short id);
void PreUpdatePanel(double interpfrac); void PreUpdatePanel(double interpfrac);
void UpdatePanel(double interpfrac); void UpdatePanel(double interpfrac);
void PlayerUpdateArmor(SWPlayer* pp,short value); void PlayerUpdateArmor(DSWPlayer* pp,short value);
void pToggleCrosshair(void); void pToggleCrosshair(void);
void pKillSprite(PANEL_SPRITE* psp); void pKillSprite(PANEL_SPRITE* psp);
void InitChops(SWPlayer* pp); void InitChops(DSWPlayer* pp);
void ChopsSetRetract(SWPlayer* pp); void ChopsSetRetract(DSWPlayer* pp);
END_SW_NS END_SW_NS

Some files were not shown because too many files have changed in this diff Show more