zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2025-01-18 15:42:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'PSprites'

Browse source
This commit is contained in:
Christoph Oelckers 2016-06-16 16:16:16 +02:00
commit 7ccdbf9b62
28 changed files with 1020 additions and 520 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/d_player.h
View file

@ -380,6 +380,7 @@ class player_t
{
public:
player_t();
~player_t();
player_t &operator= (const player_t &p);
void Serialize (FArchive &arc);
@ -435,6 +436,7 @@ public:
AWeapon *ReadyWeapon;
AWeapon *PendingWeapon; // WP_NOCHANGE if not changing
TObjPtr<DPSprite> psprites; // view sprites (gun, etc)
int cheats; // bit flags
int timefreezer; // Player has an active time freezer
@ -454,7 +456,6 @@ public:
int extralight; // so gun flashes light up areas
short fixedcolormap; // can be set to REDCOLORMAP, etc.
short fixedlightlevel;
pspdef_t psprites[NUMPSPRITES]; // view sprites (gun, etc)
int morphTics; // player is a chicken/pig if > 0
PClassPlayerPawn *MorphedPlayerClass; // [MH] (for SBARINFO) class # for this player instance when morphed
int MorphStyle; // which effects to apply for this player instance when morphed
@ -526,6 +527,12 @@ public:
}
int GetSpawnClass();
// PSprite layers
void TickPSprites();
void DestroyPSprites();
DPSprite *FindPSprite(int layer);
DPSprite *GetPSprite(PSPLayers layer); // Used ONLY for compatibility with the old hardcoded layers.
};
// Bookkeeping on players - state.

38
src/g_doom/a_doomweaps.cpp
View file

@ -73,16 +73,15 @@ DEFINE_ACTION_FUNCTION(AActor, A_FirePistol)
bool accurate;
if (self->player != NULL)
if (self->player != nullptr)
{
AWeapon *weapon = self->player->ReadyWeapon;
if (weapon != NULL && ACTION_CALL_FROM_WEAPON())
if (weapon != nullptr && ACTION_CALL_FROM_WEAPON())
{
if (!weapon->DepleteAmmo (weapon->bAltFire, true, 1))
return 0;
P_SetPsprite (self->player, ps_flash, weapon->FindState(NAME_Flash));
self->player->psprites[ps_flash].processPending = true;
P_SetPsprite(self->player, PSP_FLASH, weapon->FindState(NAME_Flash), true);
}
self->player->mo->PlayAttacking2 ();
@ -263,19 +262,18 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireShotgun)
int i;
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
S_Sound (self, CHAN_WEAPON, "weapons/shotgf", 1, ATTN_NORM);
AWeapon *weapon = self->player->ReadyWeapon;
if (weapon != NULL && ACTION_CALL_FROM_WEAPON())
if (weapon != nullptr && ACTION_CALL_FROM_WEAPON())
{
if (!weapon->DepleteAmmo (weapon->bAltFire, true, 1))
return 0;
P_SetPsprite (player, ps_flash, weapon->FindState(NAME_Flash));
self->player->psprites[ps_flash].processPending = true;
P_SetPsprite(player, PSP_FLASH, weapon->FindState(NAME_Flash), true);
}
player->mo->PlayAttacking2 ();
@ -300,19 +298,18 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireShotgun2)
int damage;
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
S_Sound (self, CHAN_WEAPON, "weapons/sshotf", 1, ATTN_NORM);
AWeapon *weapon = self->player->ReadyWeapon;
if (weapon != NULL && ACTION_CALL_FROM_WEAPON())
if (weapon != nullptr && ACTION_CALL_FROM_WEAPON())
{
if (!weapon->DepleteAmmo (weapon->bAltFire, true, 2))
return 0;
P_SetPsprite (player, ps_flash, weapon->FindState(NAME_Flash));
self->player->psprites[ps_flash].processPending = true;
P_SetPsprite(player, PSP_FLASH, weapon->FindState(NAME_Flash), true);
}
player->mo->PlayAttacking2 ();
@ -384,15 +381,13 @@ void P_SetSafeFlash(AWeapon *weapon, player_t *player, FState *flashstate, int i
if (flashstate + index < cls->OwnedStates + cls->NumOwnedStates)
{
// we're ok so set the state
P_SetPsprite (player, ps_flash, flashstate + index);
player->psprites[ps_flash].processPending = true;
P_SetPsprite(player, PSP_FLASH, flashstate + index, true);
return;
}
else
{
// oh, no! The state is beyond the end of the state table so use the original flash state.
P_SetPsprite (player, ps_flash, flashstate);
player->psprites[ps_flash].processPending = true;
P_SetPsprite(player, PSP_FLASH, flashstate, true);
return;
}
}
@ -408,8 +403,7 @@ void P_SetSafeFlash(AWeapon *weapon, player_t *player, FState *flashstate, int i
{ // Invalid state. With no index offset, it should at least be valid.
index = 0;
}
P_SetPsprite (player, ps_flash, flashstate + index);
player->psprites[ps_flash].processPending = true;
P_SetPsprite(player, PSP_FLASH, flashstate + index, true);
}
//
@ -421,13 +415,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireCGun)
player_t *player;
if (self == NULL || NULL == (player = self->player))
if (self == nullptr || nullptr == (player = self->player))
{
return 0;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL && ACTION_CALL_FROM_WEAPON())
if (weapon != nullptr && ACTION_CALL_FROM_WEAPON())
{
if (!weapon->DepleteAmmo (weapon->bAltFire, true, 1))
return 0;
@ -435,12 +429,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireCGun)
S_Sound (self, CHAN_WEAPON, "weapons/chngun", 1, ATTN_NORM);
FState *flash = weapon->FindState(NAME_Flash);
if (flash != NULL)
if (flash != nullptr)
{
// [RH] Fix for Sparky's messed-up Dehacked patch! Blargh!
FState * atk = weapon->FindState(NAME_Fire);
int theflash = clamp (int(player->psprites[ps_weapon].state - atk), 0, 1);
int theflash = clamp (int(player->GetPSprite(PSP_WEAPON)->GetState() - atk), 0, 1);
if (flash[theflash].sprite != flash->sprite)
{

2
src/g_game.cpp
View file

@ -1750,6 +1750,8 @@ void G_DoPlayerPop(int playernum)
players[playernum].mo = NULL;
players[playernum].camera = NULL;
}
players[playernum].DestroyPSprites();
}
void G_ScreenShot (char *filename)

14
src/g_heretic/a_chicken.cpp
View file

@ -123,9 +123,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_Feathers)
void P_UpdateBeak (AActor *self)
{
if (self->player != NULL)
if (self->player != nullptr)
{
self->player->psprites[ps_weapon].sy = WEAPONTOP + self->player->chickenPeck / 2;
self->player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP + self->player->chickenPeck / 2;
}
}
@ -141,12 +141,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_BeakRaise)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
player->psprites[ps_weapon].sy = WEAPONTOP;
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->GetReadyState());
player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP;
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->GetReadyState());
return 0;
}
@ -192,7 +192,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_BeakAttackPL1)
}
P_PlayPeck (player->mo);
player->chickenPeck = 12;
player->psprites[ps_weapon].tics -= pr_beakatkpl1() & 7;
player->GetPSprite(PSP_WEAPON)->Tics -= pr_beakatkpl1() & 7;
return 0;
}
@ -227,6 +227,6 @@ DEFINE_ACTION_FUNCTION(AActor, A_BeakAttackPL2)
}
P_PlayPeck (player->mo);
player->chickenPeck = 12;
player->psprites[ps_weapon].tics -= pr_beakatkpl2()&3;
player->GetPSprite(PSP_WEAPON)->Tics -= pr_beakatkpl2()&3;
return 0;
}

26
src/g_heretic/a_hereticweaps.cpp
View file

@ -259,7 +259,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GauntletAttack)
FTranslatedLineTarget t;
int actualdamage = 0;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -267,13 +267,14 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GauntletAttack)
PARAM_INT(power);
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
if (weapon != nullptr)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return 0;
player->GetPSprite(PSP_WEAPON)->x = ((pr_gatk() & 3) - 2);
player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP + (pr_gatk() & 3);
}
player->psprites[ps_weapon].sx = ((pr_gatk()&3)-2);
player->psprites[ps_weapon].sy = WEAPONTOP + (pr_gatk()&3);
Angle = self->Angles.Yaw;
if (power)
{
@ -425,7 +426,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireMacePL1)
AActor *ball;
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -436,13 +437,14 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireMacePL1)
return 0;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
if (weapon != nullptr)
{
if (!weapon->DepleteAmmo(weapon->bAltFire))
return 0;
player->GetPSprite(PSP_WEAPON)->x = ((pr_maceatk() & 3) - 2);
player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP + (pr_maceatk() & 3);
}
player->psprites[ps_weapon].sx = ((pr_maceatk() & 3) - 2);
player->psprites[ps_weapon].sy = WEAPONTOP + (pr_maceatk() & 3);
ball = P_SpawnPlayerMissile(self, PClass::FindActor("MaceFX1"), self->Angles.Yaw + (((pr_maceatk() & 7) - 4) * (360. / 256)));
if (ball)
{
@ -1158,11 +1160,11 @@ IMPLEMENT_CLASS (APhoenixRodPowered)
void APhoenixRodPowered::EndPowerup ()
{
P_SetPsprite (Owner->player, ps_weapon, SisterWeapon->GetReadyState());
DepleteAmmo (bAltFire);
Owner->player->refire = 0;
S_StopSound (Owner, CHAN_WEAPON);
Owner->player->ReadyWeapon = SisterWeapon;
P_SetPsprite(Owner->player, PSP_WEAPON, SisterWeapon->GetReadyState());
}
class APhoenixFX1 : public AActor
@ -1298,7 +1300,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FirePhoenixPL2)
player_t *player;
APhoenixRod *flamethrower;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -1306,9 +1308,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_FirePhoenixPL2)
soundid = "weapons/phoenixpowshoot";
flamethrower = static_cast<APhoenixRod *> (player->ReadyWeapon);
if (flamethrower == NULL || --flamethrower->FlameCount == 0)
if (flamethrower == nullptr || --flamethrower->FlameCount == 0)
{ // Out of flame
P_SetPsprite (player, ps_weapon, flamethrower->FindState("Powerdown"));
P_SetPsprite(player, PSP_WEAPON, flamethrower->FindState("Powerdown"));
player->refire = 0;
S_StopSound (self, CHAN_WEAPON);
return 0;

12
src/g_hexen/a_clericstaff.cpp
View file

@ -58,7 +58,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CStaffCheck)
FTranslatedLineTarget t;
PClassActor *puff;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -77,7 +77,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CStaffCheck)
if (t.linetarget)
{
P_LineAttack(pmo, angle, 1.5 * MELEERANGE, slope, damage, NAME_Melee, puff, false, &t);
if (t.linetarget != NULL)
if (t.linetarget != nullptr)
{
pmo->Angles.Yaw = t.angleFromSource;
if (((t.linetarget->player && (!t.linetarget->IsTeammate(pmo) || level.teamdamage != 0)) || t.linetarget->flags3&MF3_ISMONSTER)
@ -89,13 +89,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_CStaffCheck)
{
pmo->health = player->health = newLife;
}
if (weapon != NULL)
if (weapon != nullptr)
{
FState * newstate = weapon->FindState("Drain");
if (newstate != NULL) P_SetPsprite(player, ps_weapon, newstate);
if (newstate != nullptr) P_SetPsprite(player, PSP_WEAPON, newstate);
}
}
if (weapon != NULL)
if (weapon != nullptr)
{
weapon->DepleteAmmo(weapon->bAltFire, false);
}
@ -187,7 +187,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CStaffCheckBlink)
{
if (!--self->weaponspecial)
{
P_SetPsprite (self->player, ps_weapon, self->player->ReadyWeapon->FindState ("Blink"));
P_SetPsprite(self->player, PSP_WEAPON, self->player->ReadyWeapon->FindState ("Blink"));
self->weaponspecial = (pr_blink()+50)>>2;
}
else

32
src/g_hexen/a_fighteraxe.cpp
View file

@ -70,13 +70,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeCheckReady)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
if (player->ReadyWeapon->Ammo1->Amount)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("ReadyGlow"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("ReadyGlow"));
}
else
{
@ -97,13 +97,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeCheckReadyG)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
if (player->ReadyWeapon->Ammo1->Amount <= 0)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("Ready"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("Ready"));
}
else
{
@ -124,13 +124,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeCheckUp)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
if (player->ReadyWeapon->Ammo1->Amount)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("SelectGlow"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("SelectGlow"));
}
else
{
@ -151,13 +151,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeCheckUpG)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
if (player->ReadyWeapon->Ammo1->Amount <= 0)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("Select"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("Select"));
}
else
{
@ -178,13 +178,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeCheckAtk)
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
if (player->ReadyWeapon->Ammo1->Amount)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("FireGlow"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("FireGlow"));
}
return 0;
}
@ -210,7 +210,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeAttack)
PClassActor *pufftype;
FTranslatedLineTarget t;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -241,7 +241,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FAxeAttack)
if (t.linetarget)
{
P_LineAttack(pmo, angle, AXERANGE, slope, damage, NAME_Melee, pufftype, true, &t);
if (t.linetarget != NULL)
if (t.linetarget != nullptr)
{
if (t.linetarget->flags3&MF3_ISMONSTER || t.linetarget->player)
{
@ -265,15 +265,15 @@ axedone:
if (useMana == 2)
{
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
if (weapon != nullptr)
{
weapon->DepleteAmmo (weapon->bAltFire, false);
if ((weapon->Ammo1 == NULL || weapon->Ammo1->Amount == 0) &&
if ((weapon->Ammo1 == nullptr || weapon->Ammo1->Amount == 0) &&
(!(weapon->WeaponFlags & WIF_PRIMARY_USES_BOTH) ||
weapon->Ammo2 == NULL || weapon->Ammo2->Amount == 0))
weapon->Ammo2 == nullptr || weapon->Ammo2->Amount == 0))
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState ("Fire") + 5);
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState ("Fire") + 5);
}
}
}

4
src/g_hexen/a_fighterplayer.cpp
View file

@ -105,7 +105,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FPunchAttack)
int i;
player_t *player;
if (NULL == (player = self->player))
if (nullptr == (player = self->player))
{
return 0;
}
@ -120,7 +120,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_FPunchAttack)
if (pmo->weaponspecial >= 3)
{
pmo->weaponspecial = 0;
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->FindState("Fire2"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState("Fire2"));
S_Sound (pmo, CHAN_VOICE, "*fistgrunt", 1, ATTN_NORM);
}
return 0;

4
src/g_hexen/a_pig.cpp
View file

@ -37,9 +37,9 @@ void APigPlayer::MorphPlayerThink ()
}
if(Vel.X == 0 && Vel.Y == 0 && pr_pigplayerthink() < 64)
{ // Snout sniff
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
P_SetPsprite(player, ps_weapon, player->ReadyWeapon->FindState("Grunt"));
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->FindState("Grunt"));
}
S_Sound (this, CHAN_VOICE, "PigActive1", 1, ATTN_NORM); // snort
return;

73
src/g_shared/a_artifacts.cpp
View file

@ -1109,17 +1109,17 @@ void APowerWeaponLevel2::InitEffect ()
Super::InitEffect();
if (Owner->player == NULL)
if (Owner->player == nullptr)
return;
weapon = Owner->player->ReadyWeapon;
if (weapon == NULL)
if (weapon == nullptr)
return;
sister = weapon->SisterWeapon;
if (sister == NULL)
if (sister == nullptr)
return;
if (!(sister->WeaponFlags & WIF_POWERED_UP))
@ -1131,7 +1131,7 @@ void APowerWeaponLevel2::InitEffect ()
if (weapon->GetReadyState() != sister->GetReadyState())
{
P_SetPsprite (Owner->player, ps_weapon, sister->GetReadyState());
P_SetPsprite(Owner->player, PSP_WEAPON, sister->GetReadyState());
}
}
@ -1294,29 +1294,42 @@ void APowerTargeter::Travelled ()
void APowerTargeter::InitEffect ()
{
// Why is this called when the inventory isn't even attached yet
// in APowerup::CreateCopy?
if (!Owner->FindInventory(GetClass(), true))
return;
player_t *player;
Super::InitEffect();
if ((player = Owner->player) == NULL)
if ((player = Owner->player) == nullptr)
return;
FState *state = FindState("Targeter");
if (state != NULL)
if (state != nullptr)
{
P_SetPsprite (player, ps_targetcenter, state + 0);
P_SetPsprite (player, ps_targetleft, state + 1);
P_SetPsprite (player, ps_targetright, state + 2);
P_SetPsprite(player, PSP_TARGETCENTER, state + 0);
P_SetPsprite(player, PSP_TARGETLEFT, state + 1);
P_SetPsprite(player, PSP_TARGETRIGHT, state + 2);
}
player->psprites[ps_targetcenter].sx = (160-3);
player->psprites[ps_targetcenter].sy =
player->psprites[ps_targetleft].sy =
player->psprites[ps_targetright].sy = (100-3);
player->GetPSprite(PSP_TARGETCENTER)->x = (160-3);
player->GetPSprite(PSP_TARGETCENTER)->y =
player->GetPSprite(PSP_TARGETLEFT)->y =
player->GetPSprite(PSP_TARGETRIGHT)->y = (100-3);
PositionAccuracy ();
}
void APowerTargeter::AttachToOwner(AActor *other)
{
Super::AttachToOwner(other);
// Let's actually properly call this for the targeters.
InitEffect();
}
bool APowerTargeter::HandlePickup(AInventory *item)
{
if (Super::HandlePickup(item))
@ -1327,13 +1340,11 @@ bool APowerTargeter::HandlePickup(AInventory *item)
return false;
}
void APowerTargeter::DoEffect ()
{
Super::DoEffect ();
if (Owner != NULL && Owner->player != NULL)
if (Owner != nullptr && Owner->player != nullptr)
{
player_t *player = Owner->player;
@ -1342,17 +1353,17 @@ void APowerTargeter::DoEffect ()
{
FState *state = FindState("Targeter");
if (state != NULL)
if (state != nullptr)
{
if (EffectTics & 32)
{
P_SetPsprite (player, ps_targetright, NULL);
P_SetPsprite (player, ps_targetleft, state+1);
P_SetPsprite(player, PSP_TARGETRIGHT, nullptr);
P_SetPsprite(player, PSP_TARGETLEFT, state + 1);
}
else if (EffectTics & 16)
{
P_SetPsprite (player, ps_targetright, state+2);
P_SetPsprite (player, ps_targetleft, NULL);
P_SetPsprite(player, PSP_TARGETRIGHT, state + 2);
P_SetPsprite(player, PSP_TARGETLEFT, nullptr);
}
}
}
@ -1362,11 +1373,17 @@ void APowerTargeter::DoEffect ()
void APowerTargeter::EndEffect ()
{
Super::EndEffect();
if (Owner != NULL && Owner->player != NULL)
if (Owner != nullptr && Owner->player != nullptr)
{
P_SetPsprite (Owner->player, ps_targetcenter, NULL);
P_SetPsprite (Owner->player, ps_targetleft, NULL);
P_SetPsprite (Owner->player, ps_targetright, NULL);
// Calling GetPSprite here could crash if we're creating a new game.
// This is because P_SetupLevel nulls the player's mo before destroying
// every DThinker which in turn ends up calling this.
// However P_SetupLevel is only called after G_NewInit which calls
// every player's dtor which destroys all their psprites.
DPSprite *pspr;
if ((pspr = Owner->player->FindPSprite(PSP_TARGETCENTER)) != nullptr) pspr->SetState(nullptr);
if ((pspr = Owner->player->FindPSprite(PSP_TARGETLEFT)) != nullptr) pspr->SetState(nullptr);
if ((pspr = Owner->player->FindPSprite(PSP_TARGETRIGHT)) != nullptr) pspr->SetState(nullptr);
}
}
@ -1374,10 +1391,10 @@ void APowerTargeter::PositionAccuracy ()
{
player_t *player = Owner->player;
if (player != NULL)
if (player != nullptr)
{
player->psprites[ps_targetleft].sx = (160-3) - ((100 - player->mo->accuracy));
player->psprites[ps_targetright].sx = (160-3)+ ((100 - player->mo->accuracy));
player->GetPSprite(PSP_TARGETLEFT)->x = (160-3) - ((100 - player->mo->accuracy));
player->GetPSprite(PSP_TARGETRIGHT)->x = (160-3)+ ((100 - player->mo->accuracy));
}
}

1
src/g_shared/a_artifacts.h
View file

@ -182,6 +182,7 @@ protected:
void EndEffect ();
void PositionAccuracy ();
void Travelled ();
void AttachToOwner(AActor *other);
bool HandlePickup(AInventory *item);
};

9
src/g_shared/a_weapons.cpp
View file

@ -608,15 +608,18 @@ bool AWeapon::DepleteAmmo (bool altFire, bool checkEnough, int ammouse)
void AWeapon::PostMorphWeapon ()
{
if (Owner == NULL)
DPSprite *pspr;
if (Owner == nullptr)
{
return;
}
Owner->player->PendingWeapon = WP_NOCHANGE;
Owner->player->ReadyWeapon = this;
Owner->player->psprites[ps_weapon].sy = WEAPONBOTTOM;
Owner->player->refire = 0;
P_SetPsprite (Owner->player, ps_weapon, GetUpState());
pspr = Owner->player->GetPSprite(PSP_WEAPON);
pspr->y = WEAPONBOTTOM;
pspr->SetState(GetUpState());
}
//===========================================================================

26
src/g_strife/a_strifestuff.cpp
View file

@ -350,11 +350,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_ItBurnsItBurns)
S_Sound (self, CHAN_VOICE, "human/imonfire", 1, ATTN_NORM);
if (self->player != NULL && self->player->mo == self)
if (self->player != nullptr && self->player->mo == self)
{
P_SetPsprite (self->player, ps_weapon, self->FindState("FireHands"));
P_SetPsprite (self->player, ps_flash, NULL);
self->player->ReadyWeapon = NULL;
P_SetPsprite(self->player, PSP_STRIFEHANDS, self->FindState("FireHands"));
self->player->ReadyWeapon = nullptr;
self->player->PendingWeapon = WP_NOCHANGE;
self->player->playerstate = PST_LIVE;
self->player->extralight = 3;
@ -376,12 +375,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_CrispyPlayer)
{
PARAM_ACTION_PROLOGUE;
if (self->player != NULL && self->player->mo == self)
if (self->player != nullptr && self->player->mo == self)
{
self->player->playerstate = PST_DEAD;
P_SetPsprite (self->player, ps_weapon,
self->player->psprites[ps_weapon].state +
(self->FindState("FireHandsLower") - self->FindState("FireHands")));
DPSprite *psp;
psp = self->player->GetPSprite(PSP_STRIFEHANDS);
psp->SetState(psp->GetState() + (self->FindState("FireHandsLower") - self->FindState("FireHands")));
}
return 0;
}
@ -390,13 +390,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_HandLower)
{
PARAM_ACTION_PROLOGUE;
if (self->player != NULL)
if (self->player != nullptr)
{
pspdef_t *psp = &self->player->psprites[ps_weapon];
psp->sy += 9;
if (psp->sy > WEAPONBOTTOM*2)
DPSprite *psp = self->player->GetPSprite(PSP_STRIFEHANDS);
psp->y += 9;
if (psp->y > WEAPONBOTTOM*2)
{
P_SetPsprite (self->player, ps_weapon, NULL);
psp->SetState(nullptr);
}
if (self->player->extralight > 0) self->player->extralight--;
}

46
src/g_strife/a_strifeweapons.cpp
View file

@ -216,10 +216,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_ClearFlash)
player_t *player = self->player;
if (player == NULL)
if (player == nullptr)
return 0;
P_SetPsprite (player, ps_flash, NULL);
P_SetPsprite (player, PSP_FLASH, nullptr);
return 0;
}
@ -233,9 +233,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_ShowElectricFlash)
{
PARAM_ACTION_PROLOGUE;
if (self->player != NULL)
if (self->player != nullptr)
{
P_SetPsprite (self->player, ps_flash, self->player->ReadyWeapon->FindState(NAME_Flash));
P_SetPsprite (self->player, PSP_FLASH, self->player->ReadyWeapon->FindState(NAME_Flash));
}
return 0;
}
@ -498,10 +498,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_FireMauler2Pre)
S_Sound (self, CHAN_WEAPON, "weapons/mauler2charge", 1, ATTN_NORM);
if (self->player != NULL)
if (self->player != nullptr)
{
self->player->psprites[ps_weapon].sx += pr_mauler2.Random2() / 64.;
self->player->psprites[ps_weapon].sy += pr_mauler2.Random2() / 64.;
self->player->GetPSprite(PSP_WEAPON)->x += pr_mauler2.Random2() / 64.;
self->player->GetPSprite(PSP_WEAPON)->y += pr_mauler2.Random2() / 64.;
}
return 0;
}
@ -698,24 +698,23 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireGrenade)
DAngle an;
AWeapon *weapon;
if (player == NULL || grenadetype == NULL)
if (player == nullptr || grenadetype == nullptr)
return 0;
if ((weapon = player->ReadyWeapon) == NULL)
if ((weapon = player->ReadyWeapon) == nullptr)
return 0;
if (!weapon->DepleteAmmo (weapon->bAltFire))
return 0;
P_SetPsprite (player, ps_flash, flash);
self->player->psprites[ps_flash].processPending = true;
P_SetPsprite (player, PSP_FLASH, flash, true);
if (grenadetype != NULL)
if (grenadetype != nullptr)
{
self->AddZ(32);
grenade = P_SpawnSubMissile (self, grenadetype, self);
self->AddZ(-32);
if (grenade == NULL)
if (grenade == nullptr)
return 0;
if (grenade->SeeSound != 0)
@ -849,15 +848,16 @@ DEFINE_ACTION_FUNCTION(AActor, A_SelectSigilView)
{
PARAM_ACTION_PROLOGUE;
DPSprite *pspr;
int pieces;
if (self->player == NULL)
if (self->player == nullptr)
{
return 0;
}
pieces = static_cast<ASigil*>(self->player->ReadyWeapon)->NumPieces;
P_SetPsprite (self->player, ps_weapon,
self->player->psprites[ps_weapon].state + pieces);
pspr = self->player->GetPSprite(PSP_WEAPON);
pspr->SetState(pspr->GetState() + pieces);
return 0;
}
@ -875,9 +875,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_SelectSigilDown)
{
PARAM_ACTION_PROLOGUE;
DPSprite *pspr;
int pieces;
if (self->player == NULL)
if (self->player == nullptr)
{
return 0;
}
@ -887,8 +888,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SelectSigilDown)
{
pieces = static_cast<ASigil*>(self->player->ReadyWeapon)->NumPieces;
}
P_SetPsprite (self->player, ps_weapon,
self->player->psprites[ps_weapon].state + pieces);
pspr = self->player->GetPSprite(PSP_WEAPON);
pspr->SetState(pspr->GetState() + pieces);
return 0;
}
@ -904,15 +905,16 @@ DEFINE_ACTION_FUNCTION(AActor, A_SelectSigilAttack)
{
PARAM_ACTION_PROLOGUE;
DPSprite *pspr;
int pieces;
if (self->player == NULL)
if (self->player == nullptr)
{
return 0;
}
pieces = static_cast<ASigil*>(self->player->ReadyWeapon)->NumPieces;
P_SetPsprite (self->player, ps_weapon,
self->player->psprites[ps_weapon].state + 4*pieces - 3);
pspr = self->player->GetPSprite(PSP_WEAPON);
pspr->SetState(pspr->GetState() + 4*pieces - 3);
return 0;
}

10
src/m_cheat.cpp
View file

@ -314,7 +314,7 @@ void cht_DoCheat (player_t *player, int cheat)
// [GRB]
case CHT_RESSURECT:
if (player->playerstate != PST_LIVE && player->mo != NULL)
if (player->playerstate != PST_LIVE && player->mo != nullptr)
{
if (player->mo->IsKindOf(RUNTIME_CLASS(APlayerChunk)))
{
@ -343,9 +343,9 @@ void cht_DoCheat (player_t *player, int cheat)
player->mo->Translation = TRANSLATION(TRANSLATION_Players, BYTE(player-players));
}
player->mo->DamageType = NAME_None;
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
P_SetPsprite(player, ps_weapon, player->ReadyWeapon->GetUpState());
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->GetUpState());
}
if (player->morphTics > 0)
@ -932,10 +932,8 @@ void cht_Take (player_t *player, const char *name, int amount)
if (weapon)
weapon->Destroy ();
player->ReadyWeapon = NULL;
player->ReadyWeapon = nullptr;
player->PendingWeapon = WP_NOCHANGE;
player->psprites[ps_weapon].state = NULL;
player->psprites[ps_flash].state = NULL;
}
}

1
src/p_local.h
View file

@ -76,7 +76,6 @@ extern int bmapnegy;
// P_PSPR
//
void P_SetupPsprites (player_t* curplayer, bool startweaponup);
void P_MovePsprites (player_t* curplayer);
void P_DropWeapon (player_t* player);

6
src/p_mobj.cpp
View file

@ -997,12 +997,10 @@ void AActor::ClearInventory()
invp = &inv->Inventory;
}
}
if (player != NULL)
if (player != nullptr)
{
player->ReadyWeapon = NULL;
player->ReadyWeapon = nullptr;
player->PendingWeapon = WP_NOCHANGE;
player->psprites[ps_weapon].state = NULL;
player->psprites[ps_flash].state = NULL;
}
}

673
src/p_pspr.cpp
View file

@ -93,25 +93,165 @@ static const FGenericButtons ButtonChecks[] =
// CODE --------------------------------------------------------------------
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
IMPLEMENT_POINTY_CLASS(DPSprite)
DECLARE_POINTER(Caller)
DECLARE_POINTER(Next)
END_POINTERS
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
DPSprite::DPSprite(player_t *owner, AActor *caller, int id)
: processPending(true),
firstTic(true),
x(.0), y(.0),
oldx(.0), oldy(.0),
Flags(0), ID(id),
Caller(caller),
Owner(owner)
{
DPSprite *prev = nullptr;
DPSprite *next = Owner->psprites;
while (next != nullptr && next->ID < ID)
{
prev = next;
next = next->Next;
}
Next = next;
GC::WriteBarrier(this, next);
if (prev == nullptr)
{
Owner->psprites = this;
GC::WriteBarrier(this);
}
else
{
prev->Next = this;
GC::WriteBarrier(prev, this);
}
if (Next && Next->ID == ID && ID != 0)
Next->Destroy(); // Replace it.
if (Caller->IsKindOf(RUNTIME_CLASS(AWeapon)) || Caller->IsKindOf(RUNTIME_CLASS(APlayerPawn)))
Flags = (PSPF_ADDWEAPON|PSPF_ADDBOB|PSPF_POWDOUBLE|PSPF_CVARFAST);
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
DPSprite *player_t::FindPSprite(int layer)
{
if (layer == 0)
return nullptr;
DPSprite *pspr = psprites;
while (pspr)
{
if (pspr->ID == layer)
break;
pspr = pspr->Next;
}
return pspr;
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
void P_SetPsprite(player_t *player, PSPLayers id, FState *state, bool pending)
{
if (player == nullptr) return;
player->GetPSprite(id)->SetState(state, pending);
}
DPSprite *player_t::GetPSprite(PSPLayers layer)
{
AActor *oldcaller = nullptr;
AActor *newcaller = nullptr;
if (layer >= PSP_TARGETCENTER)
{
if (mo != nullptr)
{
newcaller = mo->FindInventory(RUNTIME_CLASS(APowerTargeter), true);
}
}
else if (layer == PSP_STRIFEHANDS)
{
newcaller = mo;
}
else
{
newcaller = ReadyWeapon;
}
assert(newcaller != nullptr);
DPSprite *pspr = FindPSprite(layer);
if (pspr == nullptr)
{
pspr = new DPSprite(this, newcaller, layer);
}
else
{
oldcaller = pspr->Caller;
}
// Always update the caller here in case we switched weapon
// or if the layer was being used by an inventory item before.
pspr->Caller = newcaller;
if (newcaller != oldcaller)
{ // Only change the flags if this layer was created now or if we updated the caller.
if (layer >= PSP_TARGETCENTER)
{ // The targeter layers were affected by those.
pspr->Flags |= (PSPF_CVARFAST|PSPF_POWDOUBLE);
}
}
return pspr;
}
//---------------------------------------------------------------------------
//
// PROC P_NewPspriteTick
//
//---------------------------------------------------------------------------
void P_NewPspriteTick()
void DPSprite::NewTick()
{
// This function should be called after the beginning of a tick, before any possible
// prprite-event, or near the end, after any possible psprite event.
// Because data is reset for every tick (which it must be) this has no impact on savegames.
for (int i = 0; i<MAXPLAYERS; i++)
for (int i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
{
pspdef_t *pspdef = players[i].psprites;
for (int j = 0;j < NUMPSPRITES; j++)
DPSprite *pspr = players[i].psprites;
while (pspr)
{
pspdef[j].processPending = true;
pspr->processPending = true;
pspr->oldx = pspr->x;
pspr->oldy = pspr->y;
pspr = pspr->Next;
}
}
}
@ -123,79 +263,89 @@ void P_NewPspriteTick()
//
//---------------------------------------------------------------------------
void P_SetPsprite (player_t *player, int position, FState *state, bool nofunction)
void DPSprite::SetState(FState *newstate, bool pending)
{
pspdef_t *psp;
if (position == ps_weapon && !nofunction)
if (ID == PSP_WEAPON)
{ // A_WeaponReady will re-set these as needed
player->WeaponState &= ~(WF_WEAPONREADY | WF_WEAPONREADYALT | WF_WEAPONBOBBING | WF_WEAPONSWITCHOK | WF_WEAPONRELOADOK | WF_WEAPONZOOMOK |
Owner->WeaponState &= ~(WF_WEAPONREADY | WF_WEAPONREADYALT | WF_WEAPONBOBBING | WF_WEAPONSWITCHOK | WF_WEAPONRELOADOK | WF_WEAPONZOOMOK |
WF_USER1OK | WF_USER2OK | WF_USER3OK | WF_USER4OK);
}
psp = &player->psprites[position];
psp->processPending = false; // Do not subsequently perform periodic processing within the same tick.
processPending = pending;
do
{
if (state == NULL)
if (newstate == nullptr)
{ // Object removed itself.
psp->state = NULL;
break;
Destroy();
return;
}
psp->state = state;
State = newstate;
if (state->sprite != SPR_FIXED)
if (newstate->sprite != SPR_FIXED)
{ // okay to change sprite and/or frame
if (!state->GetSameFrame())
if (!newstate->GetSameFrame())
{ // okay to change frame
psp->frame = state->GetFrame();
Frame = newstate->GetFrame();
}
if (state->sprite != SPR_NOCHANGE)
if (newstate->sprite != SPR_NOCHANGE)
{ // okay to change sprite
psp->sprite = state->sprite;
Sprite = newstate->sprite;
}
}
Tics = newstate->GetTics(); // could be 0
if (sv_fastweapons == 2 && position == ps_weapon)
psp->tics = state->ActionFunc == NULL ? 0 : 1;
else if (sv_fastweapons == 3)
psp->tics = (state->GetTics() != 0);
else if (sv_fastweapons)
psp->tics = 1; // great for producing decals :)
else
psp->tics = state->GetTics(); // could be 0
if (state->GetMisc1())
{ // Set coordinates.
psp->sx = state->GetMisc1();
}
if (state->GetMisc2())
if (Flags & PSPF_CVARFAST)
{
psp->sy = state->GetMisc2();
if (sv_fastweapons == 2 && ID == PSP_WEAPON)
Tics = newstate->ActionFunc == nullptr ? 0 : 1;
else if (sv_fastweapons == 3)
Tics = (newstate->GetTics() != 0);
else if (sv_fastweapons)
Tics = 1; // great for producing decals :)
}
if (!nofunction && player->mo != NULL)
{
FState *newstate;
if (state->CallAction(player->mo, player->ReadyWeapon, &newstate))
if (ID != PSP_FLASH)
{ // It's still possible to set the flash layer's offsets with the action function.
if (newstate->GetMisc1())
{ // Set coordinates.
x = newstate->GetMisc1();
}
if (newstate->GetMisc2())
{
if (newstate != NULL)
y = newstate->GetMisc2();
}
}
if (Owner->mo != nullptr)
{
FState *nextstate;
if (newstate->CallAction(Owner->mo, Caller, &nextstate))
{
// It's possible this call resulted in this very layer being replaced.
if (ObjectFlags & OF_EuthanizeMe)
{
state = newstate;
psp->tics = 0;
return;
}
if (nextstate != nullptr)
{
newstate = nextstate;
Tics = 0;
continue;
}
if (psp->state == NULL)
if (State == nullptr)
{
break;
Destroy();
return;
}
}
}
state = psp->state->GetNextState();
} while (!psp->tics); // An initial state of 0 could cycle through.
newstate = State->GetNextState();
} while (!Tics); // An initial state of 0 could cycle through.
return;
}
//---------------------------------------------------------------------------
@ -209,15 +359,14 @@ void P_SetPsprite (player_t *player, int position, FState *state, bool nofunctio
void P_BringUpWeapon (player_t *player)
{
FState *newstate;
AWeapon *weapon;
if (player->PendingWeapon == WP_NOCHANGE)
{
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
player->psprites[ps_weapon].sy = WEAPONTOP;
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->GetReadyState());
player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP;
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->GetReadyState());
}
return;
}
@ -226,7 +375,7 @@ void P_BringUpWeapon (player_t *player)
// If the player has a tome of power, use this weapon's powered up
// version, if one is available.
if (weapon != NULL &&
if (weapon != nullptr &&
weapon->SisterWeapon &&
weapon->SisterWeapon->WeaponFlags & WIF_POWERED_UP &&
player->mo->FindInventory (RUNTIME_CLASS(APowerWeaponLevel2), true))
@ -234,30 +383,26 @@ void P_BringUpWeapon (player_t *player)
weapon = weapon->SisterWeapon;
}
if (weapon != NULL)
player->PendingWeapon = WP_NOCHANGE;
player->ReadyWeapon = weapon;
player->mo->weaponspecial = 0;
if (weapon != nullptr)
{
if (weapon->UpSound)
{
S_Sound (player->mo, CHAN_WEAPON, weapon->UpSound, 1, ATTN_NORM);
}
newstate = weapon->GetUpState ();
player->refire = 0;
}
else
{
newstate = NULL;
}
player->PendingWeapon = WP_NOCHANGE;
player->ReadyWeapon = weapon;
player->psprites[ps_weapon].sy = player->cheats & CF_INSTANTWEAPSWITCH
? WEAPONTOP : WEAPONBOTTOM;
// make sure that the previous weapon's flash state is terminated.
// When coming here from a weapon drop it may still be active.
P_SetPsprite(player, ps_flash, NULL);
P_SetPsprite (player, ps_weapon, newstate);
player->mo->weaponspecial = 0;
}
player->GetPSprite(PSP_WEAPON)->y = player->cheats & CF_INSTANTWEAPSWITCH
? WEAPONTOP : WEAPONBOTTOM;
// make sure that the previous weapon's flash state is terminated.
// When coming here from a weapon drop it may still be active.
P_SetPsprite(player, PSP_FLASH, nullptr);
P_SetPsprite(player, PSP_WEAPON, weapon->GetUpState());
}
}
//---------------------------------------------------------------------------
//
@ -271,24 +416,24 @@ void P_FireWeapon (player_t *player, FState *state)
// [SO] 9/2/02: People were able to do an awful lot of damage
// when they were observers...
if (player->Bot == NULL && bot_observer)
if (player->Bot == nullptr && bot_observer)
{
return;
}
weapon = player->ReadyWeapon;
if (weapon == NULL || !weapon->CheckAmmo (AWeapon::PrimaryFire, true))
if (weapon == nullptr || !weapon->CheckAmmo (AWeapon::PrimaryFire, true))
{
return;
}
player->mo->PlayAttacking ();
weapon->bAltFire = false;
if (state == NULL)
if (state == nullptr)
{
state = weapon->GetAtkState(!!player->refire);
}
P_SetPsprite (player, ps_weapon, state);
P_SetPsprite(player, PSP_WEAPON, state);
if (!(weapon->WeaponFlags & WIF_NOALERT))
{
P_NoiseAlert (player->mo, player->mo, false);
@ -307,13 +452,13 @@ void P_FireWeaponAlt (player_t *player, FState *state)
// [SO] 9/2/02: People were able to do an awful lot of damage
// when they were observers...
if (player->Bot == NULL && bot_observer)
if (player->Bot == nullptr && bot_observer)
{
return;
}
weapon = player->ReadyWeapon;
if (weapon == NULL || weapon->FindState(NAME_AltFire) == NULL || !weapon->CheckAmmo (AWeapon::AltFire, true))
if (weapon == nullptr || weapon->FindState(NAME_AltFire) == nullptr || !weapon->CheckAmmo (AWeapon::AltFire, true))
{
return;
}
@ -321,12 +466,12 @@ void P_FireWeaponAlt (player_t *player, FState *state)
player->mo->PlayAttacking ();
weapon->bAltFire = true;
if (state == NULL)
if (state == nullptr)
{
state = weapon->GetAltAtkState(!!player->refire);
}
P_SetPsprite (player, ps_weapon, state);
P_SetPsprite(player, PSP_WEAPON, state);
if (!(weapon->WeaponFlags & WIF_NOALERT))
{
P_NoiseAlert (player->mo, player->mo, false);
@ -343,15 +488,15 @@ void P_FireWeaponAlt (player_t *player, FState *state)
void P_DropWeapon (player_t *player)
{
if (player == NULL)
if (player == nullptr)
{
return;
}
// Since the weapon is dropping, stop blocking switching.
player->WeaponState &= ~WF_DISABLESWITCH;
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->GetDownState());
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->GetDownState());
}
}
@ -367,7 +512,7 @@ void P_DropWeapon (player_t *player)
//
//============================================================================
void P_BobWeapon (player_t *player, pspdef_t *psp, float *x, float *y, double ticfrac)
void P_BobWeapon (player_t *player, float *x, float *y, double ticfrac)
{
static float curbob;
double xx[2], yy[2];
@ -377,7 +522,7 @@ void P_BobWeapon (player_t *player, pspdef_t *psp, float *x, float *y, double ti
weapon = player->ReadyWeapon;
if (weapon == NULL || weapon->WeaponFlags & WIF_DONTBOB)
if (weapon == nullptr || weapon->WeaponFlags & WIF_DONTBOB)
{
*x = *y = 0;
return;
@ -528,7 +673,7 @@ void DoReadyWeaponToFire (AActor *self, bool prim, bool alt)
}
// Play ready sound, if any.
if (weapon->ReadySound && player->psprites[ps_weapon].state == weapon->FindState(NAME_Ready))
if (weapon->ReadySound && player->GetPSprite(PSP_WEAPON)->GetState() == weapon->FindState(NAME_Ready))
{
if (!(weapon->WeaponFlags & WIF_READYSNDHALF) || pr_wpnreadysnd() < 128)
{
@ -547,8 +692,8 @@ void DoReadyWeaponToBob (AActor *self)
{
// Prepare for bobbing action.
self->player->WeaponState |= WF_WEAPONBOBBING;
self->player->psprites[ps_weapon].sx = 0;
self->player->psprites[ps_weapon].sy = WEAPONTOP;
self->player->GetPSprite(PSP_WEAPON)->x = 0;
self->player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP;
}
}
@ -673,12 +818,12 @@ void P_CheckWeaponSwitch (player_t *player)
static void P_CheckWeaponButtons (player_t *player)
{
if (player->Bot == NULL && bot_observer)
if (player->Bot == nullptr && bot_observer)
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon == NULL)
if (weapon == nullptr)
{
return;
}
@ -693,11 +838,11 @@ static void P_CheckWeaponButtons (player_t *player)
// [XA] don't change state if still null, so if the modder
// sets WRF_xxx to true but forgets to define the corresponding
// state, the weapon won't disappear. ;)
if (state != NULL)
if (state != nullptr)
{
P_SetPsprite(player, ps_weapon, state);
P_SetPsprite(player, PSP_WEAPON, state);
return;
}
}
}
}
}
@ -785,7 +930,7 @@ DEFINE_ACTION_FUNCTION(AInventory, A_CheckReload)
//---------------------------------------------------------------------------
//
// PROC A_WeaponOffset
// PROC A_OverlayOffset
//
//---------------------------------------------------------------------------
enum WOFFlags
@ -795,48 +940,95 @@ enum WOFFlags
WOF_ADD = 1 << 2,
};
DEFINE_ACTION_FUNCTION(AInventory, A_WeaponOffset)
void A_OverlayOffset(AActor *self, int layer, double wx, double wy, int flags)
{
PARAM_ACTION_PROLOGUE;
PARAM_FLOAT_OPT(wx) { wx = 0.; }
PARAM_FLOAT_OPT(wy) { wy = 32.; }
PARAM_INT_OPT(flags) { flags = 0; }
if ((flags & WOF_KEEPX) && (flags & WOF_KEEPY))
{
return 0;
return;
}
player_t *player = self->player;
pspdef_t *psp;
DPSprite *psp;
if (player && (player->playerstate != PST_DEAD))
{
psp = &player->psprites[ps_weapon];
psp = player->FindPSprite(layer);
if (psp == nullptr)
return;
if (!(flags & WOF_KEEPX))
{
if (flags & WOF_ADD)
{
psp->sx += wx;
psp->x += wx;
}
else
{
psp->sx = wx;
psp->x = wx;
}
}
if (!(flags & WOF_KEEPY))
{
if (flags & WOF_ADD)
{
psp->sy += wy;
psp->y += wy;
}
else
{
psp->sy = wy;
psp->y = wy;
}
}
}
}
DEFINE_ACTION_FUNCTION(AActor, A_OverlayOffset)
{
PARAM_ACTION_PROLOGUE;
PARAM_INT_OPT(layer) { layer = PSP_WEAPON; }
PARAM_FLOAT_OPT(wx) { wx = 0.; }
PARAM_FLOAT_OPT(wy) { wy = 32.; }
PARAM_INT_OPT(flags) { flags = 0; }
A_OverlayOffset(self, layer, wx, wy, flags);
return 0;
}
DEFINE_ACTION_FUNCTION(AActor, A_WeaponOffset)
{
PARAM_ACTION_PROLOGUE;
PARAM_FLOAT_OPT(wx) { wx = 0.; }
PARAM_FLOAT_OPT(wy) { wy = 32.; }
PARAM_INT_OPT(flags) { flags = 0; }
A_OverlayOffset(self, PSP_WEAPON, wx, wy, flags);
return 0;
}
//---------------------------------------------------------------------------
//
// PROC A_OverlayFlags
//
//---------------------------------------------------------------------------
DEFINE_ACTION_FUNCTION(AActor, A_OverlayFlags)
{
PARAM_ACTION_PROLOGUE;
PARAM_INT(layer);
PARAM_INT(flags);
PARAM_BOOL(set);
if (self->player == nullptr)
return 0;
DPSprite *pspr = self->player->FindPSprite(layer);
if (pspr == nullptr)
return 0;
if (set)
pspr->Flags |= flags;
else
pspr->Flags &= ~flags;
return 0;
}
@ -851,35 +1043,40 @@ DEFINE_ACTION_FUNCTION(AInventory, A_Lower)
PARAM_ACTION_PROLOGUE;
player_t *player = self->player;
pspdef_t *psp;
DPSprite *psp;
if (NULL == player)
if (nullptr == player)
{
return 0;
}
psp = &player->psprites[ps_weapon];
if (nullptr == player->ReadyWeapon)
{
P_BringUpWeapon(player);
return 0;
}
psp = player->GetPSprite(PSP_WEAPON);
if (player->morphTics || player->cheats & CF_INSTANTWEAPSWITCH)
{
psp->sy = WEAPONBOTTOM;
psp->y = WEAPONBOTTOM;
}
else
{
psp->sy += LOWERSPEED;
psp->y += LOWERSPEED;
}
if (psp->sy < WEAPONBOTTOM)
if (psp->y < WEAPONBOTTOM)
{ // Not lowered all the way yet
return 0;
}
if (player->playerstate == PST_DEAD)
{ // Player is dead, so don't bring up a pending weapon
psp->sy = WEAPONBOTTOM;
psp->y = WEAPONBOTTOM;
// Player is dead, so keep the weapon off screen
P_SetPsprite (player, ps_weapon, NULL);
psp->SetState(nullptr);
return 0;
}
// [RH] Clear the flash state. Only needed for Strife.
P_SetPsprite (player, ps_flash, NULL);
P_SetPsprite(player, PSP_FLASH, nullptr);
P_BringUpWeapon (player);
return 0;
}
@ -894,14 +1091,14 @@ DEFINE_ACTION_FUNCTION(AInventory, A_Raise)
{
PARAM_ACTION_PROLOGUE;
if (self == NULL)
if (self == nullptr)
{
return 0;
}
player_t *player = self->player;
pspdef_t *psp;
DPSprite *psp;
if (NULL == player)
if (nullptr == player)
{
return 0;
}
@ -910,26 +1107,43 @@ DEFINE_ACTION_FUNCTION(AInventory, A_Raise)
P_DropWeapon(player);
return 0;
}
psp = &player->psprites[ps_weapon];
psp->sy -= RAISESPEED;
if (psp->sy > WEAPONTOP)
if (player->ReadyWeapon == nullptr)
{
return 0;
}
psp = player->GetPSprite(PSP_WEAPON);
psp->y -= RAISESPEED;
if (psp->y > WEAPONTOP)
{ // Not raised all the way yet
return 0;
}
psp->sy = WEAPONTOP;
if (player->ReadyWeapon != NULL)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->GetReadyState());
}
else
{
player->psprites[ps_weapon].state = NULL;
}
psp->y = WEAPONTOP;
psp->SetState(player->ReadyWeapon->GetReadyState());
return 0;
}
//---------------------------------------------------------------------------
//
// PROC A_Overlay
//
//---------------------------------------------------------------------------
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Overlay)
{
PARAM_ACTION_PROLOGUE;
PARAM_INT (layer);
PARAM_STATE_OPT (state) { state = nullptr; }
player_t *player = self->player;
if (player == nullptr)
return 0;
DPSprite *pspr;
pspr = new DPSprite(player, stateowner, layer);
pspr->SetState(state);
return 0;
}
//
// A_GunFlash
@ -942,12 +1156,12 @@ enum GF_Flags
DEFINE_ACTION_FUNCTION_PARAMS(AInventory, A_GunFlash)
{
PARAM_ACTION_PROLOGUE;
PARAM_STATE_OPT(flash) { flash = NULL; }
PARAM_STATE_OPT(flash) { flash = nullptr; }
PARAM_INT_OPT (flags) { flags = 0; }
player_t *player = self->player;
if (NULL == player)
if (nullptr == player)
{
return 0;
}
@ -955,18 +1169,18 @@ DEFINE_ACTION_FUNCTION_PARAMS(AInventory, A_GunFlash)
{
player->mo->PlayAttacking2 ();
}
if (flash == NULL)
if (flash == nullptr)
{
if (player->ReadyWeapon->bAltFire)
{
flash = player->ReadyWeapon->FindState(NAME_AltFlash);
}
if (flash == NULL)
if (flash == nullptr)
{
flash = player->ReadyWeapon->FindState(NAME_Flash);
}
}
P_SetPsprite (player, ps_flash, flash);
P_SetPsprite(player, PSP_FLASH, flash);
return 0;
}
@ -1084,13 +1298,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AInventory, A_Light)
void P_SetupPsprites(player_t *player, bool startweaponup)
{
int i;
// Remove all psprites
for (i = 0; i < NUMPSPRITES; i++)
{
player->psprites[i].state = NULL;
}
player->DestroyPSprites();
// Spawn the ready weapon
player->PendingWeapon = !startweaponup ? player->ReadyWeapon : WP_NOCHANGE;
P_BringUpWeapon (player);
@ -1104,61 +1314,162 @@ void P_SetupPsprites(player_t *player, bool startweaponup)
//
//------------------------------------------------------------------------
void P_MovePsprites (player_t *player)
void player_t::TickPSprites()
{
int i;
pspdef_t *psp;
FState *state;
// [RH] If you don't have a weapon, then the psprites should be NULL.
if (player->ReadyWeapon == NULL && (player->health > 0 || player->mo->DamageType != NAME_Fire))
DPSprite *pspr = psprites;
while (pspr)
{
P_SetPsprite (player, ps_weapon, NULL);
P_SetPsprite (player, ps_flash, NULL);
if (player->PendingWeapon != WP_NOCHANGE)
// Destroy the psprite if it's from a weapon that isn't currently selected by the player
// or if it's from an inventory item that the player no longer owns.
if ((pspr->Caller == nullptr ||
(pspr->Caller->IsKindOf(RUNTIME_CLASS(AInventory)) && barrier_cast<AInventory *>(pspr->Caller)->Owner != pspr->Owner->mo) ||
(pspr->Caller->IsKindOf(RUNTIME_CLASS(AWeapon)) && pspr->Caller != pspr->Owner->ReadyWeapon)))
{
P_BringUpWeapon (player);
pspr->Destroy();
}
else
{
pspr->Tick();
}
pspr = pspr->Next;
}
if (ReadyWeapon == nullptr && (health > 0 || mo->DamageType != NAME_Fire))
{
if (PendingWeapon != WP_NOCHANGE)
P_BringUpWeapon(this);
}
else
{
psp = &player->psprites[0];
for (i = 0; i < NUMPSPRITES; i++, psp++)
P_CheckWeaponSwitch(this);
if (WeaponState & (WF_WEAPONREADY | WF_WEAPONREADYALT))
{
if ((state = psp->state) != NULL && psp->processPending) // a null state means not active
P_CheckWeaponFire(this);
}
// Check custom buttons
P_CheckWeaponButtons(this);
}
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
void DPSprite::Tick()
{
if (processPending)
{
// drop tic count and possibly change state
if (Tics != -1) // a -1 tic count never changes
{
Tics--;
// [BC] Apply double firing speed.
if ((Flags & PSPF_POWDOUBLE) && Tics && (Owner->cheats & CF_DOUBLEFIRINGSPEED))
Tics--;
if (!Tics)
SetState(State->GetNextState());
}
}
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
void DPSprite::Serialize(FArchive &arc)
{
Super::Serialize(arc);
arc << Next << Caller << Owner << Flags
<< State << Tics << Sprite << Frame
<< ID << x << y << oldx << oldy;
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
void player_t::DestroyPSprites()
{
DPSprite *pspr = psprites;
psprites = nullptr;
while (pspr)
{
DPSprite *next = pspr->Next;
pspr->Next = nullptr;
pspr->Destroy();
pspr = next;
}
}
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
void DPSprite::Destroy()
{
// Do not crash if this gets called on partially initialized objects.
if (Owner != nullptr && Owner->psprites != nullptr)
{
if (Owner->psprites != this)
{
DPSprite *prev = Owner->psprites;
while (prev != nullptr && prev->Next != this)
prev = prev->Next;
if (prev != nullptr && prev->Next == this)
{
// drop tic count and possibly change state
if (psp->tics != -1) // a -1 tic count never changes
{
psp->tics--;
// [BC] Apply double firing speed.
if ( psp->tics && (player->cheats & CF_DOUBLEFIRINGSPEED))
psp->tics--;
if(!psp->tics)
{
P_SetPsprite (player, i, psp->state->GetNextState());
}
}
prev->Next = Next;
GC::WriteBarrier(prev, Next);
}
}
player->psprites[ps_flash].sx = player->psprites[ps_weapon].sx;
player->psprites[ps_flash].sy = player->psprites[ps_weapon].sy;
P_CheckWeaponSwitch (player);
if (player->WeaponState & (WF_WEAPONREADY | WF_WEAPONREADYALT))
else
{
P_CheckWeaponFire (player);
}
// Check custom buttons
P_CheckWeaponButtons(player);
Owner->psprites = Next;
GC::WriteBarrier(Next);
}
}
Super::Destroy();
}
FArchive &operator<< (FArchive &arc, pspdef_t &def)
//------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------
ADD_STAT(psprites)
{
arc << def.state << def.tics << def.sx << def.sy
<< def.sprite << def.frame;
return arc;
FString out;
DPSprite *pspr;
for (int i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
continue;
out.AppendFormat("[psprites] player: %d | layers: ", i);
pspr = players[i].psprites;
while (pspr)
{
out.AppendFormat("%d, ", pspr->GetID());
pspr = pspr->GetNext();
}
out.AppendFormat("\n");
}
return out;
}

95
src/p_pspr.h
View file

@ -34,59 +34,82 @@
// the right spot at 320x200.
#define WEAPONTOP (32+6./16)
class AInventory;
class FArchive;
//
// Overlay psprites are scaled shapes
// drawn directly on the view screen,
// coordinates are given for a 320*200 view screen.
//
typedef enum
enum PSPLayers // These are all called by the owner's ReadyWeapon.
{
ps_weapon,
ps_flash,
ps_targetcenter,
ps_targetleft,
ps_targetright,
NUMPSPRITES
} psprnum_t;
/*
inline FArchive &operator<< (FArchive &arc, psprnum_t &i)
{
BYTE val = (BYTE)i;
arc << val;
i = (psprnum_t)val;
return arc;
}
*/
struct pspdef_t
{
FState* state; // a NULL state means not active
int tics;
double sx;
double sy;
int sprite;
int frame;
bool processPending; // true: waiting for periodic processing on this tick
PSP_STRIFEHANDS = -1,
PSP_WEAPON = 1,
PSP_FLASH = 1000,
PSP_TARGETCENTER = INT_MAX - 2,
PSP_TARGETLEFT,
PSP_TARGETRIGHT,
};
class FArchive;
enum PSPFlags
{
PSPF_ADDWEAPON = 1 << 0,
PSPF_ADDBOB = 1 << 1,
PSPF_POWDOUBLE = 1 << 2,
PSPF_CVARFAST = 1 << 3,
};
FArchive &operator<< (FArchive &, pspdef_t &);
class DPSprite : public DObject
{
DECLARE_CLASS (DPSprite, DObject)
HAS_OBJECT_POINTERS
public:
DPSprite(player_t *owner, AActor *caller, int id);
class player_t;
class AActor;
struct FState;
static void NewTick();
void SetState(FState *newstate, bool pending = false);
int GetID() const { return ID; }
int GetSprite() const { return Sprite; }
int GetFrame() const { return Frame; }
FState* GetState() const { return State; }
DPSprite* GetNext() { return Next; }
AActor* GetCaller() { return Caller; }
double x, y;
double oldx, oldy;
bool firstTic;
int Tics;
int Flags;
private:
DPSprite () {}
void Serialize(FArchive &arc);
void Tick();
void Destroy();
TObjPtr<AActor> Caller;
TObjPtr<DPSprite> Next;
player_t *Owner;
FState *State;
int Sprite;
int Frame;
int ID;
bool processPending; // true: waiting for periodic processing on this tick
friend class player_t;
friend void CopyPlayer(player_t *dst, player_t *src, const char *name);
};
void P_NewPspriteTick();
void P_SetPsprite (player_t *player, int position, FState *state, bool nofunction=false);
void P_CalcSwing (player_t *player);
void P_SetPsprite(player_t *player, PSPLayers id, FState *state, bool pending = false);
void P_BringUpWeapon (player_t *player);
void P_FireWeapon (player_t *player);
void P_DropWeapon (player_t *player);
void P_BobWeapon (player_t *player, pspdef_t *psp, float *x, float *y, double ticfrac);
void P_BobWeapon (player_t *player, float *x, float *y, double ticfrac);
DAngle P_BulletSlope (AActor *mo, FTranslatedLineTarget *pLineTarget = NULL, int aimflags = 0);
void P_GunShot (AActor *mo, bool accurate, PClassActor *pufftype, DAngle pitch);

17
src/p_saveg.cpp
View file

@ -274,7 +274,7 @@ static void CopyPlayer (player_t *dst, player_t *src, const char *name)
dst->cheats |= chasecam;
if (dst->Bot != NULL)
if (dst->Bot != nullptr)
{
botinfo_t *thebot = bglobal.botinfo;
while (thebot && stricmp (name, thebot->name))
@ -296,10 +296,23 @@ static void CopyPlayer (player_t *dst, player_t *src, const char *name)
dst->userinfo.SkinNumChanged(R_FindSkin(skins[dst->userinfo.GetSkin()].name, dst->CurrentPlayerClass));
// Make sure the player pawn points to the proper player struct.
if (dst->mo != NULL)
if (dst->mo != nullptr)
{
dst->mo->player = dst;
}
// Same for the psprites.
DPSprite *pspr = dst->psprites;
while (pspr)
{
pspr->Owner = dst;
pspr = pspr->Next;
}
// Don't let the psprites be destroyed when src is destroyed.
src->psprites = nullptr;
// These 2 variables may not be overwritten.
dst->attackdown = attackdown;
dst->usedown = usedown;

2
src/p_tick.cpp
View file

@ -87,7 +87,7 @@ void P_Ticker (void)
if (paused || P_CheckTickerPaused())
return;
P_NewPspriteTick();
DPSprite::NewTick();
// [RH] Frozen mode is only changed every 4 tics, to make it work with A_Tracer().
if ((level.time & 3) == 0)

96
src/p_user.cpp
View file

@ -270,6 +270,7 @@ player_t::player_t()
WeaponState(0),
ReadyWeapon(0),
PendingWeapon(0),
psprites(0),
cheats(0),
timefreezer(0),
refire(0),
@ -315,7 +316,11 @@ player_t::player_t()
{
memset (&cmd, 0, sizeof(cmd));
memset (frags, 0, sizeof(frags));
memset (psprites, 0, sizeof(psprites));
}
player_t::~player_t()
{
DestroyPSprites();
}
player_t &player_t::operator=(const player_t &p)
@ -371,7 +376,7 @@ player_t &player_t::operator=(const player_t &p)
extralight = p.extralight;
fixedcolormap = p.fixedcolormap;
fixedlightlevel = p.fixedlightlevel;
memcpy(psprites, &p.psprites, sizeof(psprites));
psprites = p.psprites;
morphTics = p.morphTics;
MorphedPlayerClass = p.MorphedPlayerClass;
MorphStyle = p.MorphStyle;
@ -433,6 +438,7 @@ size_t player_t::FixPointers (const DObject *old, DObject *rep)
if (ReadyWeapon == old) ReadyWeapon = static_cast<AWeapon *>(rep), changed++;
if (PendingWeapon == old) PendingWeapon = static_cast<AWeapon *>(rep), changed++;
if (*&PremorphWeapon == old) PremorphWeapon = static_cast<AWeapon *>(rep), changed++;
if (psprites == old) psprites = static_cast<DPSprite *>(rep), changed++;
if (*&ConversationNPC == old) ConversationNPC = replacement, changed++;
if (*&ConversationPC == old) ConversationPC = replacement, changed++;
if (*&MUSINFOactor == old) MUSINFOactor = replacement, changed++;
@ -451,6 +457,7 @@ size_t player_t::PropagateMark()
GC::Mark(ConversationPC);
GC::Mark(MUSINFOactor);
GC::Mark(PremorphWeapon);
GC::Mark(psprites);
if (PendingWeapon != WP_NOCHANGE)
{
GC::Mark(PendingWeapon);
@ -1370,34 +1377,37 @@ void APlayerPawn::ActivateMorphWeapon ()
{
PClassActor *morphweapon = PClass::FindActor (MorphWeapon);
player->PendingWeapon = WP_NOCHANGE;
player->psprites[ps_weapon].sy = WEAPONTOP;
if (morphweapon == NULL || !morphweapon->IsDescendantOf (RUNTIME_CLASS(AWeapon)))
if (player->ReadyWeapon != nullptr)
{
player->GetPSprite(PSP_WEAPON)->y = WEAPONTOP;
}
if (morphweapon == nullptr || !morphweapon->IsDescendantOf (RUNTIME_CLASS(AWeapon)))
{ // No weapon at all while morphed!
player->ReadyWeapon = NULL;
P_SetPsprite (player, ps_weapon, NULL);
player->ReadyWeapon = nullptr;
}
else
{
player->ReadyWeapon = static_cast<AWeapon *>(player->mo->FindInventory (morphweapon));
if (player->ReadyWeapon == NULL)
if (player->ReadyWeapon == nullptr)
{
player->ReadyWeapon = static_cast<AWeapon *>(player->mo->GiveInventoryType (morphweapon));
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
player->ReadyWeapon->GivenAsMorphWeapon = true; // flag is used only by new beastweap semantics in P_UndoPlayerMorph
}
}
if (player->ReadyWeapon != NULL)
if (player->ReadyWeapon != nullptr)
{
P_SetPsprite (player, ps_weapon, player->ReadyWeapon->GetReadyState());
}
else
{
P_SetPsprite (player, ps_weapon, NULL);
P_SetPsprite(player, PSP_WEAPON, player->ReadyWeapon->GetReadyState());
}
}
P_SetPsprite (player, ps_flash, NULL);
if (player->ReadyWeapon != nullptr)
{
P_SetPsprite(player, PSP_FLASH, nullptr);
}
player->PendingWeapon = WP_NOCHANGE;
}
@ -2114,7 +2124,7 @@ void P_DeathThink (player_t *player)
int dir;
DAngle delta;
P_MovePsprites (player);
player->TickPSprites();
player->onground = (player->mo->Z() <= player->mo->floorz);
if (player->mo->IsKindOf (RUNTIME_CLASS(APlayerChunk)))
@ -2634,7 +2644,7 @@ void P_PlayerThink (player_t *player)
}
}
// Cycle psprites
P_MovePsprites (player);
player->TickPSprites();
// Other Counters
if (player->damagecount)
@ -3064,8 +3074,56 @@ void player_t::Serialize (FArchive &arc)
for (i = 0; i < MAXPLAYERS; i++)
arc << frags[i];
for (i = 0; i < NUMPSPRITES; i++)
arc << psprites[i];
if (SaveVersion < 4547)
{
int layer = PSP_WEAPON;
for (i = 0; i < 5; i++)
{
FState *state;
int tics;
double sx, sy;
int sprite;
int frame;
arc << state << tics
<< sx << sy
<< sprite << frame;
if (state != nullptr &&
((layer < PSP_TARGETCENTER && ReadyWeapon != nullptr) ||
(layer >= PSP_TARGETCENTER && mo->FindInventory(RUNTIME_CLASS(APowerTargeter), true))))
{
DPSprite *pspr;
pspr = GetPSprite(PSPLayers(layer));
pspr->State = state;
pspr->Tics = tics;
pspr->Sprite = sprite;
pspr->Frame = frame;
pspr->Owner = this;
if (layer == PSP_FLASH)
{
pspr->x = 0;
pspr->y = 0;
}
else
{
pspr->x = sx;
pspr->y = sy;
}
}
if (layer == PSP_WEAPON)
layer = PSP_FLASH;
else if (layer == PSP_FLASH)
layer = PSP_TARGETCENTER;
else
layer++;
}
}
else
arc << psprites;
arc << CurrentPlayerClass;

304
src/r_things.cpp
View file

@ -92,6 +92,7 @@ extern double globaluclip, globaldclip;
extern float MaskedScaleY;
#define MINZ double((2048*4) / double(1 << 20))
#define BASEXCENTER (160)
#define BASEYCENTER (100)
EXTERN_CVAR (Bool, st_scale)
@ -111,9 +112,15 @@ double pspriteyscale;
fixed_t sky1scale; // [RH] Sky 1 scale factor
fixed_t sky2scale; // [RH] Sky 2 scale factor
vissprite_t *VisPSprites[NUMPSPRITES];
int VisPSpritesX1[NUMPSPRITES];
FDynamicColormap *VisPSpritesBaseColormap[NUMPSPRITES];
// Used to store a psprite's drawing information if it needs to be drawn later.
struct vispsp_t
{
vissprite_t *vis;
FDynamicColormap *basecolormap;
int x1;
};
TArray<vispsp_t> vispsprites;
unsigned int vispspindex;
static int spriteshade;
@ -1269,48 +1276,41 @@ void R_AddSprites (sector_t *sec, int lightlevel, int fakeside)
}
}
//
// R_DrawPSprite
//
void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double sy)
void R_DrawPSprite(DPSprite *pspr, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac)
{
double tx;
int x1;
int x2;
double sx, sy;
spritedef_t* sprdef;
spriteframe_t* sprframe;
FTextureID picnum;
WORD flip;
FTexture* tex;
vissprite_t* vis;
static vissprite_t avis[NUMPSPRITES + 1];
static vissprite_t *avisp[countof(avis)];
bool noaccel;
bool noaccel;
bool isweapon;
static TArray<vissprite_t> avis;
assert(pspnum >= 0 && pspnum < NUMPSPRITES);
if (avisp[0] == NULL)
{
for (unsigned i = 0; i < countof(avis); ++i)
{
avisp[i] = &avis[i];
}
}
if (avis.Size() < vispspindex + 1)
avis.Reserve(avis.Size() - vispspindex + 1);
// decide which patch to use
if ( (unsigned)psp->sprite >= (unsigned)sprites.Size ())
if ((unsigned)pspr->GetSprite() >= (unsigned)sprites.Size())
{
DPrintf ("R_DrawPSprite: invalid sprite number %i\n", psp->sprite);
DPrintf("R_DrawPSprite: invalid sprite number %i\n", pspr->GetSprite());
return;
}
sprdef = &sprites[psp->sprite];
if (psp->frame >= sprdef->numframes)
sprdef = &sprites[pspr->GetSprite()];
if (pspr->GetFrame() >= sprdef->numframes)
{
DPrintf ("R_DrawPSprite: invalid sprite frame %i : %i\n", psp->sprite, psp->frame);
DPrintf("R_DrawPSprite: invalid sprite frame %i : %i\n", pspr->GetSprite(), pspr->GetFrame());
return;
}
sprframe = &SpriteFrames[sprdef->spriteframes + psp->frame];
sprframe = &SpriteFrames[sprdef->spriteframes + pspr->GetFrame()];
picnum = sprframe->Texture[0];
flip = sprframe->Flip & 1;
@ -1319,15 +1319,39 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
if (tex->UseType == FTexture::TEX_Null)
return;
isweapon = pspr->GetCaller()->IsKindOf(RUNTIME_CLASS(AWeapon));
if (pspr->firstTic)
{ // Can't interpolate the first tic.
pspr->firstTic = false;
pspr->oldx = pspr->x;
pspr->oldy = pspr->y;
}
sx = pspr->oldx + (pspr->x - pspr->oldx) * ticfrac;
sy = pspr->oldy + (pspr->y - pspr->oldy) * ticfrac;
if (pspr->Flags & PSPF_ADDBOB)
{
sx += bobx;
sy += boby;
}
if (pspr->Flags & PSPF_ADDWEAPON && pspr->GetID() != PSP_WEAPON)
{
sx += wx;
sy += wy;
}
// calculate edges of the shape
tx = sx - (320 / 2);
tx = sx - BASEXCENTER;
tx -= tex->GetScaledLeftOffset();
x1 = xs_RoundToInt(CenterX + tx * pspritexscale);
// off the right side
if (x1 > viewwidth)
return;
return;
tx += tex->GetScaledWidth();
x2 = xs_RoundToInt(CenterX + tx * pspritexscale);
@ -1335,9 +1359,9 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
// off the left side
if (x2 <= 0)
return;
// store information in a vissprite
vis = avisp[NUMPSPRITES];
vis = &avis[vispspindex];
vis->renderflags = owner->renderflags;
vis->floorclip = 0;
@ -1345,14 +1369,14 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
if (camera->player && (RenderTarget != screen ||
viewheight == RenderTarget->GetHeight() ||
(RenderTarget->GetWidth() > 320 && !st_scale)))
(RenderTarget->GetWidth() > (BASEXCENTER * 2) && !st_scale)))
{ // Adjust PSprite for fullscreen views
AWeapon *weapon = NULL;
if (camera->player != NULL)
AWeapon *weapon = nullptr;
if (camera->player != nullptr)
{
weapon = camera->player->ReadyWeapon;
}
if (pspnum <= ps_flash && weapon != NULL && weapon->YAdjust != 0)
if (isweapon && weapon != nullptr && weapon->YAdjust != 0)
{
if (RenderTarget != screen || viewheight == RenderTarget->GetHeight())
{
@ -1360,11 +1384,11 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
}
else
{
vis->texturemid -= StatusBar->GetDisplacement () * weapon->YAdjust;
vis->texturemid -= StatusBar->GetDisplacement() * weapon->YAdjust;
}
}
}
if (pspnum <= ps_flash)
if (isweapon)
{ // Move the weapon down for 1280x1024.
vis->texturemid -= BaseRatioSizes[WidescreenRatio][2];
}
@ -1388,11 +1412,11 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
}
if (vis->x1 > x1)
vis->startfrac += vis->xiscale*(vis->x1-x1);
vis->startfrac += vis->xiscale*(vis->x1 - x1);
noaccel = false;
FDynamicColormap *colormap_to_use = NULL;
if (pspnum <= ps_flash)
FDynamicColormap *colormap_to_use = nullptr;
if (isweapon)
{
vis->Style.Alpha = float(owner->Alpha);
vis->Style.RenderStyle = owner->RenderStyle;
@ -1413,16 +1437,16 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
{
if (invertcolormap)
{ // Fade to white
mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(255,255,255), mybasecolormap->Desaturate);
mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(255, 255, 255), mybasecolormap->Desaturate);
invertcolormap = false;
}
else
{ // Fade to black
mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(0,0,0), mybasecolormap->Desaturate);
mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(0, 0, 0), mybasecolormap->Desaturate);
}
}
if (realfixedcolormap != NULL)
if (realfixedcolormap != nullptr)
{ // fixed color
vis->Style.colormap = realfixedcolormap->Colormap;
}
@ -1436,25 +1460,25 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
{
vis->Style.colormap = mybasecolormap->Maps + fixedlightlev;
}
else if (!foggy && psp->state->GetFullbright())
else if (!foggy && pspr->GetState()->GetFullbright())
{ // full bright
vis->Style.colormap = mybasecolormap->Maps; // [RH] use basecolormap
}
else
{ // local light
vis->Style.colormap = mybasecolormap->Maps + (GETPALOOKUP (0, spriteshade) << COLORMAPSHIFT);
vis->Style.colormap = mybasecolormap->Maps + (GETPALOOKUP(0, spriteshade) << COLORMAPSHIFT);
}
}
if (camera->Inventory != NULL)
if (camera->Inventory != nullptr)
{
lighttable_t *oldcolormap = vis->Style.colormap;
camera->Inventory->AlterWeaponSprite (&vis->Style);
camera->Inventory->AlterWeaponSprite(&vis->Style);
if (vis->Style.colormap != oldcolormap)
{
// The colormap has changed. Is it one we can easily identify?
// If not, then don't bother trying to identify it for
// hardware accelerated drawing.
if (vis->Style.colormap < SpecialColormaps[0].Colormap ||
if (vis->Style.colormap < SpecialColormaps[0].Colormap ||
vis->Style.colormap > SpecialColormaps.Last().Colormap)
{
noaccel = true;
@ -1462,7 +1486,7 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
// Has the basecolormap changed? If so, we can't hardware accelerate it,
// since we don't know what it is anymore.
else if (vis->Style.colormap < mybasecolormap->Maps ||
vis->Style.colormap >= mybasecolormap->Maps + NUMCOLORMAPS*256)
vis->Style.colormap >= mybasecolormap->Maps + NUMCOLORMAPS * 256)
{
noaccel = true;
}
@ -1482,7 +1506,7 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
}
// If the main colormap has fixed lights, and this sprite is being drawn with that
// colormap, disable acceleration so that the lights can remain fixed.
if (!noaccel && realfixedcolormap == NULL &&
if (!noaccel && realfixedcolormap == nullptr &&
NormalLightHasFixedLights && mybasecolormap == &NormalLight &&
vis->pic->UseBasePalette())
{
@ -1505,18 +1529,19 @@ void R_DrawPSprite (pspdef_t* psp, int pspnum, AActor *owner, double sx, double
style.CheckFuzz();
if (style.BlendOp != STYLEOP_Fuzz)
{
VisPSpritesX1[pspnum] = x1;
VisPSpritesBaseColormap[pspnum] = colormap_to_use;
VisPSprites[pspnum] = vis;
swapvalues(avisp[pspnum], avisp[NUMPSPRITES]);
if (vispsprites.Size() < vispspindex + 1)
vispsprites.Reserve(vispsprites.Size() - vispspindex + 1);
vispsprites[vispspindex].vis = vis;
vispsprites[vispspindex].basecolormap = colormap_to_use;
vispsprites[vispspindex].x1 = x1;
vispspindex++;
return;
}
}
R_DrawVisSprite (vis);
R_DrawVisSprite(vis);
}
//==========================================================================
//
// R_DrawPlayerSprites
@ -1527,7 +1552,8 @@ void R_DrawPlayerSprites ()
{
int i;
int lightnum;
pspdef_t* psp;
DPSprite* psp;
DPSprite* weapon;
sector_t* sec = NULL;
static sector_t tempsec;
int floorlight, ceilinglight;
@ -1540,28 +1566,35 @@ void R_DrawPlayerSprites ()
(r_deathcamera && camera->health <= 0))
return;
if(fixedlightlev < 0 && viewsector->e && viewsector->e->XFloor.lightlist.Size()) {
for(i = viewsector->e->XFloor.lightlist.Size() - 1; i >= 0; i--)
if(ViewPos.Z <= viewsector->e->XFloor.lightlist[i].plane.Zat0()) {
if (fixedlightlev < 0 && viewsector->e && viewsector->e->XFloor.lightlist.Size())
{
for (i = viewsector->e->XFloor.lightlist.Size() - 1; i >= 0; i--)
{
if (ViewPos.Z <= viewsector->e->XFloor.lightlist[i].plane.Zat0())
{
rover = viewsector->e->XFloor.lightlist[i].caster;
if(rover) {
if(rover->flags & FF_DOUBLESHADOW && ViewPos.Z <= rover->bottom.plane->Zat0())
if (rover)
{
if (rover->flags & FF_DOUBLESHADOW && ViewPos.Z <= rover->bottom.plane->Zat0())
break;
sec = rover->model;
if(rover->flags & FF_FADEWALLS)
if (rover->flags & FF_FADEWALLS)
basecolormap = sec->ColorMap;
else
basecolormap = viewsector->e->XFloor.lightlist[i].extra_colormap;
}
break;
}
if(!sec) {
}
if(!sec)
{
sec = viewsector;
basecolormap = sec->ColorMap;
}
floorlight = ceilinglight = sec->lightlevel;
} else {
// This used to use camera->Sector but due to interpolation that can be incorrect
}
else
{ // This used to use camera->Sector but due to interpolation that can be incorrect
// when the interpolated viewpoint is in a different sector than the camera.
sec = R_FakeFlat (viewsector, &tempsec, &floorlight,
&ceilinglight, false);
@ -1585,27 +1618,47 @@ void R_DrawPlayerSprites ()
if (camera->player != NULL)
{
double centerhack = CenterY;
float ofsx, ofsy;
double wx, wy;
float bobx, boby;
CenterY = viewheight / 2;
P_BobWeapon (camera->player, &camera->player->psprites[ps_weapon], &ofsx, &ofsy, r_TicFracF);
P_BobWeapon (camera->player, &bobx, &boby, r_TicFracF);
// Interpolate the main weapon layer once so as to be able to add it to other layers.
if ((weapon = camera->player->FindPSprite(PSP_WEAPON)) != nullptr)
{
if (weapon->firstTic)
{
wx = weapon->x;
wy = weapon->y;
}
else
{
wx = weapon->oldx + (weapon->x - weapon->oldx) * r_TicFracF;
wy = weapon->oldy + (weapon->y - weapon->oldy) * r_TicFracF;
}
}
else
{
wx = 0;
wy = 0;
}
// add all active psprites
for (i = 0, psp = camera->player->psprites;
i < NUMPSPRITES;
i++, psp++)
psp = camera->player->psprites;
while (psp)
{
// [RH] Don't draw the targeter's crosshair if the player already has a crosshair set.
if (psp->state && (i != ps_targetcenter || CrosshairImage == NULL))
// It's possible this psprite's caller is now null but the layer itself hasn't been destroyed
// because it didn't tick yet (if we typed 'take all' while in the console for example).
// In this case let's simply not draw it to avoid crashing.
if ((psp->GetID() != PSP_TARGETCENTER || CrosshairImage == nullptr) && psp->GetCaller() != nullptr)
{
R_DrawPSprite (psp, i, camera, psp->sx + ofsx, psp->sy + ofsy);
}
// [RH] Don't bob the targeter.
if (i == ps_flash)
{
ofsx = ofsy = 0;
R_DrawPSprite(psp, camera, bobx, boby, wx, wy, r_TicFracF);
}
psp = psp->GetNext();
}
CenterY = centerhack;
@ -1623,65 +1676,62 @@ void R_DrawPlayerSprites ()
void R_DrawRemainingPlayerSprites()
{
for (int i = 0; i < NUMPSPRITES; ++i)
for (unsigned int i = 0; i < vispspindex; i++)
{
vissprite_t *vis;
vis = VisPSprites[i];
VisPSprites[i] = NULL;
vis = vispsprites[i].vis;
FDynamicColormap *colormap = vispsprites[i].basecolormap;
bool flip = vis->xiscale < 0;
FSpecialColormap *special = NULL;
PalEntry overlay = 0;
FColormapStyle colormapstyle;
bool usecolormapstyle = false;
if (vis != NULL)
if (vis->Style.colormap >= SpecialColormaps[0].Colormap &&
vis->Style.colormap < SpecialColormaps[SpecialColormaps.Size()].Colormap)
{
FDynamicColormap *colormap = VisPSpritesBaseColormap[i];
bool flip = vis->xiscale < 0;
FSpecialColormap *special = NULL;
PalEntry overlay = 0;
FColormapStyle colormapstyle;
bool usecolormapstyle = false;
if (vis->Style.colormap >= SpecialColormaps[0].Colormap &&
vis->Style.colormap < SpecialColormaps[SpecialColormaps.Size()].Colormap)
{
// Yuck! There needs to be a better way to store colormaps in the vissprite... :(
ptrdiff_t specialmap = (vis->Style.colormap - SpecialColormaps[0].Colormap) / sizeof(FSpecialColormap);
special = &SpecialColormaps[specialmap];
}
else if (colormap->Color == PalEntry(255,255,255) &&
colormap->Desaturate == 0)
{
overlay = colormap->Fade;
overlay.a = BYTE(((vis->Style.colormap - colormap->Maps) >> 8) * 255 / NUMCOLORMAPS);
}
else
{
usecolormapstyle = true;
colormapstyle.Color = colormap->Color;
colormapstyle.Fade = colormap->Fade;
colormapstyle.Desaturate = colormap->Desaturate;
colormapstyle.FadeLevel = ((vis->Style.colormap - colormap->Maps) >> 8) / float(NUMCOLORMAPS);
}
screen->DrawTexture(vis->pic,
viewwindowx + VisPSpritesX1[i],
viewwindowy + viewheight/2 - vis->texturemid * vis->yscale - 0.5,
DTA_DestWidthF, FIXED2DBL(vis->pic->GetWidth() * vis->xscale),
DTA_DestHeightF, vis->pic->GetHeight() * vis->yscale,
DTA_Translation, TranslationToTable(vis->Translation),
DTA_FlipX, flip,
DTA_TopOffset, 0,
DTA_LeftOffset, 0,
DTA_ClipLeft, viewwindowx,
DTA_ClipTop, viewwindowy,
DTA_ClipRight, viewwindowx + viewwidth,
DTA_ClipBottom, viewwindowy + viewheight,
DTA_AlphaF, vis->Style.Alpha,
DTA_RenderStyle, vis->Style.RenderStyle,
DTA_FillColor, vis->FillColor,
DTA_SpecialColormap, special,
DTA_ColorOverlay, overlay.d,
DTA_ColormapStyle, usecolormapstyle ? &colormapstyle : NULL,
TAG_DONE);
// Yuck! There needs to be a better way to store colormaps in the vissprite... :(
ptrdiff_t specialmap = (vis->Style.colormap - SpecialColormaps[0].Colormap) / sizeof(FSpecialColormap);
special = &SpecialColormaps[specialmap];
}
else if (colormap->Color == PalEntry(255,255,255) &&
colormap->Desaturate == 0)
{
overlay = colormap->Fade;
overlay.a = BYTE(((vis->Style.colormap - colormap->Maps) >> 8) * 255 / NUMCOLORMAPS);
}
else
{
usecolormapstyle = true;
colormapstyle.Color = colormap->Color;
colormapstyle.Fade = colormap->Fade;
colormapstyle.Desaturate = colormap->Desaturate;
colormapstyle.FadeLevel = ((vis->Style.colormap - colormap->Maps) >> 8) / float(NUMCOLORMAPS);
}
screen->DrawTexture(vis->pic,
viewwindowx + vispsprites[i].x1,
viewwindowy + viewheight/2 - vis->texturemid * vis->yscale - 0.5,
DTA_DestWidthF, FIXED2DBL(vis->pic->GetWidth() * vis->xscale),
DTA_DestHeightF, vis->pic->GetHeight() * vis->yscale,
DTA_Translation, TranslationToTable(vis->Translation),
DTA_FlipX, flip,
DTA_TopOffset, 0,
DTA_LeftOffset, 0,
DTA_ClipLeft, viewwindowx,
DTA_ClipTop, viewwindowy,
DTA_ClipRight, viewwindowx + viewwidth,
DTA_ClipBottom, viewwindowy + viewheight,
DTA_AlphaF, vis->Style.Alpha,
DTA_RenderStyle, vis->Style.RenderStyle,
DTA_FillColor, vis->FillColor,
DTA_SpecialColormap, special,
DTA_ColorOverlay, overlay.d,
DTA_ColormapStyle, usecolormapstyle ? &colormapstyle : NULL,
TAG_DONE);
}
vispspindex = 0;
}
//

1
src/r_things.h
View file

@ -130,7 +130,6 @@ void R_WallSpriteColumn (void (*drawfunc)(const BYTE *column, const FTexture::Sp
void R_CacheSprite (spritedef_t *sprite);
void R_SortVisSprites (int (*compare)(const void *, const void *), size_t first);
void R_AddSprites (sector_t *sec, int lightlevel, int fakeside);
void R_AddPSprites ();
void R_DrawSprites ();
void R_ClearSprites ();
void R_DrawMasked ();

13
src/thingdef/thingdef_codeptr.cpp
View file

@ -5839,15 +5839,18 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetTics)
PARAM_ACTION_PROLOGUE;
PARAM_INT(tics_to_set);
if (stateowner != self && self->player != NULL && stateowner->IsKindOf(RUNTIME_CLASS(AWeapon)))
{ // Is this a weapon? Need to check psp states for a match, then. Blah.
for (int i = 0; i < NUMPSPRITES; ++i)
if (self->player != nullptr)
{ // Need to check psp states for a match, then. Blah.
DPSprite *pspr = self->player->psprites;
while (pspr)
{
if (self->player->psprites[i].state == callingstate)
if (pspr->GetState() == callingstate)
{
self->player->psprites[i].tics = tics_to_set;
pspr->Tics = tics_to_set;
return 0;
}
pspr = pspr->GetNext();
}
}
// Just set tics for self.

5
wadsrc/static/actors/actor.txt
View file

@ -334,6 +334,11 @@ ACTOR Actor native //: Thinker
native void A_TransferPointer(int ptr_source, int ptr_recepient, int sourcefield, int recepientfield=AAPTR_DEFAULT, int flags=0);
action native A_CopyFriendliness(int ptr_source = AAPTR_MASTER);
action native A_Overlay(int layer, state start = "");
action native A_WeaponOffset(float wx = 0, float wy = 32, int flags = 0);
action native A_OverlayOffset(int layer = PSP_WEAPON, float wx = 0, float wy = 32, int flags = 0);
action native A_OverlayFlags(int layer, int flags, bool set);
native int ACS_NamedExecute(name script, int mapnum=0, int arg1=0, int arg2=0, int arg3=0);
native int ACS_NamedSuspend(name script, int mapnum=0);
native int ACS_NamedTerminate(name script, int mapnum=0);

18
wadsrc/static/actors/constants.txt
View file

@ -576,4 +576,20 @@ enum
WOF_KEEPX = 1,
WOF_KEEPY = 1 << 1,
WOF_ADD = 1 << 2,
};
};
// Flags for psprite layers
enum
{
PSPF_ADDWEAPON = 1 << 0,
PSPF_ADDBOB = 1 << 1,
PSPF_POWDOUBLE = 1 << 2,
PSPF_CVARFAST = 1 << 3,
};
// Default psprite layers
enum
{
PSP_WEAPON = 1,
PSP_FLASH = 1000,
};

3
wadsrc/static/actors/shared/inventory.txt
View file

@ -48,8 +48,7 @@ ACTOR Inventory native
action native A_RestoreSpecialDoomThing();
action native A_RestoreSpecialThing1();
action native A_RestoreSpecialThing2();
action native A_WeaponOffset(float wx = 0, float wy = 32, int flags = 0);
States
{
HideDoomish: