zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-13 16:07:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

- got rid of PClassWeapon.

Browse source 
Still 5 subclasses of PClass left...
This commit is contained in:
Christoph Oelckers 2017-02-07 19:02:27 +01:00
parent 776509e68a
commit 7ed554158c
8 changed files with 118 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/d_net.cpp
View file

@ -2638,7 +2638,7 @@ void Net_DoCommand (int type, BYTE **stream, int player)
} }
for(i = 0; i < count; ++i) for(i = 0; i < count; ++i)
{ {
PClassWeapon *wpn = Net_ReadWeapon(stream); PClassActor *wpn = Net_ReadWeapon(stream);
players[pnum].weapons.AddSlot(slot, wpn, pnum == consoleplayer); players[pnum].weapons.AddSlot(slot, wpn, pnum == consoleplayer);
} }
} }
@ -2647,7 +2647,7 @@ void Net_DoCommand (int type, BYTE **stream, int player)
case DEM_ADDSLOT: case DEM_ADDSLOT:
{ {
int slot = ReadByte(stream); int slot = ReadByte(stream);
PClassWeapon *wpn = Net_ReadWeapon(stream); PClassActor *wpn = Net_ReadWeapon(stream);
players[player].weapons.AddSlot(slot, wpn, player == consoleplayer); players[player].weapons.AddSlot(slot, wpn, player == consoleplayer);
} }
break; break;
@ -2655,7 +2655,7 @@ void Net_DoCommand (int type, BYTE **stream, int player)
case DEM_ADDSLOTDEFAULT: case DEM_ADDSLOTDEFAULT:
{ {
int slot = ReadByte(stream); int slot = ReadByte(stream);
PClassWeapon *wpn = Net_ReadWeapon(stream); PClassActor *wpn = Net_ReadWeapon(stream);
players[player].weapons.AddSlotDefault(slot, wpn, player == consoleplayer); players[player].weapons.AddSlotDefault(slot, wpn, player == consoleplayer);
} }
break; break;

1
src/dobject.h
View file

@ -94,7 +94,6 @@ enum
CLASSREG_PClass, CLASSREG_PClass,
CLASSREG_PClassActor, CLASSREG_PClassActor,
CLASSREG_PClassInventory, CLASSREG_PClassInventory,
CLASSREG_PClassWeapon,
CLASSREG_PClassPlayerPawn, CLASSREG_PClassPlayerPawn,
CLASSREG_PClassType, CLASSREG_PClassType,
CLASSREG_PClassClass, CLASSREG_PClassClass,

8
src/dobjtype.cpp
View file

@ -3030,6 +3030,13 @@ void PClass::StaticShutdown ()
FlatpointerArena.FreeAllBlocks(); FlatpointerArena.FreeAllBlocks();
bShutdown = true; bShutdown = true;
for (unsigned i = 0; i < PClass::AllClasses.Size(); ++i)
{
PClass *type = PClass::AllClasses[i];
PClass::AllClasses[i] = NULL;
type->Destroy();
}
AllClasses.Clear(); AllClasses.Clear();
PClassActor::AllActorClasses.Clear(); PClassActor::AllActorClasses.Clear();
@ -3129,7 +3136,6 @@ PClass *ClassReg::RegisterClass()
&PClass::RegistrationInfo, &PClass::RegistrationInfo,
&PClassActor::RegistrationInfo, &PClassActor::RegistrationInfo,
&PClassInventory::RegistrationInfo, &PClassInventory::RegistrationInfo,
&PClassWeapon::RegistrationInfo,
&PClassPlayerPawn::RegistrationInfo, &PClassPlayerPawn::RegistrationInfo,
&PClassType::RegistrationInfo, &PClassType::RegistrationInfo,
&PClassClass::RegistrationInfo, &PClassClass::RegistrationInfo,

10
src/fragglescript/t_func.cpp
View file

@ -2675,8 +2675,8 @@ void FParser::SF_PlayerWeapon()
script_error("weaponnum out of range! %d\n", weaponnum); script_error("weaponnum out of range! %d\n", weaponnum);
return; return;
} }
PClassWeapon * ti = static_cast<PClassWeapon *>(PClass::FindActor(WeaponNames[weaponnum])); auto ti = PClass::FindActor(WeaponNames[weaponnum]);
if (!ti) if (!ti || !ti->IsDescendantOf(RUNTIME_CLASS(AWeapon)))
{ {
script_error("incompatibility in playerweapon %d\n", weaponnum); script_error("incompatibility in playerweapon %d\n", weaponnum);
return; return;
@ -2686,7 +2686,7 @@ void FParser::SF_PlayerWeapon()
{ {
AActor * wp = players[playernum].mo->FindInventory(ti); AActor * wp = players[playernum].mo->FindInventory(ti);
t_return.type = svt_int; t_return.type = svt_int;
t_return.value.i = wp!=NULL;; t_return.value.i = wp!=NULL;
return; return;
} }
else else
@ -2756,8 +2756,8 @@ void FParser::SF_PlayerSelectedWeapon()
script_error("weaponnum out of range! %d\n", weaponnum); script_error("weaponnum out of range! %d\n", weaponnum);
return; return;
} }
PClassWeapon * ti = static_cast<PClassWeapon *>(PClass::FindActor(WeaponNames[weaponnum])); auto ti = PClass::FindActor(WeaponNames[weaponnum]);
if (!ti) if (!ti || !ti->IsDescendantOf(RUNTIME_CLASS(AWeapon)))
{ {
script_error("incompatibility in playerweapon %d\n", weaponnum); script_error("incompatibility in playerweapon %d\n", weaponnum);
return; return;

199
src/g_inventory/a_weapons.cpp
View file

@ -113,42 +113,11 @@ FString WeaponSection;
TArray<FString> KeyConfWeapons; TArray<FString> KeyConfWeapons;
FWeaponSlots *PlayingKeyConf; FWeaponSlots *PlayingKeyConf;
TArray<PClassWeapon *> Weapons_ntoh; TArray<PClassActor *> Weapons_ntoh;
TMap<PClassWeapon *, int> Weapons_hton; TMap<PClassActor *, int> Weapons_hton;
static int ntoh_cmp(const void *a, const void *b); static int ntoh_cmp(const void *a, const void *b);
IMPLEMENT_CLASS(PClassWeapon, false, false)
//===========================================================================
//
//
//
//===========================================================================
PClassWeapon::PClassWeapon()
{
SlotNumber = -1;
SlotPriority = INT_MAX;
}
//===========================================================================
//
//
//
//===========================================================================
void PClassWeapon::DeriveData(PClass *newclass)
{
assert(newclass->IsKindOf(RUNTIME_CLASS(PClassWeapon)));
Super::DeriveData(newclass);
PClassWeapon *newc = static_cast<PClassWeapon *>(newclass);
newc->SlotNumber = SlotNumber;
newc->SlotPriority = SlotPriority;
}
//=========================================================================== //===========================================================================
// //
// //
@ -273,7 +242,7 @@ bool AWeapon::CheckAmmo (int fireMode, bool autoSwitch, bool requireAmmo, int am
bool gotSome = CheckAmmo (PrimaryFire, false) || CheckAmmo (AltFire, false); bool gotSome = CheckAmmo (PrimaryFire, false) || CheckAmmo (AltFire, false);
if (!gotSome && autoSwitch) if (!gotSome && autoSwitch)
{ {
barrier_cast<APlayerPawn *>(Owner)->PickNewWeapon (NULL); barrier_cast<APlayerPawn *>(Owner)->PickNewWeapon (nullptr);
} }
return gotSome; return gotSome;
} }
@ -282,10 +251,10 @@ bool AWeapon::CheckAmmo (int fireMode, bool autoSwitch, bool requireAmmo, int am
{ {
return true; return true;
} }
count1 = (Ammo1 != NULL) ? Ammo1->Amount : 0; count1 = (Ammo1 != nullptr) ? Ammo1->Amount : 0;
count2 = (Ammo2 != NULL) ? Ammo2->Amount : 0; count2 = (Ammo2 != nullptr) ? Ammo2->Amount : 0;
if ((WeaponFlags & WIF_DEHAMMO) && (Ammo1 == NULL)) if ((WeaponFlags & WIF_DEHAMMO) && (Ammo1 == nullptr))
{ {
lAmmoUse1 = 0; lAmmoUse1 = 0;
} }
@ -307,7 +276,7 @@ bool AWeapon::CheckAmmo (int fireMode, bool autoSwitch, bool requireAmmo, int am
{ {
enoughmask = 1 << altFire; enoughmask = 1 << altFire;
} }
if (altFire && FindState(NAME_AltFire) == NULL) if (altFire && FindState(NAME_AltFire) == nullptr)
{ // If this weapon has no alternate fire, then there is never enough ammo for it { // If this weapon has no alternate fire, then there is never enough ammo for it
enough &= 1; enough &= 1;
} }
@ -318,7 +287,7 @@ bool AWeapon::CheckAmmo (int fireMode, bool autoSwitch, bool requireAmmo, int am
// out of ammo, pick a weapon to change to // out of ammo, pick a weapon to change to
if (autoSwitch) if (autoSwitch)
{ {
barrier_cast<APlayerPawn *>(Owner)->PickNewWeapon (NULL); barrier_cast<APlayerPawn *>(Owner)->PickNewWeapon (nullptr);
} }
return false; return false;
} }
@ -353,7 +322,7 @@ bool AWeapon::DepleteAmmo (bool altFire, bool checkEnough, int ammouse)
} }
if (!altFire) if (!altFire)
{ {
if (Ammo1 != NULL) if (Ammo1 != nullptr)
{ {
if (ammouse >= 0 && (WeaponFlags & WIF_DEHAMMO)) if (ammouse >= 0 && (WeaponFlags & WIF_DEHAMMO))
{ {
@ -364,25 +333,25 @@ bool AWeapon::DepleteAmmo (bool altFire, bool checkEnough, int ammouse)
Ammo1->Amount -= AmmoUse1; Ammo1->Amount -= AmmoUse1;
} }
} }
if ((WeaponFlags & WIF_PRIMARY_USES_BOTH) && Ammo2 != NULL) if ((WeaponFlags & WIF_PRIMARY_USES_BOTH) && Ammo2 != nullptr)
{ {
Ammo2->Amount -= AmmoUse2; Ammo2->Amount -= AmmoUse2;
} }
} }
else else
{ {
if (Ammo2 != NULL) if (Ammo2 != nullptr)
{ {
Ammo2->Amount -= AmmoUse2; Ammo2->Amount -= AmmoUse2;
} }
if ((WeaponFlags & WIF_ALT_USES_BOTH) && Ammo1 != NULL) if ((WeaponFlags & WIF_ALT_USES_BOTH) && Ammo1 != nullptr)
{ {
Ammo1->Amount -= AmmoUse1; Ammo1->Amount -= AmmoUse1;
} }
} }
if (Ammo1 != NULL && Ammo1->Amount < 0) if (Ammo1 != nullptr && Ammo1->Amount < 0)
Ammo1->Amount = 0; Ammo1->Amount = 0;
if (Ammo2 != NULL && Ammo2->Amount < 0) if (Ammo2 != nullptr && Ammo2->Amount < 0)
Ammo2->Amount = 0; Ammo2->Amount = 0;
} }
return true; return true;
@ -547,14 +516,14 @@ FState *AWeapon::GetStateForButtonName (FName button)
bool FWeaponSlot::AddWeapon(const char *type) bool FWeaponSlot::AddWeapon(const char *type)
{ {
return AddWeapon(static_cast<PClassWeapon *>(PClass::FindClass(type))); return AddWeapon(static_cast<PClassActor *>(PClass::FindClass(type)));
} }
bool FWeaponSlot::AddWeapon(PClassWeapon *type) bool FWeaponSlot::AddWeapon(PClassActor *type)
{ {
unsigned int i; unsigned int i;
if (type == NULL) if (type == nullptr)
{ {
return false; return false;
} }
@ -595,10 +564,10 @@ void FWeaponSlot :: AddWeaponList(const char *list, bool clear)
Clear(); Clear();
} }
tok = strtok(buff, " "); tok = strtok(buff, " ");
while (tok != NULL) while (tok != nullptr)
{ {
AddWeapon(tok); AddWeapon(tok);
tok = strtok(NULL, " "); tok = strtok(nullptr, " ");
} }
} }
@ -611,7 +580,7 @@ void FWeaponSlot :: AddWeaponList(const char *list, bool clear)
// //
//=========================================================================== //===========================================================================
int FWeaponSlot::LocateWeapon(PClassWeapon *type) int FWeaponSlot::LocateWeapon(PClassActor *type)
{ {
unsigned int i; unsigned int i;
@ -642,22 +611,22 @@ AWeapon *FWeaponSlot::PickWeapon(player_t *player, bool checkammo)
{ {
int i, j; int i, j;
if (player->mo == NULL) if (player->mo == nullptr)
{ {
return NULL; return nullptr;
} }
// Does this slot even have any weapons? // Does this slot even have any weapons?
if (Weapons.Size() == 0) if (Weapons.Size() == 0)
{ {
return player->ReadyWeapon; return player->ReadyWeapon;
} }
if (player->ReadyWeapon != NULL) if (player->ReadyWeapon != nullptr)
{ {
for (i = 0; (unsigned)i < Weapons.Size(); i++) for (i = 0; (unsigned)i < Weapons.Size(); i++)
{ {
if (Weapons[i].Type == player->ReadyWeapon->GetClass() || if (Weapons[i].Type == player->ReadyWeapon->GetClass() ||
(player->ReadyWeapon->WeaponFlags & WIF_POWERED_UP && (player->ReadyWeapon->WeaponFlags & WIF_POWERED_UP &&
player->ReadyWeapon->SisterWeapon != NULL && player->ReadyWeapon->SisterWeapon != nullptr &&
player->ReadyWeapon->SisterWeapon->GetClass() == Weapons[i].Type)) player->ReadyWeapon->SisterWeapon->GetClass() == Weapons[i].Type))
{ {
for (j = (i == 0 ? Weapons.Size() - 1 : i - 1); for (j = (i == 0 ? Weapons.Size() - 1 : i - 1);
@ -666,7 +635,7 @@ AWeapon *FWeaponSlot::PickWeapon(player_t *player, bool checkammo)
{ {
AWeapon *weap = static_cast<AWeapon *> (player->mo->FindInventory(Weapons[j].Type)); AWeapon *weap = static_cast<AWeapon *> (player->mo->FindInventory(Weapons[j].Type));
if (weap != NULL && weap->IsKindOf(RUNTIME_CLASS(AWeapon))) if (weap != nullptr && weap->IsKindOf(RUNTIME_CLASS(AWeapon)))
{ {
if (!checkammo || weap->CheckAmmo(AWeapon::EitherFire, false)) if (!checkammo || weap->CheckAmmo(AWeapon::EitherFire, false))
{ {
@ -681,7 +650,7 @@ AWeapon *FWeaponSlot::PickWeapon(player_t *player, bool checkammo)
{ {
AWeapon *weap = static_cast<AWeapon *> (player->mo->FindInventory(Weapons[i].Type)); AWeapon *weap = static_cast<AWeapon *> (player->mo->FindInventory(Weapons[i].Type));
if (weap != NULL && weap->IsKindOf(RUNTIME_CLASS(AWeapon))) if (weap != nullptr && weap->IsKindOf(RUNTIME_CLASS(AWeapon)))
{ {
if (!checkammo || weap->CheckAmmo(AWeapon::EitherFire, false)) if (!checkammo || weap->CheckAmmo(AWeapon::EitherFire, false))
{ {
@ -737,7 +706,7 @@ void FWeaponSlot::Sort()
for (i = 1; i < (int)Weapons.Size(); ++i) for (i = 1; i < (int)Weapons.Size(); ++i)
{ {
int pos = Weapons[i].Position; int pos = Weapons[i].Position;
PClassWeapon *type = Weapons[i].Type; PClassActor *type = Weapons[i].Type;
for (j = i - 1; j >= 0 && Weapons[j].Position > pos; --j) for (j = i - 1; j >= 0 && Weapons[j].Position > pos; --j)
{ {
Weapons[j + 1] = Weapons[j]; Weapons[j + 1] = Weapons[j];
@ -786,7 +755,7 @@ void FWeaponSlots::Clear()
// //
//=========================================================================== //===========================================================================
ESlotDef FWeaponSlots::AddDefaultWeapon (int slot, PClassWeapon *type) ESlotDef FWeaponSlots::AddDefaultWeapon (int slot, PClassActor *type)
{ {
int currSlot, index; int currSlot, index;
@ -811,7 +780,7 @@ ESlotDef FWeaponSlots::AddDefaultWeapon (int slot, PClassWeapon *type)
// //
//=========================================================================== //===========================================================================
bool FWeaponSlots::LocateWeapon (PClassWeapon *type, int *const slot, int *const index) bool FWeaponSlots::LocateWeapon (PClassActor *type, int *const slot, int *const index)
{ {
int i, j; int i, j;
@ -820,8 +789,8 @@ bool FWeaponSlots::LocateWeapon (PClassWeapon *type, int *const slot, int *const
j = Slots[i].LocateWeapon(type); j = Slots[i].LocateWeapon(type);
if (j >= 0) if (j >= 0)
{ {
if (slot != NULL) *slot = i; if (slot != nullptr) *slot = i;
if (index != NULL) *index = j; if (index != nullptr) *index = j;
return true; return true;
} }
} }
@ -858,14 +827,14 @@ static bool FindMostRecentWeapon(player_t *player, int *slot, int *index)
{ {
return player->weapons.LocateWeapon(player->PendingWeapon->GetClass(), slot, index); return player->weapons.LocateWeapon(player->PendingWeapon->GetClass(), slot, index);
} }
else if (player->ReadyWeapon != NULL) else if (player->ReadyWeapon != nullptr)
{ {
AWeapon *weap = player->ReadyWeapon; AWeapon *weap = player->ReadyWeapon;
if (!player->weapons.LocateWeapon(weap->GetClass(), slot, index)) if (!player->weapons.LocateWeapon(weap->GetClass(), slot, index))
{ {
// If the current weapon wasn't found and is powered up, // If the current weapon wasn't found and is powered up,
// look for its non-powered up version. // look for its non-powered up version.
if (weap->WeaponFlags & WIF_POWERED_UP && weap->SisterWeaponType != NULL) if (weap->WeaponFlags & WIF_POWERED_UP && weap->SisterWeaponType != nullptr)
{ {
return player->weapons.LocateWeapon(weap->SisterWeaponType, slot, index); return player->weapons.LocateWeapon(weap->SisterWeaponType, slot, index);
} }
@ -894,16 +863,16 @@ AWeapon *FWeaponSlots::PickNextWeapon(player_t *player)
int startslot, startindex; int startslot, startindex;
int slotschecked = 0; int slotschecked = 0;
if (player->mo == NULL) if (player->mo == nullptr)
{ {
return NULL; return nullptr;
} }
if (player->ReadyWeapon == NULL || FindMostRecentWeapon(player, &startslot, &startindex)) if (player->ReadyWeapon == nullptr || FindMostRecentWeapon(player, &startslot, &startindex))
{ {
int slot; int slot;
int index; int index;
if (player->ReadyWeapon == NULL) if (player->ReadyWeapon == nullptr)
{ {
startslot = NUM_WEAPON_SLOTS - 1; startslot = NUM_WEAPON_SLOTS - 1;
startindex = Slots[startslot].Size() - 1; startindex = Slots[startslot].Size() - 1;
@ -922,9 +891,9 @@ AWeapon *FWeaponSlots::PickNextWeapon(player_t *player)
slot = 0; slot = 0;
} }
} }
PClassWeapon *type = Slots[slot].GetWeapon(index); PClassActor *type = Slots[slot].GetWeapon(index);
AWeapon *weap = static_cast<AWeapon *>(player->mo->FindInventory(type)); AWeapon *weap = static_cast<AWeapon *>(player->mo->FindInventory(type));
if (weap != NULL && weap->CheckAmmo(AWeapon::EitherFire, false)) if (weap != nullptr && weap->CheckAmmo(AWeapon::EitherFire, false))
{ {
return weap; return weap;
} }
@ -949,16 +918,16 @@ AWeapon *FWeaponSlots::PickPrevWeapon (player_t *player)
int startslot, startindex; int startslot, startindex;
int slotschecked = 0; int slotschecked = 0;
if (player->mo == NULL) if (player->mo == nullptr)
{ {
return NULL; return nullptr;
} }
if (player->ReadyWeapon == NULL || FindMostRecentWeapon (player, &startslot, &startindex)) if (player->ReadyWeapon == nullptr || FindMostRecentWeapon (player, &startslot, &startindex))
{ {
int slot; int slot;
int index; int index;
if (player->ReadyWeapon == NULL) if (player->ReadyWeapon == nullptr)
{ {
startslot = 0; startslot = 0;
startindex = 0; startindex = 0;
@ -977,9 +946,9 @@ AWeapon *FWeaponSlots::PickPrevWeapon (player_t *player)
} }
index = Slots[slot].Size() - 1; index = Slots[slot].Size() - 1;
} }
PClassWeapon *type = Slots[slot].GetWeapon(index); PClassActor *type = Slots[slot].GetWeapon(index);
AWeapon *weap = static_cast<AWeapon *>(player->mo->FindInventory(type)); AWeapon *weap = static_cast<AWeapon *>(player->mo->FindInventory(type));
if (weap != NULL && weap->CheckAmmo(AWeapon::EitherFire, false)) if (weap != nullptr && weap->CheckAmmo(AWeapon::EitherFire, false))
{ {
return weap; return weap;
} }
@ -1011,23 +980,23 @@ void FWeaponSlots::AddExtraWeapons()
// Append extra weapons to the slots. // Append extra weapons to the slots.
for (unsigned int i = 0; i < PClassActor::AllActorClasses.Size(); ++i) for (unsigned int i = 0; i < PClassActor::AllActorClasses.Size(); ++i)
{ {
PClass *cls = PClassActor::AllActorClasses[i]; PClassActor *cls = PClassActor::AllActorClasses[i];
if (!cls->IsDescendantOf(RUNTIME_CLASS(AWeapon))) if (!cls->IsDescendantOf(RUNTIME_CLASS(AWeapon)))
{ {
continue; continue;
} }
PClassWeapon *acls = static_cast<PClassWeapon *>(cls); auto weapdef = ((AWeapon*)GetDefaultByType(cls));
if ((acls->GameFilter == GAME_Any || (acls->GameFilter & gameinfo.gametype)) && if ((cls->GameFilter == GAME_Any || (cls->GameFilter & gameinfo.gametype)) &&
acls->Replacement == NULL && // Replaced weapons don't get slotted. cls->Replacement == nullptr && // Replaced weapons don't get slotted.
!(((AWeapon *)(acls->Defaults))->WeaponFlags & WIF_POWERED_UP) && !(weapdef->WeaponFlags & WIF_POWERED_UP) &&
!LocateWeapon(acls, NULL, NULL) // Don't duplicate it if it's already present. !LocateWeapon(cls, nullptr, nullptr) // Don't duplicate it if it's already present.
) )
{ {
int slot = acls->SlotNumber; int slot = weapdef->SlotNumber;
if ((unsigned)slot < NUM_WEAPON_SLOTS) if ((unsigned)slot < NUM_WEAPON_SLOTS)
{ {
FWeaponSlot::WeaponInfo info = { acls, acls->SlotPriority }; FWeaponSlot::WeaponInfo info = { cls, weapdef->SlotPriority };
Slots[slot].Weapons.Push(info); Slots[slot].Weapons.Push(info);
} }
} }
@ -1064,8 +1033,8 @@ void FWeaponSlots::SetFromGameInfo()
{ {
for (unsigned j = 0; j < gameinfo.DefaultWeaponSlots[i].Size(); j++) for (unsigned j = 0; j < gameinfo.DefaultWeaponSlots[i].Size(); j++)
{ {
PClassWeapon *cls = dyn_cast<PClassWeapon>(PClass::FindClass(gameinfo.DefaultWeaponSlots[i][j])); PClassActor *cls = PClass::FindActor(gameinfo.DefaultWeaponSlots[i][j]);
if (cls == NULL) if (cls == nullptr)
{ {
Printf("Unknown weapon class '%s' found in default weapon slot assignments\n", Printf("Unknown weapon class '%s' found in default weapon slot assignments\n",
gameinfo.DefaultWeaponSlots[i][j].GetChars()); gameinfo.DefaultWeaponSlots[i][j].GetChars());
@ -1261,7 +1230,7 @@ CCMD (setslot)
if (argv.argc() < 2 || (slot = atoi (argv[1])) >= NUM_WEAPON_SLOTS) if (argv.argc() < 2 || (slot = atoi (argv[1])) >= NUM_WEAPON_SLOTS)
{ {
Printf("Usage: setslot [slot] [weapons]\nCurrent slot assignments:\n"); Printf("Usage: setslot [slot] [weapons]\nCurrent slot assignments:\n");
if (players[consoleplayer].mo != NULL) if (players[consoleplayer].mo != nullptr)
{ {
FString config(GameConfig->GetConfigPath(false)); FString config(GameConfig->GetConfigPath(false));
Printf(TEXTCOLOR_BLUE "Add the following to " TEXTCOLOR_ORANGE "%s" TEXTCOLOR_BLUE Printf(TEXTCOLOR_BLUE "Add the following to " TEXTCOLOR_ORANGE "%s" TEXTCOLOR_BLUE
@ -1280,7 +1249,7 @@ CCMD (setslot)
{ {
KeyConfWeapons.Push(argv.args()); KeyConfWeapons.Push(argv.args());
} }
else if (PlayingKeyConf != NULL) else if (PlayingKeyConf != nullptr)
{ {
PlayingKeyConf->Slots[slot].Clear(); PlayingKeyConf->Slots[slot].Clear();
for (int i = 2; i < argv.argc(); ++i) for (int i = 2; i < argv.argc(); ++i)
@ -1300,7 +1269,7 @@ CCMD (setslot)
Net_WriteByte(argv.argc()-2); Net_WriteByte(argv.argc()-2);
for (int i = 2; i < argv.argc(); i++) for (int i = 2; i < argv.argc(); i++)
{ {
Net_WriteWeapon(dyn_cast<PClassWeapon>(PClass::FindClass(argv[i]))); Net_WriteWeapon(dyn_cast<PClassActor>(PClass::FindClass(argv[i])));
} }
} }
} }
@ -1311,9 +1280,9 @@ CCMD (setslot)
// //
//=========================================================================== //===========================================================================
void FWeaponSlots::AddSlot(int slot, PClassWeapon *type, bool feedback) void FWeaponSlots::AddSlot(int slot, PClassActor *type, bool feedback)
{ {
if (type != NULL && !Slots[slot].AddWeapon(type) && feedback) if (type != nullptr && !Slots[slot].AddWeapon(type) && feedback)
{ {
Printf ("Could not add %s to slot %d\n", type->TypeName.GetChars(), slot); Printf ("Could not add %s to slot %d\n", type->TypeName.GetChars(), slot);
} }
@ -1329,8 +1298,8 @@ CCMD (addslot)
return; return;
} }
PClassWeapon *type= dyn_cast<PClassWeapon>(PClass::FindClass(argv[2])); PClassActor *type= dyn_cast<PClassActor>(PClass::FindClass(argv[2]));
if (type == NULL) if (type == nullptr)
{ {
Printf("%s is not a weapon\n", argv[2]); Printf("%s is not a weapon\n", argv[2]);
return; return;
@ -1340,7 +1309,7 @@ CCMD (addslot)
{ {
KeyConfWeapons.Push(argv.args()); KeyConfWeapons.Push(argv.args());
} }
else if (PlayingKeyConf != NULL) else if (PlayingKeyConf != nullptr)
{ {
PlayingKeyConf->AddSlot(int(slot), type, false); PlayingKeyConf->AddSlot(int(slot), type, false);
} }
@ -1371,9 +1340,9 @@ CCMD (weaponsection)
// CCMD addslotdefault // CCMD addslotdefault
// //
//=========================================================================== //===========================================================================
void FWeaponSlots::AddSlotDefault(int slot, PClassWeapon *type, bool feedback) void FWeaponSlots::AddSlotDefault(int slot, PClassActor *type, bool feedback)
{ {
if (type != NULL && type->IsDescendantOf(RUNTIME_CLASS(AWeapon))) if (type != nullptr && type->IsDescendantOf(RUNTIME_CLASS(AWeapon)))
{ {
switch (AddDefaultWeapon(slot, type)) switch (AddDefaultWeapon(slot, type))
{ {
@ -1396,7 +1365,7 @@ void FWeaponSlots::AddSlotDefault(int slot, PClassWeapon *type, bool feedback)
CCMD (addslotdefault) CCMD (addslotdefault)
{ {
PClassWeapon *type; PClassActor *type;
unsigned int slot; unsigned int slot;
if (argv.argc() != 3 || (slot = atoi (argv[1])) >= NUM_WEAPON_SLOTS) if (argv.argc() != 3 || (slot = atoi (argv[1])) >= NUM_WEAPON_SLOTS)
@ -1405,8 +1374,8 @@ CCMD (addslotdefault)
return; return;
} }
type = dyn_cast<PClassWeapon>(PClass::FindClass(argv[2])); type = dyn_cast<PClassActor>(PClass::FindClass(argv[2]));
if (type == NULL) if (type == nullptr)
{ {
Printf ("%s is not a weapon\n", argv[2]); Printf ("%s is not a weapon\n", argv[2]);
return; return;
@ -1416,7 +1385,7 @@ CCMD (addslotdefault)
{ {
KeyConfWeapons.Push(argv.args()); KeyConfWeapons.Push(argv.args());
} }
else if (PlayingKeyConf != NULL) else if (PlayingKeyConf != nullptr)
{ {
PlayingKeyConf->AddSlotDefault(int(slot), type, false); PlayingKeyConf->AddSlotDefault(int(slot), type, false);
} }
@ -1444,7 +1413,7 @@ void P_PlaybackKeyConfWeapons(FWeaponSlots *slots)
FString cmd(KeyConfWeapons[i]); FString cmd(KeyConfWeapons[i]);
AddCommandString(cmd.LockBuffer()); AddCommandString(cmd.LockBuffer());
} }
PlayingKeyConf = NULL; PlayingKeyConf = nullptr;
} }
//=========================================================================== //===========================================================================
@ -1461,20 +1430,20 @@ void P_PlaybackKeyConfWeapons(FWeaponSlots *slots)
void P_SetupWeapons_ntohton() void P_SetupWeapons_ntohton()
{ {
unsigned int i; unsigned int i;
PClassWeapon *cls; PClassActor *cls;
Weapons_ntoh.Clear(); Weapons_ntoh.Clear();
Weapons_hton.Clear(); Weapons_hton.Clear();
cls = NULL; cls = nullptr;
Weapons_ntoh.Push(cls); // Index 0 is always NULL. Weapons_ntoh.Push(cls); // Index 0 is always nullptr.
for (i = 0; i < PClassActor::AllActorClasses.Size(); ++i) for (i = 0; i < PClassActor::AllActorClasses.Size(); ++i)
{ {
PClassActor *cls = PClassActor::AllActorClasses[i]; PClassActor *cls = PClassActor::AllActorClasses[i];
if (cls->IsDescendantOf(RUNTIME_CLASS(AWeapon))) if (cls->IsDescendantOf(RUNTIME_CLASS(AWeapon)))
{ {
Weapons_ntoh.Push(static_cast<PClassWeapon *>(cls)); Weapons_ntoh.Push(static_cast<PClassActor *>(cls));
} }
} }
qsort(&Weapons_ntoh[1], Weapons_ntoh.Size() - 1, sizeof(Weapons_ntoh[0]), ntoh_cmp); qsort(&Weapons_ntoh[1], Weapons_ntoh.Size() - 1, sizeof(Weapons_ntoh[0]), ntoh_cmp);
@ -1500,8 +1469,8 @@ void P_SetupWeapons_ntohton()
static int ntoh_cmp(const void *a, const void *b) static int ntoh_cmp(const void *a, const void *b)
{ {
PClassWeapon *c1 = *(PClassWeapon **)a; PClassActor *c1 = *(PClassActor **)a;
PClassWeapon *c2 = *(PClassWeapon **)b; PClassActor *c2 = *(PClassActor **)b;
int g1 = c1->GameFilter == GAME_Any ? 1 : (c1->GameFilter & gameinfo.gametype) ? 0 : 2; int g1 = c1->GameFilter == GAME_Any ? 1 : (c1->GameFilter & gameinfo.gametype) ? 0 : 2;
int g2 = c2->GameFilter == GAME_Any ? 1 : (c2->GameFilter & gameinfo.gametype) ? 0 : 2; int g2 = c2->GameFilter == GAME_Any ? 1 : (c2->GameFilter & gameinfo.gametype) ? 0 : 2;
if (g1 != g2) if (g1 != g2)
@ -1541,24 +1510,24 @@ void P_WriteDemoWeaponsChunk(BYTE **demo)
void P_ReadDemoWeaponsChunk(BYTE **demo) void P_ReadDemoWeaponsChunk(BYTE **demo)
{ {
int count, i; int count, i;
PClassWeapon *type; PClassActor *type;
const char *s; const char *s;
count = ReadWord(demo); count = ReadWord(demo);
Weapons_ntoh.Resize(count); Weapons_ntoh.Resize(count);
Weapons_hton.Clear(count); Weapons_hton.Clear(count);
Weapons_ntoh[0] = type = NULL; Weapons_ntoh[0] = type = nullptr;
Weapons_hton[type] = 0; Weapons_hton[type] = 0;
for (i = 1; i < count; ++i) for (i = 1; i < count; ++i)
{ {
s = ReadStringConst(demo); s = ReadStringConst(demo);
type = dyn_cast<PClassWeapon>(PClass::FindClass(s)); type = dyn_cast<PClassActor>(PClass::FindClass(s));
// If a demo was recorded with a weapon that is no longer present, // If a demo was recorded with a weapon that is no longer present,
// should we report it? // should we report it?
Weapons_ntoh[i] = type; Weapons_ntoh[i] = type;
if (type != NULL) if (type != nullptr)
{ {
Weapons_hton[type] = i; Weapons_hton[type] = i;
} }
@ -1571,12 +1540,12 @@ void P_ReadDemoWeaponsChunk(BYTE **demo)
// //
//=========================================================================== //===========================================================================
void Net_WriteWeapon(PClassWeapon *type) void Net_WriteWeapon(PClassActor *type)
{ {
int index, *index_p; int index, *index_p;
index_p = Weapons_hton.CheckKey(type); index_p = Weapons_hton.CheckKey(type);
if (index_p == NULL) if (index_p == nullptr)
{ {
index = 0; index = 0;
} }
@ -1603,7 +1572,7 @@ void Net_WriteWeapon(PClassWeapon *type)
// //
//=========================================================================== //===========================================================================
PClassWeapon *Net_ReadWeapon(BYTE **stream) PClassActor *Net_ReadWeapon(BYTE **stream)
{ {
int index; int index;
@ -1614,7 +1583,7 @@ PClassWeapon *Net_ReadWeapon(BYTE **stream)
} }
if ((unsigned)index >= Weapons_ntoh.Size()) if ((unsigned)index >= Weapons_ntoh.Size())
{ {
return NULL; return nullptr;
} }
return Weapons_ntoh[index]; return Weapons_ntoh[index];
} }

41
src/g_inventory/a_weapons.h
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "a_pickups.h" #include "a_pickups.h"
class PClassWeapon; class PClassActor;
class AWeapon; class AWeapon;
class FWeaponSlot class FWeaponSlot
@ -12,13 +12,13 @@ public:
FWeaponSlot &operator= (const FWeaponSlot &other) { Weapons = other.Weapons; return *this; } FWeaponSlot &operator= (const FWeaponSlot &other) { Weapons = other.Weapons; return *this; }
void Clear() { Weapons.Clear(); } void Clear() { Weapons.Clear(); }
bool AddWeapon (const char *type); bool AddWeapon (const char *type);
bool AddWeapon (PClassWeapon *type); bool AddWeapon (PClassActor *type);
void AddWeaponList (const char *list, bool clear); void AddWeaponList (const char *list, bool clear);
AWeapon *PickWeapon (player_t *player, bool checkammo = false); AWeapon *PickWeapon (player_t *player, bool checkammo = false);
int Size () const { return (int)Weapons.Size(); } int Size () const { return (int)Weapons.Size(); }
int LocateWeapon (PClassWeapon *type); int LocateWeapon (PClassActor *type);
inline PClassWeapon *GetWeapon (int index) const inline PClassActor *GetWeapon (int index) const
{ {
if ((unsigned)index < Weapons.Size()) if ((unsigned)index < Weapons.Size())
{ {
@ -35,7 +35,7 @@ public:
private: private:
struct WeaponInfo struct WeaponInfo
{ {
PClassWeapon *Type; PClassActor *Type;
int Position; int Position;
}; };
void SetInitialPositions(); void SetInitialPositions();
@ -61,8 +61,8 @@ struct FWeaponSlots
AWeapon *PickPrevWeapon (player_t *player); AWeapon *PickPrevWeapon (player_t *player);
void Clear (); void Clear ();
bool LocateWeapon (PClassWeapon *type, int *const slot, int *const index); bool LocateWeapon (PClassActor *type, int *const slot, int *const index);
ESlotDef AddDefaultWeapon (int slot, PClassWeapon *type); ESlotDef AddDefaultWeapon (int slot, PClassActor *type);
void AddExtraWeapons(); void AddExtraWeapons();
void SetFromGameInfo(); void SetFromGameInfo();
void SetFromPlayer(PClassPlayerPawn *type); void SetFromPlayer(PClassPlayerPawn *type);
@ -72,36 +72,23 @@ struct FWeaponSlots
int RestoreSlots (FConfigFile *config, const char *section); int RestoreSlots (FConfigFile *config, const char *section);
void PrintSettings(); void PrintSettings();
void AddSlot(int slot, PClassWeapon *type, bool feedback); void AddSlot(int slot, PClassActor *type, bool feedback);
void AddSlotDefault(int slot, PClassWeapon *type, bool feedback); void AddSlotDefault(int slot, PClassActor *type, bool feedback);
}; };
void P_PlaybackKeyConfWeapons(FWeaponSlots *slots); void P_PlaybackKeyConfWeapons(FWeaponSlots *slots);
void Net_WriteWeapon(PClassWeapon *type); void Net_WriteWeapon(PClassActor *type);
PClassWeapon *Net_ReadWeapon(BYTE **stream); PClassActor *Net_ReadWeapon(BYTE **stream);
void P_SetupWeapons_ntohton(); void P_SetupWeapons_ntohton();
void P_WriteDemoWeaponsChunk(BYTE **demo); void P_WriteDemoWeaponsChunk(BYTE **demo);
void P_ReadDemoWeaponsChunk(BYTE **demo); void P_ReadDemoWeaponsChunk(BYTE **demo);
// A weapon is just that.
class PClassWeapon : public PClassInventory
{
DECLARE_CLASS(PClassWeapon, PClassInventory);
protected:
virtual void DeriveData(PClass *newclass);
public:
PClassWeapon();
int SlotNumber;
int SlotPriority;
};
class AWeapon : public AStateProvider class AWeapon : public AStateProvider
{ {
DECLARE_CLASS_WITH_META(AWeapon, AStateProvider, PClassWeapon) DECLARE_CLASS(AWeapon, AStateProvider)
HAS_OBJECT_POINTERS HAS_OBJECT_POINTERS
public: public:
DWORD WeaponFlags; DWORD WeaponFlags;
@ -112,7 +99,7 @@ public:
int Kickback; int Kickback;
float YAdjust; // For viewing the weapon fullscreen (visual only so no need to be a double) float YAdjust; // For viewing the weapon fullscreen (visual only so no need to be a double)
FSoundIDNoInit UpSound, ReadySound; // Sounds when coming up and idle FSoundIDNoInit UpSound, ReadySound; // Sounds when coming up and idle
PClassWeapon *SisterWeaponType; // Another weapon to pick up with this one PClassActor *SisterWeaponType; // Another weapon to pick up with this one
PClassActor *ProjectileType; // Projectile used by primary attack PClassActor *ProjectileType; // Projectile used by primary attack
PClassActor *AltProjectileType; // Projectile used by alternate attack PClassActor *AltProjectileType; // Projectile used by alternate attack
int SelectionOrder; // Lower-numbered weapons get picked first int SelectionOrder; // Lower-numbered weapons get picked first
@ -122,6 +109,8 @@ public:
int BobStyle; // [XA] Bobbing style. Defines type of bobbing (e.g. Normal, Alpha) (visual only so no need to be a double) int BobStyle; // [XA] Bobbing style. Defines type of bobbing (e.g. Normal, Alpha) (visual only so no need to be a double)
float BobSpeed; // [XA] Bobbing speed. Defines how quickly a weapon bobs. float BobSpeed; // [XA] Bobbing speed. Defines how quickly a weapon bobs.
float BobRangeX, BobRangeY; // [XA] Bobbing range. Defines how far a weapon bobs in either direction. float BobRangeX, BobRangeY; // [XA] Bobbing range. Defines how far a weapon bobs in either direction.
int SlotNumber;
int SlotPriority;
// In-inventory instance variables // In-inventory instance variables
TObjPtr<AInventory> Ammo1, Ammo2; TObjPtr<AInventory> Ammo1, Ammo2;

6
src/scripting/thingdef_properties.cpp
View file

@ -2065,8 +2065,7 @@ DEFINE_CLASS_PROPERTY(bobrangey, F, Weapon)
DEFINE_CLASS_PROPERTY(slotnumber, I, Weapon) DEFINE_CLASS_PROPERTY(slotnumber, I, Weapon)
{ {
PROP_INT_PARM(i, 0); PROP_INT_PARM(i, 0);
assert(info->IsKindOf(RUNTIME_CLASS(PClassWeapon))); defaults->SlotNumber = i;
static_cast<PClassWeapon *>(info)->SlotNumber = i;
} }
//========================================================================== //==========================================================================
@ -2075,8 +2074,7 @@ DEFINE_CLASS_PROPERTY(slotnumber, I, Weapon)
DEFINE_CLASS_PROPERTY(slotpriority, F, Weapon) DEFINE_CLASS_PROPERTY(slotpriority, F, Weapon)
{ {
PROP_DOUBLE_PARM(i, 0); PROP_DOUBLE_PARM(i, 0);
assert(info->IsKindOf(RUNTIME_CLASS(PClassWeapon))); defaults->SlotPriority = int(i*65536);
static_cast<PClassWeapon *>(info)->SlotPriority = int(i*65536);
} }
//========================================================================== //==========================================================================

2
wadsrc/static/zscript/inventory/weapons.txt
View file

@ -43,6 +43,8 @@ class Weapon : StateProvider native
Weapon.BobSpeed 1.0; Weapon.BobSpeed 1.0;
Weapon.BobRangeX 1.0; Weapon.BobRangeX 1.0;
Weapon.BobRangeY 1.0; Weapon.BobRangeY 1.0;
Weapon.SlotNumber -1;
Weapon.SlotPriority 32767;
+WEAPONSPAWN +WEAPONSPAWN
DefaultStateUsage SUF_ACTOR|SUF_OVERLAY|SUF_WEAPON; DefaultStateUsage SUF_ACTOR|SUF_OVERLAY|SUF_WEAPON;
} }