players.xml: "innateitems" and "innatetrinkets" attributes

Author: ConnorForan

changelog.txt

@@ -155,6 +155,7 @@ Added:
 * Added HistoryHUD and HistoryHUDItem classes
 * Backported new enums for GameStateFlag
 * Added "isActiveEnemy" attribute for EntityNPCs in entities2.xml (set to "true" or "false")
+* Added "innateitems" and "innatetrinkets" attributes for players.xml (comma-separated list of IDs or names)
 * Added SplitTearType.SWORD_BEAM
 * The "Error" and "Modeling Clay" trinkets now use the sprite of the item they are mimicking when smelted, like how they do in later versions of Repentance+.
 * Removed unused class constructors in Renderer.

libzhl/functions/EntityPlayer.zhl

@@ -74,7 +74,10 @@ static cleanup PosVel Entity_Player::GetMultiShotPositionVelocity(int loopIndex,
 Weapon_MultiShotParams* Entity_Player::GetMultiShotParams(Weapon_MultiShotParams* params, int weaponType);
 
 "558bec83e4f883ec0c53568bf18b0d":
-__thiscall Entity_Player* Entity_Player::InitTwin(int playerType); //replace with ePlayerType later
+__thiscall Entity_Player* Entity_Player::InitTwin(int playerType);
+
+"558bec6aff68????????64a1????????5083ec54a1????????33c58945??535657508d45??64a3????????8bd9895d??8b45??85c0":
+__thiscall void Entity_Player::ChangePlayerType(int playerType, bool unk);
 
 "558bec83e4f881ec540100008bd1":
 __thiscall Entity* Entity_Player::ThrowHeldEntity(Vector* Velocity);

repentogon/LuaInterfaces/CustomCallbacks.cpp

@@ -57,13 +57,19 @@ void CustomCallbacks::TriggerCollectibleAdded(Entity_Player& player, int collect
             .call(1);
     }
 }
+static bool s_RestoringFamiliarStates = false;
 HOOK_METHOD(Entity_Familiar, WispInit, () -> void) {
     super();
 
-    if (this->_variant == 237 && this->_subtype > 0 && this->_player) {
+    if (!s_RestoringFamiliarStates && this->_variant == 237 && this->_player && ItemConfig::IsValidCollectible(this->_subtype)) {
         CustomCallbacks::TriggerCollectibleAdded(*this->_player, this->_subtype, false, true);
     }
 }
+HOOK_METHOD(Entity_Player, RestoreGameState_PostLevelInit, (GameStatePlayer* saveState) -> void) {
+    s_RestoringFamiliarStates = true;
+    super(saveState);
+    s_RestoringFamiliarStates = false;
+}
 
 //PRE/POST_ADD_COLLECTIBLE (1004/1005)
 void ProcessPostAddCollectible(int type, int charge, bool firsttime, int slot, int vardata, Entity_Player* player) {

repentogon/Patches/ItemSpoofSystem.cpp

@@ -4,6 +4,9 @@
 #include "HookSystem.h"
 #include "EntityPlus.h"
 
+
+// Context handling
+
 struct ItemSpoofCallContext
 {
     bool isLuaRequest = false;
@@ -24,16 +27,18 @@ ItemSpoofCallContext GetContextAndReset()
     return context;
 }
 
-static std::bitset<CollectibleType::NUM_COLLECTIBLES> s_reworkedCollectibles;
-static std::bitset<ePlayerType::NUM_PLAYER_TYPES> s_reworkedBirthrights;
-static std::bitset<TrinketType::NUM_TRINKETS> s_reworkedTrinkets;
-
-void ItemSpoofSystem::StartLuaRequest(bool ignoreSpoof)
-{
+void ItemSpoofSystem::StartLuaRequest(bool ignoreSpoof) {
     s_ItemSpoofCallContext.isLuaRequest = true;
     s_ItemSpoofCallContext.ignoreSpoof = ignoreSpoof;
 }
 
+
+// "Reworked" Items
+
+static std::bitset<CollectibleType::NUM_COLLECTIBLES> s_reworkedCollectibles;
+static std::bitset<ePlayerType::NUM_PLAYER_TYPES> s_reworkedBirthrights;
+static std::bitset<TrinketType::NUM_TRINKETS> s_reworkedTrinkets;
+
 void ItemSpoofSystem::ReworkCollectible(int collectible)
 {
     assert(CollectibleType::COLLECTIBLE_NULL < collectible && collectible < CollectibleType::NUM_COLLECTIBLES);
@@ -82,6 +87,84 @@ static bool is_reworked_trinket(int trinket)
     return s_reworkedTrinkets.test(trinket);
 }
 
+
+// XML Innate Items
+
+static std::unordered_map<int, std::unordered_map<int, int>> s_playerTypeInnateCollectibles;
+static std::unordered_map<int, std::unordered_map<int, int>> s_playerTypeInnateTrinkets;
+
+const std::unordered_map<int, int>* GetPlayerTypeInnateCollectibles(int playerType) {
+    if (auto it = s_playerTypeInnateCollectibles.find(playerType); it != s_playerTypeInnateCollectibles.end())
+        return &it->second;
+    return nullptr;
+}
+
+int GetPlayerTypeInnateCollectibleCount(Entity_Player* player, int collectible) {
+    if (const auto* ptypeCollectibles = GetPlayerTypeInnateCollectibles(player->_playerType)) {
+        if (auto it = ptypeCollectibles->find(collectible); it != ptypeCollectibles->end()) {
+            return it->second;
+        }
+    }
+    return 0;
+}
+
+const std::unordered_map<int, int>* GetPlayerTypeInnateTrinkets(int playerType) {
+    if (auto it = s_playerTypeInnateTrinkets.find(playerType); it != s_playerTypeInnateTrinkets.end())
+        return &it->second;
+    return nullptr;
+}
+
+int GetPlayerTypeInnateTrinketCount(Entity_Player* player, int collectible) {
+    if (const auto* ptypeTrinkets = GetPlayerTypeInnateTrinkets(player->_playerType)) {
+        if (auto it = ptypeTrinkets->find(collectible); it != ptypeTrinkets->end()) {
+            return it->second;
+        }
+    }
+    return 0;
+}
+
+std::vector<int> ParseCommaSeparatedIdList(const std::string& str) {
+    std::vector<int> ids;
+
+    std::stringstream ss(str);
+    std::string item;
+
+    while (std::getline(ss, item, ',')) {
+        int id = std::atoi(item.c_str());
+        if (id > 0) {
+            ids.push_back(id);
+        }
+    }
+
+    return ids;
+}
+
+HOOK_METHOD_PRIORITY(ModManager, LoadConfigs, -9999, () -> void) {
+    RegisterCustomXMLAttr(XMLStuff.PlayerData, "innateitems", XMLStuff.ItemData);
+    RegisterCustomXMLAttr(XMLStuff.PlayerData, "innatetrinkets", XMLStuff.TrinketData);
+
+    super();
+
+    s_playerTypeInnateCollectibles.clear();
+    s_playerTypeInnateTrinkets.clear();
+
+    for (const auto& [playerType, playerData] : XMLStuff.PlayerData->nodes) {
+        if (auto it = playerData.find("innateitems"); it != playerData.end()) {
+            for (const int id : ParseCommaSeparatedIdList(it->second)) {
+                s_playerTypeInnateCollectibles[playerType][id]++;
+            }
+        }
+        if (auto it = playerData.find("innatetrinkets"); it != playerData.end()) {
+            for (const int id : ParseCommaSeparatedIdList(it->second)) {
+                s_playerTypeInnateTrinkets[playerType][id]++;
+            }
+        }
+    }
+}
+
+
+// Core ItemSpoofSystem hooks
+
 HOOK_METHOD_PRIORITY(Entity_Player, HasCollectible, -9999, (int collectible, bool ignoreModifiers) -> bool)
 {
     const auto context = GetContextAndReset();
@@ -105,6 +188,10 @@ HOOK_METHOD_PRIORITY(Entity_Player, HasCollectible, -9999, (int collectible, boo
                 return true;
             }
         }
+
+        if (GetPlayerTypeInnateCollectibleCount(this, collectible) > 0) {
+            return true;
+        }
     }
 
     return super(collectible, ignoreModifiers);
@@ -132,6 +219,8 @@ HOOK_METHOD_PRIORITY(Entity_Player, GetCollectibleNum, -9999, (int collectible,
             }
             innateCount += spoofs.GetInnateCount(collectible);
         }
+
+        innateCount += GetPlayerTypeInnateCollectibleCount(this, collectible);
     }
 
     return innateCount + super(collectible, ignoreModifiers);
@@ -160,6 +249,10 @@ HOOK_METHOD_PRIORITY(Entity_Player, HasTrinket, -9999, (unsigned int trinket, bo
                 return true;
             }
         }
+
+        if (GetPlayerTypeInnateTrinketCount(this, trinket) > 0) {
+            return true;
+        }
     }
 
     return super(trinket, ignoreModifiers);
@@ -187,6 +280,8 @@ HOOK_METHOD_PRIORITY(Entity_Player, GetTrinketMultiplier, -9999, (unsigned int t
             }
             innateMult += spoofs.GetInnateCount(trinket & TRINKET_ID_MASK) + spoofs.GetInnateCount(trinket | TRINKET_GOLDEN_FLAG) * 2;
         }
+
+        innateMult += GetPlayerTypeInnateTrinketCount(this, trinket);
     }
 
     int vanillaMult = super(trinket);
@@ -228,12 +323,42 @@ HOOK_METHOD_PRIORITY(Entity_Player, UpdateEffects, -9999, () -> void)
 {
     if (EntityPlayerPlus* playerPlus = GetEntityPlayerPlus(this))
     {
+        playerPlus->itemSpoofs.CheckPlayerType(*this, false);
         playerPlus->itemSpoofs.GetCollectibleSpoof().UpdateTemporaryTimers(*this);
         playerPlus->itemSpoofs.GetTrinketSpoof().UpdateTemporaryTimers(*this);
     }
     super();
 }
 
+// Detect PlayerType changes where they can happen.
+HOOK_METHOD_PRIORITY(Entity_Player, ChangePlayerType, 9999, (int playerType, bool unk) -> void) {
+    super(playerType, unk);
+    if (EntityPlayerPlus* playerPlus = GetEntityPlayerPlus(this)) {
+        playerPlus->itemSpoofs.CheckPlayerType(*this, false);
+    }
+}
+HOOK_METHOD_PRIORITY(Entity_Player, InitPostLevelInitStats, 9999, () -> void) {
+    if (EntityPlayerPlus* playerPlus = GetEntityPlayerPlus(this)) {
+        playerPlus->itemSpoofs.CheckPlayerType(*this, false);
+    }
+    super();
+}
+HOOK_METHOD_PRIORITY(Entity_Player, TriggerDeath, 9999, (bool checkOnly) -> bool) {
+    bool res = super(checkOnly);
+    if (!checkOnly) {
+        if (EntityPlayerPlus* playerPlus = GetEntityPlayerPlus(this)) {
+            playerPlus->itemSpoofs.CheckPlayerType(*this, false);
+        }
+    }
+    return res;
+}
+HOOK_METHOD_PRIORITY(Entity_Player, RestoreGameState, -9999, (GameStatePlayer* saveState) -> void) {
+    super(saveState);
+    if (EntityPlayerPlus* playerPlus = GetEntityPlayerPlus(this)) {
+        playerPlus->itemSpoofs.CheckPlayerType(*this, true);
+    }
+}
+
 
 // Serialization & Data Structure Details
 
@@ -592,4 +717,36 @@ namespace ItemSpoofSystem
         }
     }
 
+    void PlayerItemSpoofs::CheckPlayerType(Entity_Player& player, bool restoringGameState) {
+        const int prevPlayerType = lastPlayerType_;
+        const int currentPlayerType = player._playerType;
+        if (prevPlayerType != currentPlayerType) {
+            lastPlayerType_ = currentPlayerType;
+            if (restoringGameState) {
+                return;
+            }
+            if (const auto* oldCols = GetPlayerTypeInnateCollectibles(prevPlayerType)) {
+                for (const auto& [id, count] : *oldCols) {
+                    collectibleSpoof_.TriggerRemoved(player, id, count, false);
+                }
+            }
+            if (const auto* newCols = GetPlayerTypeInnateCollectibles(currentPlayerType)) {
+                for (const auto& [id, count] : *newCols) {
+                    collectibleSpoof_.TriggerAdded(player, id, count, false, false);
+                }
+            }
+            if (const auto* oldTrinkets = GetPlayerTypeInnateTrinkets(prevPlayerType)) {
+                for (const auto& [id, count] : *oldTrinkets) {
+                    trinketSpoof_.TriggerRemoved(player, id, count, false);
+                }
+            }
+            if (const auto* newTrinkets = GetPlayerTypeInnateTrinkets(currentPlayerType)) {
+                for (const auto& [id, count] : *newTrinkets) {
+                    trinketSpoof_.TriggerAdded(player, id, count, false, false);
+                }
+            }
+            player.EvaluateItems();
+        }
+    }
+
 }  // namespace ItemSpoofSystem

repentogon/Patches/ItemSpoofSystem.h

@@ -419,10 +419,16 @@ namespace ItemSpoofSystem
         TrinketSpoof& GetTrinketSpoof() {
             return trinketSpoof_;
         }
+        
+        // Check for a PlayerType change, and if a change is detected, "trigger" the add/remove of PlayerType-based innate items.
+        // Note that this is not required for the PlayerType-based innates to function correctly - this only handles stuff like TriggerCollectibleRemoved.
+        // If `restoringGameState`, update the lastPlayerType_ without triggering anything.
+        void CheckPlayerType(Entity_Player& player, bool restoringGameState);
 
     private:
         CollectibleSpoof collectibleSpoof_;
         TrinketSpoof trinketSpoof_;
+        int lastPlayerType_ = -1;
     };
 
 }  // namespace ItemSpoofSystem

repentogon/Patches/XMLData.cpp

@@ -1163,7 +1163,7 @@ void ProcessXmlNode(xml_node<char>* node,bool force = false) {
 			XMLStuff.PlayerData->byorder[XMLStuff.PlayerData->nodes.size()] = id;
 			XMLStuff.PlayerData->bymod[lastmodid].push_back(id);
 			XMLStuff.ModData->players[lastmodid] += 1;
-			}
+		}
 	break;
 	case 3: //pocketitems
 		id = 1;