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

- SW: Rename PLAYER struct to SWPlayer.

Browse source
This commit is contained in:
Mitchell Richters 2023-10-02 15:42:55 +11:00
parent d107b6a1fa
commit dbb11eed4d
45 changed files with 620 additions and 620 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

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

@ -148,7 +148,7 @@ void markgcroots()
}
void pClearSpriteList(PLAYER* pp);
void pClearSpriteList(SWPlayer* pp);
int GameVersion = 20;
@ -573,7 +573,7 @@ void TerminateLevel(void)
TRAVERSE_CONNECT(pnum)
{
PLAYER* pp = &Player[pnum];
SWPlayer* pp = &Player[pnum];
if (pp->Flags & PF_DEAD)
PlayerDeathReset(pp);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -2120,7 +2120,7 @@ void InitAllPlayerSprites(const DVector3& spawnpos, const DAngle startang)
//
//---------------------------------------------------------------------------
void PlayerLevelReset(PLAYER* pp)
void PlayerLevelReset(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -2163,7 +2163,7 @@ void PlayerLevelReset(PLAYER* pp)
//
//---------------------------------------------------------------------------
void PlayerDeathReset(PLAYER* pp)
void PlayerDeathReset(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -2255,7 +2255,7 @@ void PlayerPanelSetup(void)
//
//---------------------------------------------------------------------------
void PlayerGameReset(PLAYER* pp)
void PlayerGameReset(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -2319,7 +2319,7 @@ extern ACTOR_ACTION_SET PlayerNinjaActionSet;
//
//---------------------------------------------------------------------------
void InitPlayerSprite(PLAYER* pp, const DVector3& spawnpos, const DAngle startang)
void InitPlayerSprite(SWPlayer* pp, const DVector3& spawnpos, const DAngle startang)
{
int pnum = int(pp - Player);
double fz,cz;
@ -2404,7 +2404,7 @@ void InitPlayerSprite(PLAYER* pp, const DVector3& spawnpos, const DAngle startan
//
//---------------------------------------------------------------------------
void SpawnPlayerUnderSprite(PLAYER* pp)
void SpawnPlayerUnderSprite(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();

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

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

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

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

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

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

522
source/games/sw/src/player.cpp
View file

File diff suppressed because it is too large Load diff

18
source/games/sw/src/player.h
View file

@ -125,15 +125,15 @@ void DoPlayer(void);
void domovethings(const ticcmd_t* playercmds);
void InitAllPlayers(void);
void InitMultiPlayerInfo(const DVector3& spawnpos, const DAngle startang);
void DoPlayerDivePalette(PLAYER* pp);
void DoPlayerNightVisionPalette(PLAYER* pp);
void DoPlayerStopDiveNoWarp(PLAYER* pp);
void DoPlayerResetMovement(PLAYER* pp);
void DoPlayerZrange(PLAYER* pp);
void DoPlayerSpriteThrow(PLAYER* pp);
int DoPlayerWadeSuperJump(PLAYER* pp);
void DoPlayerWarpTeleporter(PLAYER* pp);
void UpdatePlayerSprite(PLAYER* pp);
void DoPlayerDivePalette(SWPlayer* pp);
void DoPlayerNightVisionPalette(SWPlayer* pp);
void DoPlayerStopDiveNoWarp(SWPlayer* pp);
void DoPlayerResetMovement(SWPlayer* pp);
void DoPlayerZrange(SWPlayer* pp);
void DoPlayerSpriteThrow(SWPlayer* pp);
int DoPlayerWadeSuperJump(SWPlayer* pp);
void DoPlayerWarpTeleporter(SWPlayer* pp);
void UpdatePlayerSprite(SWPlayer* pp);
void PlaySOsound(sectortype* sect,short sound_num);
void DoSpawnTeleporterEffectPlace(DSWActor* sp);
void FindMainSector(SECTOR_OBJECT* sop);

12
source/games/sw/src/predict.cpp
View file

@ -38,9 +38,9 @@ BEGIN_SW_NS
bool PredictionOn = true;
bool Prediction = false;
PLAYER PredictPlayer;
SWPlayer PredictPlayer;
//USER PredictUser;
PLAYER* ppp = &PredictPlayer;
SWPlayer* ppp = &PredictPlayer;
struct PREDICT
{
@ -53,11 +53,11 @@ struct PREDICT
PREDICT Predict[/*MOVEFIFOSIZ*/256];
int predictmovefifoplc;
void DoPlayerSectorUpdatePreMove(PLAYER*);
void DoPlayerSectorUpdatePostMove(PLAYER*);
void DoPlayerSectorUpdatePreMove(SWPlayer*);
void DoPlayerSectorUpdatePostMove(SWPlayer*);
void InitPrediction(PLAYER* pp)
void InitPrediction(SWPlayer* pp)
{
if (!PredictionOn)
return;
@ -67,7 +67,7 @@ void InitPrediction(PLAYER* pp)
//PredictUser = *pp->actor->user;
}
void DoPrediction(PLAYER* ppp)
void DoPrediction(SWPlayer* ppp)
{
#if 0
spritetype spr;

6
source/games/sw/src/quake.cpp
View file

@ -179,7 +179,7 @@ void ProcessQuakeSpot(void)
//
//
//---------------------------------------------------------------------------
void QuakeViewChange(PLAYER* pp, DVector3& tpos, DAngle& tang)
void QuakeViewChange(SWPlayer* pp, DVector3& tpos, DAngle& tang)
{
DSWActor* save_act = nullptr;
double save_dist = 62500;
@ -275,7 +275,7 @@ void SpawnQuake(sectortype* sect, const DVector3& pos, int tics, int amt, int ra
//
//---------------------------------------------------------------------------
bool SetQuake(PLAYER* pp, short tics, short amt)
bool SetQuake(SWPlayer* pp, short tics, short amt)
{
SpawnQuake(pp->cursector, pp->GetActor()->getPosWithOffsetZ(), tics, amt, 30000);
return false;
@ -293,7 +293,7 @@ int SetGunQuake(DSWActor* actor)
return 0;
}
int SetPlayerQuake(PLAYER* pp)
int SetPlayerQuake(SWPlayer* pp)
{
SpawnQuake(pp->cursector, pp->GetActor()->getPosWithOffsetZ(), 40, 8, 40000);
return 0;

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

@ -38,9 +38,9 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
BEGIN_SW_NS
void DoRotatorMatch(PLAYER* pp, short match, bool);
void DoRotatorMatch(SWPlayer* pp, short match, bool);
bool TestRotatorMatchActive(short match);
void DoMatchEverything(PLAYER* pp, short match, short state);
void DoMatchEverything(SWPlayer* pp, short match, short state);
void DoRotatorSetInterp(DSWActor*);
void DoRotatorStopInterp(DSWActor*);
@ -149,7 +149,7 @@ void SetRotatorInactive(DSWActor* actor)
//
//---------------------------------------------------------------------------
void DoRotatorOperate(PLAYER* pp, sectortype* sect)
void DoRotatorOperate(SWPlayer* pp, sectortype* sect)
{
short match = sect->hitag;
@ -167,7 +167,7 @@ void DoRotatorOperate(PLAYER* pp, sectortype* sect)
//
//---------------------------------------------------------------------------
void DoRotatorMatch(PLAYER* pp, short match, bool manual)
void DoRotatorMatch(SWPlayer* pp, short match, bool manual)
{
DSWActor* firstVator = nullptr;

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

@ -417,7 +417,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, REMOTE_CONTROL& w,
//
//---------------------------------------------------------------------------
FSerializer& Serialize(FSerializer& arc, const char* keyname, PLAYER*& w, PLAYER** def)
FSerializer& Serialize(FSerializer& arc, const char* keyname, SWPlayer*& w, SWPlayer** def)
{
int ndx = w ? int(w - Player) : -1;
arc(keyname, ndx);
@ -431,7 +431,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, PLAYER*& w, PLAYER
//
//---------------------------------------------------------------------------
FSerializer& Serialize(FSerializer& arc, const char* keyname, PLAYER& w, PLAYER* def)
FSerializer& Serialize(FSerializer& arc, const char* keyname, SWPlayer& w, SWPlayer* def)
{
if (arc.BeginObject(keyname))
{

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

@ -89,7 +89,7 @@ void UpdateStatusBar()
::UpdateStatusBar(&info);
PLAYER* pp = &Player[screenpeek];
SWPlayer* pp = &Player[screenpeek];
if (pp->cookieTime > 0)
{
const int MESSAGE_LINE = 142; // Used to be 164

50
source/games/sw/src/sector.cpp
View file

@ -58,20 +58,20 @@ enum
SINE_SLOPED = BIT(3),
};
void DoPlayerBeginForceJump(PLAYER*);
void DoPlayerBeginForceJump(SWPlayer*);
sectortype* FindNextSectorByTag(sectortype* sect, int tag);
bool TestVatorMatchActive(short match);
bool TestSpikeMatchActive(short match);
bool TestRotatorMatchActive(short match);
bool TestSlidorMatchActive(short match);
int PlayerCheckDeath(PLAYER*, DSWActor*);
void DoVatorOperate(PLAYER*, sectortype*);
void DoVatorMatch(PLAYER* pp, short match);
void DoRotatorOperate(PLAYER*, sectortype*);
void DoRotatorMatch(PLAYER* pp, short match, bool);
void DoSlidorOperate(PLAYER*, sectortype*);
void DoSlidorMatch(PLAYER* pp, short match, bool);
int PlayerCheckDeath(SWPlayer*, DSWActor*);
void DoVatorOperate(SWPlayer*, sectortype*);
void DoVatorMatch(SWPlayer* pp, short match);
void DoRotatorOperate(SWPlayer*, sectortype*);
void DoRotatorMatch(SWPlayer* pp, short match, bool);
void DoSlidorOperate(SWPlayer*, sectortype*);
void DoSlidorMatch(SWPlayer* pp, short match, bool);
void DoTornadoObject(SECTOR_OBJECT* sop);
void DoAutoTurretObject(SECTOR_OBJECT* sop);
@ -80,7 +80,7 @@ void KillMatchingCrackSprites(short match);
int DoTrapReset(short match);
int DoTrapMatch(short match);
PLAYER* GlobPlayerP;
SWPlayer* GlobPlayerP;
ANIM Anim[MAXANIM];
short AnimCnt = 0;
@ -644,7 +644,7 @@ DVector3 SectorMidPoint(sectortype* sectp)
//
//---------------------------------------------------------------------------
void DoSpringBoard(PLAYER* pp)
void DoSpringBoard(SWPlayer* pp)
{
pp->jump_speed = -pp->cursector->hitag;
@ -744,7 +744,7 @@ short DoSpawnActorTrigger(short match)
int OperateSector(sectortype* sect, short player_is_operating)
{
PLAYER* pp = GlobPlayerP;
SWPlayer* pp = GlobPlayerP;
// Don't let actors operate locked or secret doors
if (!player_is_operating)
@ -1084,7 +1084,7 @@ void DoSoundSpotMatch(short match, short sound_num, short sound_type)
if (TEST_BOOL7(actor))
{
PLAYER* pp = GlobPlayerP;
SWPlayer* pp = GlobPlayerP;
if (pp)
{
@ -1413,9 +1413,9 @@ void DoChangorMatch(short match)
//
//---------------------------------------------------------------------------
void DoMatchEverything(PLAYER* pp, short match, short state)
void DoMatchEverything(SWPlayer* pp, short match, short state)
{
PLAYER* bak;
SWPlayer* bak;
bak = GlobPlayerP;
GlobPlayerP = pp;
@ -1500,7 +1500,7 @@ bool ComboSwitchTest(short combo_type, short match)
int OperateSprite(DSWActor* actor, short player_is_operating)
{
PLAYER* pp = nullptr;
SWPlayer* pp = nullptr;
short state;
short key_num=0;
extern STATE s_Pachinko1Operate[];
@ -1903,7 +1903,7 @@ int DoTrapMatch(short match)
//
//---------------------------------------------------------------------------
void TriggerSecret(sectortype* sectp, PLAYER* pp)
void TriggerSecret(sectortype* sectp, SWPlayer* pp)
{
if (pp == Player + myconnectindex)
PlayerSound(DIGI_ANCIENTSECRET, v3df_dontpan | v3df_doppler | v3df_follow, pp);
@ -1922,7 +1922,7 @@ void TriggerSecret(sectortype* sectp, PLAYER* pp)
//
//---------------------------------------------------------------------------
void OperateTripTrigger(PLAYER* pp)
void OperateTripTrigger(SWPlayer* pp)
{
if (Prediction)
return;
@ -2048,7 +2048,7 @@ void OperateTripTrigger(PLAYER* pp)
//
//---------------------------------------------------------------------------
void OperateContinuousTrigger(PLAYER* pp)
void OperateContinuousTrigger(SWPlayer* pp)
{
if (Prediction)
return;
@ -2073,7 +2073,7 @@ void OperateContinuousTrigger(PLAYER* pp)
//
//---------------------------------------------------------------------------
short PlayerTakeSectorDamage(PLAYER* pp)
short PlayerTakeSectorDamage(SWPlayer* pp)
{
auto sectu = pp->cursector;
DSWActor* actor = pp->GetActor();
@ -2097,7 +2097,7 @@ short PlayerTakeSectorDamage(PLAYER* pp)
//---------------------------------------------------------------------------
enum { PLAYER_SOUNDEVENT_TAG = 900 };
bool NearThings(PLAYER* pp)
bool NearThings(SWPlayer* pp)
{
HitInfo near;
@ -2184,7 +2184,7 @@ bool NearThings(PLAYER* pp)
static int nti_cnt;
void NearTagList(NEAR_TAG_INFO* ntip, PLAYER* pp, double z, double dist, int type, int count)
void NearTagList(NEAR_TAG_INFO* ntip, SWPlayer* pp, double z, double dist, int type, int count)
{
short save_lotag, save_hitag;
HitInfo near;
@ -2292,7 +2292,7 @@ void NearTagList(NEAR_TAG_INFO* ntip, PLAYER* pp, double z, double dist, int typ
//
//---------------------------------------------------------------------------
void BuildNearTagList(NEAR_TAG_INFO* ntip, int size, PLAYER* pp, double z, double dist, int type, int count)
void BuildNearTagList(NEAR_TAG_INFO* ntip, int size, SWPlayer* pp, double z, double dist, int type, int count)
{
memset(ntip, -1, size);
nti_cnt = 0;
@ -2305,7 +2305,7 @@ void BuildNearTagList(NEAR_TAG_INFO* ntip, int size, PLAYER* pp, double z, doubl
//
//---------------------------------------------------------------------------
int DoPlayerGrabStar(PLAYER* pp)
int DoPlayerGrabStar(SWPlayer* pp)
{
int i;
@ -2345,7 +2345,7 @@ int DoPlayerGrabStar(PLAYER* pp)
//
//---------------------------------------------------------------------------
void PlayerOperateEnv(PLAYER* pp)
void PlayerOperateEnv(SWPlayer* pp)
{
bool found;
@ -2880,7 +2880,7 @@ void DoSector(void)
bool riding;
int sync_flag;
short pnum;
PLAYER* pp;
SWPlayer* pp;
for (sop = SectorObject; sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++)
{

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

@ -38,11 +38,11 @@ int MoveDoorDown(short door_sector, short dir, short door_speed);
int MoveDoorHoriz(short door_sector, short dir, short door_speed);
void DoDoorsClose(void);
short Switch(short SwitchSector);
void PlayerOperateEnv(PLAYER* pp);
int TeleportToSector(PLAYER* pp, int newsector);
void PlayerOperateEnv(SWPlayer* pp);
int TeleportToSector(SWPlayer* pp, int newsector);
int OperateSector(sectortype* sect,short player_is_operating);
int OperateSprite(DSWActor*, short player_is_operating);
void OperateTripTrigger(PLAYER* pp);
void OperateTripTrigger(SWPlayer* pp);
enum SO_SCALE_TYPE
{
@ -65,7 +65,7 @@ struct NEAR_TAG_INFO
void DoSpawnSpotsForKill(short match);
void DoSpawnSpotsForDamage(short match);
void DoMatchEverything(PLAYER* pp, short match, short state);
void DoMatchEverything(SWPlayer* pp, short match, short state);
bool ComboSwitchTest(short combo_type,short match);
void DoSoundSpotStopSound(short match);
void DoSector(void);

6
source/games/sw/src/slidor.cpp
View file

@ -144,7 +144,7 @@ void SetSlidorInactive(DSWActor* actor)
//
//---------------------------------------------------------------------------
void DoSlidorOperate(PLAYER* pp, sectortype* sect)
void DoSlidorOperate(SWPlayer* pp, sectortype* sect)
{
short match;
@ -165,7 +165,7 @@ void DoSlidorOperate(PLAYER* pp, sectortype* sect)
//
//---------------------------------------------------------------------------
void DoSlidorMatch(PLAYER* pp, short match, bool manual)
void DoSlidorMatch(SWPlayer* pp, short match, bool manual)
{
SWStatIterator it(STAT_SLIDOR);
while (auto actor = it.Next())
@ -577,7 +577,7 @@ int DoSlidor(DSWActor* actor)
if (!found)
{
short pnum;
PLAYER* pp;
SWPlayer* pp;
// go ahead and look for players clip box bounds
TRAVERSE_CONNECT(pnum)
{

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

@ -324,7 +324,7 @@ static void UpdateAmbients()
if (sdist < 255 && sfx->ResourceId == DIGI_WHIPME)
{
PLAYER* pp = Player + screenpeek;
SWPlayer* pp = Player + screenpeek;
if (!FAFcansee(spot->spr.pos, spot->sector(), pp->GetActor()->getPosWithOffsetZ(), pp->cursector))
{
sdist = 255;
@ -379,7 +379,7 @@ public:
int SoundSourceIndex(FSoundChan* chan) override
{
if (chan->SourceType == SOURCE_Player) return int((PLAYER*)(chan->Source) - Player);
if (chan->SourceType == SOURCE_Player) return int((SWPlayer*)(chan->Source) - Player);
return 0;
}
@ -425,7 +425,7 @@ void SWSoundEngine::CalcPosVel(int type, const void* source, const float pt[3],
{
if (pos != nullptr)
{
PLAYER* pp = Player + screenpeek;
SWPlayer* pp = Player + screenpeek;
FVector3 campos = GetSoundPos(pp->GetActor() ? pp->GetActor()->getPosWithOffsetZ() : DVector3());
DVector3 vPos = {};
bool pancheck = false;
@ -446,7 +446,7 @@ void SWSoundEngine::CalcPosVel(int type, const void* source, const float pt[3],
}
else
{
auto act = ((PLAYER*)source)->GetActor();
auto act = ((SWPlayer*)source)->GetActor();
if (act) vPos = act->getPosWithOffsetZ();
else if (pp->GetActor())
vPos = pp->GetActor()->getPosWithOffsetZ();
@ -513,7 +513,7 @@ void SWSoundEngine::CalcPosVel(int type, const void* source, const float pt[3],
void GameInterface::UpdateSounds(void)
{
PLAYER* pp = Player + screenpeek;
SWPlayer* pp = Player + screenpeek;
SoundListener listener;
DAngle tang;
@ -549,7 +549,7 @@ void GameInterface::UpdateSounds(void)
//
//==========================================================================
int _PlaySound(const FSoundID sndid, DSWActor* actor, PLAYER* pp, const DVector3* const ppos, int flags, int channel, EChanFlags cflags)
int _PlaySound(const FSoundID sndid, DSWActor* actor, SWPlayer* pp, const DVector3* const ppos, int flags, int channel, EChanFlags cflags)
{
if (Prediction || !SoundEnabled() || !soundEngine->isValidSoundId(sndid))
return -1;
@ -715,7 +715,7 @@ void PlaySpriteSound(DSWActor* actor, int attrib_ndx, int flags)
//
//==========================================================================
int _PlayerSound(int num, PLAYER* pp)
int _PlayerSound(int num, SWPlayer* pp)
{
int handle;
@ -759,7 +759,7 @@ int _PlayerSound(int num, PLAYER* pp)
return 0;
}
void StopPlayerSound(PLAYER* pp, int which)
void StopPlayerSound(SWPlayer* pp, int which)
{
soundEngine->StopSound(SOURCE_Player, pp, CHAN_VOICE, soundEngine->FindSoundByResID(which));
}

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

@ -413,7 +413,7 @@ int DoSpike(DSWActor* actor)
if (!found)
{
short pnum;
PLAYER* pp;
SWPlayer* pp;
// go ahead and look for players clip box bounds
TRAVERSE_CONNECT(pnum)
{

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

@ -87,8 +87,8 @@ int SetupPachinko4(DSWActor*);
int SetupGirlNinja(DSWActor*);
int DoSlidorInstantClose(DSWActor*);
void InitWeaponRocket(PLAYER*);
void InitWeaponUzi(PLAYER*);
void InitWeaponRocket(SWPlayer*);
void InitWeaponUzi(SWPlayer*);
int MoveSkip4, MoveSkip2, MoveSkip8;
int MinEnemySkill;
@ -547,7 +547,7 @@ void KillActor(DSWActor* actor)
if (actor->hasU())
{
PLAYER* pp;
SWPlayer* pp;
int pnum;
// doing a MissileSetPos - don't allow killing
@ -4887,7 +4887,7 @@ int DoSpawnItemTeleporterEffect(DSWActor* actor)
//
//---------------------------------------------------------------------------
void ChoosePlayerGetSound(PLAYER* pp)
void ChoosePlayerGetSound(SWPlayer* pp)
{
int choose_snd=0;
@ -4904,7 +4904,7 @@ void ChoosePlayerGetSound(PLAYER* pp)
//
//---------------------------------------------------------------------------
bool CanGetWeapon(PLAYER* pp, DSWActor* actor, int WPN)
bool CanGetWeapon(SWPlayer* pp, DSWActor* actor, int WPN)
{
switch (gNet.MultiGameType)
{
@ -4964,7 +4964,7 @@ enum
};
int DoGet(DSWActor* actor)
{
PLAYER* pp;
SWPlayer* pp;
short pnum, key_num;
bool can_see;
@ -5865,7 +5865,7 @@ void ProcessActiveVars(DSWActor* actor)
//
//---------------------------------------------------------------------------
void AdjustActiveRange(PLAYER* pp, DSWActor* actor, double dist)
void AdjustActiveRange(SWPlayer* pp, DSWActor* actor, double dist)
{
DSWActor* plActor = pp->GetActor();
@ -6011,7 +6011,7 @@ void SpriteControl(void)
{
int32_t stat;
short pnum, CloseToPlayer;
PLAYER* pp;
SWPlayer* pp;
short StateTics;
SWStatIterator it(STAT_MISC);

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

@ -694,7 +694,7 @@ int DoSumoDeathMelt(DSWActor* actor)
void BossHealthMeter(void)
{
PLAYER* pp = Player + myconnectindex;
SWPlayer* pp = Player + myconnectindex;
short color=0,metertics,meterunit;
int y;
extern bool NoMeters;

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

@ -45,7 +45,7 @@ BEGIN_SW_NS
//
//---------------------------------------------------------------------------
void PutStringInfo(PLAYER* pp, const char *string)
void PutStringInfo(SWPlayer* pp, const char *string)
{
if (pp-Player == myconnectindex)
Printf(PRINT_MEDIUM|PRINT_NOTIFY, "%s\n", string); // Put it in the console too

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

@ -1453,9 +1453,9 @@ void PlaceActorsOnTracks(void)
}
void MovePlayer(PLAYER* pp, SECTOR_OBJECT* sop, const DVector2& move)
void MovePlayer(SWPlayer* pp, SECTOR_OBJECT* sop, const DVector2& move)
{
void DoPlayerZrange(PLAYER* pp);
void DoPlayerZrange(SWPlayer* pp);
// make sure your standing on the so
if (pp->Flags & (PF_JUMPING | PF_FALLING | PF_FLYING))
@ -1527,7 +1527,7 @@ void MovePoints(SECTOR_OBJECT* sop, DAngle deltaangle, const DVector2& move)
{
int j;
int pnum;
PLAYER* pp;
SWPlayer* pp;
sectortype** sectp;
int i;
DAngle rot_ang;
@ -3316,7 +3316,7 @@ present time.
int ActorFollowTrack(DSWActor* actor, short locktics)
{
PLAYER* pp;
SWPlayer* pp;
TRACK_POINT* tpoint;
short pnum;

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

@ -40,7 +40,7 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
BEGIN_SW_NS
void DoVatorMatch(PLAYER* pp, short match);
void DoVatorMatch(SWPlayer* pp, short match);
bool TestVatorMatchActive(short match);
void ReverseVator(DSWActor* actor)
@ -133,7 +133,7 @@ void SetVatorInactive(DSWActor* actor)
}
// called for operation from the space bar
void DoVatorOperate(PLAYER* pp, sectortype* sect)
void DoVatorOperate(SWPlayer* pp, sectortype* sect)
{
short match;
@ -180,7 +180,7 @@ void DoVatorOperate(PLAYER* pp, sectortype* sect)
// called from switches and triggers
// returns first vator found
void DoVatorMatch(PLAYER* pp, short match)
void DoVatorMatch(SWPlayer* pp, short match)
{
SWStatIterator it(STAT_VATOR);
while (auto actor = it.Next())
@ -479,7 +479,7 @@ int DoVator(DSWActor* actor)
if (!found)
{
short pnum;
PLAYER* pp;
SWPlayer* pp;
// go ahead and look for players clip box bounds
TRAVERSE_CONNECT(pnum)
{

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

@ -80,7 +80,7 @@ void ProcessVisOn(void)
}
}
void VisViewChange(PLAYER* pp, int *vis)
void VisViewChange(SWPlayer* pp, int *vis)
{
short BrightestVis = NormalVisibility;
DVector3 pos;

100
source/games/sw/src/weapon.cpp
View file

@ -54,7 +54,7 @@ struct MISSILE_PLACEMENT
void SpawnZombie2(DSWActor*);
Collision move_ground_missile(DSWActor* actor, const DVector2& change, double ceildist, double flordist, uint32_t cliptype, int numtics);
void DoPlayerBeginDie(PLAYER*);
void DoPlayerBeginDie(SWPlayer*);
void ScaleSpriteVector(DSWActor* actor, int scalex, int scaley, int scalez);
void ScaleSpriteVector(DSWActor* actor, int scale);
@ -118,7 +118,7 @@ void SpawnMicroExp(DSWActor*);
void SpawnExpZadjust(DSWActor* actor, DSWActor* expActor, double upper_zsize, double lower_zsize);
int BulletHitSprite(DSWActor* actor, DSWActor* hitActor, const DVector3& pos, short ID);
int SpawnSplashXY(const DVector3& pos, sectortype*);
DSWActor* SpawnBoatSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
DSWActor* SpawnBoatSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
short StatDamageList[STAT_DAMAGE_LIST_SIZE] =
{
@ -2540,7 +2540,7 @@ int SpawnShrapX(DSWActor* actor)
int DoLavaErupt(DSWActor* actor)
{
short i,pnum;
PLAYER* pp;
SWPlayer* pp;
bool found = false;
if (TEST_BOOL1(actor))
@ -3334,7 +3334,7 @@ AutoShrap:
p = StdShrap;
if (parentActor->user.PlayerP)
{
PLAYER* pp = parentActor->user.PlayerP;
SWPlayer* pp = parentActor->user.PlayerP;
if (pp->DeathType == PLAYER_DEATH_CRUMBLE)
p = PlayerGoreFall;
@ -4628,7 +4628,7 @@ int ActorChooseDeath(DSWActor* actor, DSWActor* weapActor)
actor->user.ID == CARGIRL_R0 || actor->user.ID == MECHANICGIRL_R0 || actor->user.ID == SAILORGIRL_R0 || actor->user.ID == PRUNEGIRL_R0 ||
actor->user.ID == WASHGIRL_R0) && weapActor->hasU() && weapActor->user.ID == NINJA_RUN_R0 && weapActor->user.PlayerP)
{
PLAYER* pp = weapActor->user.PlayerP;
SWPlayer* pp = weapActor->user.PlayerP;
if (pp && !(pp->Flags & PF_DIVING)) // JBF: added null test
pp->Bloody = true;
PlaySound(DIGI_TOILETGIRLSCREAM, actor, v3df_none);
@ -4653,7 +4653,7 @@ int ActorChooseDeath(DSWActor* actor, DSWActor* weapActor)
case NINJA_RUN_R0: //sword
if (weapActor->user.PlayerP)
{
PLAYER* pp = weapActor->user.PlayerP;
SWPlayer* pp = weapActor->user.PlayerP;
if (weapActor->user.WeaponNum == WPN_FIST && StdRandomRange(1000)>500 && pp == Player+myconnectindex)
{
@ -4752,7 +4752,7 @@ int ActorChooseDeath(DSWActor* actor, DSWActor* weapActor)
// Random chance of taunting the AI's here
if (RandomRange(1000) > 400)
{
PLAYER* pp;
SWPlayer* pp;
auto own = GetOwner(weapActor);
if (own && own->hasU())
@ -5109,7 +5109,7 @@ int ActorDamageSlide(DSWActor* actor, int damage, DAngle angle)
//
//---------------------------------------------------------------------------
int PlayerDamageSlide(PLAYER* pp, int damage, DAngle angle)
int PlayerDamageSlide(SWPlayer* pp, int damage, DAngle angle)
{
damage = abs(damage);
@ -5196,7 +5196,7 @@ int GetDamage(DSWActor* actor, DSWActor* weapActor, int DamageNdx)
//
//---------------------------------------------------------------------------
int PlayerCheckDeath(PLAYER* pp, DSWActor* weapActor)
int PlayerCheckDeath(SWPlayer* pp, DSWActor* weapActor)
{
DSWActor* actor = pp->GetActor();
@ -5263,7 +5263,7 @@ int PlayerCheckDeath(PLAYER* pp, DSWActor* weapActor)
//
//---------------------------------------------------------------------------
bool PlayerTakeDamage(PLAYER* pp, DSWActor* weapActor)
bool PlayerTakeDamage(SWPlayer* pp, DSWActor* weapActor)
{
if (weapActor == nullptr)
return true;
@ -5449,7 +5449,7 @@ int DoDamage(DSWActor* actor, DSWActor* weapActor)
}
else
{
PLAYER* pp = Player + screenpeek;
SWPlayer* pp = Player + screenpeek;
ActorHealth(actor, damage);
if (actor->user.Health <= 0)
@ -6710,7 +6710,7 @@ int DoDamage(DSWActor* actor, DSWActor* weapActor)
{
if (PlayerTakeDamage(actor->user.PlayerP, weapActor))
{
PLAYER* pp = actor->user.PlayerP;
SWPlayer* pp = actor->user.PlayerP;
PlayerSound(DIGI_GASHURT, v3df_dontpan|v3df_follow|v3df_doppler,pp);
PlayerUpdateHealth(actor->user.PlayerP, damage-1000);
@ -8738,7 +8738,7 @@ int DoMine(DSWActor* actor)
// check to see if sprite is player or enemy
if ((hitActor->spr.extra & SPRX_PLAYER_OR_ENEMY))
{
PLAYER* pp;
SWPlayer* pp;
// attach weapon to sprite
SetAttach(hitActor, actor);
@ -10069,7 +10069,7 @@ void SpawnNuclearSecondaryExp(DSWActor* actor, DAngle ang)
void SpawnNuclearExp(DSWActor* actor)
{
DAngle ang=nullAngle;
PLAYER* pp = nullptr;
SWPlayer* pp = nullptr;
short rnd_rng;
ASSERT(actor->hasU());
@ -11228,7 +11228,7 @@ int DoRing(DSWActor* actor)
{
auto own = GetOwner(actor);
if (!own) return 0; // this would crash.
PLAYER* pp = own->user.PlayerP;
SWPlayer* pp = own->user.PlayerP;
double cz,fz;
if (actor->user.Flags & (SPR_UNDERWATER))
@ -11315,7 +11315,7 @@ int DoRing(DSWActor* actor)
//
//---------------------------------------------------------------------------
void InitSpellRing(PLAYER* pp)
void InitSpellRing(SWPlayer* pp)
{
short missiles;
short max_missiles = 16;
@ -11690,7 +11690,7 @@ int InitSerpRing(DSWActor* actor)
//
//---------------------------------------------------------------------------
void InitSpellNapalm(PLAYER* pp)
void InitSpellNapalm(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
unsigned i;
@ -11846,7 +11846,7 @@ int InitEnemyNapalm(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitSpellMirv(PLAYER* pp)
int InitSpellMirv(SWPlayer* pp)
{
PlaySound(DIGI_MIRVFIRE, pp, v3df_none);
@ -11925,7 +11925,7 @@ int InitEnemyMirv(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitSwordAttack(PLAYER* pp)
int InitSwordAttack(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
unsigned stat;
@ -12093,7 +12093,7 @@ int InitSwordAttack(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitFistAttack(PLAYER* pp)
int InitFistAttack(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
unsigned stat;
@ -12707,7 +12707,7 @@ void WeaponHitscanShootFeet(DSWActor* actor, DSWActor* hitActor, double *zvect)
}
}
int InitStar(PLAYER* pp)
int InitStar(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
@ -12811,7 +12811,7 @@ int InitStar(PLAYER* pp)
//
//---------------------------------------------------------------------------
void InitHeartAttack(PLAYER* pp)
void InitHeartAttack(SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
short i = 0;
@ -12864,7 +12864,7 @@ void InitHeartAttack(PLAYER* pp)
//
//---------------------------------------------------------------------------
int ContinueHitscan(PLAYER* pp, sectortype* sect, const DVector3& start, DAngle ang, const DVector3& vect)
int ContinueHitscan(SWPlayer* pp, sectortype* sect, const DVector3& start, DAngle ang, const DVector3& vect)
{
HitInfo hit{};
DSWActor* actor = pp->GetActor();
@ -12948,7 +12948,7 @@ int ContinueHitscan(PLAYER* pp, sectortype* sect, const DVector3& start, DAngle
//
//---------------------------------------------------------------------------
int InitShotgun(PLAYER* pp)
int InitShotgun(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
HitInfo hit{};
@ -13114,7 +13114,7 @@ int InitShotgun(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitLaser(PLAYER* pp)
int InitLaser(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -13204,7 +13204,7 @@ int InitLaser(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitRail(PLAYER* pp)
int InitRail(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
double zvel;
@ -13361,7 +13361,7 @@ int InitZillaRail(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitRocket(PLAYER* pp)
int InitRocket(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
double zvel;
@ -13471,7 +13471,7 @@ int InitRocket(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitBunnyRocket(PLAYER* pp)
int InitBunnyRocket(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
double zvel;
@ -13576,7 +13576,7 @@ int InitBunnyRocket(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitNuke(PLAYER* pp)
int InitNuke(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
double zvel;
@ -13743,7 +13743,7 @@ int InitEnemyNuke(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitMicro(PLAYER* pp)
int InitMicro(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
short i;
@ -14432,7 +14432,7 @@ int InitEnemyRail(DSWActor* actor)
// if co-op don't hurt teammate
if (gNet.MultiGameType == MULTI_GAME_COOPERATIVE && actor->user.ID == ZOMBIE_RUN_R0)
{
PLAYER* pp;
SWPlayer* pp;
// Check all players
TRAVERSE_CONNECT(pnum)
@ -14959,7 +14959,7 @@ int DoDefaultStat(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitTracerUzi(PLAYER* pp)
int InitTracerUzi(SWPlayer* pp)
{
if (!pp->insector())
return 0;
@ -15222,7 +15222,7 @@ bool HitscanSpriteAdjust(DSWActor* actor, walltype* hit_wall)
//
//---------------------------------------------------------------------------
int InitUzi(PLAYER* pp)
int InitUzi(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
HitInfo hit{};
@ -15233,7 +15233,7 @@ int InitUzi(PLAYER* pp)
bool FireSnd = false;
const int UZIFIRE_WAIT = 20;
void InitUziShell(PLAYER*);
void InitUziShell(SWPlayer*);
PlayerUpdateAmmo(pp, actor->user.WeaponNum, -1);
@ -15423,7 +15423,7 @@ int InitUzi(PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTankShell(DSWActor* actor, PLAYER* pp)
int InitTankShell(DSWActor* actor, SWPlayer* pp)
{
if (!SW_SHAREWARE)
PlaySound(DIGI_CANNON, pp, v3df_dontpan|v3df_doppler);
@ -15466,7 +15466,7 @@ int InitTankShell(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTurretMicro(DSWActor* actor, PLAYER* pp)
int InitTurretMicro(DSWActor* actor, SWPlayer* pp)
{
DSWActor* plActor = pp->GetActor();
TARGET_SORT* ts = TargetSort;
@ -15562,7 +15562,7 @@ int InitTurretMicro(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTurretRocket(DSWActor* actor, PLAYER* pp)
int InitTurretRocket(DSWActor* actor, SWPlayer* pp)
{
if (SW_SHAREWARE) return false; // JBF: verify
@ -15601,7 +15601,7 @@ int InitTurretRocket(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTurretFireball(DSWActor* actor, PLAYER* pp)
int InitTurretFireball(DSWActor* actor, SWPlayer* pp)
{
if (SW_SHAREWARE) return false; // JBF: verify
@ -15641,7 +15641,7 @@ int InitTurretFireball(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTurretRail(DSWActor* actor, PLAYER* pp)
int InitTurretRail(DSWActor* actor, SWPlayer* pp)
{
if (SW_SHAREWARE) return false; // JBF: verify
@ -15687,7 +15687,7 @@ int InitTurretRail(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitTurretLaser(DSWActor* actor, PLAYER* pp)
int InitTurretLaser(DSWActor* actor, SWPlayer* pp)
{
if (SW_SHAREWARE) return false; // JBF: verify
@ -15730,7 +15730,7 @@ int InitTurretLaser(DSWActor* actor, PLAYER* pp)
//
//---------------------------------------------------------------------------
int InitSobjMachineGun(DSWActor* actor, PLAYER* pp)
int InitSobjMachineGun(DSWActor* actor, SWPlayer* pp)
{
HitInfo hit{};
short cstat = 0;
@ -15820,7 +15820,7 @@ int InitSobjMachineGun(DSWActor* actor, PLAYER* pp)
return 0;
}
int InitSobjGun(PLAYER* pp)
int InitSobjGun(SWPlayer* pp)
{
short i;
bool first = false;
@ -15932,7 +15932,7 @@ int InitSobjGun(PLAYER* pp)
//
//---------------------------------------------------------------------------
DSWActor* SpawnBoatSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
DSWActor* SpawnBoatSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
{
auto actorNew = SpawnActor(STAT_MISSILE, UZI_SMOKE, s_UziSmoke, hit_sect, hitpos, hit_ang, 0);
actorNew->spr.shade = -40;
@ -15972,7 +15972,7 @@ DSWActor* SpawnBoatSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall,
//
//---------------------------------------------------------------------------
int SpawnSwordSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
int SpawnSwordSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
{
DSWActor* actor = pp->GetActor();
@ -16050,7 +16050,7 @@ DSWActor* SpawnTurretSparks(sectortype* hit_sect, walltype* hit_wall, const DVec
//
//---------------------------------------------------------------------------
DSWActor* SpawnShotgunSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
DSWActor* SpawnShotgunSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang)
{
const double SHOTGUN_SMOKE_REPEAT = 0.28125;
@ -16248,7 +16248,7 @@ int InitEnemyUzi(DSWActor* actor)
DAngle daang;
HitInfo hit{};
double zh;
void InitUziShell(PLAYER*);
void InitUziShell(SWPlayer*);
static short alternate;
@ -16391,7 +16391,7 @@ int InitEnemyUzi(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitGrenade(PLAYER* pp)
int InitGrenade(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
double zvel;
@ -16536,7 +16536,7 @@ int InitSpriteGrenade(DSWActor* actor)
//
//---------------------------------------------------------------------------
int InitMine(PLAYER* pp)
int InitMine(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -16664,7 +16664,7 @@ int HelpMissileLateral(DSWActor* actor, int dist)
//
//---------------------------------------------------------------------------
int InitFireball(PLAYER* pp)
int InitFireball(SWPlayer* pp)
{
DSWActor* actor = pp->GetActor();
@ -17952,7 +17952,7 @@ int DoFloorBlood(DSWActor* actor)
constexpr double FEET_IN_BLOOD_DIST = 18.75;
short pnum;
PLAYER* pp;
SWPlayer* pp;
double scale;

30
source/games/sw/src/weapon.h
View file

@ -38,7 +38,7 @@ inline DAngle AngToSprite(DSWActor* actor, DSWActor* other)
return (actor->spr.pos - other->spr.pos).Angle();
}
inline DAngle AngToPlayer(PLAYER* player, DSWActor* other)
inline DAngle AngToPlayer(SWPlayer* player, DSWActor* other)
{
return (player->GetActor()->getPosWithOffsetZ() - other->spr.pos).Angle();
}
@ -81,14 +81,14 @@ extern int LoWangsQueueHead;
extern TObjPtr<DSWActor*> LoWangsQueue[MAX_LOWANGS_QUEUE];
void ChangeState(DSWActor* actor, STATE* statep);
void DoPlayerBeginRecoil(PLAYER* pp, double pix_amt);
void DoPlayerBeginRecoil(SWPlayer* pp, double pix_amt);
SECTOR_OBJECT* DetectSectorObject(sectortype*);
SECTOR_OBJECT* DetectSectorObjectByWall(walltype*);
void ScaleSpriteVector(DSWActor* actor, int scale);
void QueueHole(sectortype* hit_sect, walltype* hit_wall, const DVector3& pos);
DSWActor* QueueWallBlood(DSWActor* hit, DAngle ang);
bool SlopeBounce(DSWActor*, bool *hit_wall);
int SpawnSwordSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
int SpawnSwordSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
DSWActor* SpawnBubble(DSWActor*);
void SpawnFireballExp(DSWActor*);
void SpawnFireballFlames(DSWActor* actor, DSWActor* enemyActor);
@ -100,7 +100,7 @@ int ShrapKillSprite(DSWActor*);
bool MissileSetPos(DSWActor*,VMFunction* DoWeapon,int dist);
int ActorPain(DSWActor*);
int SpawnBreakFlames(DSWActor*);
bool PlayerTakeDamage(PLAYER* pp, DSWActor* weapActor);
bool PlayerTakeDamage(SWPlayer* pp, DSWActor* weapActor);
const char *DeathString(DSWActor*);
//
@ -163,7 +163,7 @@ inline double CloseRangeDist(DSWActor* a1, DSWActor* a2, double fudge = 25)
extern short target_ang;
DSWActor* SpawnShotgunSparks(PLAYER* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
DSWActor* SpawnShotgunSparks(SWPlayer* pp, sectortype* hit_sect, walltype* hit_wall, const DVector3& hitpos, DAngle hit_ang);
int DoActorBeginSlide(DSWActor* actor, DAngle ang, double vel);
int GetOverlapSector(const DVector2& pos, sectortype** over, sectortype** under);
@ -183,12 +183,12 @@ void WallBounce(DSWActor*, DAngle ang);
#define CALTROPS 2218
#define PHOSPHORUS 1397
int PlayerInitChemBomb(PLAYER* pp);
int PlayerInitChemBomb(SWPlayer* pp);
int InitChemBomb(DSWActor*);
int PlayerInitCaltrops(PLAYER* pp);
int PlayerInitCaltrops(SWPlayer* pp);
int InitBloodSpray(DSWActor* actor, bool dogib, short velocity);
int SpawnBunnyExp(DSWActor* actor);
int InitBunnyRocket(PLAYER* pp);
int InitBunnyRocket(SWPlayer* pp);
int GetDamage(DSWActor*, DSWActor*, int DamageNdx);
int DoFlamesDamageTest(DSWActor*);
@ -212,12 +212,12 @@ int SetSuicide(DSWActor*);
void UpdateSinglePlayKills(DSWActor* actor);
int InitPlasmaFountain(DSWActor* wActor, DSWActor* sActor);
int InitCoolgDrip(DSWActor*);
int InitFireball(PLAYER* pp);
void InitSpellRing(PLAYER* pp);
void InitSpellNapalm(PLAYER* pp);
int InitFireball(SWPlayer* pp);
void InitSpellRing(SWPlayer* pp);
void InitSpellNapalm(SWPlayer* pp);
int DoStaticFlamesDamage(DSWActor*);
int InitUzi(PLAYER* pp);
int InitSobjGun(PLAYER* pp);
int InitUzi(SWPlayer* pp);
int InitSobjGun(SWPlayer* pp);
void InitFireballTrap(DSWActor* actor);
void InitBoltTrap(DSWActor* actor);
void InitSpearTrap(DSWActor*);
@ -230,9 +230,9 @@ void SpriteQueueDelete(DSWActor* actor);
int HelpMissileLateral(DSWActor*, int dist);
void AddSpriteToSectorObject(DSWActor*,SECTOR_OBJECT* sop);
void QueueReset(void);
int PlayerCheckDeath(PLAYER* pp,DSWActor*);
int PlayerCheckDeath(SWPlayer* pp,DSWActor*);
bool SpriteWarpToUnderwater(DSWActor* actor);
int PlayerDamageSlide(PLAYER* pp,int damage,DAngle ang);
int PlayerDamageSlide(SWPlayer* pp,int damage,DAngle ang);
bool VehicleMoveHit(DSWActor*);
int SpawnSplash(DSWActor*);
void SpawnMineExp(DSWActor*);

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

@ -771,7 +771,7 @@ int SetupZombie(DSWActor* actor)
//
//---------------------------------------------------------------------------
void SpawnZombie(PLAYER* pp, DSWActor* weaponActor)
void SpawnZombie(SWPlayer* pp, DSWActor* weaponActor)
{
auto ownerActor = GetOwner(weaponActor);