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

- Blood: Rename PLAYER struct to BloodPlayer.

Browse source
This commit is contained in:
Mitchell Richters 2023-09-30 20:56:00 +10:00
parent a20e2b64f9
commit 49104f9b24
38 changed files with 389 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -3053,7 +3053,7 @@ static void checkAddFrag(DBloodActor* killerActor, DBloodActor* actor)
{
if (killerActor->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[killerActor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[killerActor->spr.type - kDudePlayer1];
if (gGameOptions.nGameType == 1)
pPlayer->fragCount++;
}
@ -3068,7 +3068,7 @@ static void checkAddFrag(DBloodActor* killerActor, DBloodActor* actor)
case kDudeBurningInnocent:
break;
default:
PLAYER* pKillerPlayer = &gPlayer[killerActor->spr.type - kDudePlayer1];
BloodPlayer* pKillerPlayer = &gPlayer[killerActor->spr.type - kDudePlayer1];
pKillerPlayer->fragCount++;
break;
}
@ -3616,7 +3616,7 @@ static int actDamageDude(DBloodActor* source, DBloodActor* actor, int damage, DA
}
else
{
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (actor->xspr.health > 0 || playerSeqPlaying(pPlayer, 16))
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, PLAYER* pSourcePlayer)
static int actDamageThing(DBloodActor* source, DBloodActor* actor, int damage, DAMAGE_TYPE damageType, BloodPlayer* pSourcePlayer)
{
assert(actor->spr.type >= kThingBase && actor->spr.type < kThingMax);
int nType = actor->spr.type - kThingBase;
@ -3739,7 +3739,7 @@ int actDamageSprite(DBloodActor* source, DBloodActor* actor, DAMAGE_TYPE damageT
if (source == nullptr) source = actor;
PLAYER* pSourcePlayer = nullptr;
BloodPlayer* pSourcePlayer = nullptr;
if (source->IsPlayerActor()) pSourcePlayer = &gPlayer[source->spr.type - kDudePlayer1];
if (!gGameOptions.bFriendlyFire && IsTargetTeammate(pSourcePlayer, actor)) return 0;
@ -4334,7 +4334,7 @@ static void checkFloorHit(DBloodActor* actor)
}
#endif
PLAYER* pPlayer = nullptr;
BloodPlayer* pPlayer = nullptr;
if (actor->IsPlayerActor()) pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
switch (actor2->spr.type)
@ -4691,7 +4691,7 @@ static Collision MoveThing(DBloodActor* actor)
void MoveDude(DBloodActor* actor)
{
PLAYER* pPlayer = nullptr;
BloodPlayer* pPlayer = nullptr;
if (actor->IsPlayerActor()) pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax))
{
@ -5543,8 +5543,8 @@ static void actCheckProximity()
auto Owner = actor->GetOwner();
if (!Owner->IsPlayerActor()) continue;
PLAYER* pPlayer = &gPlayer[Owner->spr.type - kDudePlayer1];
PLAYER* pPlayer2 = dudeactor->IsPlayerActor() ? &gPlayer[dudeactor->spr.type - kDudePlayer1] : nullptr;
BloodPlayer* pPlayer = &gPlayer[Owner->spr.type - kDudePlayer1];
BloodPlayer* pPlayer2 = dudeactor->IsPlayerActor() ? &gPlayer[dudeactor->spr.type - kDudePlayer1] : nullptr;
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;
@ -5975,7 +5975,7 @@ static void actCheckDudes()
}
if (actor->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (pPlayer->voodooTargets) voodooTarget(pPlayer);
if (pPlayer->hand && Chance(0x8000)) actDamageSprite(actor, actor, kDamageDrown, 12);
@ -6049,7 +6049,7 @@ static void actCheckDudes()
if (actor->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
double nDrag = FixedToFloat(gDudeDrag);
if (actor->xspr.height > 0)
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 (hitactor->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[hitactor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[hitactor->spr.type - kDudePlayer1];
if (powerupCheck(pPlayer, kPwUpReflectShots))
{
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);
PLAYER* pPlayer = getPlayerById(source->spr.type);
BloodPlayer* pPlayer = getPlayerById(source->spr.type);
if (!pPlayer) return nDamage;
//if (powerupCheck(pPlayer, kPwUpShadowCloak)) pPlayer->pwUpTime[kPwUpShadowCloak] = 0;
if (readyForCrit(source, actor))
@ -1491,7 +1491,7 @@ void aiThinkTarget(DBloodActor* actor)
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
auto ppos = pPlayer->GetActor()->spr.pos;
@ -1536,7 +1536,7 @@ void aiLookForTarget(DBloodActor* actor)
{
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (actor->GetOwner() == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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();
if (target->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
if (!pPlayer->hand)
{
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;
max <<= 4;
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (pPlayer->blindEffect < max)
{
pPlayer->blindEffect = ClipHigh(pPlayer->blindEffect + nBlind, max);
@ -74,7 +74,7 @@ void SpidBiteSeqCallback(int, DBloodActor* actor)
if (hit == 3 && gHitInfo.actor()->IsPlayerActor())
{
vec.Z += target->spr.pos.Z - actor->spr.pos.Z;
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
switch (actor->spr.type)
{
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])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
if (pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
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
{
PLAYER* pPlayer = NULL;
BloodPlayer* pPlayer = NULL;
if ((!target->IsPlayerActor()) || ((pPlayer = getPlayerById(target->spr.type)) != NULL && pPlayer->fragger == actor))
{
playGenDudeSound(actor, kGenDudeSndTargetDead);
@ -498,7 +498,7 @@ static void unicultThinkChase(DBloodActor* actor)
}
else if (target->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[target->spr.type - kDudePlayer1];
if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
{
if (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchShortW);
@ -1758,7 +1758,7 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
{
if (actTarget->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[actTarget->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actTarget->spr.type - kDudePlayer1];
if (powerupCheck(pPlayer, kPwUpShadowCloak) > 0) return;
}
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);
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
auto owneractor = actor->GetOwner();
if (owneractor == nullptr || owneractor == pPlayer->GetActor() || pPlayer->GetActor()->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
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:
{
assert(pTSprite->type >= kDudePlayer1 && pTSprite->type <= kDudePlayer8);
PLAYER* pPlayer = &gPlayer[pTSprite->type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[pTSprite->type - kDudePlayer1];
WEAPONICON weaponIcon = gWeaponIcon[pPlayer->curWeapon];
auto nTex = weaponIcon.textureID();
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)
{
PLAYER* pPlayer = &gPlayer[gViewIndex];
BloodPlayer* pPlayer = &gPlayer[gViewIndex];
int nViewSprites = tsprites.Size();
// shift before interpolating to increase precision.
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 (IsPlayerSprite(pTSprite)) {
PLAYER* thisPlayer = &gPlayer[pTSprite->type - kDudePlayer1];
BloodPlayer* thisPlayer = &gPlayer[pTSprite->type - kDudePlayer1];
if (powerupCheck(thisPlayer, kPwUpShadowCloak) && !powerupCheck(pPlayer, kPwUpBeastVision)) {
pTSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pTSprite->pal = 5;

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

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

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

@ -123,7 +123,7 @@ bool bNoDemo = false;
int gNetPlayers;
int gChokeCounter = 0;
int blood_globalflags;
PLAYER gPlayerTemp[kMaxPlayers];
BloodPlayer gPlayerTemp[kMaxPlayers];
int gHealthTemp[kMaxPlayers];
int16_t startang;
sectortype* startsector;
@ -339,7 +339,7 @@ void StartLevel(MapRecord* level, bool newgame)
{
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
PLAYER* pPlayer = &gPlayer[i];
BloodPlayer* pPlayer = &gPlayer[i];
pPlayer->GetActor()->xspr.health &= 0xf000;
pPlayer->GetActor()->xspr.health |= gHealthTemp[i];
pPlayer->weaponQav = gPlayerTemp[i].weaponQav;
@ -421,7 +421,7 @@ void GameInterface::Ticker(const ticcmd_t* playercmds)
thinktime.Reset();
thinktime.Clock();
PLAYER* pPlayer = &gPlayer[myconnectindex];
BloodPlayer* pPlayer = &gPlayer[myconnectindex];
// disable synchronised input if set by game.
resetForcedSyncInput();
@ -762,13 +762,13 @@ DEFINE_ACTION_FUNCTION(_Blood, GetViewPlayer)
DEFINE_ACTION_FUNCTION(_BloodPlayer, GetHealth)
{
PARAM_SELF_STRUCT_PROLOGUE(PLAYER);
PARAM_SELF_STRUCT_PROLOGUE(BloodPlayer);
ACTION_RETURN_INT(self->GetActor()->xspr.health);
}
DEFINE_ACTION_FUNCTION_NATIVE(_BloodPlayer, powerupCheck, powerupCheck)
{
PARAM_SELF_STRUCT_PROLOGUE(PLAYER);
PARAM_SELF_STRUCT_PROLOGUE(BloodPlayer);
PARAM_INT(pwup);
ACTION_RETURN_INT(powerupCheck(self, pwup));
}

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

@ -172,7 +172,7 @@ inline bool IsTargetTeammate(DBloodActor* pSource, DBloodActor* pTarget)
{
if (!pSource->IsPlayerActor())
return false;
PLAYER* pSourcePlayer = &gPlayer[pSource->spr.type - kDudePlayer1];
BloodPlayer* pSourcePlayer = &gPlayer[pSource->spr.type - kDudePlayer1];
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->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (!pPlayer->bubbleTime)
return;
double top, bottom;
@ -694,7 +694,7 @@ void LeechStateTimer(DBloodActor* actor, sectortype*) // 20
//
//---------------------------------------------------------------------------
void sub_76A08(DBloodActor* actor, DBloodActor* actor2, PLAYER* pPlayer) // ???
void sub_76A08(DBloodActor* actor, DBloodActor* actor2, BloodPlayer* pPlayer) // ???
{
double top, bottom;
GetActorExtents(actor, &top, &bottom);
@ -726,7 +726,7 @@ void DropVoodooCb(DBloodActor* actor, sectortype*) // unused
evPostActor(actor, 0, kCallbackRemove);
return;
}
PLAYER* pPlayer;
BloodPlayer* pPlayer;
if (Owner->IsPlayerActor())
pPlayer = &gPlayer[Owner->spr.type - kDudePlayer1];
else
@ -753,7 +753,7 @@ void DropVoodooCb(DBloodActor* actor, sectortype*) // unused
continue;
if (actor2->hasX())
{
PLAYER* pPlayer2;
BloodPlayer* pPlayer2;
if (actor2->IsPlayerActor())
pPlayer2 = &gPlayer[actor2->spr.type - kDudePlayer1];
else

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

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

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

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

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

@ -37,7 +37,7 @@ void GameInterface::LevelCompleted(MapRecord* map, int skill)
{
if (gPlayer[i].GetActor())
{
memcpy(&gPlayerTemp[i], &gPlayer[i], sizeof(PLAYER));
memcpy(&gPlayerTemp[i], &gPlayer[i], sizeof(BloodPlayer));
gHealthTemp[i] = gPlayer[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)
{
// allow to send commands on player sprites
PLAYER* pPlayer = NULL;
BloodPlayer* pPlayer = NULL;
if (playerRXRngIsFine(rxId))
{
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(PLAYER* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac)
void hudDraw(BloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac)
{
if (gViewPos == 0)
{
@ -169,7 +169,7 @@ void hudDraw(PLAYER* pPlayer, sectortype* pSector, double bobx, double boby, dou
}
int zn = int(((pPlayer->zWeapon - pPlayer->zView - 12) * 2.) + 220);
PLAYER* pPSprite = &gPlayer[pPlayer->GetActor()->spr.type - kDudePlayer1];
BloodPlayer* pPSprite = &gPlayer[pPlayer->GetActor()->spr.type - kDudePlayer1];
if (pPlayer->GetActor()->IsPlayerActor() && pPSprite->hand == 1)
{
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);
}
const char* SetGodMode(PLAYER* pPlayer, bool god)
const char* SetGodMode(BloodPlayer* pPlayer, bool god)
{
playerSetGodMode(pPlayer, god);
bPlayerCheated = true;
@ -60,13 +60,13 @@ const char* SetClipMode(bool noclip)
return gNoClip ? GStrings("TXTB_NOCLIP") : GStrings("TXTB_NOCLIPOFF");
}
void packStuff(PLAYER* pPlayer)
void packStuff(BloodPlayer* pPlayer)
{
for (int i = 0; i < 5; i++)
packAddItem(pPlayer, i);
}
void packClear(PLAYER* pPlayer)
void packClear(BloodPlayer* pPlayer)
{
pPlayer->packItemId = 0;
for (int i = 0; i < 5; i++)
@ -76,7 +76,7 @@ void packClear(PLAYER* pPlayer)
}
}
void SetAmmo(PLAYER* pPlayer, bool stat)
void SetAmmo(BloodPlayer* pPlayer, bool stat)
{
if (stat)
{
@ -92,7 +92,7 @@ void SetAmmo(PLAYER* pPlayer, bool stat)
}
}
void SetWeapons(PLAYER* pPlayer, bool stat)
void SetWeapons(BloodPlayer* pPlayer, bool stat)
{
for (int i = 0; i < 14; i++)
{
@ -114,7 +114,7 @@ void SetWeapons(PLAYER* pPlayer, bool stat)
}
}
void SetToys(PLAYER* pPlayer, bool stat)
void SetToys(BloodPlayer* pPlayer, bool stat)
{
if (stat)
{
@ -128,7 +128,7 @@ void SetToys(PLAYER* pPlayer, bool stat)
}
}
void SetArmor(PLAYER* pPlayer, bool stat)
void SetArmor(BloodPlayer* pPlayer, bool stat)
{
int nAmount;
if (stat)
@ -145,7 +145,7 @@ void SetArmor(PLAYER* pPlayer, bool stat)
pPlayer->armor[i] = nAmount;
}
void SetKeys(PLAYER* pPlayer, bool stat)
void SetKeys(BloodPlayer* pPlayer, bool stat)
{
for (int i = 1; i <= 7; i++)
pPlayer->hasKey[i] = stat;
@ -173,7 +173,7 @@ void SetMap(bool stat)
viewSetMessage(GStrings("TXTB_NOALLMAP"));
}
void SetWooMode(PLAYER* pPlayer, bool stat)
void SetWooMode(BloodPlayer* pPlayer, bool stat)
{
if (stat)
{
@ -191,12 +191,12 @@ void SetWooMode(PLAYER* pPlayer, bool stat)
}
}
void ToggleWooMode(PLAYER* pPlayer)
void ToggleWooMode(BloodPlayer* pPlayer)
{
SetWooMode(pPlayer, !(powerupCheck(pPlayer, kPwUpTwoGuns) != 0));
}
void ToggleBoots(PLAYER* pPlayer)
void ToggleBoots(BloodPlayer* pPlayer)
{
if (powerupCheck(pPlayer, kPwUpJumpBoots))
{
@ -217,7 +217,7 @@ void ToggleBoots(PLAYER* pPlayer)
}
}
void ToggleInvisibility(PLAYER* pPlayer)
void ToggleInvisibility(BloodPlayer* pPlayer)
{
if (powerupCheck(pPlayer, kPwUpShadowCloak))
{
@ -233,7 +233,7 @@ void ToggleInvisibility(PLAYER* pPlayer)
}
}
void ToggleInvulnerability(PLAYER* pPlayer)
void ToggleInvulnerability(BloodPlayer* pPlayer)
{
if (powerupCheck(pPlayer, kPwUpDeathMask))
{
@ -249,7 +249,7 @@ void ToggleInvulnerability(PLAYER* pPlayer)
}
}
void ToggleDelirium(PLAYER* pPlayer)
void ToggleDelirium(BloodPlayer* pPlayer)
{
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)
{
// message processing is not perfect because many cheats output multiple messages.
PLAYER* pPlayer = &gPlayer[player];
BloodPlayer* pPlayer = &gPlayer[player];
if (gGameOptions.nGameType != 0 || numplayers > 1) // sp only for now.
return nullptr;
@ -512,7 +512,7 @@ static cheatseq_t s_CheatInfo[] = {
void cheatReset(void)
{
PLAYER* pPlayer = &gPlayer[myconnectindex];
BloodPlayer* pPlayer = &gPlayer[myconnectindex];
bPlayerCheated = 0;
playerSetGodMode(pPlayer, 0);
gNoClip = 0;
@ -530,7 +530,7 @@ void cheatReset(void)
static void cmd_Give(int player, uint8_t** stream, bool skip)
{
PLAYER* pPlayer = &gPlayer[player];
BloodPlayer* pPlayer = &gPlayer[player];
int type = ReadByte(stream);
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);
int qanimateoffs(int a1, int a2);
struct PLAYER;
struct BloodPlayer;
bool checkLitSprayOrTNT(PLAYER* pPlayer);
bool checkLitSprayOrTNT(BloodPlayer* pPlayer);
void WeaponInit(void);
void WeaponDraw(PLAYER* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void WeaponRaise(PLAYER* pPlayer);
void WeaponLower(PLAYER* pPlayer);
int WeaponUpgrade(PLAYER* pPlayer, int newWeapon);
void WeaponProcess(PLAYER* pPlayer);
void WeaponUpdateState(PLAYER* pPlayer);
void WeaponDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void WeaponRaise(BloodPlayer* pPlayer);
void WeaponLower(BloodPlayer* pPlayer);
int WeaponUpgrade(BloodPlayer* pPlayer, int newWeapon);
void WeaponProcess(BloodPlayer* pPlayer);
void WeaponUpdateState(BloodPlayer* pPlayer);
void teslaHit(DBloodActor* pMissile, int a2);
void WeaponPrecache();

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

@ -1175,7 +1175,7 @@ void nnExtProcessSuperSprites()
{
for (int a = connecthead; a >= 0; a = connectpoint2[a])
{
PLAYER* pPlayer = &gPlayer[a];
BloodPlayer* pPlayer = &gPlayer[a];
if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0)
continue;
@ -1213,7 +1213,7 @@ void nnExtProcessSuperSprites()
for (int a = connecthead; a >= 0; a = connectpoint2[a])
{
PLAYER* pPlayer = &gPlayer[a];
BloodPlayer* pPlayer = &gPlayer[a];
if (!pPlayer || !xsprIsFine(pPlayer->GetActor()) || pPlayer->GetActor()->xspr.health <= 0)
continue;
@ -1300,7 +1300,7 @@ void nnExtProcessSuperSprites()
if (debrisactor->xspr.physAttr & kPhysDebrisTouch)
{
PLAYER* pPlayer = NULL;
BloodPlayer* pPlayer = NULL;
for (int a = connecthead; a != -1; a = connectpoint2[a])
{
pPlayer = &gPlayer[a];
@ -1940,7 +1940,7 @@ void windGenStopWindOnSectors(DBloodActor* sourceactor)
//
//---------------------------------------------------------------------------
void trPlayerCtrlStartScene(DBloodActor* sourceactor, PLAYER* pPlayer, bool force)
void trPlayerCtrlStartScene(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool force)
{
TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->nPlayer];
@ -1982,7 +1982,7 @@ void trPlayerCtrlStartScene(DBloodActor* sourceactor, PLAYER* pPlayer, bool forc
//
//---------------------------------------------------------------------------
void trPlayerCtrlStopScene(PLAYER* pPlayer)
void trPlayerCtrlStopScene(BloodPlayer* pPlayer)
{
TRPLAYERCTRL* pCtrl = &gPlayerCtrl[pPlayer->nPlayer];
auto initiator = pCtrl->qavScene.initiator;
@ -2014,7 +2014,7 @@ void trPlayerCtrlStopScene(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlLink(DBloodActor* sourceactor, PLAYER* pPlayer, bool checkCondition)
void trPlayerCtrlLink(DBloodActor* sourceactor, BloodPlayer* pPlayer, bool checkCondition)
{
// save player's sprite index to let the tracking condition know it after savegame loading...
auto actor = pPlayer->GetActor();
@ -2074,7 +2074,7 @@ void trPlayerCtrlLink(DBloodActor* sourceactor, PLAYER* pPlayer, bool checkCondi
//
//---------------------------------------------------------------------------
void trPlayerCtrlSetRace(int value, PLAYER* pPlayer)
void trPlayerCtrlSetRace(int value, BloodPlayer* pPlayer)
{
playerSetRace(pPlayer, value);
switch (pPlayer->lifeMode)
@ -2098,7 +2098,7 @@ void trPlayerCtrlSetRace(int value, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlSetMoveSpeed(int value, PLAYER* pPlayer)
void trPlayerCtrlSetMoveSpeed(int value, BloodPlayer* pPlayer)
{
int speed = ClipRange(value, 0, 500);
for (int i = 0; i < kModeMax; i++)
@ -2119,7 +2119,7 @@ void trPlayerCtrlSetMoveSpeed(int value, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlSetJumpHeight(int value, PLAYER* pPlayer)
void trPlayerCtrlSetJumpHeight(int value, BloodPlayer* pPlayer)
{
int jump = ClipRange(value, 0, 500);
for (int i = 0; i < kModeMax; i++)
@ -2136,7 +2136,7 @@ void trPlayerCtrlSetJumpHeight(int value, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlSetScreenEffect(int value, int timeval, PLAYER* pPlayer)
void trPlayerCtrlSetScreenEffect(int value, int timeval, BloodPlayer* pPlayer)
{
int eff = ClipLow(value, 0);
int time = (eff > 0) ? timeval : 0;
@ -2179,7 +2179,7 @@ void trPlayerCtrlSetScreenEffect(int value, int timeval, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlSetLookAngle(int value, PLAYER* pPlayer)
void trPlayerCtrlSetLookAngle(int value, BloodPlayer* pPlayer)
{
static constexpr double upAngle = 289;
static constexpr double downAngle = -347;
@ -2199,7 +2199,7 @@ void trPlayerCtrlSetLookAngle(int value, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlEraseStuff(int value, PLAYER* pPlayer)
void trPlayerCtrlEraseStuff(int value, BloodPlayer* pPlayer)
{
switch (value)
@ -2251,7 +2251,7 @@ void trPlayerCtrlEraseStuff(int value, PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, PLAYER* pPlayer, TRPLAYERCTRL* pCtrl)
void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, BloodPlayer* pPlayer, TRPLAYERCTRL* pCtrl)
{
switch (data2)
{
@ -2321,7 +2321,7 @@ void trPlayerCtrlGiveStuff(int data2, int weapon, int data4, PLAYER* pPlayer, TR
//
//---------------------------------------------------------------------------
void trPlayerCtrlUsePackItem(int data2, int data3, int data4, PLAYER* pPlayer, int evCmd)
void trPlayerCtrlUsePackItem(int data2, int data3, int data4, BloodPlayer* pPlayer, int evCmd)
{
unsigned int invItem = data2 - 1;
switch (evCmd)
@ -2357,7 +2357,7 @@ void trPlayerCtrlUsePackItem(int data2, int data3, int data4, PLAYER* pPlayer, i
//
//---------------------------------------------------------------------------
void trPlayerCtrlUsePowerup(DBloodActor* sourceactor, PLAYER* pPlayer, int evCmd)
void trPlayerCtrlUsePowerup(DBloodActor* sourceactor, BloodPlayer* pPlayer, int evCmd)
{
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())
continue;
PLAYER* pPlayer = getPlayerById(iactor->spr.type);
BloodPlayer* pPlayer = getPlayerById(iactor->spr.type);
if (pXSector->Underwater)
{
if (aLower)
@ -3138,7 +3138,7 @@ void useVelocityChanger(DBloodActor* actor, sectortype* sect, DBloodActor* initi
void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
{
PLAYER* pPlayer = getPlayerById(actor->spr.type);
BloodPlayer* pPlayer = getPlayerById(actor->spr.type);
XSECTOR* pXSector = (sourceactor->sector()->hasX()) ? &sourceactor->sector()->xs() : nullptr;
bool isDude = (!pPlayer && actor->IsDudeActor());
@ -3559,7 +3559,7 @@ void damageSprites(DBloodActor* sourceactor, DBloodActor* actor)
int health = 0;
PLAYER* pPlayer = getPlayerById(actor->spr.type);
BloodPlayer* pPlayer = getPlayerById(actor->spr.type);
int dmgType = (sourceactor->xspr.data2 >= kDmgFall) ? ClipHigh(sourceactor->xspr.data2, kDmgElectric) : -1;
int dmg = actor->xspr.health << 4;
int armor[3];
@ -4304,7 +4304,7 @@ bool condCheckWall(DBloodActor* aCond, int cmpOp, bool PUSH)
bool condCheckPlayer(DBloodActor* aCond, int cmpOp, bool PUSH)
{
int var = -1;
PLAYER* pPlayer = NULL;
BloodPlayer* pPlayer = NULL;
int cond = aCond->xspr.data1 - kCondPlayerBase;
int arg1 = aCond->xspr.data2;
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)
{
int var = -1, var2 = -1, var3 = -1; PLAYER* pPlayer = NULL; bool retn = false;
int var = -1, var2 = -1, var3 = -1; BloodPlayer* pPlayer = NULL; bool retn = false;
int cond = aCond->xspr.data1 - kCondSpriteBase; int arg1 = aCond->xspr.data2;
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
{
PLAYER* pPlayer = getPlayerById(actor->xspr.data1);
BloodPlayer* pPlayer = getPlayerById(actor->xspr.data1);
if (pPlayer != NULL)
useSpriteDamager(actor, OBJ_SPRITE, 0, pPlayer->GetActor());
}
@ -5746,7 +5746,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
case kMarkerWarpDest:
if (actor->xspr.txID <= 0)
{
PLAYER* pPlayer = getPlayerById(actor->xspr.data1);
BloodPlayer* pPlayer = getPlayerById(actor->xspr.data1);
if (pPlayer != NULL && SetSpriteState(actor, actor->xspr.state ^ 1, initiator) == 1)
useTeleportTarget(actor, pPlayer->GetActor());
return true;
@ -5981,7 +5981,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
return true;
case kModernPlayerControl:
{ // WIP
PLAYER* pPlayer = NULL;
BloodPlayer* pPlayer = NULL;
int cmd = (event.cmd >= kCmdNumberic) ? event.cmd : actor->xspr.command;
@ -7252,7 +7252,7 @@ QAV* playerQavSceneLoad(int qavId)
//
//---------------------------------------------------------------------------
void playerQavSceneProcess(PLAYER* pPlayer, QAVSCENE* pQavScene)
void playerQavSceneProcess(BloodPlayer* pPlayer, QAVSCENE* pQavScene)
{
auto initiator = pQavScene->initiator;
if (initiator->hasX())
@ -7303,7 +7303,7 @@ void playerQavSceneProcess(PLAYER* pPlayer, QAVSCENE* pQavScene)
//
//---------------------------------------------------------------------------
void playerQavSceneDraw(PLAYER* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle)
void playerQavSceneDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle)
{
if (pPlayer == NULL || pPlayer->sceneQav == -1) return;
@ -7347,7 +7347,7 @@ void playerQavSceneDraw(PLAYER* pPlayer, int shade, double xpos, double ypos, in
//
//---------------------------------------------------------------------------
void playerQavScenePlay(PLAYER* pPlayer)
void playerQavScenePlay(BloodPlayer* pPlayer)
{
if (pPlayer == NULL) return;
@ -7363,7 +7363,7 @@ void playerQavScenePlay(PLAYER* pPlayer)
}
}
void playerQavSceneReset(PLAYER* pPlayer)
void playerQavSceneReset(BloodPlayer* pPlayer)
{
QAVSCENE* pQavScene = &gPlayerCtrl[pPlayer->nPlayer].qavScene;
pQavScene->initiator = nullptr;
@ -7371,28 +7371,28 @@ void playerQavSceneReset(PLAYER* pPlayer)
pQavScene->qavResrc = NULL;
}
bool playerSizeShrink(PLAYER* pPlayer, int divider)
bool playerSizeShrink(BloodPlayer* pPlayer, int divider)
{
pPlayer->GetActor()->xspr.scale = 256 / divider;
playerSetRace(pPlayer, kModeHumanShrink);
return true;
}
bool playerSizeGrow(PLAYER* pPlayer, int multiplier)
bool playerSizeGrow(BloodPlayer* pPlayer, int multiplier)
{
pPlayer->GetActor()->xspr.scale = 256 * multiplier;
playerSetRace(pPlayer, kModeHumanGrown);
return true;
}
bool playerSizeReset(PLAYER* pPlayer)
bool playerSizeReset(BloodPlayer* pPlayer)
{
playerSetRace(pPlayer, kModeHuman);
pPlayer->GetActor()->xspr.scale = 0;
return true;
}
void playerDeactivateShrooms(PLAYER* pPlayer)
void playerDeactivateShrooms(BloodPlayer* pPlayer)
{
powerupDeactivate(pPlayer, kPwUpGrowShroom);
pPlayer->pwUpTime[kPwUpGrowShroom] = 0;
@ -7407,7 +7407,7 @@ void playerDeactivateShrooms(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
PLAYER* getPlayerById(int id)
BloodPlayer* getPlayerById(int id)
{
// relative to connected players
if (id >= 1 && id <= kMaxPlayers)
@ -8381,7 +8381,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
PATROL_FOUND_SOUNDS patrolBonkles[kMaxPatrolFoundSounds];
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); PLAYER* pPlayer = NULL;
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); BloodPlayer* pPlayer = NULL;
for (int i = 0; i < kMaxPatrolFoundSounds; i++)
{
@ -9286,7 +9286,7 @@ void changeSpriteAngle(DBloodActor* pSpr, DAngle nAng)
pSpr->spr.Angles.Yaw = nAng;
else
{
PLAYER* pPlayer = getPlayerById(pSpr->spr.type);
BloodPlayer* pPlayer = getPlayerById(pSpr->spr.type);
if (pPlayer)
pPlayer->GetActor()->spr.Angles.Yaw = nAng;
else
@ -9349,7 +9349,7 @@ void killEffectGenCallbacks(DBloodActor* actor)
else if (actor->xspr.txID >= kChannelPlayer0 && actor->xspr.txID < kChannelPlayer0 + kMaxPlayers)
{
// player sprites
PLAYER* pPlayer = getPlayerById(actor->xspr.txID - kChannelPlayer0);
BloodPlayer* pPlayer = getPlayerById(actor->xspr.txID - kChannelPlayer0);
if (pPlayer && pPlayer->GetActor() != nullptr)
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 seqTxSendCmdAll(DBloodActor* pXSource, DBloodActor* nIndex, COMMAND_ID cmd, bool modernSend, DBloodActor* initiator);
// ------------------------------------------------------------------------- //
void trPlayerCtrlLink(DBloodActor* pXSource, PLAYER* pPlayer, bool checkCondition);
void trPlayerCtrlStopScene(PLAYER* pPlayer);
void trPlayerCtrlLink(DBloodActor* pXSource, BloodPlayer* pPlayer, bool checkCondition);
void trPlayerCtrlStopScene(BloodPlayer* pPlayer);
// ------------------------------------------------------------------------- //
void modernTypeTrigger(int type, sectortype* sect, walltype* wal, DBloodActor* actor, 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);
void modernTypeSendCommand(DBloodActor* nSprite, int channel, COMMAND_ID command, DBloodActor* initiator);
// ------------------------------------------------------------------------- //
bool playerSizeShrink(PLAYER* pPlayer, int divider);
bool playerSizeGrow(PLAYER* pPlayer, int multiplier);
bool playerSizeReset(PLAYER* pPlayer);
void playerDeactivateShrooms(PLAYER* pPlayer);
bool playerSizeShrink(BloodPlayer* pPlayer, int divider);
bool playerSizeGrow(BloodPlayer* pPlayer, int multiplier);
bool playerSizeReset(BloodPlayer* pPlayer);
void playerDeactivateShrooms(BloodPlayer* pPlayer);
// ------------------------------------------------------------------------- //
QAV* playerQavSceneLoad(int qavId);
void playerQavSceneProcess(PLAYER* pPlayer, QAVSCENE* pQavScene);
void playerQavScenePlay(PLAYER* pPlayer);
void playerQavSceneDraw(PLAYER* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void playerQavSceneReset(PLAYER* pPlayer);
void playerQavSceneProcess(BloodPlayer* pPlayer, QAVSCENE* pQavScene);
void playerQavScenePlay(BloodPlayer* pPlayer);
void playerQavSceneDraw(BloodPlayer* pPlayer, int shade, double xpos, double ypos, int palnum, DAngle angle);
void playerQavSceneReset(BloodPlayer* pPlayer);
// ------------------------------------------------------------------------- //
void callbackUniMissileBurst(DBloodActor* actor, sectortype* nSprite);
void callbackMakeMissileBlocking(DBloodActor* actor, sectortype* nSprite);
void callbackGenDudeUpdate(DBloodActor* actor, sectortype* nSprite);
// ------------------------------------------------------------------------- //
PLAYER* getPlayerById(int id);
BloodPlayer* getPlayerById(int id);
bool isGrown(DBloodActor* pSprite);
bool isShrinked(DBloodActor* pSprite);
bool IsBurningDude(DBloodActor* pSprite);

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

@ -34,7 +34,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
BEGIN_BLD_NS
PLAYER gPlayer[kMaxPlayers];
BloodPlayer gPlayer[kMaxPlayers];
bool gBlueFlagDropped = false;
bool gRedFlagDropped = false;
@ -230,7 +230,7 @@ DAMAGEINFO damageInfo[7] = {
//
//---------------------------------------------------------------------------
inline bool IsTargetTeammate(PLAYER* pSourcePlayer, DBloodActor* target)
inline bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target)
{
if (pSourcePlayer == nullptr)
return false;
@ -238,7 +238,7 @@ inline bool IsTargetTeammate(PLAYER* pSourcePlayer, DBloodActor* target)
return false;
if (gGameOptions.nGameType == 1 || gGameOptions.nGameType == 3)
{
PLAYER* pTargetPlayer = &gPlayer[target->spr.type - kDudePlayer1];
BloodPlayer* pTargetPlayer = &gPlayer[target->spr.type - kDudePlayer1];
if (pSourcePlayer != pTargetPlayer)
{
if (gGameOptions.nGameType == 1)
@ -258,7 +258,7 @@ inline bool IsTargetTeammate(PLAYER* pSourcePlayer, DBloodActor* target)
//
//---------------------------------------------------------------------------
int powerupCheck(PLAYER* pPlayer, int nPowerUp)
int powerupCheck(BloodPlayer* pPlayer, int nPowerUp)
{
assert(pPlayer != NULL);
assert(nPowerUp >= 0 && nPowerUp < kMaxPowerUps);
@ -275,7 +275,7 @@ int powerupCheck(PLAYER* pPlayer, int nPowerUp)
//
//---------------------------------------------------------------------------
bool powerupActivate(PLAYER* pPlayer, int nPowerUp)
bool powerupActivate(BloodPlayer* pPlayer, int nPowerUp)
{
if (powerupCheck(pPlayer, nPowerUp) > 0 && gPowerUpInfo[nPowerUp].pickupOnce)
return 0;
@ -348,7 +348,7 @@ bool powerupActivate(PLAYER* pPlayer, int nPowerUp)
//
//---------------------------------------------------------------------------
void powerupDeactivate(PLAYER* pPlayer, int nPowerUp)
void powerupDeactivate(BloodPlayer* pPlayer, int nPowerUp)
{
int nPack = powerupToPackItem(nPowerUp);
if (nPack >= 0)
@ -403,7 +403,7 @@ void powerupDeactivate(PLAYER* pPlayer, int nPowerUp)
//
//---------------------------------------------------------------------------
void powerupSetState(PLAYER* pPlayer, int nPowerUp, bool bState)
void powerupSetState(BloodPlayer* pPlayer, int nPowerUp, bool bState)
{
if (!bState)
powerupActivate(pPlayer, nPowerUp);
@ -417,7 +417,7 @@ void powerupSetState(PLAYER* pPlayer, int nPowerUp, bool bState)
//
//---------------------------------------------------------------------------
void powerupProcess(PLAYER* pPlayer)
void powerupProcess(BloodPlayer* pPlayer)
{
pPlayer->packItemTime = ClipLow(pPlayer->packItemTime - 4, 0);
for (int i = kMaxPowerUps - 1; i >= 0; i--)
@ -453,7 +453,7 @@ void powerupProcess(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void powerupClear(PLAYER* pPlayer)
void powerupClear(BloodPlayer* pPlayer)
{
for (int i = kMaxPowerUps - 1; i >= 0; i--)
{
@ -519,7 +519,7 @@ int powerupToPackItem(int nPowerUp)
//
//---------------------------------------------------------------------------
bool packAddItem(PLAYER* pPlayer, unsigned int nPack)
bool packAddItem(BloodPlayer* pPlayer, unsigned int nPack)
{
if (nPack <= 4)
{
@ -545,12 +545,12 @@ bool packAddItem(PLAYER* pPlayer, unsigned int nPack)
//
//---------------------------------------------------------------------------
int packCheckItem(PLAYER* pPlayer, int nPack)
int packCheckItem(BloodPlayer* pPlayer, int nPack)
{
return pPlayer->packSlots[nPack].curAmount;
}
bool packItemActive(PLAYER* pPlayer, int nPack)
bool packItemActive(BloodPlayer* pPlayer, int nPack)
{
return pPlayer->packSlots[nPack].isActive;
}
@ -561,7 +561,7 @@ bool packItemActive(PLAYER* pPlayer, int nPack)
//
//---------------------------------------------------------------------------
void packUseItem(PLAYER* pPlayer, int nPack)
void packUseItem(BloodPlayer* pPlayer, int nPack)
{
bool v4 = 0;
int nPowerUp = -1;
@ -614,7 +614,7 @@ void packUseItem(PLAYER* pPlayer, int nPack)
//
//---------------------------------------------------------------------------
void packPrevItem(PLAYER* pPlayer)
void packPrevItem(BloodPlayer* pPlayer)
{
if (pPlayer->packItemTime > 0)
{
@ -643,7 +643,7 @@ void packPrevItem(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void packNextItem(PLAYER* pPlayer)
void packNextItem(BloodPlayer* pPlayer)
{
if (pPlayer->packItemTime > 0)
{
@ -671,7 +671,7 @@ void packNextItem(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
bool playerSeqPlaying(PLAYER* pPlayer, int nSeq)
bool playerSeqPlaying(BloodPlayer* pPlayer, int nSeq)
{
int nCurSeq = seqGetID(pPlayer->GetActor());
if (pPlayer->pDudeInfo->seqStartID + nSeq == nCurSeq && seqGetStatus(pPlayer->GetActor()) >= 0)
@ -685,7 +685,7 @@ bool playerSeqPlaying(PLAYER* pPlayer, int nSeq)
//
//---------------------------------------------------------------------------
void playerSetRace(PLAYER* pPlayer, int nLifeMode)
void playerSetRace(BloodPlayer* pPlayer, int nLifeMode)
{
assert(nLifeMode >= kModeHuman && nLifeMode <= kModeHumanGrown);
DUDEINFO* pDudeInfo = pPlayer->pDudeInfo;
@ -705,12 +705,12 @@ void playerSetRace(PLAYER* pPlayer, int nLifeMode)
//
//---------------------------------------------------------------------------
void playerSetGodMode(PLAYER* pPlayer, bool bGodMode)
void playerSetGodMode(BloodPlayer* pPlayer, bool bGodMode)
{
pPlayer->godMode = bGodMode;
}
void playerResetInertia(PLAYER* pPlayer)
void playerResetInertia(BloodPlayer* pPlayer)
{
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->GetActor()->spr.pos.Z - pPosture->eyeAboveZ;
@ -719,7 +719,7 @@ void playerResetInertia(PLAYER* pPlayer)
viewBackupView(pPlayer->nPlayer);
}
void playerCorrectInertia(PLAYER* pPlayer, const DVector3& oldpos)
void playerCorrectInertia(BloodPlayer* pPlayer, const DVector3& oldpos)
{
auto zAdj = pPlayer->GetActor()->spr.pos.Z - oldpos.Z;
pPlayer->zView += zAdj;
@ -729,7 +729,7 @@ void playerCorrectInertia(PLAYER* pPlayer, const DVector3& oldpos)
pPlayer->GetActor()->opos.Z += zAdj;
}
void playerResetPowerUps(PLAYER* pPlayer)
void playerResetPowerUps(BloodPlayer* pPlayer)
{
for (int i = 0; i < kMaxPowerUps; i++) {
if (!VanillaMode() && (i == kPwUpJumpBoots || i == kPwUpDivingSuit || i == kPwUpCrystalBall || i == kPwUpBeastVision))
@ -738,7 +738,7 @@ void playerResetPowerUps(PLAYER* pPlayer)
}
}
void playerResetPosture(PLAYER* pPlayer) {
void playerResetPosture(BloodPlayer* pPlayer) {
memcpy(pPlayer->pPosture, gPostureDefaults, sizeof(gPostureDefaults));
if (!VanillaMode()) {
pPlayer->bobPhase = 0;
@ -759,7 +759,7 @@ void playerResetPosture(PLAYER* pPlayer) {
void playerStart(int nPlayer, int bNewLevel)
{
PLAYER* pPlayer = &gPlayer[nPlayer];
BloodPlayer* pPlayer = &gPlayer[nPlayer];
InputPacket* pInput = &pPlayer->input;
ZONE* pStartZone = NULL;
@ -918,7 +918,7 @@ void playerStart(int nPlayer, int bNewLevel)
//
//---------------------------------------------------------------------------
void playerReset(PLAYER* pPlayer)
void playerReset(BloodPlayer* pPlayer)
{
static int dword_136400[] = {
3, 4, 2, 8, 9, 10, 7, 1, 1, 1, 1, 1, 1, 1
@ -984,7 +984,7 @@ void playerInit(int nPlayer, unsigned int a2)
if (!(a2 & 1))
gPlayer[nPlayer] = {};
PLAYER* pPlayer = &gPlayer[nPlayer];
BloodPlayer* pPlayer = &gPlayer[nPlayer];
pPlayer->nPlayer = nPlayer;
pPlayer->teamId = nPlayer;
if (gGameOptions.nGameType == 3)
@ -1004,7 +1004,7 @@ void playerInit(int nPlayer, unsigned int a2)
//
//---------------------------------------------------------------------------
bool findDroppedLeech(PLAYER* a1, DBloodActor* a2)
bool findDroppedLeech(BloodPlayer* a1, DBloodActor* a2)
{
BloodStatIterator it(kStatThing);
while (auto actor = it.Next())
@ -1023,7 +1023,7 @@ bool findDroppedLeech(PLAYER* a1, DBloodActor* a2)
//
//---------------------------------------------------------------------------
bool PickupItem(PLAYER* pPlayer, DBloodActor* itemactor)
bool PickupItem(BloodPlayer* pPlayer, DBloodActor* itemactor)
{
char buffer[80];
int pickupSnd = 775;
@ -1256,7 +1256,7 @@ bool PickupItem(PLAYER* pPlayer, DBloodActor* itemactor)
//
//---------------------------------------------------------------------------
bool PickupAmmo(PLAYER* pPlayer, DBloodActor* ammoactor)
bool PickupAmmo(BloodPlayer* pPlayer, DBloodActor* ammoactor)
{
const AMMOITEMDATA* pAmmoItemData = &gAmmoItemData[ammoactor->spr.type - kItemAmmoBase];
int nAmmoType = pAmmoItemData->type;
@ -1280,7 +1280,7 @@ bool PickupAmmo(PLAYER* pPlayer, DBloodActor* ammoactor)
//
//---------------------------------------------------------------------------
bool PickupWeapon(PLAYER* pPlayer, DBloodActor* weaponactor)
bool PickupWeapon(BloodPlayer* pPlayer, DBloodActor* weaponactor)
{
const WEAPONITEMDATA* pWeaponItemData = &gWeaponItemData[weaponactor->spr.type - kItemWeaponBase];
int nWeaponType = pWeaponItemData->type;
@ -1325,7 +1325,7 @@ bool PickupWeapon(PLAYER* pPlayer, DBloodActor* weaponactor)
//
//---------------------------------------------------------------------------
void PickUp(PLAYER* pPlayer, DBloodActor* actor)
void PickUp(BloodPlayer* pPlayer, DBloodActor* actor)
{
const char* msg = nullptr;
int nType = actor->spr.type;
@ -1376,7 +1376,7 @@ void PickUp(PLAYER* pPlayer, DBloodActor* actor)
//
//---------------------------------------------------------------------------
void CheckPickUp(PLAYER* pPlayer)
void CheckPickUp(BloodPlayer* pPlayer)
{
auto plActor = pPlayer->GetActor();
auto ppos = plActor->spr.pos;
@ -1417,7 +1417,7 @@ void CheckPickUp(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
int ActionScan(PLAYER* pPlayer, HitInfo* out)
int ActionScan(BloodPlayer* pPlayer, HitInfo* out)
{
auto plActor = pPlayer->GetActor();
*out = {};
@ -1509,7 +1509,7 @@ unsigned GameInterface::getCrouchState()
//
//---------------------------------------------------------------------------
void ProcessInput(PLAYER* pPlayer)
void ProcessInput(BloodPlayer* pPlayer)
{
enum
{
@ -1764,7 +1764,7 @@ void ProcessInput(PLAYER* pPlayer)
CheckPickUp(pPlayer);
}
void playerProcess(PLAYER* pPlayer)
void playerProcess(BloodPlayer* pPlayer)
{
DBloodActor* actor = pPlayer->GetActor();
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
@ -1892,12 +1892,12 @@ void playerProcess(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
DBloodActor* playerFireMissile(PLAYER* pPlayer, double xyoff, const DVector3& dv, int nType)
DBloodActor* playerFireMissile(BloodPlayer* pPlayer, double xyoff, const DVector3& dv, int nType)
{
return actFireMissile(pPlayer->GetActor(), xyoff, pPlayer->zWeapon - pPlayer->GetActor()->spr.pos.Z, dv, nType);
}
DBloodActor* playerFireThing(PLAYER* pPlayer, double xyoff, double zvel, int thingType, double nSpeed)
DBloodActor* playerFireThing(BloodPlayer* 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);
}
@ -1908,7 +1908,7 @@ DBloodActor* playerFireThing(PLAYER* pPlayer, double xyoff, double zvel, int thi
//
//---------------------------------------------------------------------------
void playerFrag(PLAYER* pKiller, PLAYER* pVictim)
void playerFrag(BloodPlayer* pKiller, BloodPlayer* pVictim)
{
assert(pKiller != NULL);
assert(pVictim != NULL);
@ -1974,11 +1974,11 @@ void playerFrag(PLAYER* pKiller, PLAYER* pVictim)
//
//---------------------------------------------------------------------------
void FragPlayer(PLAYER* pPlayer, DBloodActor* killer)
void FragPlayer(BloodPlayer* pPlayer, DBloodActor* killer)
{
if (killer && killer->IsPlayerActor())
{
PLAYER* pKiller = &gPlayer[killer->spr.type - kDudePlayer1];
BloodPlayer* pKiller = &gPlayer[killer->spr.type - kDudePlayer1];
playerFrag(pKiller, pPlayer);
int nTeam1 = pKiller->teamId & 1;
int nTeam2 = pPlayer->teamId & 1;
@ -2005,7 +2005,7 @@ void FragPlayer(PLAYER* pPlayer, DBloodActor* killer)
//
//---------------------------------------------------------------------------
int playerDamageArmor(PLAYER* pPlayer, DAMAGE_TYPE nType, int nDamage)
int playerDamageArmor(BloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage)
{
DAMAGEINFO* pDamageInfo = &damageInfo[nType];
int nArmorType = pDamageInfo->armorType;
@ -2032,7 +2032,7 @@ int playerDamageArmor(PLAYER* pPlayer, DAMAGE_TYPE nType, int nDamage)
//
//---------------------------------------------------------------------------
void flagDropped(PLAYER* pPlayer, int a2)
void flagDropped(BloodPlayer* pPlayer, int a2)
{
DBloodActor* playeractor = pPlayer->GetActor();
DBloodActor* actor;
@ -2066,7 +2066,7 @@ void flagDropped(PLAYER* pPlayer, int a2)
//
//---------------------------------------------------------------------------
int playerDamageSprite(DBloodActor* source, PLAYER* pPlayer, DAMAGE_TYPE nDamageType, int nDamage)
int playerDamageSprite(DBloodActor* source, BloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage)
{
assert(pPlayer != NULL);
if (pPlayer->damageControl[nDamageType] || pPlayer->godMode)
@ -2234,7 +2234,7 @@ int playerDamageSprite(DBloodActor* source, PLAYER* pPlayer, DAMAGE_TYPE nDamage
//
//---------------------------------------------------------------------------
int UseAmmo(PLAYER* pPlayer, int nAmmoType, int nDec)
int UseAmmo(BloodPlayer* pPlayer, int nAmmoType, int nDec)
{
if (gInfiniteAmmo)
return 9999;
@ -2250,7 +2250,7 @@ int UseAmmo(PLAYER* pPlayer, int nAmmoType, int nDec)
//
//---------------------------------------------------------------------------
void voodooTarget(PLAYER* pPlayer)
void voodooTarget(BloodPlayer* pPlayer)
{
DBloodActor* actor = pPlayer->GetActor();
double aimz = pPlayer->aim.Z;
@ -2277,7 +2277,7 @@ void voodooTarget(PLAYER* pPlayer)
//
//---------------------------------------------------------------------------
void playerLandingSound(PLAYER* pPlayer)
void playerLandingSound(BloodPlayer* pPlayer)
{
static int surfaceSound[] = {
-1,
@ -2322,7 +2322,7 @@ void PlayerSurvive(int, DBloodActor* actor)
sfxPlay3DSound(actor, 3009, 0, 6);
if (actor->IsPlayerActor())
{
PLAYER* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
BloodPlayer* pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
if (pPlayer->nPlayer == myconnectindex)
viewSetMessage(GStrings("TXT_LIVEAGAIM"));
else
@ -2347,7 +2347,7 @@ void PlayerKneelsOver(int, DBloodActor* actor)
{
if (gPlayer[p].GetActor() == actor)
{
PLAYER* pPlayer = &gPlayer[p];
BloodPlayer* pPlayer = &gPlayer[p];
playerDamageSprite(pPlayer->fragger, pPlayer, kDamageSpirit, 500 << 4);
return;
}
@ -2396,7 +2396,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, POSTURE& w, POSTUR
return arc;
}
FSerializer& Serialize(FSerializer& arc, const char* keyname, PLAYER& w, PLAYER* def)
FSerializer& Serialize(FSerializer& arc, const char* keyname, BloodPlayer& w, BloodPlayer* def)
{
if (arc.BeginObject(keyname))
{
@ -2563,76 +2563,76 @@ void SerializePlayers(FSerializer& arc)
DEFINE_FIELD_X(BloodPlayer, PLAYER, newWeapon)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponQav)
DEFINE_FIELD_X(BloodPlayer, PLAYER, qavCallback)
DEFINE_FIELD_X(BloodPlayer, PLAYER, isRunning)
DEFINE_FIELD_X(BloodPlayer, PLAYER, posture) // stand, crouch, swim
DEFINE_FIELD_X(BloodPlayer, PLAYER, sceneQav) // by NoOne: used to keep qav id
DEFINE_FIELD_X(BloodPlayer, PLAYER, bobPhase)
DEFINE_FIELD_X(BloodPlayer, PLAYER, bobAmp)
DEFINE_FIELD_X(BloodPlayer, PLAYER, bobHeight)
DEFINE_FIELD_X(BloodPlayer, PLAYER, bobWidth)
DEFINE_FIELD_X(BloodPlayer, PLAYER, swayAmp)
DEFINE_FIELD_X(BloodPlayer, PLAYER, swayHeight)
DEFINE_FIELD_X(BloodPlayer, PLAYER, swayWidth)
DEFINE_FIELD_X(BloodPlayer, PLAYER, nPlayer) // Connect id
DEFINE_FIELD_X(BloodPlayer, PLAYER, lifeMode)
DEFINE_FIELD_X(BloodPlayer, PLAYER, zView)
DEFINE_FIELD_X(BloodPlayer, PLAYER, zViewVel)
DEFINE_FIELD_X(BloodPlayer, PLAYER, zWeapon)
DEFINE_FIELD_X(BloodPlayer, PLAYER, zWeaponVel)
DEFINE_FIELD_X(BloodPlayer, PLAYER, slope)
DEFINE_FIELD_X(BloodPlayer, PLAYER, isUnderwater)
DEFINE_FIELD_X(BloodPlayer, PLAYER, hasKey)
DEFINE_FIELD_X(BloodPlayer, PLAYER, hasFlag)
DEFINE_FIELD_X(BloodPlayer, PLAYER, damageControl)
DEFINE_FIELD_X(BloodPlayer, PLAYER, curWeapon)
DEFINE_FIELD_X(BloodPlayer, PLAYER, nextWeapon)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponTimer)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponState)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponAmmo) //rename
DEFINE_FIELD_X(BloodPlayer, PLAYER, hasWeapon)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponMode)
DEFINE_FIELD_X(BloodPlayer, PLAYER, weaponOrder)
DEFINE_FIELD_X(BloodPlayer, PLAYER, ammoCount)
DEFINE_FIELD_X(BloodPlayer, PLAYER, qavLoop)
DEFINE_FIELD_X(BloodPlayer, PLAYER, fuseTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, throwTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, throwPower)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, newWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponQav)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, qavCallback)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, isRunning)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, posture) // stand, crouch, swim
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, sceneQav) // by NoOne: used to keep qav id
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobPhase)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobAmp)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobHeight)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bobWidth)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayAmp)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayHeight)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, swayWidth)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, nPlayer) // Connect id
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, lifeMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zView)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zViewVel)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, zWeaponVel)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, slope)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, isUnderwater)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasKey)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasFlag)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, damageControl)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, curWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, nextWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponTimer)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponState)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponAmmo) //rename
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hasWeapon)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, weaponOrder)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, ammoCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, qavLoop)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fuseTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, throwTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, throwPower)
//DEFINE_FIELD_X(BloodPlayer, PLAYER, aim) // world
DEFINE_FIELD_X(BloodPlayer, PLAYER, aimTargetsCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, aimTargetsCount)
//DEFINE_FIELD_X(BloodPlayer, PLAYER, aimTargets)
DEFINE_FIELD_X(BloodPlayer, PLAYER, deathTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, pwUpTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, teamId)
DEFINE_FIELD_X(BloodPlayer, PLAYER, fragCount)
DEFINE_FIELD_X(BloodPlayer, PLAYER, fragInfo)
DEFINE_FIELD_X(BloodPlayer, PLAYER, underwaterTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, bubbleTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, restTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, kickPower)
DEFINE_FIELD_X(BloodPlayer, PLAYER, laughCount)
DEFINE_FIELD_X(BloodPlayer, PLAYER, godMode)
DEFINE_FIELD_X(BloodPlayer, PLAYER, fallScream)
DEFINE_FIELD_X(BloodPlayer, PLAYER, cantJump)
DEFINE_FIELD_X(BloodPlayer, PLAYER, packItemTime) // pack timer
DEFINE_FIELD_X(BloodPlayer, PLAYER, packItemId) // pack id 1: diving suit, 2: crystal ball, 3:
DEFINE_FIELD_X(BloodPlayer, PLAYER, packSlots) // at325 1]: diving suit, [2]: crystal ball,
DEFINE_FIELD_X(BloodPlayer, PLAYER, armor) // armor
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, deathTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, pwUpTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, teamId)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fragCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fragInfo)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, underwaterTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, bubbleTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, restTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, kickPower)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, laughCount)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, godMode)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, fallScream)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, cantJump)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packItemTime) // pack timer
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packItemId) // pack id 1: diving suit, 2: crystal ball, 3:
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, packSlots) // at325 1]: diving suit, [2]: crystal ball,
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, armor) // armor
//DEFINE_FIELD_X(BloodPlayer, PLAYER, voodooTarget)
DEFINE_FIELD_X(BloodPlayer, PLAYER, flickerEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, tiltEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, visibility)
DEFINE_FIELD_X(BloodPlayer, PLAYER, painEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, blindEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, chokeEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, handTime)
DEFINE_FIELD_X(BloodPlayer, PLAYER, hand) // if true, there is hand start choking the player
DEFINE_FIELD_X(BloodPlayer, PLAYER, pickupEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, flashEffect) // if true, reduce pPlayer->visibility counter
DEFINE_FIELD_X(BloodPlayer, PLAYER, quakeEffect)
DEFINE_FIELD_X(BloodPlayer, PLAYER, player_par)
DEFINE_FIELD_X(BloodPlayer, PLAYER, nWaterPal)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, flickerEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, tiltEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, visibility)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, painEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, blindEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, chokeEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, handTime)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, hand) // if true, there is hand start choking the player
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, pickupEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, flashEffect) // if true, reduce pPlayer->visibility counter
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, quakeEffect)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, player_par)
DEFINE_FIELD_X(BloodPlayer, BloodPlayer, nWaterPal)
END_BLD_NS

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

@ -78,7 +78,7 @@ struct POSTURE
extern POSTURE gPostureDefaults[kModeMax][kPostureMax];
struct PLAYER
struct BloodPlayer
{
DBloodActor* actor;
DUDEINFO* pDudeInfo;
@ -196,9 +196,9 @@ struct POWERUPINFO
FTextureID textureID() const { return tileGetTextureID(picno); }
};
void playerResetPosture(PLAYER* pPlayer);
void playerResetPosture(BloodPlayer* pPlayer);
extern PLAYER gPlayer[kMaxPlayers];
extern BloodPlayer gPlayer[kMaxPlayers];
extern bool gBlueFlagDropped;
extern bool gRedFlagDropped;
@ -208,40 +208,40 @@ extern int team_ticker[kMaxPlayers];
extern AMMOINFO gAmmoInfo[];
extern POWERUPINFO gPowerUpInfo[kMaxPowerUps];
bool IsTargetTeammate(PLAYER* pSourcePlayer, DBloodActor* target);
int powerupCheck(PLAYER* pPlayer, int nPowerUp);
bool powerupActivate(PLAYER* pPlayer, int nPowerUp);
void powerupDeactivate(PLAYER* pPlayer, int nPowerUp);
void powerupSetState(PLAYER* pPlayer, int nPowerUp, bool bState);
void powerupProcess(PLAYER* pPlayer);
void powerupClear(PLAYER* pPlayer);
bool IsTargetTeammate(BloodPlayer* pSourcePlayer, DBloodActor* target);
int powerupCheck(BloodPlayer* pPlayer, int nPowerUp);
bool powerupActivate(BloodPlayer* pPlayer, int nPowerUp);
void powerupDeactivate(BloodPlayer* pPlayer, int nPowerUp);
void powerupSetState(BloodPlayer* pPlayer, int nPowerUp, bool bState);
void powerupProcess(BloodPlayer* pPlayer);
void powerupClear(BloodPlayer* pPlayer);
int packItemToPowerup(int nPack);
int powerupToPackItem(int nPowerUp);
bool packAddItem(PLAYER* pPlayer, unsigned int nPack);
int packCheckItem(PLAYER* pPlayer, int nPack);
bool packItemActive(PLAYER* pPlayer, int nPack);
void packUseItem(PLAYER* pPlayer, int nPack);
void packPrevItem(PLAYER* pPlayer);
void packNextItem(PLAYER* pPlayer);
bool playerSeqPlaying(PLAYER* pPlayer, int nSeq);
void playerSetRace(PLAYER* pPlayer, int nLifeMode);
void playerSetGodMode(PLAYER* pPlayer, bool bGodMode);
void playerResetInertia(PLAYER* pPlayer);
void playerCorrectInertia(PLAYER* pPlayer, const DVector3& oldpos);
bool packAddItem(BloodPlayer* pPlayer, unsigned int nPack);
int packCheckItem(BloodPlayer* pPlayer, int nPack);
bool packItemActive(BloodPlayer* pPlayer, int nPack);
void packUseItem(BloodPlayer* pPlayer, int nPack);
void packPrevItem(BloodPlayer* pPlayer);
void packNextItem(BloodPlayer* pPlayer);
bool playerSeqPlaying(BloodPlayer* pPlayer, int nSeq);
void playerSetRace(BloodPlayer* pPlayer, int nLifeMode);
void playerSetGodMode(BloodPlayer* pPlayer, bool bGodMode);
void playerResetInertia(BloodPlayer* pPlayer);
void playerCorrectInertia(BloodPlayer* pPlayer, const DVector3& oldpos);
void playerStart(int nPlayer, int bNewLevel = 0);
void playerReset(PLAYER* pPlayer);
void playerReset(BloodPlayer* pPlayer);
void playerInit(int nPlayer, unsigned int a2);
void CheckPickUp(PLAYER* pPlayer);
void ProcessInput(PLAYER* pPlayer);
void playerProcess(PLAYER* pPlayer);
DBloodActor* playerFireMissile(PLAYER* pPlayer, double xyoff, const DVector3& vec, int nType);
DBloodActor* playerFireThing(PLAYER* pPlayer, double xyoff, double zvel, int thingType, double nSpeed);
void playerFrag(PLAYER* pKiller, PLAYER* pVictim);
int playerDamageArmor(PLAYER* pPlayer, DAMAGE_TYPE nType, int nDamage);
int playerDamageSprite(DBloodActor* nSource, PLAYER* pPlayer, DAMAGE_TYPE nDamageType, int nDamage);
int UseAmmo(PLAYER* pPlayer, int nAmmoType, int nDec);
void voodooTarget(PLAYER* pPlayer);
void playerLandingSound(PLAYER* pPlayer);
void CheckPickUp(BloodPlayer* pPlayer);
void ProcessInput(BloodPlayer* pPlayer);
void playerProcess(BloodPlayer* pPlayer);
DBloodActor* playerFireMissile(BloodPlayer* pPlayer, double xyoff, const DVector3& vec, int nType);
DBloodActor* playerFireThing(BloodPlayer* pPlayer, double xyoff, double zvel, int thingType, double nSpeed);
void playerFrag(BloodPlayer* pKiller, BloodPlayer* pVictim);
int playerDamageArmor(BloodPlayer* pPlayer, DAMAGE_TYPE nType, int nDamage);
int playerDamageSprite(DBloodActor* nSource, BloodPlayer* pPlayer, DAMAGE_TYPE nDamageType, int nDamage);
int UseAmmo(BloodPlayer* pPlayer, int nAmmoType, int nDec);
void voodooTarget(BloodPlayer* pPlayer);
void playerLandingSound(BloodPlayer* pPlayer);
void PlayerSurvive(int, DBloodActor*);
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
void fakePlayerProcess(PLAYER* pPlayer, InputPacket* pInput);
void fakePlayerProcess(BloodPlayer* pPlayer, InputPacket* pInput);
void fakeActProcessSprites(void);
bool gPrediction = true;
@ -98,7 +98,7 @@ void viewUpdatePrediction(InputPacket* pInput)
#endif
}
static void fakeProcessInput(PLAYER* pPlayer, InputPacket* pInput)
static void fakeProcessInput(BloodPlayer* pPlayer, InputPacket* pInput)
{
#if 0
POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][predict.posture];
@ -253,7 +253,7 @@ static void fakeProcessInput(PLAYER* pPlayer, InputPacket* pInput)
#endif
}
void fakePlayerProcess(PLAYER* pPlayer, InputPacket* pInput)
void fakePlayerProcess(BloodPlayer* pPlayer, InputPacket* pInput)
{
#if 0
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, PLAYER* pData)
void QAV::Play(int start, int end, int nCallback, BloodPlayer* pData)
{
auto pActor = pData ? pData->GetActor() : nullptr;
assert(ticksPerFrame > 0);
@ -326,7 +326,7 @@ void qavProcessTicker(QAV* const pQAV, int* duration, int* lastTick)
//
//---------------------------------------------------------------------------
void qavProcessTimer(PLAYER* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration, bool const ignoreWeaponTimer)
void qavProcessTimer(BloodPlayer* 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.
if (!paused)

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

@ -230,13 +230,13 @@ struct QAV
uint16_t res_id;
FRAMEINFO frames[1]; // 24
void Draw(int ticks, int stat, int shade, int palnum, bool to3dview, double const interpfrac, DAngle angle = nullAngle);
void Play(int, int, int, PLAYER*);
void Play(int, int, int, BloodPlayer*);
void Precache(int palette = 0);
};
QAV* getQAV(int res_id);
void qavProcessTicker(QAV* const pQAV, int* duration, int* lastTick);
void qavProcessTimer(PLAYER* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration = false, bool const ignoreWeaponTimer = false);
void qavProcessTimer(BloodPlayer* const pPlayer, QAV* const pQAV, int* duration, double* interpfrac, bool const fixedduration = false, bool const ignoreWeaponTimer = false);
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(PLAYER* pPlayer)
void UpdateStatusBar(BloodPlayer* pPlayer)
{
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)
{
PLAYER* pPlayer = &gPlayer[myconnectindex];
BloodPlayer* pPlayer = &gPlayer[myconnectindex];
FVector3 camera;
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()
{
PLAYER* pPlayer = &gPlayer[myconnectindex];
BloodPlayer* pPlayer = &gPlayer[myconnectindex];
SoundListener listener;
if (pPlayer->GetActor())

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

@ -58,7 +58,7 @@ void sfxKillAllSounds(void);
void sfxSetReverb(bool toggle);
void sfxSetReverb2(bool toggle);
void ambProcess(PLAYER* pPlayer);
void ambProcess(BloodPlayer* pPlayer);
void ambKillAll(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;
if (nPlayer >= 0 && nPlayer < kMaxPlayers && playeringame[nPlayer])
{
PLAYER* pPlayer = &gPlayer[nPlayer];
BloodPlayer* pPlayer = &gPlayer[nPlayer];
if (pPlayer->GetActor()->xspr.health > 0)
{
evKillActor(actor);
@ -598,7 +598,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
case kSoundPlayer:
if (gGameOptions.nGameType == 0)
{
PLAYER* pPlayer = &gPlayer[myconnectindex];
BloodPlayer* pPlayer = &gPlayer[myconnectindex];
if (pPlayer->GetActor()->xspr.health <= 0)
break;
@ -1596,7 +1596,7 @@ void OperateTeleport(sectortype* pSector)
{
if (actor->spr.statnum == kStatDude)
{
PLAYER* pPlayer;
BloodPlayer* pPlayer;
bool bPlayer = actor->IsPlayerActor();
if (bPlayer)
pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];

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

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

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

@ -73,13 +73,13 @@ extern DAngle gScreenTiltO, gScreenTilt;
extern int gShowFrameRate;
extern int gLastPal;
void hudDraw(PLAYER* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac);
void hudDraw(BloodPlayer* pPlayer, sectortype* pSector, double bobx, double boby, double zDelta, DAngle angle, int basepal, double interpfrac);
void viewInitializePrediction(void);
void viewUpdatePrediction(InputPacket* pInput);
void viewCorrectPrediction(void);
void viewBackupView(int nPlayer);
void InitStatusBar(void);
void UpdateStatusBar(PLAYER* pPlayer);
void UpdateStatusBar(BloodPlayer* pPlayer);
void viewInit(void);
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);
@ -89,7 +89,7 @@ void viewSetErrorMessage(const char* pMessage);
void DoLensEffect(void);
void UpdateDacs(int nPalette, bool bNoTint = false);
void viewDrawScreen(bool sceneonly = false);
void viewUpdateDelirium(PLAYER* pPlayer);
void viewUpdateDelirium(BloodPlayer* pPlayer);
void viewSetSystemMessage(const char* pMessage, ...);
inline void viewInterpolateSector(sectortype* pSector)

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