A little more safety

Author: Alphalaneous

mod.json

@@ -1,12 +1,12 @@
 {
-    "geode": "4.9.0",
+    "geode": "4.10.0",
     "gd": {
         "win": "2.2074",
         "android": "2.2074",
         "mac": "2.2074",
         "ios": "2.2074"
     },
-    "version": "v2.0.20",
+    "version": "v2.0.21",
     "id": "alphalaneous.happy_textures",
     "name": "Happy Textures :3",
     "developer": "Alphalaneous",

src/NodeModding.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Geode/Geode.hpp>
+#include <Geode/binding/GJGameLevel.hpp>
 #include <Geode/modify/CCObject.hpp>
 #include <Geode/modify/CCPoolManager.hpp>
 #include <Geode/modify/CCDictionary.hpp>
@@ -9,6 +10,7 @@
 #include <alphalaneous.alphas_geode_utils/include/Fields.h>
 #include "Macros.hpp"
 #include "LateQueue.hpp"
+#include "Utils.hpp"
 
 using namespace geode::prelude;
 
@@ -28,55 +30,22 @@ class $modify(CCDictionary) {
     }
 };
 
-static std::unordered_map<CCObject*, uintptr_t> s_nodeVTables;
-
-static bool checkNodeValidity(CCObject* node) {
-    auto ret = *(uintptr_t*)node == s_nodeVTables[node];
-    s_nodeVTables.erase(node);
-    return ret;
-}
-
-static void setNodeVTable(CCNode* node) {
-    s_nodeVTables[node] = *(uintptr_t*)node;
-}
-
-static std::unordered_map<const std::type_info*, bool> s_isNodeCache;
-
-static bool isNode(CCObject* obj) {
-    const std::type_info* ti = &typeid(*obj);
-
-    auto it = s_isNodeCache.find(ti);
-    if (it != s_isNodeCache.end()) {
-        return it->second;
-    }
-
-    bool isNode = typeinfo_cast<CCNode*>(obj) != nullptr;
-    s_isNodeCache.emplace(ti, isNode);
-
-    return isNode;
-}
 
 class $modify(HTCCObject, CCObject) {
 
-    static std::string_view extract(std::string_view s) {
-        if (auto pos = s.rfind("::"); pos != std::string_view::npos)
-            return s.substr(pos + 2);
-        return s;
-    }
-
     CCObject* autorelease() {
         auto modding = UIModding::get();
         if (!modding->doModify) return CCObject::autorelease();
 
-        if (isNode(this)) {
+        if (modding->isNode(this)) {
             MyCCNode* node = reinterpret_cast<MyCCNode*>(this);
 
             auto fields = node->m_fields.self();
             if (!fields->m_modified) {
-                setNodeVTable(node);
+                modding->setNodeVTable(node);
                 LateQueue::get()->queue(node, [modding, node = Ref(node), fields] {
-                    if (!checkNodeValidity(node)) return;
-                    modding->doUICheckForType(extract(cocos::getObjectName(node)), node);
+                    if (!modding->checkNodeValidity(node)) return;
+                    modding->doUICheckForType(Utils::extract(cocos::getObjectName(node)), node);
                     fields->m_modified = true;
                 });
             }

src/UIModding.cpp

@@ -1416,6 +1416,8 @@ void UIModding::handleModifications(CCNode* node, matjson::Value nodeObject, boo
 void UIModding::reloadChildren(CCNode* parentNode, bool transition) {
     if (!parentNode) return;
     MyCCNode* myParentNode = static_cast<MyCCNode*>(parentNode);
+    if (!checkNodeValidity(myParentNode)) return;
+    
     for (const matjson::Value& value : myParentNode->getAttributes()) {
         handleModifications(myParentNode, value, transition);
     }
@@ -1607,3 +1609,34 @@ void UIModding::doUICheckForType(std::string_view type, CCNode* node) {
     removalQueue.clear();
 }
 
+bool UIModding::checkNodeValidity(CCObject* node) {
+    auto ret = *(uintptr_t*)node == m_nodeVTables[node];
+    m_nodeVTables.erase(node);
+    return ret;
+}
+
+void UIModding::setNodeVTable(CCNode* node) {
+    m_nodeVTables[node] = *(uintptr_t*)node;
+}
+
+bool UIModding::isNode(CCObject* obj) {
+    const std::type_info* ti = &typeid(*obj);
+
+    auto it = m_isNodeCache.find(ti);
+    if (it != m_isNodeCache.end()) {
+        return it->second;
+    }
+
+    bool isNode = typeinfo_cast<CCNode*>(obj) && !typeinfo_cast<GJGameLevel*>(obj);
+    m_isNodeCache.emplace(ti, isNode);
+
+    return isNode;
+}
+
+UIModding* UIModding::get() {
+
+    if (!instance) {
+        instance = new UIModding();
+    };
+    return instance;
+}

src/UIModding.hpp

@@ -31,6 +31,9 @@ class UIModding {
     std::unordered_map<CCTexture2D*, std::string> textureToNameMap;
     bool firstMenuLayer = true;
 
+    std::unordered_map<CCObject*, uintptr_t> m_nodeVTables;
+    std::unordered_map<const std::type_info*, bool> m_isNodeCache;
+
     std::vector<FileWatcher*> listeners;
     std::vector<Ref<CCNode>> removalQueue;
 
@@ -103,11 +106,9 @@ class UIModding {
     void evaluateIf(CCNode* node, const matjson::Value& ifArray);
     std::vector<std::string> generateValidSprites(const std::string& path, const matjson::Value& spriteList);
 
-    static UIModding* get() {
+    bool checkNodeValidity(CCObject* node);
+    void setNodeVTable(CCNode* node);
+    bool isNode(CCObject* obj);
 
-        if (!instance) {
-            instance = new UIModding();
-        };
-        return instance;
-    }
+    static UIModding* get();
 };

src/Utils.hpp

@@ -263,6 +263,12 @@ namespace Utils {
         return AlphaUtils::Cocos::hasNode(child, node);
     }
 
+    static std::string_view extract(std::string_view s) {
+        if (auto pos = s.rfind("::"); pos != std::string_view::npos)
+            return s.substr(pos + 2);
+        return s;
+    }
+
     static std::string_view trim(std::string_view s) {
         const auto is_space = [](unsigned char c) {
             return c == ' ' || c == '\t' || c == '\n' ||