diff --git a/Engine_Master_UPC/AnimationComponent.cpp b/Engine_Master_UPC/AnimationComponent.cpp
index b2443907..68f23e65 100644
--- a/Engine_Master_UPC/AnimationComponent.cpp
+++ b/Engine_Master_UPC/AnimationComponent.cpp
@@ -13,9 +13,10 @@
 #include "GameObject.h"
 #include "Transform.h"
 #include "StateMachineScript.h"
-#include "ScriptFactory.h"
+#include "GenericTypeFactory.h"
 #include "Script.h"
-#include "ScriptComponentRef.h"
+#include "ComponentRef.h"
+#include "FieldUtils.h"
 #include "ModuleScene.h"
 #include "Scene.h"
 
@@ -873,163 +874,8 @@ void AnimationComponent::drawStateBehaviourFieldsUi(AnimationStateMachineState&
 
 void AnimationComponent::drawScriptFieldsUi(Script& script)
 {
-    ScriptFieldList fieldList = script.getExposedFields();
-    char* base = reinterpret_cast<char*>(&script);
-
-    for (const ScriptFieldInfo& field : fieldList.fields)
-    {
-        void* data = base + field.offset;
-        bool changed = false;
-
-        switch (field.type)
-        {
-        case ScriptFieldType::Float:
-        {
-            float* value = reinterpret_cast<float*>(data);
-            changed = ImGui::DragFloat(field.name, value, field.floatInfo.dragSpeed, field.floatInfo.min, field.floatInfo.max);
-            break;
-        }
-
-        case ScriptFieldType::Int:
-        {
-            int* value = reinterpret_cast<int*>(data);
-            changed = ImGui::DragInt(field.name, value);
-            break;
-        }
-
-        case ScriptFieldType::Bool:
-        {
-            bool* value = reinterpret_cast<bool*>(data);
-            changed = ImGui::Checkbox(field.name, value);
-            break;
-        }
-
-        case ScriptFieldType::Vec3:
-        {
-            Vector3* value = reinterpret_cast<Vector3*>(data);
-            changed = ImGui::DragFloat3(field.name, &value->x, 0.1f);
-            break;
-        }
-
-        case ScriptFieldType::EnumInt:
-        {
-            int* value = reinterpret_cast<int*>(data);
-
-            const char* preview = "";
-            if (*value >= 0 && *value < field.enumInfo.count)
-            {
-                preview = field.enumInfo.names[*value];
-            }
-
-            if (ImGui::BeginCombo(field.name, preview))
-            {
-                for (int enumIndex = 0; enumIndex < field.enumInfo.count; ++enumIndex)
-                {
-                    bool selected = (*value == enumIndex);
-                    if (ImGui::Selectable(field.enumInfo.names[enumIndex], selected))
-                    {
-                        *value = enumIndex;
-                        changed = true;
-                    }
-
-                    if (selected)
-                    {
-                        ImGui::SetItemDefaultFocus();
-                    }
-                }
-
-                ImGui::EndCombo();
-            }
-            break;
-        }
-
-        case ScriptFieldType::String:
-        {
-            std::string* value = reinterpret_cast<std::string*>(data);
-
-            char buffer[256];
-            std::strncpy(buffer, value->c_str(), sizeof(buffer));
-            buffer[sizeof(buffer) - 1] = '\0';
-
-            if (ImGui::InputText(field.name, buffer, sizeof(buffer)))
-            {
-                *value = buffer;
-                changed = true;
-            }
-            break;
-        }
-
-        case ScriptFieldType::ComponentRef:
-        {
-            ScriptComponentRef<Component>* componentReference = reinterpret_cast<ScriptComponentRef<Component>*>(data);
-
-            Component* component = componentReference->component;
-
-            ImGui::Text("%s", field.name);
-            ImGui::SameLine();
-
-            if (component != nullptr)
-            {
-                ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "%s", component->getOwner()->GetName().c_str());
-            }
-            else
-            {
-                ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "None");
-            }
-
-            if (ImGui::BeginDragDropTarget())
-            {
-                if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("GAME_OBJECT"))
-                {
-                    GameObject* droppedObject = *(GameObject**)payload->Data;
-                    GameObject* sceneObject = app->getModuleScene()->getScene()->findGameObjectByUID(droppedObject->GetID());
-
-                    if (sceneObject != nullptr)
-                    {
-                        Component* candidate = nullptr;
-
-                        if (field.componentRefInfo.componentType == ComponentType::TRANSFORM)
-                        {
-                            candidate = sceneObject->GetTransform();
-                        }
-                        else
-                        {
-                            candidate = sceneObject->GetComponent(field.componentRefInfo.componentType);
-                        }
-
-                        if (candidate != nullptr)
-                        {
-                            componentReference->uid = candidate->getID();
-                            componentReference->component = candidate;
-                            script.onFieldEdited(field);
-                            changed = true;
-                        }
-                    }
-                }
-
-                ImGui::EndDragDropTarget();
-            }
-
-            ImGui::SameLine();
-
-            std::string clearLabel = std::string("Clear###") + field.name;
-            if (ImGui::Button(clearLabel.c_str()))
-            {
-                componentReference->uid = 0;
-                componentReference->component = nullptr;
-                script.onFieldEdited(field);
-                changed = true;
-            }
-            break;
-        }
-        }
-
-        if (changed)
-        {
-            script.onFieldEdited(field);
-            m_stateMachineDirty = true;
-        }
-    }
+    FieldUtils::drawUi(script, reinterpret_cast<char*>(&script));
+    m_stateMachineDirty = true;
 }
 void AnimationComponent::debugDrawRecursive(GameObject* go)
 {
@@ -1689,7 +1535,7 @@ StateMachineScript* AnimationComponent::createStateBehaviourIfNeeded(const Anima
         return existing;
     }
 
-    std::unique_ptr<Script> newScript = ScriptFactory::createScript(state.behaviourScriptName, getOwner());
+    std::unique_ptr<Script> newScript = ScriptFactory::create(state.behaviourScriptName, getOwner());
     if (!newScript)
     {
         return nullptr;
@@ -1807,64 +1653,16 @@ void AnimationComponent::invalidateAllStateBehaviours()
 
 std::string AnimationComponent::serializeScriptFields(const Script& script) const
 {
-    rapidjson::Document document;
-    document.SetObject();
-    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
-
-    ScriptFieldList fieldList = script.getExposedFields();
-    const char* base = reinterpret_cast<const char*>(&script);
-
-    for (const ScriptFieldInfo& field : fieldList.fields)
-    {
-        const void* data = base + field.offset;
+    JsonArchive archive(ArchiveMode::Output);
+    FieldUtils::serialize(script, reinterpret_cast<const char*>(&script), archive);
 
-        rapidjson::Value key(field.name, allocator);
-
-        switch (field.type)
-        {
-        case ScriptFieldType::Float:
-            document.AddMember(key, *reinterpret_cast<const float*>(data), allocator);
-            break;
-
-        case ScriptFieldType::Int:
-        case ScriptFieldType::EnumInt:
-            document.AddMember(key, *reinterpret_cast<const int*>(data), allocator);
-            break;
-
-        case ScriptFieldType::Bool:
-            document.AddMember(key, *reinterpret_cast<const bool*>(data), allocator);
-            break;
-
-        case ScriptFieldType::Vec3:
-        {
-            const Vector3* value = reinterpret_cast<const Vector3*>(data);
-            rapidjson::Value array(rapidjson::kArrayType);
-            array.PushBack(value->x, allocator);
-            array.PushBack(value->y, allocator);
-            array.PushBack(value->z, allocator);
-            document.AddMember(key, array, allocator);
-            break;
-        }
-
-        case ScriptFieldType::String:
-        {
-            const std::string* value = reinterpret_cast<const std::string*>(data);
-            document.AddMember(key, rapidjson::Value(value->c_str(), allocator), allocator);
-            break;
-        }
-
-        case ScriptFieldType::ComponentRef:
-        {
-            const ScriptComponentRef<Component>* componentReference = reinterpret_cast<const ScriptComponentRef<Component>*>(data);
-            document.AddMember(key, static_cast<uint64_t>(componentReference->uid), allocator);
-            break;
-        }
-        }
-    }
+    rapidjson::Document doc;
+    rapidjson::Value value = archive.extractValue(doc.GetAllocator());
+    doc.Swap(value);
 
     rapidjson::StringBuffer buffer;
     rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    document.Accept(writer);
+    doc.Accept(writer);
 
     return buffer.GetString();
 }
@@ -1884,71 +1682,9 @@ void AnimationComponent::deserializeScriptFields(Script& script, const std::stri
         return;
     }
 
-    ScriptFieldList fieldList = script.getExposedFields();
-    char* base = reinterpret_cast<char*>(&script);
-
-    for (const ScriptFieldInfo& field : fieldList.fields)
-    {
-        if (!document.HasMember(field.name))
-        {
-            continue;
-        }
-
-        void* data = base + field.offset;
-        const rapidjson::Value& valueJson = document[field.name];
-
-        switch (field.type)
-        {
-        case ScriptFieldType::Float:
-            if (valueJson.IsNumber())
-            {
-                *reinterpret_cast<float*>(data) = valueJson.GetFloat();
-            }
-            break;
-
-        case ScriptFieldType::Int:
-        case ScriptFieldType::EnumInt:
-            if (valueJson.IsInt())
-            {
-                *reinterpret_cast<int*>(data) = valueJson.GetInt();
-            }
-            break;
-
-        case ScriptFieldType::Bool:
-            if (valueJson.IsBool())
-            {
-                *reinterpret_cast<bool*>(data) = valueJson.GetBool();
-            }
-            break;
-
-        case ScriptFieldType::Vec3:
-            if (valueJson.IsArray() && valueJson.Size() == 3)
-            {
-                Vector3* vector = reinterpret_cast<Vector3*>(data);
-                vector->x = valueJson[0].GetFloat();
-                vector->y = valueJson[1].GetFloat();
-                vector->z = valueJson[2].GetFloat();
-            }
-            break;
-
-        case ScriptFieldType::String:
-            if (valueJson.IsString())
-            {
-                *reinterpret_cast<std::string*>(data) = valueJson.GetString();
-            }
-            break;
-
-        case ScriptFieldType::ComponentRef:
-            if (valueJson.IsUint64())
-            {
-                ScriptComponentRef<Component>* componentReference = reinterpret_cast<ScriptComponentRef<Component>*>(data);
-                componentReference->uid = static_cast<UID>(valueJson.GetUint64());
-                componentReference->component = nullptr;
-            }
-            break;
-        }
-    }
-
+    JsonArchive archive(ArchiveMode::Input);
+    archive.setValue(document);
+    FieldUtils::deserialize(script, reinterpret_cast<char*>(&script), archive);
     script.onAfterDeserialize();
 }
 
diff --git a/Engine_Master_UPC/Application.cpp b/Engine_Master_UPC/Application.cpp
index 08420bd7..78a384e9 100644
--- a/Engine_Master_UPC/Application.cpp
+++ b/Engine_Master_UPC/Application.cpp
@@ -24,7 +24,7 @@
 #include "ModuleMusic.h"
 #include "ModuleScripting.h"
 
-#include "ScriptFactory.h"
+#include "GenericTypeFactory.h"
 
 #include "Settings.h"
 #include "ThreadPool.h"
@@ -46,12 +46,13 @@ Application::Application(int argc, wchar_t** argv, void* hWnd)
     modules.push_back(m_moduleResources = new ModuleResources(m_moduleD3d12M->getDevice(), m_moduleD3d12M->getCommandQueue()));
 
     //Needed to create the LOGs
-    modules.push_back(m_moduleEditor = new ModuleEditor());
     modules.push_back(m_moduleHaptics = new ModuleHaptics());
 
     modules.push_back(m_moduleScripting = new ModuleScripting());
 
     modules.push_back(m_moduleAssets = new ModuleAssets());
+
+    modules.push_back(m_moduleEditor = new ModuleEditor());
     modules.push_back(m_eventSystemModule = new ModuleEventSystem());
 
     modules.push_back(m_moduleUI = new ModuleUI());
diff --git a/Engine_Master_UPC/Asset.h b/Engine_Master_UPC/Asset.h
index e6d93c99..8df54dba 100644
--- a/Engine_Master_UPC/Asset.h
+++ b/Engine_Master_UPC/Asset.h
@@ -5,10 +5,11 @@
 #include "MD5Fwd.h"
 #include "ImportSettings.h"
 #include <memory>
+#include "EngineAPI.h"
 
 class IArchive;
 
-class Asset : public ISerializable
+class ENGINE_API Asset : public ISerializable
 {
 public:
     Asset() = default;
@@ -35,3 +36,5 @@ class Asset : public ISerializable
     AssetType m_type = AssetType::UNKNOWN;
     std::unique_ptr<ImportSettings> m_importSettings;
 };
+
+#pragma warning(pop)
diff --git a/Engine_Master_UPC/AssetCache.h b/Engine_Master_UPC/AssetCache.h
index dfd6693c..ff943b38 100644
--- a/Engine_Master_UPC/AssetCache.h
+++ b/Engine_Master_UPC/AssetCache.h
@@ -30,9 +30,9 @@ class AssetCache
     void clear();
 
     std::shared_ptr<Asset> get(const UID& uid);
+    void insert(const UID& uid, std::shared_ptr<Asset> asset);
 
 private:
-    void insert(const UID& uid, std::shared_ptr<Asset> asset);
 
     WeakCache<UID, Asset> m_cache;
 };
diff --git a/Engine_Master_UPC/AssetCache.inl b/Engine_Master_UPC/AssetCache.inl
index b1b31728..c6374e46 100644
--- a/Engine_Master_UPC/AssetCache.inl
+++ b/Engine_Master_UPC/AssetCache.inl
@@ -9,7 +9,13 @@
 #include "FileIO.h"
 #include "AssetsDictionary.h"
 #include "JsonArchive.h"
+#include "DataContainer.h"
+#include "GenericTypeFactory.h"
+
+#include <rapidjson/document.h>
+#include <rapidjson/filereadstream.h>
 #include <cstdint>
+#include <cstdio>
 #include <vector>
 
 template<typename T>
@@ -40,6 +46,42 @@ std::shared_ptr<T> AssetCache::loadFromLibrary(AssetReference& ref, ImporterRegi
     std::shared_ptr<Asset> asset(importer->createAssetInstance(ref));
     importer->load(buffer.data(), asset.get());
 
+    if (ref.m_type == AssetType::DATA_CONTAINER)
+    {
+        DataContainer* dc = dynamic_cast<DataContainer*>(asset.get());
+        if (dc && dc->getExposedFields().fields.empty())
+        {
+            const AssetIndexEntry* entry = index.findEntry(ref.m_uid);
+            if (entry && !entry->sourcePath.empty())
+            {
+                std::string pathStr = entry->sourcePath.string();
+                FILE* fp = std::fopen(pathStr.c_str(), "rb");
+                if (fp)
+                {
+                    char buf[65536];
+                    rapidjson::FileReadStream is(fp, buf, sizeof(buf));
+                    rapidjson::Document doc;
+                    doc.ParseStream(is);
+                    std::fclose(fp);
+
+                    if (!doc.HasParseError() && doc.HasMember("_typeName") &&
+                        doc["_typeName"].IsString())
+                    {
+                        const char* typeName = doc["_typeName"].GetString();
+                        auto derived = DataContainerFactory::create(typeName, ref);
+                        if (derived)
+                        {
+                            JsonArchive archive(ArchiveMode::Input);
+                            archive.setValue(doc);
+                            derived->serialize(archive);
+                            asset.reset(derived.release());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
 #ifndef GAME_RELEASE
     const AssetIndexEntry* entry = index.findEntry(ref.m_uid);
     if (entry && !entry->sourcePath.empty())
diff --git a/Engine_Master_UPC/AssetRef.h b/Engine_Master_UPC/AssetRef.h
index 4eb5e917..dec1dd3a 100644
--- a/Engine_Master_UPC/AssetRef.h
+++ b/Engine_Master_UPC/AssetRef.h
@@ -1,13 +1,23 @@
 #pragma once
 
 #include "AssetReference.h"
+#include <memory>
 
-template<typename>
+class DataContainer;
+
+template<typename T = void>
 struct AssetRef
 {
     AssetReference m_ref;
+    std::shared_ptr<T> m_data;
+
+    T* get() const
+    {
+        return m_data.get();
+    }
 };
 
 using PrefabRef = AssetRef<struct Prefab>;
 using SceneRef = AssetRef<struct Scene>;
 using MaterialRef = AssetRef<struct BasicMaterial>;
+using DataContainerRef = AssetRef<DataContainer>;
diff --git a/Engine_Master_UPC/AssetType.h b/Engine_Master_UPC/AssetType.h
index add97566..663cc422 100644
--- a/Engine_Master_UPC/AssetType.h
+++ b/Engine_Master_UPC/AssetType.h
@@ -16,6 +16,7 @@
     X(NAVMESH)                 \
     X(SOUND_BANK)              \
     X(SCRIPT)                  \
+    X(DATA_CONTAINER) 			\
     X(UNKNOWN)
 
 #define ASSET_ENUM(name) name,
diff --git a/Engine_Master_UPC/Assets/Scripts/CameraFollow.h b/Engine_Master_UPC/Assets/Scripts/CameraFollow.h
index 5dcfc646..a1d9d1d6 100644
--- a/Engine_Master_UPC/Assets/Scripts/CameraFollow.h
+++ b/Engine_Master_UPC/Assets/Scripts/CameraFollow.h
@@ -14,11 +14,11 @@ class CameraFollow : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
     Vector3 m_transformOffset = Vector3(0.0f, 0.0f, 0.0f);
     Vector3 m_rotationOffset = Vector3(0.0f, 0.0f, 0.0f);
diff --git a/Engine_Master_UPC/Assets/Scripts/LocalMultiplayerSetup.h b/Engine_Master_UPC/Assets/Scripts/LocalMultiplayerSetup.h
index 956db6ec..9fabc06b 100644
--- a/Engine_Master_UPC/Assets/Scripts/LocalMultiplayerSetup.h
+++ b/Engine_Master_UPC/Assets/Scripts/LocalMultiplayerSetup.h
@@ -11,11 +11,11 @@ class LocalMultiplayerSetup : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
     ScriptMethodList getExposedMethods() const override;
 
-    ScriptComponentRef<Transform> keyboardGamepadButton;
-	ScriptComponentRef<Transform> twoGamepadButton;
+    ComponentRef<Transform> keyboardGamepadButton;
+	ComponentRef<Transform> twoGamepadButton;
 
     void setKeyboardGamepad();
     void setTwoGamepad();
diff --git a/Engine_Master_UPC/Assets/Scripts/PlayerController.h b/Engine_Master_UPC/Assets/Scripts/PlayerController.h
index 06611a9e..74e7fa9e 100644
--- a/Engine_Master_UPC/Assets/Scripts/PlayerController.h
+++ b/Engine_Master_UPC/Assets/Scripts/PlayerController.h
@@ -17,7 +17,7 @@ class PlayerController : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     bool getGodMode() const { return m_godMode; }
     int getPlayerIndex() const { return m_playerIndex; }
diff --git a/Engine_Master_UPC/Assets/Scripts/TestingButton.cpp b/Engine_Master_UPC/Assets/Scripts/TestingButton.cpp
index 6b113019..9abf9aeb 100644
--- a/Engine_Master_UPC/Assets/Scripts/TestingButton.cpp
+++ b/Engine_Master_UPC/Assets/Scripts/TestingButton.cpp
@@ -37,7 +37,7 @@ void TestingButton::Update()
 
 }
 
-void TestingButton::onFieldEdited(const ScriptFieldInfo& field)
+void TestingButton::onFieldEdited(const FieldInfo& field)
 {
 
 }
diff --git a/Engine_Master_UPC/Assets/Scripts/TestingButton.h b/Engine_Master_UPC/Assets/Scripts/TestingButton.h
index b0f1704d..06077a17 100644
--- a/Engine_Master_UPC/Assets/Scripts/TestingButton.h
+++ b/Engine_Master_UPC/Assets/Scripts/TestingButton.h
@@ -14,7 +14,7 @@ class TestingButton : public Script
 
     ScriptMethodList getExposedMethods() const override;
 
-    void onFieldEdited(const ScriptFieldInfo& field) override;
+    void onFieldEdited(const FieldInfo& field) override;
     void onAfterDeserialize() override;
 
 public:
diff --git a/Engine_Master_UPC/Assets/Scripts/TriggerArea.h b/Engine_Master_UPC/Assets/Scripts/TriggerArea.h
index 0384e0bb..5e729c1b 100644
--- a/Engine_Master_UPC/Assets/Scripts/TriggerArea.h
+++ b/Engine_Master_UPC/Assets/Scripts/TriggerArea.h
@@ -16,7 +16,7 @@ class TriggerArea final : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     float m_xWidth = 2.0f;
@@ -24,8 +24,8 @@ class TriggerArea final : public Script
 
     std::string m_sceneToLoad;
 
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
 private:
     bool containsPoint(const Vector3& triggerCenter, const Vector3& point) const;
diff --git a/Engine_Master_UPC/CommandCreateDataContainer.cpp b/Engine_Master_UPC/CommandCreateDataContainer.cpp
new file mode 100644
index 00000000..5965d37d
--- /dev/null
+++ b/Engine_Master_UPC/CommandCreateDataContainer.cpp
@@ -0,0 +1,93 @@
+#include "Globals.h"
+#include "CommandCreateDataContainer.h"
+
+#include "Application.h"
+#include "ModuleAssets.h"
+#include "GenericTypeFactory.h"
+#include "DataContainer.h"
+#include "Extensions.h"
+#include "UID.h"
+#include "JsonArchive.h"
+#include "FieldUtils.h"
+
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
+
+#include <fstream>
+
+CommandCreateDataContainer::CommandCreateDataContainer(
+    const std::filesystem::path& targetDir,
+    const std::string& typeName,
+    const std::string& assetName)
+    : m_targetDir(targetDir)
+    , m_typeName(typeName)
+    , m_assetName(assetName)
+{
+}
+
+void CommandCreateDataContainer::run()
+{
+    std::filesystem::path filePath = m_targetDir / (m_assetName + DATA_CONTAINER_EXTENSION);
+
+    if (std::filesystem::exists(filePath))
+    {
+        int suffix = 2;
+        while (true)
+        {
+            std::string numberedName = m_assetName + "_" + std::to_string(suffix);
+            filePath = m_targetDir / (numberedName + DATA_CONTAINER_EXTENSION);
+            if (!std::filesystem::exists(filePath))
+            {
+                break;
+            }
+            ++suffix;
+        }
+    }
+
+    rapidjson::Document doc;
+    doc.SetObject();
+    rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
+
+    doc.AddMember("_typeName", rapidjson::Value(m_typeName.c_str(), allocator), allocator);
+
+    AssetReference tempRef(INVALID_UID);
+    auto instance = DataContainerFactory::create(m_typeName, tempRef);
+    if (instance)
+    {
+        JsonArchive archive(ArchiveMode::Output);
+        instance->serialize(archive);
+        rapidjson::Value instanceJson = archive.extractValue(allocator);
+
+        if (instanceJson.IsObject())
+        {
+            for (auto it = instanceJson.MemberBegin(); it != instanceJson.MemberEnd(); ++it)
+            {
+                if (!doc.HasMember(it->name.GetString()))
+                {
+                    doc.AddMember(
+                        rapidjson::Value(it->name, allocator),
+                        rapidjson::Value(it->value, allocator),
+                        allocator
+                    );
+                }
+            }
+        }
+    }
+
+    rapidjson::StringBuffer buffer;
+    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+    doc.Accept(writer);
+
+    std::ofstream file(filePath);
+    if (!file.is_open())
+    {
+        DEBUG_ERROR("[CommandCreateDataContainer] Could not create '%s'.", filePath.string().c_str());
+        return;
+    }
+
+    file << buffer.GetString();
+    file.close();
+
+    app->getModuleAssets()->refresh();
+}
diff --git a/Engine_Master_UPC/CommandCreateDataContainer.h b/Engine_Master_UPC/CommandCreateDataContainer.h
new file mode 100644
index 00000000..3f0e54ab
--- /dev/null
+++ b/Engine_Master_UPC/CommandCreateDataContainer.h
@@ -0,0 +1,18 @@
+#pragma once
+#include "ICommand.h"
+
+#include <filesystem>
+#include <string>
+
+class CommandCreateDataContainer : public ICommand
+{
+public:
+    CommandCreateDataContainer(const std::filesystem::path& targetDir, const std::string& typeName, const std::string& assetName);
+
+    void run() override;
+
+private:
+    std::filesystem::path m_targetDir;
+    std::string m_typeName;
+    std::string m_assetName;
+};
\ No newline at end of file
diff --git a/Engine_Master_UPC/CommandQueue.cpp b/Engine_Master_UPC/CommandQueue.cpp
index 14224a3a..8f1d0a33 100644
--- a/Engine_Master_UPC/CommandQueue.cpp
+++ b/Engine_Master_UPC/CommandQueue.cpp
@@ -68,6 +68,14 @@ ComPtr<GraphicsCommandList> CommandQueue::getCommandList()
 
         DXCall(commandAllocator->Reset());
     }
+    else if (!m_CommandAllocatorQueue.empty() && m_CommandAllocatorQueue.size() >= MAX_POOL_SIZE)
+    {
+        waitForFenceValue(m_CommandAllocatorQueue.front().fenceValue);
+        commandAllocator = m_CommandAllocatorQueue.front().commandAllocator;
+        m_CommandAllocatorQueue.pop();
+
+        DXCall(commandAllocator->Reset());
+    }
     else
     {
         commandAllocator = createCommandAllocator();
diff --git a/Engine_Master_UPC/CommandQueue.h b/Engine_Master_UPC/CommandQueue.h
index 1f39e630..6942e3f5 100644
--- a/Engine_Master_UPC/CommandQueue.h
+++ b/Engine_Master_UPC/CommandQueue.h
@@ -2,6 +2,7 @@
 
 #include <d3d12.h>
 #include <wrl.h>
+#include "Globals.h"
 
 #include <cstdint>
 #include <queue>
@@ -24,6 +25,8 @@ class CommandQueue
     CommandQueue(ComPtr<ID3D12Device4> device, D3D12_COMMAND_LIST_TYPE type);
     virtual ~CommandQueue();
 
+    static constexpr size_t MAX_POOL_SIZE = FRAMES_IN_FLIGHT + 1;
+
     ComPtr<GraphicsCommandList> getCommandList();
     ComPtr<ID3D12CommandQueue>  getD3D12CommandQueue() const;
 
diff --git a/Engine_Master_UPC/ScriptComponentRef.h b/Engine_Master_UPC/ComponentRef.h
similarity index 71%
rename from Engine_Master_UPC/ScriptComponentRef.h
rename to Engine_Master_UPC/ComponentRef.h
index 15462077..438c6055 100644
--- a/Engine_Master_UPC/ScriptComponentRef.h
+++ b/Engine_Master_UPC/ComponentRef.h
@@ -6,7 +6,7 @@
 #include <vector>
 
 template<typename T>
-struct ScriptComponentRef
+struct ComponentRef
 {
     UID uid = 0;
     Component* component = nullptr;
@@ -17,4 +17,5 @@ struct ScriptComponentRef
     }
 };
 
-using ScriptComponentRefList = std::vector<ScriptComponentRef<Component>>;
\ No newline at end of file
+using ComponentRefList = std::vector<ComponentRef<Component>>;
+
diff --git a/Engine_Master_UPC/DataContainer.cpp b/Engine_Master_UPC/DataContainer.cpp
new file mode 100644
index 00000000..f2c24411
--- /dev/null
+++ b/Engine_Master_UPC/DataContainer.cpp
@@ -0,0 +1,185 @@
+#include "Globals.h"
+#include "DataContainer.h"
+#include "Application.h"
+#include "ModuleAssets.h"
+#include "FieldUtils.h"
+#include "JsonArchive.h"
+#include "GenericTypeFactory.h"
+
+#include <string>
+
+void DataContainer::serialize(IArchive& archive)
+{
+    std::string typeName = getTypeName();
+    if (DataContainerFactory::isRegistered(typeName))
+    {
+        archive.serialize(typeName, "_typeName");
+    }
+
+    FieldList fields = getExposedFields();
+    if (!fields.fields.empty())
+    {
+        FieldUtils::serialize(*this, reinterpret_cast<const char*>(this), archive);
+        return;
+    }
+
+    // Fallback: when there are no bound fields (base DataContainer during
+    // initial import), copy the raw JSON into m_data so that
+    // resolveDataContainerType can discover _typeName and upgrade
+    // to the correct derived class (e.g. BoundConfig).
+    JsonArchive* jarc = dynamic_cast<JsonArchive*>(&archive);
+    if (jarc && jarc->mode() == ArchiveMode::Input)
+    {
+        const rapidjson::Value* input = jarc->currentInput();
+        if (input && input->IsObject())
+        {
+            m_data.CopyFrom(*input, m_data.GetAllocator());
+        }
+    }
+}
+
+void DataContainer::drawUI()
+{
+	ImGui::Text("Data Container");
+	ImGui::Separator();
+
+	ImGui::TextDisabled("UID: %llu", static_cast<unsigned long long>(getUID()));
+
+	ImGui::Spacing();
+
+	if (ImGui::Button("Save"))
+	{
+		app->getModuleAssets()->save(*this);
+	}
+
+	ImGui::SameLine();
+	ImGui::TextDisabled("(Ctrl+S)");
+
+	ImGui::Spacing();
+	ImGui::SeparatorText("Properties");
+
+	FieldList fields = getExposedFields();
+	if (!fields.fields.empty())
+	{
+		FieldUtils::drawUi(*this, reinterpret_cast<char*>(this));
+		return;
+	}
+
+	if (m_data.IsObject() && m_data.MemberCount() == 0)
+	{
+		ImGui::TextDisabled("No properties defined.");
+		ImGui::Spacing();
+		ImGui::TextWrapped("Override getExposedFields() in a subclass to add typed properties,");
+		ImGui::TextWrapped("or add entries directly in the .datacontainer JSON file.");
+		return;
+	}
+
+	if (!m_data.IsObject())
+	{
+		ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Invalid data document.");
+		return;
+	}
+
+	for (auto it = m_data.MemberBegin(); it != m_data.MemberEnd(); ++it)
+	{
+		const char* key = it->name.GetString();
+		rapidjson::Value& value = it->value;
+
+		ImGui::PushID(key);
+
+		if (value.IsString())
+		{
+			std::string buffer = value.GetString();
+			buffer.resize(256, '\0');
+			if (ImGui::InputText(key, &buffer[0], buffer.size()))
+			{
+				value.SetString(buffer.c_str(), m_data.GetAllocator());
+			}
+		}
+		else if (value.IsInt())
+		{
+			int v = value.GetInt();
+			if (ImGui::InputInt(key, &v))
+			{
+				value.SetInt(v);
+			}
+		}
+		else if (value.IsInt64())
+		{
+			int v = static_cast<int>(value.GetInt64());
+			if (ImGui::InputInt(key, &v))
+			{
+				value.SetInt64(v);
+			}
+		}
+		else if (value.IsUint64())
+		{
+			int v = static_cast<int>(value.GetUint64());
+			if (ImGui::InputInt(key, &v))
+			{
+				value.SetUint64(static_cast<uint64_t>(v));
+			}
+		}
+		else if (value.IsFloat() || value.IsDouble())
+		{
+			float v = value.GetFloat();
+			if (ImGui::DragFloat(key, &v, 0.1f))
+			{
+				value.SetFloat(v);
+			}
+		}
+		else if (value.IsBool())
+		{
+			bool v = value.GetBool();
+			if (ImGui::Checkbox(key, &v))
+			{
+				value.SetBool(v);
+			}
+		}
+		else if (value.IsArray())
+		{
+			if (ImGui::TreeNode(key, "%s [%u items]", key, value.Size()))
+			{
+				for (rapidjson::SizeType i = 0; i < value.Size(); ++i)
+				{
+					ImGui::PushID(static_cast<int>(i));
+					rapidjson::Value& elem = value[i];
+
+					if (elem.IsString())
+					{
+						ImGui::Text("[%u]: %s", i, elem.GetString());
+					}
+					else if (elem.IsNumber())
+					{
+						if (elem.IsInt())
+							ImGui::Text("[%u]: %d", i, elem.GetInt());
+						else
+							ImGui::Text("[%u]: %.3f", i, elem.GetFloat());
+					}
+					else if (elem.IsBool())
+					{
+						ImGui::Text("[%u]: %s", i, elem.GetBool() ? "true" : "false");
+					}
+					else if (elem.IsObject())
+					{
+						ImGui::Text("[%u]: { ... }", i);
+					}
+
+					ImGui::PopID();
+				}
+
+				ImGui::TreePop();
+			}
+		}
+		else if (value.IsObject())
+		{
+			ImGui::Text("%s: { ... }", key);
+		}
+		else
+		{
+			ImGui::TextDisabled("%s: (unsupported type)", key);
+		}
+
+		ImGui::PopID();
+	}
+}
diff --git a/Engine_Master_UPC/DataContainer.h b/Engine_Master_UPC/DataContainer.h
new file mode 100644
index 00000000..7596c1a6
--- /dev/null
+++ b/Engine_Master_UPC/DataContainer.h
@@ -0,0 +1,53 @@
+#pragma once
+#include "Asset.h"
+#include "IFieldContainer.h"
+
+#pragma warning(push)
+#pragma warning(disable: 4251)
+
+#include <rapidjson/document.h>
+#include <typeinfo>
+#include <cstring>
+
+class ImporterDataContainer;
+
+class ENGINE_API DataContainer : public Asset, public IFieldContainer
+{
+public:
+	friend class ImporterDataContainer;
+
+	DataContainer() = default;
+	explicit DataContainer(AssetReference& id)
+		: Asset(id, AssetType::DATA_CONTAINER)
+	{
+		m_data.SetObject();
+	}
+
+	virtual void syncFromData() {}
+	void drawUI() override;
+
+	void serialize(IArchive& archive) override;
+
+	const rapidjson::Document& getData() const { return m_data; }
+	rapidjson::Document& getDataMutable() { return m_data; }
+
+	virtual const char* getTypeName() const
+	{
+		const char* name = typeid(*this).name();
+#ifdef _MSC_VER
+		if (std::strncmp(name, "class ", 6) == 0) return name + 6;
+		if (std::strncmp(name, "struct ", 7) == 0) return name + 7;
+#endif
+		return name;
+	}
+
+	virtual const char* getDisplayTypeName() const
+	{
+		return getTypeName();
+	}
+
+protected:
+	rapidjson::Document m_data;
+};
+
+#pragma warning(pop)
\ No newline at end of file
diff --git a/Engine_Master_UPC/DataContainerAPI.h b/Engine_Master_UPC/DataContainerAPI.h
new file mode 100644
index 00000000..0e1d4df5
--- /dev/null
+++ b/Engine_Master_UPC/DataContainerAPI.h
@@ -0,0 +1,38 @@
+#pragma once
+
+// Include this header in your external project to create custom DataContainer assets
+// (similar to Unity ScriptableObjects)
+//
+// Usage (field-based, header-only):
+//   class MyConfig : public DataContainer {
+//       DECLARE_DATACONTAINER(MyConfig)   // handles auto-registration
+//   public:
+//       MyConfig() = default;
+//       explicit MyConfig(AssetReference& id) : DataContainer(id) {}
+//       float m_value = 10.0f;
+//
+//       IMPLEMENT_DATACONTAINER_FIELDS(MyConfig,
+//           SERIALIZED_FLOAT(m_value, "My Value", 0, 100, 1.0f)
+//       )
+//   };
+//
+// The class auto-registers and appears in the FileDialog "Create" menu and "Asset" top menu.
+// Note: The header must be included by at least one .cpp file for registration to take effect.
+
+#include "DataContainer.h"
+#include "FieldMacros.h"
+#include "EngineAPI.h"
+#include "AssetRef.h"
+
+#define DECLARE_DATACONTAINER(TypeName) \
+	public: \
+		static std::unique_ptr<DataContainer> CreateInstance(AssetReference& uid) { \
+			return std::make_unique<TypeName>(uid); \
+		} \
+	private: \
+		static inline const bool s_registered_ = []() -> bool { \
+			::registerDataContainer(#TypeName, #TypeName, &TypeName::CreateInstance); \
+			return true; \
+		}();
+
+#define IMPLEMENT_DATACONTAINER(TypeName)
diff --git a/Engine_Master_UPC/DataContainerExporter.cpp b/Engine_Master_UPC/DataContainerExporter.cpp
new file mode 100644
index 00000000..8d74814a
--- /dev/null
+++ b/Engine_Master_UPC/DataContainerExporter.cpp
@@ -0,0 +1,184 @@
+#include "Globals.h"
+#include "DataContainerExporter.h"
+
+#include "AssetsDictionary.h"
+#include "Extensions.h"
+#include "Application.h"
+#include "ModuleAssets.h"
+
+#include <rapidjson/document.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/stringbuffer.h>
+#include "rapidjson/filereadstream.h"
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+
+namespace fs = std::filesystem;
+
+bool DataContainerExporter::exportToJson(const fs::path& outputPath)
+{
+    rapidjson::Document root;
+    root.SetObject();
+    rapidjson::Document::AllocatorType& allocator = root.GetAllocator();
+
+    fs::path assetsRoot = ASSETS_FOLDER;
+    if (!assetsRoot.is_absolute())
+    {
+        assetsRoot = fs::absolute(assetsRoot);
+    }
+
+    if (!fs::exists(assetsRoot))
+    {
+        DEBUG_ERROR("[DataContainerExporter] Assets folder '%s' not found.", assetsRoot.string().c_str());
+        return false;
+    }
+
+    // Scan recursively for .datacontainer files
+    for (const auto& entry : fs::recursive_directory_iterator(assetsRoot))
+    {
+        if (!entry.is_regular_file())
+            continue;
+
+        const fs::path& filePath = entry.path();
+        if (filePath.extension().string() != DATA_CONTAINER_EXTENSION)
+            continue;
+
+        // Read the .datacontainer file
+        FILE* fp = std::fopen(filePath.string().c_str(), "rb");
+        if (!fp)
+        {
+            DEBUG_WARN("[DataContainerExporter] Could not open '%s'.", filePath.string().c_str());
+            continue;
+        }
+
+        char readBuffer[65536];
+        rapidjson::FileReadStream is(fp, readBuffer, sizeof(readBuffer));
+        rapidjson::Document doc;
+        doc.ParseStream(is);
+        std::fclose(fp);
+
+        if (doc.HasParseError() || !doc.IsObject())
+        {
+            DEBUG_WARN("[DataContainerExporter] Parse error in '%s'.", filePath.string().c_str());
+            continue;
+        }
+
+        // Use filename stem as key
+        std::string key = filePath.stem().string();
+        rapidjson::Value keyVal(key.c_str(), allocator);
+
+        // Deep-copy the document's members into a new value
+        rapidjson::Value obj(rapidjson::kObjectType);
+        for (auto it = doc.MemberBegin(); it != doc.MemberEnd(); ++it)
+        {
+            rapidjson::Value name(it->name.GetString(), allocator);
+            rapidjson::Value value;
+            value.CopyFrom(it->value, allocator);
+            obj.AddMember(name, value, allocator);
+        }
+
+        root.AddMember(keyVal, obj, allocator);
+
+        DEBUG_LOG("[DataContainerExporter] Exported '%s'.", key.c_str());
+    }
+
+    if (root.MemberCount() == 0)
+    {
+        DEBUG_WARN("[DataContainerExporter] No .datacontainer files found to export.");
+        return false;
+    }
+
+    // Write combined JSON
+    rapidjson::StringBuffer buffer;
+    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+    root.Accept(writer);
+
+    std::ofstream file(outputPath);
+    if (!file.is_open())
+    {
+        DEBUG_ERROR("[DataContainerExporter] Could not write '%s'.", outputPath.string().c_str());
+        return false;
+    }
+
+    file << buffer.GetString();
+    file.close();
+
+    DEBUG_LOG("[DataContainerExporter] Exported %llu data assets to '%s'.",
+        static_cast<unsigned long long>(root.MemberCount()), outputPath.string().c_str());
+    return true;
+}
+
+bool DataContainerExporter::importFromJson(const fs::path& inputPath)
+{
+    FILE* fp = std::fopen(inputPath.string().c_str(), "rb");
+    if (!fp)
+    {
+        DEBUG_ERROR("[DataContainerExporter] Could not open '%s'.", inputPath.string().c_str());
+        return false;
+    }
+
+    char readBuffer[65536];
+    rapidjson::FileReadStream is(fp, readBuffer, sizeof(readBuffer));
+    rapidjson::Document root;
+    root.ParseStream(is);
+    std::fclose(fp);
+
+    if (root.HasParseError() || !root.IsObject())
+    {
+        DEBUG_ERROR("[DataContainerExporter] Parse error in '%s'.", inputPath.string().c_str());
+        return false;
+    }
+
+    fs::path assetsRoot = ASSETS_FOLDER;
+    if (!assetsRoot.is_absolute())
+    {
+        assetsRoot = fs::absolute(assetsRoot);
+    }
+
+    if (!fs::exists(assetsRoot))
+    {
+        DEBUG_ERROR("[DataContainerExporter] Assets folder '%s' not found.", assetsRoot.string().c_str());
+        return false;
+    }
+
+    size_t importedCount = 0;
+
+    for (auto it = root.MemberBegin(); it != root.MemberEnd(); ++it)
+    {
+        if (!it->value.IsObject())
+        {
+            DEBUG_WARN("[DataContainerExporter] Skipping '%s': value is not an object.", it->name.GetString());
+            continue;
+        }
+
+        std::string name = it->name.GetString();
+        fs::path filePath = assetsRoot / (name + DATA_CONTAINER_EXTENSION);
+
+        // Serialize this entry back to JSON
+        rapidjson::StringBuffer buffer;
+        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+        it->value.Accept(writer);
+
+        std::ofstream file(filePath);
+        if (!file.is_open())
+        {
+            DEBUG_ERROR("[DataContainerExporter] Could not write '%s'.", filePath.string().c_str());
+            continue;
+        }
+
+        file << buffer.GetString();
+        file.close();
+
+        DEBUG_LOG("[DataContainerExporter] Imported '%s'.", name.c_str());
+        ++importedCount;
+    }
+
+    // Refresh the asset system to pick up new/changed files
+    app->getModuleAssets()->refresh();
+
+    DEBUG_LOG("[DataContainerExporter] Imported %zu data assets from '%s'.",
+        importedCount, inputPath.string().c_str());
+    return importedCount > 0;
+}
diff --git a/Engine_Master_UPC/DataContainerExporter.h b/Engine_Master_UPC/DataContainerExporter.h
new file mode 100644
index 00000000..b9e8434c
--- /dev/null
+++ b/Engine_Master_UPC/DataContainerExporter.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <filesystem>
+
+class DataContainerExporter
+{
+public:
+    // Scans ASSETS_FOLDER for all .datacontainer files and writes them as a single
+    // JSON object keyed by filename stem (e.g. "MyConfig" -> { ... }).
+    static bool exportToJson(const std::filesystem::path& outputPath);
+
+    // Reads a combined JSON file and writes each entry back as an individual
+    // .datacontainer file in ASSETS_FOLDER. Existing files are overwritten.
+    static bool importFromJson(const std::filesystem::path& inputPath);
+};
diff --git a/Engine_Master_UPC/DebugDrawPass.cpp b/Engine_Master_UPC/DebugDrawPass.cpp
index cecaedcf..ff6a5ac1 100644
--- a/Engine_Master_UPC/DebugDrawPass.cpp
+++ b/Engine_Master_UPC/DebugDrawPass.cpp
@@ -466,7 +466,7 @@ class DDRenderInterfaceCoreD3D12 final : public dd::RenderInterface
     ComPtr<ID3D12CommandAllocator>    uploadCommandAllocator;
     ComPtr<ID3D12Fence1>              uploadFence;
     HANDLE                            uploadEvent = NULL;
-    uint32_t                          uploadFenceValue = 0;
+    uint64_t                          uploadFenceValue = 0;
     D3D12_CPU_DESCRIPTOR_HANDLE       cpuTextHandle;
     D3D12_GPU_DESCRIPTOR_HANDLE       gpuTextHandle;
 
diff --git a/Engine_Master_UPC/Engine.vcxproj b/Engine_Master_UPC/Engine.vcxproj
index 144dda8a..efbcdd9b 100644
--- a/Engine_Master_UPC/Engine.vcxproj
+++ b/Engine_Master_UPC/Engine.vcxproj
@@ -336,7 +336,12 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClInclude Include="ComponentSoundSource.h" />
     <ClInclude Include="ContentRegistry.h" />
     <ClInclude Include="CommandCreateFolder.h" />
+    <ClInclude Include="CommandCreateDataContainer.h" />
     <ClInclude Include="CommandCutItem.h" />
+    <ClInclude Include="DataContainer.h" />
+    <ClInclude Include="DataContainerExporter.h" />
+    <ClInclude Include="GenericTypeFactory.h" />
+    <ClInclude Include="DataContainerAPI.h" />
     <ClInclude Include="Delegates.h" />
     <ClInclude Include="DescriptorHeapBlock.h" />
     <ClInclude Include="DescriptorHandle.h" />
@@ -415,19 +420,19 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClInclude Include="Scene.h" />
     <ClInclude Include="ScenePicking.h" />
     <ClInclude Include="ScriptAPI.h" />
-    <ClInclude Include="ScriptAutoRegister.h" />
-    <ClInclude Include="ScriptComponentRef.h" />
-    <ClInclude Include="ScriptFieldHandler.h" />
-    <ClInclude Include="ScriptFieldHandlerRegistry.h" />
-    <ClInclude Include="ScriptFieldInfo.h" />
-    <ClInclude Include="ScriptCreator.h" />
+    <ClInclude Include="ComponentRef.h" />
+    <ClInclude Include="FieldHandler.h" />
+    <ClInclude Include="FieldHandlerRegistry.h" />
+    <ClInclude Include="FieldInfo.h" />
+    <ClInclude Include="IFieldContainer.h" />
     <ClInclude Include="SceneDataCB.h" />
     <ClInclude Include="SceneLightingSettings.h" />
     <ClInclude Include="SceneReferenceResolver.h" />
-    <ClInclude Include="ScriptFieldMacros.h" />
+    <ClInclude Include="FieldMacros.h" />
+    <ClInclude Include="FieldTypeTraits.h" />
+    <ClInclude Include="FieldUtils.h" />
     <ClInclude Include="ScriptMethodInfo.h" />
     <ClInclude Include="ScriptMethodList.h" />
-    <ClInclude Include="ScriptRegistry.h" />
     <ClInclude Include="Skin.h" />
     <ClInclude Include="SkinAsset.h" />
     <ClInclude Include="SkinningComputePass.h" />
@@ -544,6 +549,7 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClInclude Include="ModuleResources.h" />
     <ClInclude Include="RingBuffer.h" />
     <ClInclude Include="WindowMusicDebug.h" />
+    <ClInclude Include="WindowDataContainerManager.h" />
     <ClInclude Include="WindowSceneEditor.h" />
     <ClInclude Include="SceneSnapshot.h" />
     <ClInclude Include="Script.h" />
@@ -751,8 +757,10 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClCompile Include="ComponentSoundSource.cpp" />
     <ClCompile Include="ContentRegistry.cpp" />
     <ClCompile Include="ComponentFactory.cpp" />
+    <ClCompile Include="DataContainerExporter.cpp" />
     <ClCompile Include="DescriptorHeapBlock.cpp" />
     <ClCompile Include="CommandCreateFolder.cpp" />
+    <ClCompile Include="CommandCreateDataContainer.cpp" />
     <ClCompile Include="CommandCutItem.cpp" />
     <ClCompile Include="CommandDeleteAsset.cpp" />
     <ClCompile Include="CommandDeleteFolder.cpp" />
@@ -776,6 +784,7 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClCompile Include="HierarchyTreeRenderer.cpp" />
     <ClCompile Include="HierarchyUtils.cpp" />
     <ClCompile Include="CommandImportAsset.cpp" />
+    <ClCompile Include="DataContainer.cpp" />
     <ClCompile Include="ImporterFont.cpp" />
     <ClCompile Include="ImporterGltf.cpp" />
     <ClCompile Include="ImporterNavMesh.cpp" />
@@ -797,8 +806,8 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClCompile Include="PlayerPass.cpp" />
     <ClCompile Include="PlayerRenderBufferComponent.cpp" />
     <ClCompile Include="PrefabManager.cpp" />
+    <ClCompile Include="FieldHandler_GroupLabel.cpp" />
     <ClCompile Include="ScriptBuildSystem.cpp" />
-    <ClCompile Include="ScriptFieldHandler_GroupLabel.cpp" />
     <ClCompile Include="ScriptLibraryLoader.cpp" />
     <ClCompile Include="ShadowMapPass.cpp" />
     <ClCompile Include="SoundBankAsset.cpp" />
@@ -814,16 +823,17 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClCompile Include="TriggerSystem.cpp" />
     <ClCompile Include="ScenePicking.cpp" />
     <ClCompile Include="NavModifierVolumeComponent.cpp" />
-    <ClCompile Include="ScriptFieldHandler_AssetRef.cpp" />
-    <ClCompile Include="ScriptFieldHandler_Bool.cpp" />
-    <ClCompile Include="ScriptFieldHandler_ComponentRef.cpp" />
-    <ClCompile Include="ScriptFieldHandler_ComponentRefList.cpp" />
-    <ClCompile Include="ScriptFieldHandler_EnumInt.cpp" />
-    <ClCompile Include="ScriptFieldHandler_Float.cpp" />
-    <ClCompile Include="ScriptFieldHandler_Int.cpp" />
-    <ClCompile Include="ScriptFieldHandler_List.cpp" />
-    <ClCompile Include="ScriptFieldHandler_String.cpp" />
-    <ClCompile Include="ScriptFieldHandler_Vec3.cpp" />
+    <ClCompile Include="FieldHandler_Bool.cpp" />
+    <ClCompile Include="FieldHandler_ComponentRef.cpp" />
+    <ClCompile Include="FieldHandler_ComponentRefList.cpp" />
+    <ClCompile Include="FieldHandler_EnumInt.cpp" />
+    <ClCompile Include="FieldHandler_Float.cpp" />
+    <ClCompile Include="FieldHandler_Int.cpp" />
+    <ClCompile Include="FieldHandler_List.cpp" />
+    <ClCompile Include="FieldHandler_String.cpp" />
+    <ClCompile Include="FieldHandler_Vec3.cpp" />
+    <ClCompile Include="FieldUtils.cpp" />
+    <ClCompile Include="FieldHandler_AssetRef.cpp" />
     <ClCompile Include="Skin.cpp" />
     <ClCompile Include="ParticleEmitter.cpp" />
     <ClCompile Include="ParticleModule.cpp" />
@@ -932,9 +942,9 @@ $(SolutionDir)3rdParty\RecastNavigation\DebugUtils\Include;
     <ClCompile Include="ModuleResources.cpp" />
     <ClCompile Include="RingBuffer.cpp" />
     <ClCompile Include="WindowMusicDebug.cpp" />
+    <ClCompile Include="WindowDataContainerManager.cpp" />
     <ClCompile Include="WindowSceneEditor.cpp" />
     <ClCompile Include="ScriptComponent.cpp" />
-    <ClCompile Include="ScriptFactory.cpp" />
     <ClCompile Include="SimpleMath.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
diff --git a/Engine_Master_UPC/Engine.vcxproj.filters b/Engine_Master_UPC/Engine.vcxproj.filters
index aa988476..a98e54d3 100644
--- a/Engine_Master_UPC/Engine.vcxproj.filters
+++ b/Engine_Master_UPC/Engine.vcxproj.filters
@@ -26,7 +26,7 @@
     <ClCompile Include="UID.cpp">
       <Filter>Persistence\UID</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_List.cpp">
+    <ClCompile Include="FieldHandler_List.cpp">
       <Filter>Core\Scripting\FieldTypeHandler</Filter>
     </ClCompile>
     <ClCompile Include="ParticleSystemComponent.cpp">
@@ -128,7 +128,7 @@
     <ClCompile Include="PdbPatcher.cpp">
       <Filter>Core\Scripting\HotReloading\Pdb</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_GroupLabel.cpp">
+    <ClCompile Include="FieldHandler_GroupLabel.cpp">
       <Filter>Core\Scripting\FieldTypeHandler</Filter>
     </ClCompile>
     <ClCompile Include="EmitterRender.cpp">
@@ -283,6 +283,8 @@
     </ClCompile>
     <ClCompile Include="3rdParty\imgui-node-editor-master\imgui_node_editor_api.cpp">
       <Filter>Editor\imgui\NodeEditor</Filter>
+    <ClCompile Include="ImporterGltf.cpp">
+      <Filter>Persistence\Importers\External\Gltf</Filter>
     </ClCompile>
     <ClCompile Include="WindowSceneEditor.cpp">
       <Filter>Editor\Views</Filter>
@@ -293,28 +295,31 @@
     <ClCompile Include="ScriptFactory.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_Bool.cpp">
+    <ClCompile Include="FieldHandler_Bool.cpp">
+      <Filter>Core\Scripting</Filter>
+    </ClCompile>
+    <ClCompile Include="FieldHandler_ComponentRef.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_ComponentRef.cpp">
+    <ClCompile Include="FieldHandler_ComponentRefList.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_ComponentRefList.cpp">
+    <ClCompile Include="FieldHandler_EnumInt.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_EnumInt.cpp">
+    <ClCompile Include="FieldHandler_Float.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_Float.cpp">
+    <ClCompile Include="FieldHandler_Int.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_Int.cpp">
+    <ClCompile Include="FieldHandler_String.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_String.cpp">
+    <ClCompile Include="FieldHandler_Vec3.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
-    <ClCompile Include="ScriptFieldHandler_Vec3.cpp">
+    <ClCompile Include="FieldHandler_AssetRef.cpp">
       <Filter>Core\Scripting</Filter>
     </ClCompile>
     <ClCompile Include="Asset.cpp">
@@ -377,6 +382,8 @@
     <ClCompile Include="GeometryPass.cpp">
       <Filter>D3D12\Rendering\Pass</Filter>
     </ClCompile>
+    <ClCompile Include="AnimationComponent.cpp">
+      <Filter>Animations</Filter>
     <ClCompile Include="ContentRegistry.cpp">
       <Filter>Persistence\ToChange</Filter>
     </ClCompile>
@@ -397,6 +404,8 @@
     </ClCompile>
     <ClCompile Include="ImGuiPass.cpp">
       <Filter>D3D12\Rendering\Pass</Filter>
+    <ClCompile Include="CommandAddChildToPrefabRoot.cpp">
+      <Filter>Core\Commands</Filter>
     </ClCompile>
     <ClCompile Include="Keyboard.cpp">
       <Filter>Inputs\Keyboard</Filter>
@@ -472,24 +481,23 @@
     </ClCompile>
     <ClCompile Include="WindowInspector.cpp">
       <Filter>Editor\Views</Filter>
-    </ClCompile>
     <ClCompile Include="ModuleResources.cpp">
       <Filter>D3D12\Resources</Filter>
     </ClCompile>
     <ClCompile Include="ModuleUI.cpp">
       <Filter>Persistence\Importers\External\UI</Filter>
-    </ClCompile>
     <ClCompile Include="ModuleEventSystem.cpp">
       <Filter>Persistence\Importers\External\UI\Events</Filter>
     </ClCompile>
     <ClCompile Include="ModuleNavigation.cpp">
       <Filter>NavMesh</Filter>
-    </ClCompile>
     <ClCompile Include="ModuleScene.cpp">
       <Filter>GameEntity</Filter>
     </ClCompile>
     <ClCompile Include="ModuleGameView.cpp">
       <Filter>GameEntity</Filter>
+    <ClCompile Include="FieldUtils.cpp">
+      <Filter>Core\Scripting</Filter>
     </ClCompile>
     <ClCompile Include="ModuleD3D12.cpp">
       <Filter>D3D12</Filter>
@@ -518,6 +526,8 @@
     <ClCompile Include="UIImagePass.cpp">
       <Filter>D3D12\Rendering\Pass</Filter>
     </ClCompile>
+    <ClCompile Include="ParticleSystemComponent.cpp">
+      <Filter>GameEntity\Components</Filter>
     <ClCompile Include="PrefabUI.cpp">
       <Filter>Prefabs</Filter>
     </ClCompile>
@@ -565,6 +575,9 @@
     </ClCompile>
     <ClCompile Include="ModuleCamera.cpp">
       <Filter>D3D12\Rendering</Filter>
+    <ClCompile Include="PrefabUI.cpp">
+      <Filter>Prefabs</Filter>
+      <Filter>Prefabs</Filter>
     </ClCompile>
     <ClCompile Include="RenderSurface.cpp">
       <Filter>D3D12\Wrappers</Filter>
@@ -613,28 +626,21 @@
     </ClCompile>
     <ClCompile Include="ImportSettings.cpp">
       <Filter>Persistence\Importers</Filter>
-    </ClCompile>
     <ClCompile Include="MeshRenderer.cpp">
       <Filter>GameEntity\Components</Filter>
-    </ClCompile>
+    <ClCompile Include="TextureImportSettings.cpp" />
+    <ClCompile Include="ImportSettings.cpp" />
+    <ClCompile Include="DataContainerExporter.cpp" />
+    <ClCompile Include="CommandCreateDataContainer.cpp" />
+    <ClCompile Include="DataContainer.cpp" />
+    <ClCompile Include="JsonArchive.cpp" />
+    <ClCompile Include="WindowDataContainerManager.cpp" />
     <ClCompile Include="NavMeshGeometryExtractor.cpp">
       <Filter>NavMesh</Filter>
     </ClCompile>
     <ClCompile Include="UINavigation.cpp">
       <Filter>Persistence\Importers\External\UI\Events</Filter>
     </ClCompile>
-    <ClCompile Include="ForwardPrepass.cpp" />
-    <ClCompile Include="PlayerPass.cpp" />
-    <ClCompile Include="PlayerRenderBufferComponent.cpp" />
-    <ClCompile Include="UILayoutUtils.cpp">
-      <Filter>Persistence\Importers\External\UI</Filter>
-    </ClCompile>
-    <ClCompile Include="ImporterNavMesh.cpp" />
-    <ClCompile Include="ImporterSoundBank.cpp" />
-    <ClCompile Include="NavMeshAsset.cpp" />
-    <ClCompile Include="NavMeshBuildSettings.cpp" />
-    <ClCompile Include="SoundBankAsset.cpp" />
-    <ClCompile Include="ScriptFieldHandler_AssetRef.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="3rdParty\imgui-node-editor-master\crude_json.h">
@@ -850,22 +856,16 @@
     <ClInclude Include="ScriptAPI.h">
       <Filter>Core</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptAutoRegister.h">
-      <Filter>Core\Scripting</Filter>
-    </ClInclude>
-    <ClInclude Include="ScriptComponentRef.h">
+    <ClInclude Include="ComponentRef.h">
       <Filter>Core\Scripting</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptFieldHandler.h">
+    <ClInclude Include="FieldHandler.h">
       <Filter>Core\Scripting\FieldTypeHandler</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptFieldHandlerRegistry.h">
+    <ClInclude Include="FieldHandlerRegistry.h">
       <Filter>Core\Scripting\FieldTypeHandler</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptFieldInfo.h">
-      <Filter>Core\Scripting</Filter>
-    </ClInclude>
-    <ClInclude Include="ScriptCreator.h">
+    <ClInclude Include="FieldInfo.h">
       <Filter>Core\Scripting</Filter>
     </ClInclude>
     <ClInclude Include="SceneDataCB.h">
@@ -877,7 +877,7 @@
     <ClInclude Include="SceneReferenceResolver.h">
       <Filter>GameEntity\Scene</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptFieldMacros.h">
+    <ClInclude Include="FieldMacros.h">
       <Filter>Core\Scripting</Filter>
     </ClInclude>
     <ClInclude Include="ScriptMethodInfo.h">
@@ -1138,9 +1138,6 @@
     <ClInclude Include="Script.h">
       <Filter>Core\Scripting</Filter>
     </ClInclude>
-    <ClInclude Include="ScriptFactory.h">
-      <Filter>Core\Scripting</Filter>
-    </ClInclude>
     <ClInclude Include="ComponentFactory.h">
       <Filter>GameEntity\Components</Filter>
     </ClInclude>
@@ -1167,27 +1164,47 @@
     </ClInclude>
     <ClInclude Include="KeyCode.h">
       <Filter>Inputs\Keyboard</Filter>
+    <ClInclude Include="DataContainer.h">
+      <Filter>Core\Scripting</Filter>
+    </ClInclude>
+    <ClInclude Include="DataContainerAPI.h">
+      <Filter>Core\Scripting</Filter>
     </ClInclude>
+    <ClInclude Include="DataContainerExporter.h">
+      <Filter>Core\Scripting</Filter>
+    </ClInclude>
+    <ClInclude Include="ScriptFactory.h">
+      <Filter>Core\Scripting</Filter>
+    </ClInclude>
+    <ClInclude Include="FieldInfo.h">
+      <Filter>Core\Scripting</Filter>
     <ClInclude Include="PlayerBinding.h">
       <Filter>Inputs</Filter>
-    </ClInclude>
+      <Filter>Core\Scripting</Filter>
+    <ClInclude Include="IFieldContainer.h">
+      <Filter>Core\Scripting</Filter>
     <ClInclude Include="MD5Fwd.h">
       <Filter>Maths</Filter>
-    </ClInclude>
+      <Filter>Core\Scripting</Filter>
+    <ClInclude Include="ComponentRef.h">
+      <Filter>Core\Scripting</Filter>
     <ClInclude Include="CanvasRenderMode.h">
       <Filter>Persistence\Importers\External\UI</Filter>
-    </ClInclude>
+      <Filter>Core\Scripting</Filter>
     <ClInclude Include="ParticleSystemComponent.h">
       <Filter>GameEntity\Components</Filter>
+      <Filter>Core\Scripting</Filter>
     </ClInclude>
     <ClInclude Include="ParticleCommands.h">
       <Filter>ParticleSystem</Filter>
-    </ClInclude>
+    <ClInclude Include="3rdParty\imgui-node-editor-master\crude_json.h">
+      <Filter>Editor\imgui\NodeEditor</Filter>
     <ClInclude Include="ParticlesPass.h">
       <Filter>D3D12\Rendering\Pass</Filter>
     </ClInclude>
     <ClInclude Include="ParticleEmitter.h">
       <Filter>ParticleSystem</Filter>
+      <Filter>Editor\imgui\NodeEditor</Filter>
     </ClInclude>
     <ClInclude Include="ModuleParticleSystem.h">
       <Filter>ParticleSystem</Filter>
@@ -1203,12 +1220,18 @@
     </ClInclude>
     <ClInclude Include="ParticleModule.h">
       <Filter>ParticleSystem</Filter>
-    </ClInclude>
+    <ClInclude Include="DeviceType.h" />
+    <ClInclude Include="ICommand.h" />
+    <ClInclude Include="KeyCode.h" />
+    <ClInclude Include="PlayerBinding.h" />
+    <ClInclude Include="AnimationComponent.h">
+      <Filter>Animations</Filter>
     <ClInclude Include="EmitterColor.h">
       <Filter>ParticleSystem\Properties</Filter>
     </ClInclude>
     <ClInclude Include="EmitterVelocity.h">
       <Filter>ParticleSystem\Properties</Filter>
+      <Filter>Animations</Filter>
     </ClInclude>
     <ClInclude Include="Transform.h">
       <Filter>GameEntity\Components</Filter>
@@ -1227,7 +1250,8 @@
     </ClInclude>
     <ClInclude Include="PrefabEditSession.h">
       <Filter>Prefabs</Filter>
-    </ClInclude>
+    <ClInclude Include="CommandAddChildToPrefabRoot.h">
+      <Filter>Core\Commands</Filter>
     <ClInclude Include="PrefabUI.h">
       <Filter>Prefabs</Filter>
     </ClInclude>
@@ -1236,15 +1260,21 @@
     </ClInclude>
     <ClInclude Include="WwiseEvent.h">
       <Filter>MusicSystem\Wwise</Filter>
+      <Filter>Core\Commands</Filter>
     </ClInclude>
     <ClInclude Include="SoundReference.h">
       <Filter>MusicSystem</Filter>
     </ClInclude>
     <ClInclude Include="ModuleMusic.h">
       <Filter>MusicSystem</Filter>
+    <ClInclude Include="CommandCreateDataContainer.h">
+      <Filter>Core\Commands</Filter>
     </ClInclude>
+    <ClInclude Include="CommandCutItem.h">
+      <Filter>Core\Commands</Filter>
     <ClInclude Include="WwiseManager.h">
       <Filter>MusicSystem\Wwise</Filter>
+      <Filter>Core\Commands</Filter>
     </ClInclude>
     <ClInclude Include="WwiseBank.h">
       <Filter>MusicSystem\Wwise</Filter>
@@ -1299,9 +1329,14 @@
     </ClInclude>
     <ClInclude Include="SSAOGeometryPass.h">
       <Filter>D3D12\Rendering\Pass</Filter>
+    <ClInclude Include="WindowDataContainerManager.h">
+      <Filter>Editor\Views</Filter>
     </ClInclude>
+    <ClInclude Include="OptickProfiler.h">
+      <Filter>Editor\Views\Debugging</Filter>
     <ClInclude Include="SSAOPass.h">
       <Filter>D3D12\Rendering\Pass</Filter>
+      <Filter>Editor\Views\Debugging</Filter>
     </ClInclude>
     <ClInclude Include="SSAOSettings.h">
       <Filter>D3D12\Rendering\Pass</Filter>
@@ -1320,13 +1355,27 @@
     </ClInclude>
     <ClInclude Include="UISheet.h">
       <Filter>Persistence\Importers\External\UI</Filter>
+    <ClInclude Include="CanvasRenderMode.h" />
+    <ClInclude Include="FieldMacros.h">
+      <Filter>Core\Scripting</Filter>
     </ClInclude>
+    <ClInclude Include="FieldTypeTraits.h">
+      <Filter>Core\Scripting</Filter>
+    </ClInclude>
+    <ClInclude Include="FieldUtils.h">
+      <Filter>Core\Scripting</Filter>
     <ClInclude Include="TextureImportSettings.h">
       <Filter>Persistence\Importers\External</Filter>
+      <Filter>Core\Scripting</Filter>
+    <ClInclude Include="GenericTypeFactory.h">
+      <Filter>Core</Filter>
     </ClInclude>
+    <ClInclude Include="TriggerComponent.h">
+      <Filter>GameEntity\Components</Filter>
     <ClInclude Include="targetver.h" />
     <ClInclude Include="Application.h">
       <Filter>Core\Application</Filter>
+      <Filter>GameEntity\Components</Filter>
     </ClInclude>
     <ClInclude Include="CommandCreateGameObject.h">
       <Filter>Core\Commands</Filter>
@@ -1375,9 +1424,31 @@
     </ClInclude>
     <ClInclude Include="TrailComponent.h">
       <Filter>GameEntity\Components</Filter>
+    <ClInclude Include="EmitterArea.h">
+      <Filter>ParticleSystem\Properties</Filter>
+    </ClInclude>
+    <ClInclude Include="3rdParty\ImguiColorGradient\imgui_color_gradient.h" />
+    <ClInclude Include="3rdParty\ImGuiBezier\imgui_bezier.h" />
+    <ClInclude Include="EmitterSpawn.h">
+      <Filter>ParticleSystem\Properties</Filter>
+    </ClInclude>
+    <ClInclude Include="FieldHandler.h">
+      <Filter>Core\Scripting\FieldTypeHandler</Filter>
+    </ClInclude>
+    <ClInclude Include="FieldHandlerRegistry.h">
+      <Filter>Core\Scripting\FieldTypeHandler</Filter>
+    </ClInclude>
+    <ClInclude Include="ModuleHaptics.h">
+      <Filter>Haptics</Filter>
+    </ClInclude>
+    <ClInclude Include="HapticEffectDefinition.h">
+      <Filter>Haptics</Filter>
     </ClInclude>
+    <ClInclude Include="HapticEffectLibrary.h">
+      <Filter>Haptics</Filter>
     <ClInclude Include="GamePad.h">
       <Filter>Inputs\GamePad</Filter>
+      <Filter>Haptics</Filter>
     </ClInclude>
     <ClInclude Include="GeometryPass.h">
       <Filter>D3D12\Rendering\Pass</Filter>
@@ -1390,12 +1461,14 @@
     </ClInclude>
     <ClInclude Include="LightingPass.h">
       <Filter>D3D12\Rendering\Pass</Filter>
-    </ClInclude>
+    <ClInclude Include="AssetReference.h">
+      <Filter>Persistence\Assets</Filter>
     <ClInclude Include="3rdParty\ImGuizmo\ImGuizmo.h">
       <Filter>Editor\imgui</Filter>
     </ClInclude>
     <ClInclude Include="3rdParty\imgui-docking\imgui.h">
       <Filter>Editor\imgui</Filter>
+      <Filter>Persistence\Assets</Filter>
     </ClInclude>
     <ClInclude Include="3rdParty\imgui-docking\backends\imgui_impl_dx12.h">
       <Filter>Editor\imgui</Filter>
diff --git a/Engine_Master_UPC/EngineAPI.cpp b/Engine_Master_UPC/EngineAPI.cpp
index b31ffe47..328cb063 100644
--- a/Engine_Master_UPC/EngineAPI.cpp
+++ b/Engine_Master_UPC/EngineAPI.cpp
@@ -15,7 +15,7 @@
 
 #include "Scene.h"
 #include "Keyboard.h"
-#include "ScriptFactory.h"
+#include "GenericTypeFactory.h"
 
 #include "GameObject.h"
 #include "Transform.h"
@@ -47,9 +47,14 @@
 
 #include <DetourNavMeshQuery.h>
 
-void registerScript(const char* scriptName, ScriptCreator creator)
+void registerScript(const char* scriptName, ScriptFactory::Creator creator)
 {
-    ScriptFactory::registerScript(scriptName, creator);
+	ScriptFactory::registerType(scriptName, scriptName, creator);
+}
+
+void registerDataContainer(const char* name, const char* displayName, DataContainerFactory::Creator creator)
+{
+	DataContainerFactory::registerType(name, displayName, creator);
 }
 
 namespace GameObjectAPI
diff --git a/Engine_Master_UPC/EngineAPI.h b/Engine_Master_UPC/EngineAPI.h
index 780a5302..548db459 100644
--- a/Engine_Master_UPC/EngineAPI.h
+++ b/Engine_Master_UPC/EngineAPI.h
@@ -6,8 +6,8 @@
 #define ENGINE_API __declspec(dllimport)
 #endif
 
+#include "GenericTypeFactory.h"
 #include "AssetReference.h"
-#include "ScriptCreator.h"
 #include "ComponentType.h"
 #include "Tag.h"
 #include "SimpleMath.h"
@@ -17,6 +17,7 @@
 
 using DirectX::SimpleMath::Vector3;
 using DirectX::SimpleMath::Vector2;
+using DirectX::SimpleMath::Matrix;
 
 class GameObject;
 class Transform;
@@ -42,7 +43,8 @@ enum class QuadtreeTarget : uint8_t
     Both = Dynamic | Static
 };
 
-ENGINE_API void registerScript(const char* scriptName, ScriptCreator creator);
+ENGINE_API void registerScript(const char* scriptName, ScriptFactory::Creator creator);
+ENGINE_API void registerDataContainer(const char* name, const char* displayName, DataContainerFactory::Creator creator);
 
 namespace GameObjectAPI 
 {
diff --git a/Engine_Master_UPC/Extensions.h b/Engine_Master_UPC/Extensions.h
index a7db9628..81253ec0 100644
--- a/Engine_Master_UPC/Extensions.h
+++ b/Engine_Master_UPC/Extensions.h
@@ -7,6 +7,7 @@ constexpr const char* ANIMATION_EXTENSION = ".anim";
 constexpr const char* ANIMATION_STATE_MACHINE_EXTENSION = ".statemachine";
 constexpr const char* SCENE_EXTENSION = ".scene";
 constexpr const char* NAVMESH_EXTENSION = ".navmesh";
+constexpr const char* DATA_CONTAINER_EXTENSION = ".datacontainer";
 
 constexpr const char* PNG_EXTENSION = ".png";
 constexpr const char* JPG_EXTENSION = ".jpg";
diff --git a/Engine_Master_UPC/FieldHandler.h b/Engine_Master_UPC/FieldHandler.h
new file mode 100644
index 00000000..1d4b6690
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler.h
@@ -0,0 +1,15 @@
+#pragma once
+
+class IArchive;
+class IFieldContainer;
+class SceneReferenceResolver;
+
+struct FieldInfo;
+
+struct FieldHandler
+{
+    void (*drawUi)(const FieldInfo& field, void* data, IFieldContainer& container);
+    void (*serialize)(const FieldInfo& field, void* data, IArchive& archive);
+    void (*clone)(const FieldInfo& field, const void* sourceData, void* targetData);
+    void (*fixReferences)(const FieldInfo& field, void* data, const SceneReferenceResolver& resolver);
+};
diff --git a/Engine_Master_UPC/FieldHandlerRegistry.h b/Engine_Master_UPC/FieldHandlerRegistry.h
new file mode 100644
index 00000000..a3527561
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandlerRegistry.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "FieldInfo.h"
+#include "EngineAPI.h"
+
+struct FieldHandler;
+
+ENGINE_API const FieldHandler* getFloatFieldHandler();
+ENGINE_API const FieldHandler* getIntFieldHandler();
+ENGINE_API const FieldHandler* getBoolFieldHandler();
+ENGINE_API const FieldHandler* getVec3FieldHandler();
+ENGINE_API const FieldHandler* getEnumIntFieldHandler();
+ENGINE_API const FieldHandler* getComponentRefFieldHandler();
+ENGINE_API const FieldHandler* getComponentRefListFieldHandler();
+ENGINE_API const FieldHandler* getStringFieldHandler();
+ENGINE_API const FieldHandler* getListFieldHandler(FieldType elementType);
+
+ENGINE_API const FieldHandler* getGroupLabelFieldHandler();
+ENGINE_API const FieldHandler* getAssetRefFieldHandler();
diff --git a/Engine_Master_UPC/FieldHandler_AssetRef.cpp b/Engine_Master_UPC/FieldHandler_AssetRef.cpp
new file mode 100644
index 00000000..49f6e4bb
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_AssetRef.cpp
@@ -0,0 +1,186 @@
+#include "Globals.h"
+
+#include "FieldInfo.h"
+#include "FieldHandler.h"
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "AssetRef.h"
+#include "AssetReference.h"
+#include "AssetType.h"
+
+#include "Application.h"
+#include "ModuleAssets.h"
+#include "AssetIndex.h"
+#include "DataContainer.h"
+
+namespace
+{
+    void drawAssetRefFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        AssetRef<void>* assetRef = reinterpret_cast<AssetRef<void>*>(data);
+
+        const bool hasAsset = assetRef->m_ref.isValid();
+        const char* displayName = field.name;
+
+        ImGui::Text("%s", displayName);
+        ImGui::SameLine();
+
+        if (hasAsset)
+        {
+            ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "Assigned (UID %llu)", assetRef->m_ref.m_uid);
+        }
+        else
+        {
+            ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "None");
+        }
+
+        if (ImGui::BeginDragDropTarget())
+        {
+            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("ASSET"))
+            {
+                const UID droppedUID = *static_cast<const UID*>(payload->Data);
+                AssetReference* resolved = app->getModuleAssets()->findReference(droppedUID);
+                if (resolved)
+                {
+                    assetRef->m_ref = *resolved;
+                    if (resolved->m_type == AssetType::DATA_CONTAINER)
+                    {
+                        assetRef->m_data = app->getModuleAssets()->load<DataContainer>(*resolved);
+                    }
+                    container.onFieldEdited(field);
+                    delete resolved;
+                }
+            }
+
+            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("PREFAB_ASSET"))
+            {
+                const std::string pathStr(static_cast<const char*>(payload->Data));
+                const UID uid = app->getModuleAssets()->getIndex().findUID(std::filesystem::path(pathStr));
+                AssetReference* resolved = app->getModuleAssets()->findReference(uid);
+                if (resolved)
+                {
+                    assetRef->m_ref = *resolved;
+                    container.onFieldEdited(field);
+                    delete resolved;
+                }
+            }
+
+            ImGui::EndDragDropTarget();
+        }
+
+        ImGui::SameLine();
+
+        std::string clearLabel = std::string("Clear###") + field.name;
+        if (ImGui::Button(clearLabel.c_str()))
+        {
+            assetRef->m_ref = AssetReference();
+            assetRef->m_data = nullptr;
+            container.onFieldEdited(field);
+        }
+
+        if (assetRef->m_data != nullptr)
+        {
+            auto* dc = static_cast<DataContainer*>(assetRef->m_data.get());
+            ImGui::Text("%s", dc->getDisplayTypeName());
+
+            FieldList dcFields = dc->getExposedFields();
+            if (!dcFields.fields.empty())
+            {
+                ImGui::Spacing();
+
+                std::string headerId = std::string(field.name) + " Settings###" + field.name + "_Settings";
+                if (ImGui::CollapsingHeader(headerId.c_str(), ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    ImGui::Indent();
+
+                    char* dcBase = reinterpret_cast<char*>(dc);
+                    bool currentGroupOpen = true;
+
+                    for (const FieldInfo& dcField : dcFields.fields)
+                    {
+                        if (dcField.type == FieldType::GroupCollapseBegin)
+                        {
+                            ImGui::Spacing();
+                            currentGroupOpen = ImGui::CollapsingHeader(dcField.name, ImGuiTreeNodeFlags_DefaultOpen);
+                            continue;
+                        }
+
+                        if (dcField.type == FieldType::GroupCollapseEnd)
+                        {
+                            currentGroupOpen = true;
+                            continue;
+                        }
+
+                        if (!currentGroupOpen)
+                            continue;
+
+                        void* dcData = dcBase + dcField.offset;
+                        assert(dcField.handler != nullptr);
+                        dcField.handler->drawUi(dcField, dcData, container);
+                    }
+
+                    ImGui::Spacing();
+                    if (ImGui::Button("Save"))
+                    {
+                        app->getModuleAssets()->save(*dc);
+                    }
+
+                    ImGui::Unindent();
+                }
+            }
+        }
+    }
+
+    void serializeAssetRefField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        AssetRef<void>* ref = reinterpret_cast<AssetRef<void>*>(data);
+        uint64_t uid = static_cast<uint64_t>(ref->m_ref.m_uid);
+        archive.serialize(uid, field.name);
+        ref->m_ref.m_uid = static_cast<UID>(uid);
+
+        uint32_t type = static_cast<uint32_t>(ref->m_ref.m_type);
+        std::string typeKey = std::string(field.name) + "_type";
+        archive.serializeStringEnum(type, typeKey.c_str(), AssetTypeToString, StringToAssetType);
+        ref->m_ref.m_type = static_cast<AssetType>(type);
+    }
+
+    void cloneAssetRefField(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        const AssetRef<void>* sourceRef = reinterpret_cast<const AssetRef<void>*>(sourceData);
+        AssetRef<void>* targetRef = reinterpret_cast<AssetRef<void>*>(targetData);
+        targetRef->m_ref = sourceRef->m_ref;
+        targetRef->m_data = sourceRef->m_data;
+    }
+
+    void fixReferencesAssetRefField(const FieldInfo&, void* data, const SceneReferenceResolver&)
+    {
+        AssetRef<void>* assetRef = reinterpret_cast<AssetRef<void>*>(data);
+
+        if (!assetRef->m_ref.isValid() && assetRef->m_ref.hasUID())
+        {
+            AssetReference* resolved = app->getModuleAssets()->findReference(assetRef->m_ref.m_uid);
+            if (resolved)
+            {
+                assetRef->m_ref = *resolved;
+                if (resolved->m_type == AssetType::DATA_CONTAINER)
+                {
+                    assetRef->m_data = app->getModuleAssets()->load<DataContainer>(*resolved);
+                }
+                delete resolved;
+            }
+        }
+    }
+
+    const FieldHandler assetRefFieldHandler = {
+        &drawAssetRefFieldUi,
+        &serializeAssetRefField,
+        &cloneAssetRefField,
+        &fixReferencesAssetRefField
+    };
+}
+
+const FieldHandler* getAssetRefFieldHandler()
+{
+    return &assetRefFieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldHandler_Bool.cpp b/Engine_Master_UPC/FieldHandler_Bool.cpp
new file mode 100644
index 00000000..39e48cf9
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_Bool.cpp
@@ -0,0 +1,40 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+
+namespace
+{
+    void drawBoolFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        bool* value = reinterpret_cast<bool*>(data);
+
+        if (ImGui::Checkbox(field.name, value))
+        {
+            container.onFieldEdited(field);
+        }
+    }
+
+    void serializeBoolField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        bool value = *reinterpret_cast<const bool*>(data);
+        archive.serialize(value, field.name);
+    }
+
+    void cloneBoolField(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        *reinterpret_cast<bool*>(targetData) = *reinterpret_cast<const bool*>(sourceData);
+    }
+
+    void fixReferencesBoolField(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler boolFieldHandler ={&drawBoolFieldUi, &serializeBoolField, &cloneBoolField, &fixReferencesBoolField};
+}
+
+const FieldHandler* getBoolFieldHandler()
+{
+    return &boolFieldHandler;
+}
diff --git a/Engine_Master_UPC/ScriptFieldHandler_ComponentRef.cpp b/Engine_Master_UPC/FieldHandler_ComponentRef.cpp
similarity index 65%
rename from Engine_Master_UPC/ScriptFieldHandler_ComponentRef.cpp
rename to Engine_Master_UPC/FieldHandler_ComponentRef.cpp
index 18a86c96..f20534ee 100644
--- a/Engine_Master_UPC/ScriptFieldHandler_ComponentRef.cpp
+++ b/Engine_Master_UPC/FieldHandler_ComponentRef.cpp
@@ -1,10 +1,11 @@
 #include "Globals.h"
 
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldHandler.h"
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "ScriptComponentRef.h"
+#include "FieldInfo.h"
+#include "FieldHandler.h"
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "ComponentRef.h"
 #include "SceneReferenceResolver.h"
 
 #include "Application.h"
@@ -15,9 +16,9 @@
 
 namespace
 {
-    void drawComponentRefFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
+    void drawComponentRefFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
     {
-        ScriptComponentRef<Component>* componentReference = reinterpret_cast<ScriptComponentRef<Component>*>(data);
+        ComponentRef<Component>* componentReference = reinterpret_cast<ComponentRef<Component>*>(data);
 
         Component* component = componentReference->component;
 
@@ -57,7 +58,7 @@ namespace
                     {
                         componentReference->uid = candidate->getID();
                         componentReference->component = candidate;
-                        script.onFieldEdited(field);
+                        container.onFieldEdited(field);
                     }
                 }
             }
@@ -72,31 +73,31 @@ namespace
         {
             componentReference->uid = 0;
             componentReference->component = nullptr;
-            script.onFieldEdited(field);
+            container.onFieldEdited(field);
         }
     }
 
-    void serializeComponentRefField(const ScriptFieldInfo& field, void* data, IArchive& archive)
+    void serializeComponentRefField(const FieldInfo& field, void* data, IArchive& archive)
     {
-        ScriptComponentRef<Component>* componentReference = reinterpret_cast<ScriptComponentRef<Component>*>(data);
+        ComponentRef<Component>* componentReference = reinterpret_cast<ComponentRef<Component>*>(data);
         archive.serialize(componentReference->uid, field.name);
         if (archive.mode() == ArchiveMode::Input)
             componentReference->component = nullptr;
     }
 
-    void cloneComponentRefField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
+    void cloneComponentRefField(const FieldInfo&, const void* sourceData, void* targetData)
     {
-        const ScriptComponentRef<Component>* sourceRef = reinterpret_cast<const ScriptComponentRef<Component>*>(sourceData);
+        const ComponentRef<Component>* sourceRef = reinterpret_cast<const ComponentRef<Component>*>(sourceData);
 
-        ScriptComponentRef<Component>* targetRef = reinterpret_cast<ScriptComponentRef<Component>*>(targetData);
+        ComponentRef<Component>* targetRef = reinterpret_cast<ComponentRef<Component>*>(targetData);
 
         targetRef->uid = sourceRef->uid;
         targetRef->component = nullptr;
     }
 
-    void fixReferencesComponentRefField(const ScriptFieldInfo& field, void* data, const SceneReferenceResolver& resolver)
+    void fixReferencesComponentRefField(const FieldInfo& field, void* data, const SceneReferenceResolver& resolver)
     {
-        ScriptComponentRef<Component>* componentReference = reinterpret_cast<ScriptComponentRef<Component>*>(data);
+        ComponentRef<Component>* componentReference = reinterpret_cast<ComponentRef<Component>*>(data);
 
         componentReference->component = nullptr;
 
@@ -117,10 +118,10 @@ namespace
         }
     }
 
-    const ScriptFieldHandler componentRefFieldHandler = { &drawComponentRefFieldUi, &serializeComponentRefField, &cloneComponentRefField, &fixReferencesComponentRefField};
+    const FieldHandler componentRefFieldHandler = { &drawComponentRefFieldUi, &serializeComponentRefField, &cloneComponentRefField, &fixReferencesComponentRefField};
 }
 
-const ScriptFieldHandler* getComponentRefFieldHandler()
+const FieldHandler* getComponentRefFieldHandler()
 {
     return &componentRefFieldHandler;
-}
\ No newline at end of file
+}
diff --git a/Engine_Master_UPC/ScriptFieldHandler_ComponentRefList.cpp b/Engine_Master_UPC/FieldHandler_ComponentRefList.cpp
similarity index 77%
rename from Engine_Master_UPC/ScriptFieldHandler_ComponentRefList.cpp
rename to Engine_Master_UPC/FieldHandler_ComponentRefList.cpp
index e8643d0d..672a483a 100644
--- a/Engine_Master_UPC/ScriptFieldHandler_ComponentRefList.cpp
+++ b/Engine_Master_UPC/FieldHandler_ComponentRefList.cpp
@@ -1,8 +1,9 @@
 #include "Globals.h"
 
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "ScriptComponentRef.h"
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "ComponentRef.h"
 #include "SceneReferenceResolver.h"
 
 #include "Application.h"
@@ -13,9 +14,9 @@
 
 namespace
 {
-    void drawComponentRefListFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
+    void drawComponentRefListFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
     {
-        ScriptComponentRefList* componentList = reinterpret_cast<ScriptComponentRefList*>(data);
+        ComponentRefList* componentList = reinterpret_cast<ComponentRefList*>(data);
 
         const float lineHeight = ImGui::GetTextLineHeightWithSpacing();
         const ImVec2 avail = ImGui::GetContentRegionAvail();
@@ -35,7 +36,7 @@ namespace
 
             for (size_t index = 0; index < componentList->size(); ++index)
             {
-                ScriptComponentRef<Component>& entry = (*componentList)[index];
+                ComponentRef<Component>& entry = (*componentList)[index];
                 Component* component = entry.component;
 
                 ImGui::PushID(static_cast<int>(index));
@@ -86,7 +87,7 @@ namespace
             if (removeIndex >= 0)
             {
                 componentList->erase(componentList->begin() + removeIndex);
-                script.onFieldEdited(field);
+                container.onFieldEdited(field);
             }
         }
         ImGui::EndChild();
@@ -97,7 +98,7 @@ namespace
             if (!componentList->empty())
             {
                 componentList->clear();
-                script.onFieldEdited(field);
+                container.onFieldEdited(field);
             }
         }
 
@@ -134,12 +135,12 @@ namespace
 
                         if (candidate != nullptr)
                         {
-                            ScriptComponentRef<Component> newEntry;
+                            ComponentRef<Component> newEntry;
                             newEntry.uid = candidate->getID();
                             newEntry.component = candidate;
 
                             componentList->push_back(newEntry);
-                            script.onFieldEdited(field);
+                            container.onFieldEdited(field);
                         }
                     }
                 }
@@ -150,9 +151,9 @@ namespace
         ImGui::EndChild();
     }
 
-    void serializeComponentRefListField(const ScriptFieldInfo& field, void* data, IArchive& archive)
+    void serializeComponentRefListField(const FieldInfo& field, void* data, IArchive& archive)
     {
-        ScriptComponentRefList* componentList = reinterpret_cast<ScriptComponentRefList*>(data);
+        ComponentRefList* componentList = reinterpret_cast<ComponentRefList*>(data);
         uint32_t count = archive.mode() == ArchiveMode::Output ? static_cast<uint32_t>(componentList->size()) : 0;
         archive.beginArray(count, field.name);
 
@@ -171,7 +172,7 @@ namespace
             }
             else
             {
-                ScriptComponentRef<Component> entry;
+                ComponentRef<Component> entry;
                 archive.serialize(entry.uid, "");
                 entry.component = nullptr;
                 componentList->push_back(std::move(entry));
@@ -181,28 +182,28 @@ namespace
         archive.endArray();
     }
 
-    void cloneComponentRefListField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
+    void cloneComponentRefListField(const FieldInfo&, const void* sourceData, void* targetData)
     {
-        const ScriptComponentRefList* sourceList = reinterpret_cast<const ScriptComponentRefList*>(sourceData);
-        ScriptComponentRefList* targetList = reinterpret_cast<ScriptComponentRefList*>(targetData);
+        const ComponentRefList* sourceList = reinterpret_cast<const ComponentRefList*>(sourceData);
+        ComponentRefList* targetList = reinterpret_cast<ComponentRefList*>(targetData);
 
         targetList->clear();
         targetList->reserve(sourceList->size());
 
-        for (const ScriptComponentRef<Component>& sourceEntry : *sourceList)
+        for (const ComponentRef<Component>& sourceEntry : *sourceList)
         {
-            ScriptComponentRef<Component> targetEntry;
+            ComponentRef<Component> targetEntry;
             targetEntry.uid = sourceEntry.uid;
             targetEntry.component = nullptr;
             targetList->push_back(targetEntry);
         }
     }
 
-    void fixReferencesComponentRefListField(const ScriptFieldInfo& field, void* data, const SceneReferenceResolver& resolver)
+    void fixReferencesComponentRefListField(const FieldInfo& field, void* data, const SceneReferenceResolver& resolver)
     {
-        ScriptComponentRefList* componentList = reinterpret_cast<ScriptComponentRefList*>(data);
+        ComponentRefList* componentList = reinterpret_cast<ComponentRefList*>(data);
 
-        for (ScriptComponentRef<Component>& entry : *componentList)
+        for (ComponentRef<Component>& entry : *componentList)
         {
             entry.component = nullptr;
 
@@ -224,10 +225,10 @@ namespace
         }
     }
 
-    const ScriptFieldHandler componentRefListFieldHandler = {&drawComponentRefListFieldUi, &serializeComponentRefListField, &cloneComponentRefListField, &fixReferencesComponentRefListField};
+    const FieldHandler componentRefListFieldHandler = {&drawComponentRefListFieldUi, &serializeComponentRefListField, &cloneComponentRefListField, &fixReferencesComponentRefListField};
 }
 
-const ScriptFieldHandler* getComponentRefListFieldHandler()
+const FieldHandler* getComponentRefListFieldHandler()
 {
     return &componentRefListFieldHandler;
-}
\ No newline at end of file
+}
diff --git a/Engine_Master_UPC/ScriptFieldHandler_EnumInt.cpp b/Engine_Master_UPC/FieldHandler_EnumInt.cpp
similarity index 50%
rename from Engine_Master_UPC/ScriptFieldHandler_EnumInt.cpp
rename to Engine_Master_UPC/FieldHandler_EnumInt.cpp
index 795bf2ad..32da8196 100644
--- a/Engine_Master_UPC/ScriptFieldHandler_EnumInt.cpp
+++ b/Engine_Master_UPC/FieldHandler_EnumInt.cpp
@@ -1,12 +1,12 @@
 #include "Globals.h"
 
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
+#include "FieldHandlerRegistry.h"
 #include "IArchive.h"
+#include "IFieldContainer.h"
 
 namespace
 {
-    void drawEnumIntFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
+    void drawEnumIntFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
     {
         int* value = reinterpret_cast<int*>(data);
 
@@ -24,7 +24,7 @@ namespace
                 if (ImGui::Selectable(field.enumInfo.names[enumIndex], selected))
                 {
                     *value = enumIndex;
-                    script.onFieldEdited(field);
+                    container.onFieldEdited(field);
                 }
 
                 if (selected)
@@ -36,28 +36,31 @@ namespace
         }
     }
 
-    void serializeEnumIntField(const ScriptFieldInfo& field, void* data, IArchive& archive)
+    void serializeEnumIntField(const FieldInfo& field, void* data, IArchive& archive)
     {
-        int* value = reinterpret_cast<int*>(data);
-        uint32_t v = static_cast<uint32_t>(*value);
-        archive.serialize(v, field.name);
-        if (archive.mode() == ArchiveMode::Input)
-            *value = static_cast<int>(v);
+        uint32_t value = static_cast<uint32_t>(*reinterpret_cast<const int*>(data));
+        archive.serialize(value, field.name);
     }
 
-    void cloneEnumIntField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
+    void deserializeEnumIntField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        uint32_t raw = *reinterpret_cast<uint32_t*>(data);
+        archive.serialize(raw, field.name);
+    }
+
+    void cloneEnumIntField(const FieldInfo&, const void* sourceData, void* targetData)
     {
         *reinterpret_cast<int*>(targetData) = *reinterpret_cast<const int*>(sourceData);
     }
 
-    void fixReferencesEnumIntField(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
+    void fixReferencesEnumIntField(const FieldInfo&, void*, const SceneReferenceResolver&)
     {
     }
 
-    const ScriptFieldHandler enumIntFieldHandler = {&drawEnumIntFieldUi, &serializeEnumIntField, &cloneEnumIntField, &fixReferencesEnumIntField};
+    const FieldHandler enumIntFieldHandler = {&drawEnumIntFieldUi, &serializeEnumIntField, &cloneEnumIntField, &fixReferencesEnumIntField};
 }
 
-const ScriptFieldHandler* getEnumIntFieldHandler()
+const FieldHandler* getEnumIntFieldHandler()
 {
     return &enumIntFieldHandler;
-}
\ No newline at end of file
+}
diff --git a/Engine_Master_UPC/FieldHandler_Float.cpp b/Engine_Master_UPC/FieldHandler_Float.cpp
new file mode 100644
index 00000000..9a557c5d
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_Float.cpp
@@ -0,0 +1,48 @@
+#include "Globals.h"
+
+#include "FieldInfo.h"
+#include "FieldHandler.h"
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "SceneReferenceResolver.h"
+
+namespace
+{
+    void drawFloatFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        float* value = reinterpret_cast<float*>(data);
+
+        if (ImGui::DragFloat(field.name, value, field.floatInfo.dragSpeed, field.floatInfo.min, field.floatInfo.max))
+        {
+            container.onFieldEdited(field);
+        }
+    }
+
+    void serializeFloatField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        float value = *reinterpret_cast<const float*>(data);
+        archive.serialize(value, field.name);
+    }
+
+    void deserializeFloatField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        archive.serialize(*reinterpret_cast<float*>(data), field.name);
+    }
+
+    void cloneFloatField(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        *reinterpret_cast<float*>(targetData) = *reinterpret_cast<const float*>(sourceData);
+    }
+
+    void fixReferencesFloatField(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler floatFieldHandler = { &drawFloatFieldUi, &serializeFloatField, &cloneFloatField, &fixReferencesFloatField};
+}
+
+const FieldHandler* getFloatFieldHandler()
+{
+    return &floatFieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldHandler_GroupLabel.cpp b/Engine_Master_UPC/FieldHandler_GroupLabel.cpp
new file mode 100644
index 00000000..a37e2b34
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_GroupLabel.cpp
@@ -0,0 +1,37 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+
+namespace
+{
+    void drawGroupLabelUi(const FieldInfo& field, void*, IFieldContainer&)
+    {
+        ImGui::Spacing();
+        ImGui::SeparatorText(field.name);
+    }
+
+    void serializeGroupLabel(const FieldInfo&, void*, IArchive&)
+    {
+    }
+
+    void deserializeGroupLabel(const FieldInfo&, void*, IArchive&)
+    {
+    }
+
+    void cloneGroupLabel(const FieldInfo&, const void*, void*)
+    {
+    }
+
+    void fixReferencesGroupLabel(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler groupLabelFieldHandler = {&drawGroupLabelUi, &serializeGroupLabel, &cloneGroupLabel, &fixReferencesGroupLabel};
+}
+
+const FieldHandler* getGroupLabelFieldHandler()
+{
+    return &groupLabelFieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldHandler_Int.cpp b/Engine_Master_UPC/FieldHandler_Int.cpp
new file mode 100644
index 00000000..89e19f17
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_Int.cpp
@@ -0,0 +1,46 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+
+namespace
+{
+    void drawIntFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        int* value = reinterpret_cast<int*>(data);
+
+        if (ImGui::DragInt(field.name, value))
+        {
+            container.onFieldEdited(field);
+        }
+    }
+
+    void serializeIntField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        uint32_t value = static_cast<uint32_t>(*reinterpret_cast<const int*>(data));
+        archive.serialize(value, field.name);
+    }
+
+    void deserializeIntField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        uint32_t raw = *reinterpret_cast<uint32_t*>(data);
+        archive.serialize(raw, field.name);
+    }
+
+    void cloneIntField(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        *reinterpret_cast<int*>(targetData) = *reinterpret_cast<const int*>(sourceData);
+    }
+
+    void fixReferencesIntField(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler intFieldHandler = {&drawIntFieldUi, &serializeIntField, &cloneIntField, &fixReferencesIntField};
+}
+
+const FieldHandler* getIntFieldHandler()
+{
+    return &intFieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldHandler_List.cpp b/Engine_Master_UPC/FieldHandler_List.cpp
new file mode 100644
index 00000000..a34cc8ae
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_List.cpp
@@ -0,0 +1,305 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "ComponentRef.h"
+#include "SceneReferenceResolver.h"
+
+#include "Application.h"
+#include "ModuleScene.h"
+#include "Scene.h"
+#include "GameObject.h"
+#include "Transform.h"
+
+namespace
+{
+    // --- Element-to-archive / archive-to-Element helpers ---
+
+    template<typename T>
+    void elementSerialize(const T& element, IArchive& archive);
+
+    template<>
+    void elementSerialize<float>(const float& element, IArchive& archive)
+    {
+        float val = element;
+        archive.serialize(val);
+    }
+
+    template<>
+    void elementSerialize<int>(const int& element, IArchive& archive)
+    {
+        uint32_t val = static_cast<uint32_t>(element);
+        archive.serialize(val);
+    }
+
+    template<>
+    void elementSerialize<bool>(const bool& element, IArchive& archive)
+    {
+        bool val = element;
+        archive.serialize(val);
+    }
+
+    template<>
+    void elementSerialize<Vector3>(const Vector3& element, IArchive& archive)
+    {
+        Vector3 val = element;
+        archive.serialize(val);
+    }
+
+    template<>
+    void elementSerialize<std::string>(const std::string& element, IArchive& archive)
+    {
+        std::string val = element;
+        archive.serialize(val);
+    }
+
+    template<>
+    void elementSerialize<ComponentRef<Component>>(const ComponentRef<Component>& element, IArchive& archive)
+    {
+        uint64_t val = static_cast<uint64_t>(element.uid);
+        archive.serialize(val);
+    }
+
+    template<typename T>
+    void elementDeserialize(T& element, IArchive& archive);
+
+    template<>
+    void elementDeserialize<float>(float& element, IArchive& archive)
+    {
+        archive.serialize(element);
+    }
+
+    template<>
+    void elementDeserialize<int>(int& element, IArchive& archive)
+    {
+        uint32_t raw = static_cast<uint32_t>(element);
+        archive.serialize(raw);
+    }
+
+    template<>
+    void elementDeserialize<bool>(bool& element, IArchive& archive)
+    {
+        archive.serialize(element);
+    }
+
+    template<>
+    void elementDeserialize<Vector3>(Vector3& element, IArchive& archive)
+    {
+        archive.serialize(element);
+    }
+
+    template<>
+    void elementDeserialize<std::string>(std::string& element, IArchive& archive)
+    {
+        archive.serialize(element);
+    }
+
+    template<>
+    void elementDeserialize<ComponentRef<Component>>(ComponentRef<Component>& element, IArchive& archive)
+    {
+        uint64_t val = static_cast<uint64_t>(element.uid);
+        archive.serialize(val);
+        element.uid = static_cast<UID>(val);
+        element.component = nullptr;
+    }
+
+    // --- Generic list handler templates ---
+
+    template<typename T>
+    void drawListFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        auto* vec = reinterpret_cast<std::vector<T>*>(data);
+        const FieldHandler* elemHandler = field.listInfo.elementHandler;
+
+        std::string headerLabel = std::string(field.name) + " (" + std::to_string(vec->size()) + ")";
+        ImGui::Text("%s", headerLabel.c_str());
+
+        int removeIndex = -1;
+
+        for (size_t i = 0; i < vec->size(); ++i)
+        {
+            ImGui::PushID(static_cast<int>(i));
+
+            char elementLabel[64];
+            snprintf(elementLabel, sizeof(elementLabel), "[%zu]", i);
+
+            FieldInfo elementField = field;
+            elementField.name = elementLabel;
+            elementField.type = field.listInfo.elementType;
+            elementField.handler = elemHandler;
+
+            T elemCopy = (*vec)[i];
+            elemHandler->drawUi(elementField, &elemCopy, container);
+            (*vec)[i] = elemCopy;
+
+            ImGui::SameLine();
+
+            if (ImGui::Button("X"))
+            {
+                removeIndex = static_cast<int>(i);
+            }
+
+            ImGui::PopID();
+        }
+
+        if (removeIndex >= 0)
+        {
+            vec->erase(vec->begin() + removeIndex);
+            container.onFieldEdited(field);
+        }
+
+        std::string addLabel = std::string("+ Add Element##") + field.name;
+        if (ImGui::Button(addLabel.c_str()))
+        {
+            vec->push_back(T{});
+            container.onFieldEdited(field);
+        }
+
+        ImGui::SameLine();
+
+        std::string clearLabel = std::string("Clear All##") + field.name;
+        if (ImGui::Button(clearLabel.c_str()))
+        {
+            if (!vec->empty())
+            {
+                vec->clear();
+                container.onFieldEdited(field);
+            }
+        }
+    }
+
+    template<typename T>
+    void serializeListField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        const auto* vec = reinterpret_cast<const std::vector<T>*>(data);
+
+        uint32_t count = static_cast<uint32_t>(vec->size());
+        archive.beginArray(count, field.name);
+
+        for (const T& elem : *vec)
+        {
+            elementSerialize(elem, archive);
+        }
+
+        archive.endArray();
+    }
+
+    template<typename T>
+    void deserializeListField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        auto* vec = reinterpret_cast<std::vector<T>*>(data);
+        vec->clear();
+
+        uint32_t count = 0;
+        archive.beginArray(count, field.name);
+        vec->reserve(count);
+
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            T elem{};
+            elementDeserialize(elem, archive);
+            vec->push_back(std::move(elem));
+        }
+
+        archive.endArray();
+    }
+
+    template<typename T>
+    void cloneListField(const FieldInfo& field, const void* sourceData, void* targetData)
+    {
+        const auto* sourceVec = reinterpret_cast<const std::vector<T>*>(sourceData);
+        auto* targetVec = reinterpret_cast<std::vector<T>*>(targetData);
+        const FieldHandler* elemHandler = field.listInfo.elementHandler;
+
+        targetVec->clear();
+        targetVec->reserve(sourceVec->size());
+
+        for (const T& sourceElem : *sourceVec)
+        {
+            T targetElem;
+            elemHandler->clone(field, &sourceElem, &targetElem);
+            targetVec->push_back(std::move(targetElem));
+        }
+    }
+
+    template<typename T>
+    void fixReferencesListField(const FieldInfo& field, void* data, const SceneReferenceResolver& resolver)
+    {
+        auto* vec = reinterpret_cast<std::vector<T>*>(data);
+        const FieldHandler* elemHandler = field.listInfo.elementHandler;
+
+        for (size_t i = 0; i < vec->size(); ++i)
+        {
+            T elemCopy = (*vec)[i];
+            elemHandler->fixReferences(field, &elemCopy, resolver);
+            (*vec)[i] = elemCopy;
+        }
+    }
+
+    // --- Template instantiations for each supported element type ---
+
+    const FieldHandler floatListHandler = {
+        &drawListFieldUi<float>,
+        &serializeListField<float>,
+        &cloneListField<float>,
+        &fixReferencesListField<float>
+    };
+
+    const FieldHandler intListHandler = {
+        &drawListFieldUi<int>,
+        &serializeListField<int>,
+        &cloneListField<int>,
+        &fixReferencesListField<int>
+    };
+
+    const FieldHandler boolListHandler = {
+        &drawListFieldUi<bool>,
+        &serializeListField<bool>,
+        &cloneListField<bool>,
+        &fixReferencesListField<bool>
+    };
+
+    const FieldHandler vec3ListHandler = {
+        &drawListFieldUi<Vector3>,
+        &serializeListField<Vector3>,
+        &cloneListField<Vector3>,
+        &fixReferencesListField<Vector3>
+    };
+
+    const FieldHandler stringListHandler = {
+        &drawListFieldUi<std::string>,
+        &serializeListField<std::string>,
+        &cloneListField<std::string>,
+        &fixReferencesListField<std::string>
+    };
+
+    const FieldHandler enumIntListHandler = {
+        &drawListFieldUi<int>,
+        &serializeListField<int>,
+        &cloneListField<int>,
+        &fixReferencesListField<int>
+    };
+
+    const FieldHandler componentRefListHandler = {
+        &drawListFieldUi<ComponentRef<Component>>,
+        &serializeListField<ComponentRef<Component>>,
+        &cloneListField<ComponentRef<Component>>,
+        &fixReferencesListField<ComponentRef<Component>>
+    };
+}
+
+const FieldHandler* getListFieldHandler(FieldType elementType)
+{
+    switch (elementType)
+    {
+        case FieldType::Float:        return &floatListHandler;
+        case FieldType::Int:          return &intListHandler;
+        case FieldType::Bool:         return &boolListHandler;
+        case FieldType::Vec3:         return &vec3ListHandler;
+        case FieldType::String:       return &stringListHandler;
+        case FieldType::EnumInt:      return &enumIntListHandler;
+        case FieldType::ComponentRef: return &componentRefListHandler;
+        default:                      return nullptr;
+    }
+}
diff --git a/Engine_Master_UPC/FieldHandler_String.cpp b/Engine_Master_UPC/FieldHandler_String.cpp
new file mode 100644
index 00000000..6233b931
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_String.cpp
@@ -0,0 +1,51 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+
+namespace
+{
+    void drawStringFieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        std::string* value = reinterpret_cast<std::string*>(data);
+
+        char buffer[256];
+        std::strncpy(buffer, value->c_str(), sizeof(buffer));
+        buffer[sizeof(buffer) - 1] = '\0';
+
+        if (ImGui::InputText(field.name, buffer, sizeof(buffer)))
+        {
+            *value = buffer;
+            container.onFieldEdited(field);
+        }
+    }
+
+    void serializeStringField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        const std::string* value = reinterpret_cast<const std::string*>(data);
+        std::string copy = *value;
+        archive.serialize(copy, field.name);
+    }
+
+    void deserializeStringField(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        archive.serialize(*reinterpret_cast<std::string*>(data), field.name);
+    }
+
+    void cloneStringField(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        *reinterpret_cast<std::string*>(targetData) = *reinterpret_cast<const std::string*>(sourceData);
+    }
+
+    void fixReferencesStringField(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler stringFieldHandler = {&drawStringFieldUi, &serializeStringField, &cloneStringField, &fixReferencesStringField};
+}
+
+const FieldHandler* getStringFieldHandler()
+{
+    return &stringFieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldHandler_Vec3.cpp b/Engine_Master_UPC/FieldHandler_Vec3.cpp
new file mode 100644
index 00000000..c1a9b329
--- /dev/null
+++ b/Engine_Master_UPC/FieldHandler_Vec3.cpp
@@ -0,0 +1,45 @@
+#include "Globals.h"
+
+#include "FieldHandlerRegistry.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+
+namespace
+{
+    void drawVec3FieldUi(const FieldInfo& field, void* data, IFieldContainer& container)
+    {
+        Vector3* value = reinterpret_cast<Vector3*>(data);
+
+        if (ImGui::DragFloat3(field.name, &value->x, 0.1f))
+        {
+            container.onFieldEdited(field);
+        }
+    }
+
+    void serializeVec3Field(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        Vector3 value = *reinterpret_cast<const Vector3*>(data);
+        archive.serialize(value, field.name);
+    }
+
+    void deserializeVec3Field(const FieldInfo& field, void* data, IArchive& archive)
+    {
+        archive.serialize(*reinterpret_cast<Vector3*>(data), field.name);
+    }
+
+    void cloneVec3Field(const FieldInfo&, const void* sourceData, void* targetData)
+    {
+        *reinterpret_cast<Vector3*>(targetData) = *reinterpret_cast<const Vector3*>(sourceData);
+    }
+
+    void fixReferencesVec3Field(const FieldInfo&, void*, const SceneReferenceResolver&)
+    {
+    }
+
+    const FieldHandler vec3FieldHandler = {&drawVec3FieldUi, &serializeVec3Field, &cloneVec3Field, &fixReferencesVec3Field};
+}
+
+const FieldHandler* getVec3FieldHandler()
+{
+    return &vec3FieldHandler;
+}
diff --git a/Engine_Master_UPC/FieldInfo.h b/Engine_Master_UPC/FieldInfo.h
new file mode 100644
index 00000000..fbd182d6
--- /dev/null
+++ b/Engine_Master_UPC/FieldInfo.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <vector>
+#include "ComponentType.h"
+#include "FieldHandler.h"
+
+enum class FieldType
+{
+    Float,
+    Int,
+    Bool,
+    Vec3,
+    EnumInt,
+    ComponentRef,
+    ComponentRefList,
+    String,
+    List,
+    GroupLabel,
+    GroupCollapseBegin,
+    GroupCollapseEnd,
+    AssetRef,
+};
+
+struct FieldFloatInfo
+{
+    float min = 0.0f;
+    float max = 0.0f;
+    float dragSpeed = 0.1f;
+};
+
+struct FieldEnumInfo
+{
+    const char** names = nullptr;
+    int count = 0;
+};
+
+struct FieldComponentRefInfo
+{
+    ComponentType componentType;
+};
+
+struct FieldListInfo
+{
+    FieldType elementType;
+    const FieldHandler* elementHandler;
+};
+
+
+struct FieldInfo
+{
+    const char* name;
+    FieldType type;
+    size_t offset;
+
+    const FieldHandler* handler = nullptr;
+
+    FieldFloatInfo floatInfo{};
+    FieldEnumInfo enumInfo{};
+    FieldComponentRefInfo componentRefInfo{ ComponentType::TRANSFORM };
+    FieldListInfo listInfo{ FieldType::Float, nullptr };
+
+    bool editorOnly = false;
+
+    bool isDataField() const
+    {
+        return !editorOnly;
+    }
+};
+
+struct FieldList
+{
+    std::vector<FieldInfo> fields;
+
+    FieldList() = default;
+
+    FieldList(const FieldInfo* fieldArray, size_t fieldCount)
+    {
+        append(fieldArray, fieldCount);
+    }
+
+    void append(const FieldInfo* fieldArray, size_t fieldCount)
+    {
+        fields.insert(fields.end(), fieldArray, fieldArray + fieldCount);
+    }
+};
diff --git a/Engine_Master_UPC/FieldMacros.h b/Engine_Master_UPC/FieldMacros.h
new file mode 100644
index 00000000..7957511c
--- /dev/null
+++ b/Engine_Master_UPC/FieldMacros.h
@@ -0,0 +1,135 @@
+#pragma once
+
+#include <cstddef>
+
+#include "FieldInfo.h"
+#include "FieldHandlerRegistry.h"
+#include "FieldTypeTraits.h"
+
+#define FIELD_COUNT(FieldArrayName) \
+    (sizeof(FieldArrayName) / sizeof(FieldInfo))
+
+
+#define IMPLEMENT_FIELDS(TypeName, ...)                                       \
+    FieldList TypeName::getExposedFields() const                              \
+    {                                                                         \
+        using ThisType = TypeName;                                            \
+        static const FieldInfo ownFields[] = { __VA_ARGS__ };                \
+        return FieldList(ownFields, FIELD_COUNT(ownFields));                  \
+    }
+
+
+#define IMPLEMENT_FIELDS_INHERITED(TypeName, BaseType, ...)                   \
+    FieldList TypeName::getExposedFields() const                              \
+    {                                                                         \
+        using ThisType = TypeName;                                            \
+        FieldList exposedFields = BaseType::getExposedFields();               \
+        static const FieldInfo ownFields[] = { __VA_ARGS__ };                \
+        exposedFields.append(ownFields, FIELD_COUNT(ownFields));              \
+        return exposedFields;                                                 \
+    }
+
+// Inline version — for placing inside the class body (header-only types like DataContainer)
+#define IMPLEMENT_FIELDS_INLINE(TypeName, ...)                                \
+    FieldList getExposedFields() const override                               \
+    {                                                                         \
+        using ThisType = TypeName;                                            \
+        static const FieldInfo ownFields[] = { __VA_ARGS__ };                \
+        return FieldList(ownFields, FIELD_COUNT(ownFields));                  \
+    }
+
+#define IMPLEMENT_FIELDS_INLINE_INHERITED(TypeName, BaseType, ...)            \
+    FieldList getExposedFields() const override                               \
+    {                                                                         \
+        using ThisType = TypeName;                                            \
+        FieldList fields = BaseType::getExposedFields();                      \
+        static const FieldInfo ownFields[] = { __VA_ARGS__ };                \
+        fields.append(ownFields, FIELD_COUNT(ownFields));                     \
+        return fields;                                                        \
+    }
+
+// Backward compatibility aliases
+#define IMPLEMENT_SCRIPT_FIELDS IMPLEMENT_FIELDS
+#define IMPLEMENT_SCRIPT_FIELDS_INHERITED IMPLEMENT_FIELDS_INHERITED
+#define IMPLEMENT_DATACONTAINER_FIELDS IMPLEMENT_FIELDS_INLINE
+#define IMPLEMENT_DATACONTAINER_FIELDS_INHERITED IMPLEMENT_FIELDS_INLINE_INHERITED
+#define SCRIPT_FIELD_COUNT FIELD_COUNT
+
+// Field helper macros
+
+#define SERIALIZED_FLOAT(MemberName, DisplayName, Min, Max, Speed) \
+    { DisplayName, FieldType::Float, offsetof(ThisType, MemberName), getFloatFieldHandler(), { Min, Max, Speed } }
+
+#define SERIALIZED_INT(MemberName, DisplayName) \
+    { DisplayName, FieldType::Int, offsetof(ThisType, MemberName), getIntFieldHandler() }
+
+#define SERIALIZED_BOOL(MemberName, DisplayName) \
+    { DisplayName, FieldType::Bool, offsetof(ThisType, MemberName), getBoolFieldHandler() }
+
+#define SERIALIZED_VEC3(MemberName, DisplayName) \
+    { DisplayName, FieldType::Vec3, offsetof(ThisType, MemberName), getVec3FieldHandler() }
+
+#define SERIALIZED_STRING(MemberName, DisplayName) \
+    { DisplayName, FieldType::String, offsetof(ThisType, MemberName), getStringFieldHandler() }
+
+#define SERIALIZED_ENUM_INT(MemberName, DisplayName, NamesArray, Count) \
+    { DisplayName, FieldType::EnumInt, offsetof(ThisType, MemberName), getEnumIntFieldHandler(), {}, { NamesArray, Count } }
+
+#define SERIALIZED_COMPONENT_REF(MemberName, DisplayName, ComponentTypeValue) \
+    { DisplayName, FieldType::ComponentRef, offsetof(ThisType, MemberName), getComponentRefFieldHandler(), {}, {}, { ComponentTypeValue } }
+
+#define SERIALIZED_ASSET_REF(MemberName, DisplayName, AssetTypeValue) \
+    { DisplayName, FieldType::AssetRef, offsetof(ThisType, MemberName), getAssetRefFieldHandler() }
+
+#define SERIALIZED_COMPONENT_REF_LIST(MemberName, DisplayName, ComponentTypeValue) \
+    { DisplayName, FieldType::ComponentRefList, offsetof(ThisType, MemberName), getComponentRefListFieldHandler(), {}, {}, { ComponentTypeValue } }
+
+// Vector (std::vector<T>) field macros
+
+// Generic -- auto-detects the element type at compile time
+#define SERIALIZED_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), \
+      getListFieldHandler(fieldTypeOf<typename decltype(ThisType::MemberName)::value_type>()), \
+      {}, {}, {}, \
+      { fieldTypeOf<typename decltype(ThisType::MemberName)::value_type>(), \
+        fieldHandlerOf<typename decltype(ThisType::MemberName)::value_type>() } }
+
+// Type-specific convenience macros (no auto-detection needed)
+
+#define SERIALIZED_FLOAT_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::Float), {}, {}, {}, { FieldType::Float, getFloatFieldHandler() } }
+
+#define SERIALIZED_INT_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::Int), {}, {}, {}, { FieldType::Int, getIntFieldHandler() } }
+
+#define SERIALIZED_BOOL_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::Bool), {}, {}, {}, { FieldType::Bool, getBoolFieldHandler() } }
+
+#define SERIALIZED_VEC3_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::Vec3), {}, {}, {}, { FieldType::Vec3, getVec3FieldHandler() } }
+
+#define SERIALIZED_STRING_VECTOR(MemberName, DisplayName) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::String), {}, {}, {}, { FieldType::String, getStringFieldHandler() } }
+
+#define SERIALIZED_ENUM_INT_VECTOR(MemberName, DisplayName, NamesArray, Count) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::EnumInt), {}, { NamesArray, Count }, {}, { FieldType::EnumInt, getEnumIntFieldHandler() } }
+
+#define SERIALIZED_COMPONENT_REF_VECTOR(MemberName, DisplayName, ComponentTypeValue) \
+    { DisplayName, FieldType::List, offsetof(ThisType, MemberName), getListFieldHandler(FieldType::ComponentRef), {}, {}, { ComponentTypeValue }, { FieldType::ComponentRef, getComponentRefFieldHandler() } }
+
+// Non serializable fields macros
+
+#define FIELD_GROUP_LABEL(DisplayName) \
+    { DisplayName, FieldType::GroupLabel, 0, getGroupLabelFieldHandler(), {}, {}, {}, {}, true }
+
+// These fields are internal, only meant to be used inside the FIELD_GROUP_COLLAPSE macro
+#define INTERNAL_FIELD_GROUP_COLLAPSE_BEGIN(DisplayName) \
+    { DisplayName, FieldType::GroupCollapseBegin, 0, nullptr, {}, {}, {}, {}, true }
+
+#define INTERNAL_FIELD_GROUP_COLLAPSE_END() \
+    { "", FieldType::GroupCollapseEnd, 0, nullptr, {}, {}, {}, {}, true }
+
+#define FIELD_GROUP_COLLAPSE(DisplayName, ...) \
+    INTERNAL_FIELD_GROUP_COLLAPSE_BEGIN(DisplayName), \
+    __VA_ARGS__, \
+    INTERNAL_FIELD_GROUP_COLLAPSE_END()
diff --git a/Engine_Master_UPC/ScriptFieldTypeTraits.h b/Engine_Master_UPC/FieldTypeTraits.h
similarity index 55%
rename from Engine_Master_UPC/ScriptFieldTypeTraits.h
rename to Engine_Master_UPC/FieldTypeTraits.h
index e39f4165..254d2b66 100644
--- a/Engine_Master_UPC/ScriptFieldTypeTraits.h
+++ b/Engine_Master_UPC/FieldTypeTraits.h
@@ -3,32 +3,39 @@
 #include <type_traits>
 #include <string>
 
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldHandlerRegistry.h"
+#include "FieldInfo.h"
+#include "FieldHandlerRegistry.h"
 
 class Component;
-template<typename T> struct ScriptComponentRef;
+template<typename T> struct ComponentRef;
 
 template<typename T>
-constexpr ScriptFieldType scriptFieldTypeOf()
+constexpr FieldType fieldTypeOf()
 {
-    if constexpr (std::is_same_v<T, float>)                          return ScriptFieldType::Float;
-    else if constexpr (std::is_same_v<T, int>)                       return ScriptFieldType::Int;
-    else if constexpr (std::is_same_v<T, bool>)                      return ScriptFieldType::Bool;
-    else if constexpr (std::is_same_v<T, Vector3>)                   return ScriptFieldType::Vec3;
-    else if constexpr (std::is_same_v<T, std::string>)               return ScriptFieldType::String;
-    else if constexpr (std::is_same_v<T, ScriptComponentRef<Component>>) return ScriptFieldType::ComponentRef;
-    else return ScriptFieldType::Float;
+    if constexpr (std::is_same_v<T, float>)                          return FieldType::Float;
+    else if constexpr (std::is_same_v<T, int>)                       return FieldType::Int;
+    else if constexpr (std::is_same_v<T, bool>)                      return FieldType::Bool;
+    else if constexpr (std::is_same_v<T, Vector3>)                   return FieldType::Vec3;
+    else if constexpr (std::is_same_v<T, std::string>)               return FieldType::String;
+    else if constexpr (std::is_same_v<T, ComponentRef<Component>>) return FieldType::ComponentRef;
+    else return FieldType::Float;
 }
 
 template<typename T>
-const ScriptFieldHandler* scriptFieldHandlerOf()
+const FieldHandler* fieldHandlerOf()
 {
     if constexpr (std::is_same_v<T, float>)                          return getFloatFieldHandler();
     else if constexpr (std::is_same_v<T, int>)                       return getIntFieldHandler();
     else if constexpr (std::is_same_v<T, bool>)                      return getBoolFieldHandler();
     else if constexpr (std::is_same_v<T, Vector3>)                   return getVec3FieldHandler();
     else if constexpr (std::is_same_v<T, std::string>)               return getStringFieldHandler();
-    else if constexpr (std::is_same_v<T, ScriptComponentRef<Component>>) return getComponentRefFieldHandler();
+    else if constexpr (std::is_same_v<T, ComponentRef<Component>>) return getComponentRefFieldHandler();
     else return nullptr;
 }
+
+// Backward compatibility aliases
+template<typename T>
+constexpr FieldType scriptFieldTypeOf() { return fieldTypeOf<T>(); }
+
+template<typename T>
+const FieldHandler* scriptFieldHandlerOf() { return fieldHandlerOf<T>(); }
diff --git a/Engine_Master_UPC/FieldUtils.cpp b/Engine_Master_UPC/FieldUtils.cpp
new file mode 100644
index 00000000..bec68b13
--- /dev/null
+++ b/Engine_Master_UPC/FieldUtils.cpp
@@ -0,0 +1,109 @@
+#include "Globals.h"
+#include "FieldUtils.h"
+#include "IArchive.h"
+#include "IFieldContainer.h"
+#include "FieldInfo.h"
+#include "SceneReferenceResolver.h"
+
+namespace FieldUtils
+{
+    void drawUi(IFieldContainer& container, char* base)
+    {
+        FieldList fieldList = container.getExposedFields();
+        bool currentGroupOpen = true;
+
+        for (const FieldInfo& field : fieldList.fields)
+        {
+            if (field.type == FieldType::GroupCollapseBegin)
+            {
+                ImGui::Spacing();
+                currentGroupOpen = ImGui::CollapsingHeader(field.name, ImGuiTreeNodeFlags_DefaultOpen);
+                continue;
+            }
+
+            if (field.type == FieldType::GroupCollapseEnd)
+            {
+                currentGroupOpen = true;
+                continue;
+            }
+
+            if (!currentGroupOpen)
+                continue;
+
+            void* data = base + field.offset;
+            assert(field.handler != nullptr);
+            field.handler->drawUi(field, data, container);
+        }
+    }
+
+    void serialize(const IFieldContainer& container, const char* base, IArchive& archive)
+    {
+        FieldList fieldList = container.getExposedFields();
+
+        for (const FieldInfo& field : fieldList.fields)
+        {
+            if (!field.isDataField())
+                continue;
+
+            const void* data = base + field.offset;
+            assert(field.handler != nullptr);
+            field.handler->serialize(field, const_cast<void*>(data), archive);
+        }
+    }
+
+    void deserialize(IFieldContainer& container, char* base, IArchive& archive)
+    {
+        FieldList fieldList = container.getExposedFields();
+
+        for (const FieldInfo& field : fieldList.fields)
+        {
+            if (!field.isDataField())
+                continue;
+
+            void* data = base + field.offset;
+            assert(field.handler != nullptr);
+            field.handler->serialize(field, data, archive);
+        }
+    }
+
+
+    void clone(const IFieldContainer& source, const char* srcBase, IFieldContainer& target, char* dstBase)
+    {
+        FieldList sourceFields = source.getExposedFields();
+        FieldList targetFields = target.getExposedFields();
+
+        const size_t count = std::min(sourceFields.fields.size(), targetFields.fields.size());
+
+        for (size_t i = 0; i < count; ++i)
+        {
+            const FieldInfo& sourceField = sourceFields.fields[i];
+            const FieldInfo& targetField = targetFields.fields[i];
+
+            if (!sourceField.isDataField() || !targetField.isDataField())
+                continue;
+
+            assert(sourceField.handler == targetField.handler);
+
+            const void* sourceData = srcBase + sourceField.offset;
+            void* targetData = dstBase + targetField.offset;
+
+            assert(sourceField.handler != nullptr);
+            sourceField.handler->clone(sourceField, sourceData, targetData);
+        }
+    }
+
+    void fixReferences(IFieldContainer& container, char* base, const SceneReferenceResolver& resolver)
+    {
+        FieldList fieldList = container.getExposedFields();
+
+        for (const FieldInfo& field : fieldList.fields)
+        {
+            if (!field.isDataField())
+                continue;
+
+            void* data = base + field.offset;
+            assert(field.handler != nullptr);
+            field.handler->fixReferences(field, data, resolver);
+        }
+    }
+}
diff --git a/Engine_Master_UPC/FieldUtils.h b/Engine_Master_UPC/FieldUtils.h
new file mode 100644
index 00000000..d1d0a123
--- /dev/null
+++ b/Engine_Master_UPC/FieldUtils.h
@@ -0,0 +1,14 @@
+#pragma once
+
+class IArchive;
+class IFieldContainer;
+class SceneReferenceResolver;
+
+namespace FieldUtils
+{
+    void drawUi(IFieldContainer& container, char* base);
+    void serialize(const IFieldContainer& container, const char* base, IArchive& archive);
+    void deserialize(IFieldContainer& container, char* base, IArchive& archive);
+    void clone(const IFieldContainer& source, const char* srcBase, IFieldContainer& target, char* dstBase);
+    void fixReferences(IFieldContainer& container, char* base, const SceneReferenceResolver& resolver);
+}
diff --git a/Engine_Master_UPC/GenericTypeFactory.h b/Engine_Master_UPC/GenericTypeFactory.h
new file mode 100644
index 00000000..d92ea40c
--- /dev/null
+++ b/Engine_Master_UPC/GenericTypeFactory.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+struct AssetReference;
+class Script;
+class GameObject;
+class DataContainer;
+
+template<typename TBase, typename... TCreateArgs>
+class GenericTypeFactory
+{
+public:
+	using Creator = std::unique_ptr<TBase>(*)(TCreateArgs...);
+
+	struct Entry
+	{
+		std::string name;
+		std::string displayName;
+		Creator creator;
+	};
+
+	static void registerType(const std::string& name, const std::string& displayName, Creator creator)
+	{
+		for (auto& entry : m_registry)
+		{
+			if (entry.name == name)
+			{
+				entry.creator = creator;
+				return;
+			}
+		}
+		m_registry.push_back({ name, displayName, creator });
+	}
+
+	static std::unique_ptr<TBase> create(const std::string& name, TCreateArgs... args)
+	{
+		for (const auto& entry : m_registry)
+		{
+			if (entry.name == name)
+			{
+				return entry.creator(std::forward<TCreateArgs>(args)...);
+			}
+		}
+		return nullptr;
+	}
+
+	static bool isRegistered(const std::string& name)
+	{
+		return std::any_of(m_registry.begin(), m_registry.end(),
+			[&](const Entry& e) { return e.name == name; });
+	}
+
+	static const std::vector<Entry>& getAllRegistered()
+	{
+		return m_registry;
+	}
+
+	static void clear()
+	{
+		m_registry.clear();
+	}
+
+
+private:
+	static inline std::vector<Entry> m_registry;
+};
+
+using ScriptFactory = GenericTypeFactory<Script, GameObject*>;
+using DataContainerFactory = GenericTypeFactory<DataContainer, AssetReference&>;
+
+
diff --git a/Engine_Master_UPC/IFieldContainer.h b/Engine_Master_UPC/IFieldContainer.h
new file mode 100644
index 00000000..ce562670
--- /dev/null
+++ b/Engine_Master_UPC/IFieldContainer.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "FieldInfo.h"
+
+class IFieldContainer
+{
+public:
+    virtual ~IFieldContainer() = default;
+
+    virtual FieldList getExposedFields() const
+    {
+        return {};
+    }
+
+    virtual void onFieldEdited(const FieldInfo& field) {}
+
+    virtual void onAfterDeserialize() {}
+};
diff --git a/Engine_Master_UPC/ImGuiPass.cpp b/Engine_Master_UPC/ImGuiPass.cpp
index 96a97864..58534ea1 100644
--- a/Engine_Master_UPC/ImGuiPass.cpp
+++ b/Engine_Master_UPC/ImGuiPass.cpp
@@ -90,7 +90,11 @@ ImGuiPass::ImGuiPass(ID3D12Device4* device, HWND hWnd, D3D12_CPU_DESCRIPTOR_HAND
 
 ImGuiPass::~ImGuiPass()
 {
-    heap = nullptr;
+    if (m_fontDescriptor.IsValid())
+    {
+        app->getModuleDescriptors()->getHeap(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV).free(m_fontDescriptor.handle);
+        m_fontDescriptor = {};
+    }
 
     ImGui_ImplDX12_Shutdown();
     ImGui_ImplWin32_Shutdown();
diff --git a/Engine_Master_UPC/ImGuiPass.h b/Engine_Master_UPC/ImGuiPass.h
index 16625246..1fa2680a 100644
--- a/Engine_Master_UPC/ImGuiPass.h
+++ b/Engine_Master_UPC/ImGuiPass.h
@@ -4,14 +4,10 @@
 
 class ImGuiPass: public IRenderPass
 {
-    DescriptorHeap* heap;
-
 public:
     ImGuiPass(ID3D12Device4* device, HWND hWnd, D3D12_CPU_DESCRIPTOR_HANDLE cpuTextHandle = { 0 }, D3D12_GPU_DESCRIPTOR_HANDLE gpuTextHandle = { 0 });
     ~ImGuiPass();
 
-    DescriptorHeap* GetHeap() { return heap; }
-
     void startFrame();
     virtual void prepare(const RenderContext& ctx) override {}
     void apply(ID3D12GraphicsCommandList4* commandList) override;
diff --git a/Engine_Master_UPC/ImporterRegistry.cpp b/Engine_Master_UPC/ImporterRegistry.cpp
index 6b4f6db0..225cae51 100644
--- a/Engine_Master_UPC/ImporterRegistry.cpp
+++ b/Engine_Master_UPC/ImporterRegistry.cpp
@@ -16,6 +16,7 @@
 #include "AnimationAsset.h"
 #include "SkinAsset.h"
 #include "AnimationStateMachineAsset.h"
+#include "DataContainer.h"
 
 ImporterRegistry::ImporterRegistry()
 {
@@ -42,6 +43,7 @@ ImporterRegistry::ImporterRegistry()
     m_importers.push_back(std::make_unique<ImporterNative<Scene, AssetType::SCENE>>(std::initializer_list<const char*>{SCENE_EXTENSION}));
     m_importers.push_back(std::make_unique<ImporterNavMesh>());
     m_importers.push_back(std::make_unique<ImporterSoundBank>());
+    m_importers.push_back(std::make_unique<ImporterNative<DataContainer, AssetType::DATA_CONTAINER>>(std::initializer_list<const char*>{DATA_CONTAINER_EXTENSION}));
 }
 
 ImporterRegistry::~ImporterRegistry() = default;
diff --git a/Engine_Master_UPC/MD5.cpp b/Engine_Master_UPC/MD5.cpp
index 923973e4..3659583b 100644
--- a/Engine_Master_UPC/MD5.cpp
+++ b/Engine_Master_UPC/MD5.cpp
@@ -115,3 +115,41 @@ std::vector<int8_t> computeMD5(const std::vector<int8_t>& message) {
 	}
 	return md5;
 }
+
+MD5Hash computeMD5(const std::filesystem::path& filePath)
+{
+	std::ifstream file(filePath, std::ios::binary);
+	if (!file)
+	{
+		DEBUG_ERROR("[MD5] Could not open file for hashing: %s", filePath.string().c_str());
+		return "";
+	}
+
+	std::vector<int8_t> contents(
+		(std::istreambuf_iterator<char>(file)),
+		std::istreambuf_iterator<char>());
+
+	return to_hex_string(computeMD5(contents));
+}
+
+ uint64_t hashToUID(const MD5Hash& hash)
+{
+	if (hash.size() < 16)
+	{
+		return 0;
+	}
+
+
+	for (size_t i = 0; i < 16; ++i)
+	{
+		const char c = hash[i];
+		const bool valid = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+		if (!valid)
+		{
+			DEBUG_ERROR("[MD5] hashToUID: non-hex character '%c' at index %zu in hash '%s'.", c, i, hash.c_str());
+			return 0;
+		}
+	}
+
+	return std::stoull(hash.substr(0, 16), nullptr, 16);
+}
diff --git a/Engine_Master_UPC/MD5.h b/Engine_Master_UPC/MD5.h
index 2a8a8f90..21cdb37d 100644
--- a/Engine_Master_UPC/MD5.h
+++ b/Engine_Master_UPC/MD5.h
@@ -12,38 +12,6 @@ std::vector<int8_t>   computeMD5(const std::vector<int8_t>& message);
 inline bool isValidAsset(const MD5Hash& id) { return !id.empty(); }
 
 
-inline MD5Hash computeMD5(const std::filesystem::path& filePath) 
-{
-    std::ifstream file(filePath, std::ios::binary);
-    if (!file)
-    {
-        return "";
-    }
+MD5Hash computeMD5(const std::filesystem::path& filePath);
 
-    std::vector<int8_t> contents(
-        (std::istreambuf_iterator<char>(file)),
-        std::istreambuf_iterator<char>());
-
-    return to_hex_string(computeMD5(contents));
-}
-
-inline uint64_t hashToUID(const MD5Hash& hash)
-{
-    if (hash.size() < 16)
-    {
-        return 0;
-    }
-
-
-    for (size_t i = 0; i < 16; ++i)
-    {
-        const char c = hash[i];
-        const bool valid = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-        if (!valid)
-        {
-            return 0;
-        }
-    }
-
-    return std::stoull(hash.substr(0, 16), nullptr, 16);
-}
+uint64_t hashToUID(const MD5Hash& hash);
diff --git a/Engine_Master_UPC/ModuleAssets.cpp b/Engine_Master_UPC/ModuleAssets.cpp
index c649a26d..37322b54 100644
--- a/Engine_Master_UPC/ModuleAssets.cpp
+++ b/Engine_Master_UPC/ModuleAssets.cpp
@@ -24,6 +24,7 @@
 #include "JsonArchive.h"
 #include "Metadata.h"
 #include "UID.h"
+#include "DataContainer.h"
 
 #include <filesystem>
 #include <FileIO.h>
@@ -131,6 +132,21 @@ void ModuleAssets::importAsset(const std::filesystem::path& sourcePath, AssetRef
         return;
     }
 
+    if (reference.m_type == AssetType::DATA_CONTAINER)
+    {
+        DataContainer* baseDc = static_cast<DataContainer*>(asset.release());
+        DataContainer* derivedDc = resolveDataContainerType(baseDc);
+        if (derivedDc)
+        {
+            delete baseDc;
+            asset.reset(derivedDc);
+        }
+        else
+        {
+            asset.reset(baseDc);
+        }
+    }
+
     if (!persistAsset(asset.get(), importer, reference, sourcePath))
     {
         if (!isReimport) reference = AssetReference();
@@ -430,3 +446,31 @@ PrefabManager* ModuleAssets::getPrefabManager() const
 {
     return m_prefabManager.get();
 }
+
+DataContainer* ModuleAssets::resolveDataContainerType(DataContainer* baseContainer) const
+{
+    if (!baseContainer)
+    {
+        return nullptr;
+    }
+
+    const rapidjson::Document& data = baseContainer->getData();
+    if (!data.HasMember("_typeName") || !data["_typeName"].IsString())
+    {
+        return nullptr;
+    }
+
+    const char* typeName = data["_typeName"].GetString();
+    AssetReference ref = baseContainer->getReference();
+
+    auto derived = DataContainerFactory::create(typeName, ref);
+    if (!derived)
+    {
+        return nullptr;
+    }
+
+    JsonArchive archive(ArchiveMode::Input);
+    archive.setValue(data);
+    derived->serialize(archive);
+    return derived.release();
+}
diff --git a/Engine_Master_UPC/ModuleAssets.h b/Engine_Master_UPC/ModuleAssets.h
index d029c093..51ae4969 100644
--- a/Engine_Master_UPC/ModuleAssets.h
+++ b/Engine_Master_UPC/ModuleAssets.h
@@ -19,6 +19,7 @@ struct DependencyRecord;
 struct ScanFileResult;
 
 struct Metadata;
+class DataContainer;
 
 class ModuleAssets : public Module
 {
@@ -67,6 +68,7 @@ class ModuleAssets : public Module
 
 private:
     bool persistAsset(Asset* asset, Importer* importer, AssetReference& reference, const std::filesystem::path& sourcePath);
+    DataContainer* resolveDataContainerType(DataContainer* baseContainer) const;
 
     AssetIndex                           m_index;
     ImporterRegistry                     m_importers;
diff --git a/Engine_Master_UPC/ModuleDescriptors.cpp b/Engine_Master_UPC/ModuleDescriptors.cpp
index 71a3ae33..46ea8c01 100644
--- a/Engine_Master_UPC/ModuleDescriptors.cpp
+++ b/Engine_Master_UPC/ModuleDescriptors.cpp
@@ -24,8 +24,9 @@ ModuleDescriptors::~ModuleDescriptors()
         delete pair.second;
         pair.second = nullptr;
     }
-    delete m_stagingSRVHeap;
+	delete m_stagingSRVHeap;
     m_defferedDescriptors.clear();
+    m_defferedBlocks.clear();
 }
 
 bool ModuleDescriptors::init()
@@ -36,7 +37,7 @@ bool ModuleDescriptors::init()
 
 void ModuleDescriptors::preRender()
 {
-	UINT lastCompletedFrame = (UINT)app->getModuleD3D12()->getLastCompletedFrame();
+    UINT lastCompletedFrame = (UINT)app->getModuleD3D12()->getLastCompletedFrame();
     for (size_t i = 0; i < m_defferedDescriptors.size();) {
 
         if (lastCompletedFrame >= m_defferedDescriptors[i].frame)
diff --git a/Engine_Master_UPC/ModuleDescriptors.h b/Engine_Master_UPC/ModuleDescriptors.h
index 6fe99c5a..4b910b6a 100644
--- a/Engine_Master_UPC/ModuleDescriptors.h
+++ b/Engine_Master_UPC/ModuleDescriptors.h
@@ -11,6 +11,12 @@ struct DefferedDescriptor {
 	D3D12_DESCRIPTOR_HEAP_TYPE heap;
 };
 
+struct DefferedBlock {
+	uint64_t frame = 0;
+	DescriptorHeapBlock* block = nullptr;
+	D3D12_DESCRIPTOR_HEAP_TYPE heapType = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+};
+
 // -----------------------------------------------------------------------------
 // ModuleDescriptors
 // -----------------------------------------------------------------------------
@@ -19,10 +25,10 @@ struct DefferedDescriptor {
 // This module abstracts the creation and lifetime management of the different
 // descriptor heap types required by Direct3D 12:
 //
-// • RTV(Render Target Views)
-// • DSV(Depth Stencil Views)
-// • SRV(Shader Resource Views, e.g.textures, buffers)
-// • Samplers(Sampler descriptors for filtering / wrapping modes)
+// � RTV(Render Target Views)
+// � DSV(Depth Stencil Views)
+// � SRV(Shader Resource Views, e.g.textures, buffers)
+// � Samplers(Sampler descriptors for filtering / wrapping modes)
 class ModuleDescriptors: public Module
 {
 public:
@@ -55,5 +61,6 @@ class ModuleDescriptors: public Module
 
 	ComPtr<ID3D12Device4>												m_device{};
 	std::vector<DefferedDescriptor>										m_defferedDescriptors{};
+	std::vector<DefferedBlock>											m_defferedBlocks{};
 };
 
diff --git a/Engine_Master_UPC/ModuleEditor.cpp b/Engine_Master_UPC/ModuleEditor.cpp
index 13217d84..00013286 100644
--- a/Engine_Master_UPC/ModuleEditor.cpp
+++ b/Engine_Master_UPC/ModuleEditor.cpp
@@ -30,6 +30,12 @@
 #include "ModuleGameView.h"
 #include "ModuleAssets.h"
 #include "Mouse.h"
+#include "GenericTypeFactory.h"
+#include "ContentRegistry.h"
+#include "CommandCreateDataContainer.h"
+#include "DataContainerExporter.h"
+#include "WindowDataContainerManager.h"
+#include "FileDialog.h"
 
 #include <fstream>
 
@@ -148,6 +154,7 @@ bool ModuleEditor::init()
     registerWindowType<WindowGame>("Game");
     registerWindowType<WindowAnimationStateMachine>("Animation State Machine");
     registerWindowType<WindowMusicDebug>("Music Library");
+    registerWindowType<WindowDataContainerManager>("Data Container Manager");
 
     // ---- Spawn the default set of windows (one each) ----
     openWindow("Console");
@@ -184,6 +191,28 @@ void ModuleEditor::update()
             handleKeyboardShortcuts();
         }
     }
+
+    if (!m_dcDialogRunning.load())
+    {
+        std::optional<std::filesystem::path> result;
+        {
+            std::lock_guard lock(m_dcDialogMutex);
+            if (m_dcDialogResult.has_value())
+            {
+                result = std::move(m_dcDialogResult);
+                m_dcDialogResult.reset();
+            }
+        }
+
+        if (result.has_value())
+        {
+            if (m_dcDialogMode == 1)
+                DataContainerExporter::exportToJson(result.value());
+            else if (m_dcDialogMode == 2)
+                DataContainerExporter::importFromJson(result.value());
+            m_dcDialogMode = 0;
+        }
+    }
 }
 
 void ModuleEditor::render()
@@ -332,6 +361,7 @@ void ModuleEditor::mainMenuBar()
 
     if (ImGui::BeginMenu("Window"))
     {
+        // ---- New Window submenu – spawn additional instances ----
         // ---- New Window submenu � spawn additional instances ----
         if (!m_windowFactories.empty())
         {
@@ -352,6 +382,63 @@ void ModuleEditor::mainMenuBar()
         ImGui::EndMenu();
     }
 
+    if (ImGui::BeginMenu("Asset"))
+    {
+        const auto& dcRegistry = DataContainerFactory::getAllRegistered();
+        if (!dcRegistry.empty())
+        {
+            for (const auto& entry : dcRegistry)
+            {
+                if (ImGui::MenuItem(entry.displayName.c_str()))
+                {
+                    std::filesystem::path assetsDir = ASSETS_FOLDER;
+                    if (assetsDir.empty())
+                    {
+                        assetsDir = std::filesystem::current_path() / "Assets";
+                    }
+                    std::string assetName = std::string("New_") + entry.name;
+                    CommandCreateDataContainer(assetsDir, entry.name, assetName).run();
+                }
+            }
+        }
+        else
+        {
+            ImGui::TextDisabled("No asset types registered");
+        }
+
+        ImGui::Separator();
+        if (ImGui::MenuItem("Export Data Assets..."))
+        {
+            if (!m_dcDialogRunning.load())
+            {
+                m_dcDialogMode = 1;
+                m_dcDialogRunning.store(true);
+                { std::lock_guard lock(m_dcDialogMutex); m_dcDialogResult.reset(); }
+                std::thread([this]() {
+                    auto result = saveAs("JSON Files (*.json)\0*.json\0", "json", "Export Data Assets", ASSETS_FOLDER);
+                    { std::lock_guard lock(m_dcDialogMutex); m_dcDialogResult = std::move(result); }
+                    m_dcDialogRunning.store(false);
+                }).detach();
+            }
+        }
+        if (ImGui::MenuItem("Import Data Assets..."))
+        {
+            if (!m_dcDialogRunning.load())
+            {
+                m_dcDialogMode = 2;
+                m_dcDialogRunning.store(true);
+                { std::lock_guard lock(m_dcDialogMutex); m_dcDialogResult.reset(); }
+                std::thread([this]() {
+                    auto result = open("JSON Files (*.json)\0*.json\0", "Import Data Assets", ASSETS_FOLDER);
+                    { std::lock_guard lock(m_dcDialogMutex); m_dcDialogResult = std::move(result); }
+                    m_dcDialogRunning.store(false);
+                }).detach();
+            }
+        }
+
+        ImGui::EndMenu();
+    }
+
     ImGui::EndMainMenuBar();
 }
 
diff --git a/Engine_Master_UPC/ModuleEditor.h b/Engine_Master_UPC/ModuleEditor.h
index 89fe0b72..e52ad823 100644
--- a/Engine_Master_UPC/ModuleEditor.h
+++ b/Engine_Master_UPC/ModuleEditor.h
@@ -8,6 +8,7 @@
 #include <unordered_map>
 #include <vector>
 #include <filesystem>
+#include "mutex"
 
 class ModuleGameView;
 class WindowSceneEditor;
@@ -185,4 +186,10 @@ class ModuleEditor : public Module
     // Prefab editing
     PrefabEditSession m_prefabSession;
     bool              m_pendingExitPrefab = false;
+
+    // Async file dialog for DataContainer export/import
+    std::atomic<bool>      m_dcDialogRunning = false;
+    std::mutex             m_dcDialogMutex;
+    std::optional<std::filesystem::path> m_dcDialogResult;
+    int                    m_dcDialogMode = 0; // 1=export, 2=import
 };
\ No newline at end of file
diff --git a/Engine_Master_UPC/ModuleScripting.cpp b/Engine_Master_UPC/ModuleScripting.cpp
index d0040252..458ddae2 100644
--- a/Engine_Master_UPC/ModuleScripting.cpp
+++ b/Engine_Master_UPC/ModuleScripting.cpp
@@ -5,7 +5,6 @@
 #include "ModuleScene.h"
 #include "Scene.h"
 #include "ScriptComponent.h"
-#include "ScriptFactory.h"
 #include "AnimationComponent.h"
 #include "GameObject.h"
 #include "Extensions.h"
@@ -434,7 +433,7 @@ std::vector<ScriptSourceInfo> ModuleScripting::getAvailableScripts() const
 
         const std::string scriptName = entry.path().stem().string();
 
-        if (!ScriptFactory::isScriptRegistered(scriptName))
+        if (!ScriptFactory::isRegistered(scriptName))
         {
             continue;
         }
diff --git a/Engine_Master_UPC/NavMeshTypes.h b/Engine_Master_UPC/NavMeshTypes.h
index 84f93346..84b6cba0 100644
--- a/Engine_Master_UPC/NavMeshTypes.h
+++ b/Engine_Master_UPC/NavMeshTypes.h
@@ -1,5 +1,8 @@
 #pragma once
 #include <cstring>
+#include "SimpleMath.h"
+
+using DirectX::SimpleMath::Vector3;
 
 enum class NavAreaType
 {
diff --git a/Engine_Master_UPC/ParticlesPass.h b/Engine_Master_UPC/ParticlesPass.h
index e4d66330..a7911aa3 100644
--- a/Engine_Master_UPC/ParticlesPass.h
+++ b/Engine_Master_UPC/ParticlesPass.h
@@ -38,6 +38,7 @@ class ParticlesPass : public IRenderPass
     ComPtr<ID3D12PipelineState> m_pipelineState;
 
     std::unique_ptr<VertexBuffer> m_quadVertexBuffer;
+    std::vector<shaderParticleData> m_particleDataBuffer;
 
     // TEMPORARY
     
diff --git a/Engine_Master_UPC/PrefabUI.cpp b/Engine_Master_UPC/PrefabUI.cpp
index f5c69ee8..9ade051d 100644
--- a/Engine_Master_UPC/PrefabUI.cpp
+++ b/Engine_Master_UPC/PrefabUI.cpp
@@ -15,6 +15,7 @@
 
 #include "Prefab.h"
 #include "PrefabEditSession.h"
+#include "AssetsDictionary.h"
 #include <FileIO.h>
 
 static void linkAndSavePrefab(GameObject* go, const std::filesystem::path& savePath)
@@ -499,6 +500,7 @@ static bool beginModal(const char* id, bool& triggerFlag, const ImVec2& screenCe
 void PrefabUI::drawFileDialogModals(bool& showVariantModal,
     bool& showSavePrefabModal,
     bool& renamingPrefab,
+    bool& renamingAsset,
     FileDialogBuffers& buffers)
 {
     const ImVec2 screenCenter = ImGui::GetMainViewport()->GetCenter();
diff --git a/Engine_Master_UPC/PrefabUI.h b/Engine_Master_UPC/PrefabUI.h
index 028b2af6..2c1f1ebd 100644
--- a/Engine_Master_UPC/PrefabUI.h
+++ b/Engine_Master_UPC/PrefabUI.h
@@ -57,5 +57,6 @@ class PrefabUI
     static void drawFileDialogModals(bool& showVariantModal,
         bool& showSavePrefabModal,
         bool& renamingPrefab,
+        bool& renamingAsset,
         FileDialogBuffers& buffers);
 };
\ No newline at end of file
diff --git a/Engine_Master_UPC/Script.h b/Engine_Master_UPC/Script.h
index d24484bb..78271b70 100644
--- a/Engine_Master_UPC/Script.h
+++ b/Engine_Master_UPC/Script.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include "ScriptFieldInfo.h"
+#include "IFieldContainer.h"
 
 #include "ScriptMethodInfo.h"
 #include "ScriptMethodList.h"
 
 class GameObject;
 
-class Script
+class Script : public IFieldContainer
 {
 public:
     explicit Script(GameObject* owner) : m_owner(owner) {}
@@ -19,22 +19,11 @@ class Script
     virtual void OnTriggerEnter(GameObject* gameObject) {}
     virtual void OnTriggerExit(GameObject* gameObject) {}
 
-    virtual ScriptFieldList getExposedFields() const
-    {
-        return {};
-    }
-
     virtual ScriptMethodList getExposedMethods() const
     {
         return {};
     }
 
-    //Used when changing a field in the inspector must trigger some extra action
-    virtual void onFieldEdited(const ScriptFieldInfo& field) {}
-
-    //Used when needing to rebuild runtime state after deserializing a field
-    virtual void onAfterDeserialize() {}
-
     //Used when needing to rebuild runtime state after fixing references
     virtual void onAfterReferencesFixed() {}
 
diff --git a/Engine_Master_UPC/ScriptAPI.h b/Engine_Master_UPC/ScriptAPI.h
index b5745b95..d197ca6d 100644
--- a/Engine_Master_UPC/ScriptAPI.h
+++ b/Engine_Master_UPC/ScriptAPI.h
@@ -4,9 +4,22 @@
 #include "GameObject.h"
 #include "Transform.h"
 
-#include "ScriptAutoRegister.h"
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldMacros.h"
+#include "GenericTypeFactory.h"
+#include "FieldInfo.h"
+#include "FieldMacros.h"
 
-#include "ScriptComponentRef.h"
-#include "AssetRef.h"
\ No newline at end of file
+#include "ComponentRef.h"
+#include <AssetRef.h>
+
+#define DECLARE_SCRIPT(ScriptType)
+
+#define IMPLEMENT_SCRIPT(ScriptType) \
+	namespace { \
+		static std::unique_ptr<Script> s_create_##ScriptType(GameObject* owner) { \
+			return std::make_unique<ScriptType>(owner); \
+		} \
+		static bool s_registered_##ScriptType = ( \
+			::registerScript(#ScriptType, &s_create_##ScriptType), \
+			true \
+		); \
+	}
diff --git a/Engine_Master_UPC/ScriptAutoRegister.h b/Engine_Master_UPC/ScriptAutoRegister.h
deleted file mode 100644
index 4e56b00d..00000000
--- a/Engine_Master_UPC/ScriptAutoRegister.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "EngineAPI.h"
-
-class ScriptAutoRegister
-{
-public:
-    ScriptAutoRegister(const char* name, ScriptCreator creator)
-    {
-        registerScript(name, creator);
-    }
-};
-
-#define DECLARE_SCRIPT(ScriptType) \
-public: \
-    static std::unique_ptr<Script> Create(GameObject* owner);
-
-
-#define IMPLEMENT_SCRIPT(ScriptType)                                      \
-    std::unique_ptr<Script> ScriptType::Create(GameObject* owner)         \
-    {                                                                     \
-        return std::make_unique<ScriptType>(owner);                       \
-    }                                                                     \
-    static ScriptAutoRegister s_autoRegister_##ScriptType(                \
-        #ScriptType,                                                      \
-        &ScriptType::Create                                               \
-    );
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptComponent.cpp b/Engine_Master_UPC/ScriptComponent.cpp
index 2e727066..5d696f26 100644
--- a/Engine_Master_UPC/ScriptComponent.cpp
+++ b/Engine_Master_UPC/ScriptComponent.cpp
@@ -1,9 +1,10 @@
 #include "Globals.h"
 #include "ScriptComponent.h"
 #include "Script.h"
-#include "ScriptFactory.h"
+#include "GenericTypeFactory.h"
 #include "SceneReferenceResolver.h"
 #include "JsonArchive.h"
+#include <FieldUtils.h>
 
 ScriptComponent::ScriptComponent(UID id, GameObject* owner)
     : Component(id, ComponentType::SCRIPT, owner)
@@ -38,7 +39,7 @@ bool ScriptComponent::createScriptInstance()
         return false;
     }
 
-    std::unique_ptr<Script> newScript = ScriptFactory::createScript(m_scriptName, getOwner());
+    std::unique_ptr<Script> newScript = ScriptFactory::create(m_scriptName, getOwner());
     if (!newScript)
     {
         return false;
@@ -113,37 +114,7 @@ void ScriptComponent::debugDraw()
 
 void ScriptComponent::drawScriptFieldsUi(Script& script)
 {
-    ScriptFieldList fieldList = script.getExposedFields();
-    char* base = reinterpret_cast<char*>(&script);
-
-    bool currentGroupOpen = true;
-
-    for (const ScriptFieldInfo& field : fieldList.fields)
-    {
-        if (field.type == ScriptFieldType::GroupCollapseBegin)
-        {
-            ImGui::Spacing();
-
-            currentGroupOpen = ImGui::CollapsingHeader(field.name, ImGuiTreeNodeFlags_DefaultOpen);
-            continue;
-        }
-
-        if (field.type == ScriptFieldType::GroupCollapseEnd)
-        {
-            currentGroupOpen = true;
-            continue;
-        }
-
-        if (!currentGroupOpen)
-        {
-            continue;
-        }
-
-        void* data = base + field.offset;
-
-        assert(field.handler != nullptr);
-        field.handler->drawUi(field, data, script, *this);
-    }
+    FieldUtils::drawUi(script, reinterpret_cast<char*>(&script));
 }
 
 void ScriptComponent::serialize(IArchive& archive)
@@ -171,10 +142,10 @@ void ScriptComponent::serialize(IArchive& archive)
 
 void ScriptComponent::serializeScriptFields(Script& script, IArchive& archive)
 {
-	ScriptFieldList fieldList = script.getExposedFields();
+	FieldList fieldList = script.getExposedFields();
 	char* base = reinterpret_cast<char*>(&script);
 
-	for (const ScriptFieldInfo& field : fieldList.fields)
+	for (const FieldInfo& field : fieldList.fields)
 	{
 		if (!field.isDataField())
 			continue;
@@ -216,21 +187,7 @@ void ScriptComponent::fixReferences(const SceneReferenceResolver& resolver)
         return;
     }
 
-    ScriptFieldList fieldList = m_script->getExposedFields();
-    char* base = reinterpret_cast<char*>(m_script.get());
-
-    for (const ScriptFieldInfo& field : fieldList.fields)
-    {
-        if (!field.isDataField())
-        {
-            continue;
-        }
-
-        void* data = base + field.offset;
-
-        assert(field.handler != nullptr);
-        field.handler->fixReferences(field, data, resolver);
-    }
+    FieldUtils::fixReferences(*m_script, reinterpret_cast<char*>(m_script.get()), resolver);
 
     m_script->onAfterReferencesFixed();
 }
@@ -256,32 +213,5 @@ std::unique_ptr<Component> ScriptComponent::clone(GameObject* newOwner) const
 
 void ScriptComponent::cloneScriptFields(const Script& source, Script& target)
 {
-    ScriptFieldList sourceFields = source.getExposedFields();
-    ScriptFieldList targetFields = target.getExposedFields();
-
-    const size_t count = std::min(sourceFields.fields.size(), targetFields.fields.size());
-
-    const char* sourceBase = reinterpret_cast<const char*>(&source);
-    char* targetBase = reinterpret_cast<char*>(&target);
-
-    for (size_t i = 0; i < count; ++i)
-    {
-        const ScriptFieldInfo& sourceField = sourceFields.fields[i];
-        const ScriptFieldInfo& targetField = targetFields.fields[i];
-
-        if (!sourceField.isDataField() || !targetField.isDataField())
-        {
-            continue;
-        }
-
-        assert(sourceField.handler == targetField.handler);
-
-        const void* sourceData = sourceBase + sourceField.offset;
-        void* targetData = targetBase + targetField.offset;
-
-        assert(sourceField.handler != nullptr);
-        assert(targetField.handler != nullptr);
-
-        sourceField.handler->clone(sourceField, sourceData, targetData);
-    }
-}
\ No newline at end of file
+    FieldUtils::clone(source, reinterpret_cast<const char*>(&source), target, reinterpret_cast<char*>(&target));
+}
diff --git a/Engine_Master_UPC/ScriptCreator.h b/Engine_Master_UPC/ScriptCreator.h
deleted file mode 100644
index 547b0a09..00000000
--- a/Engine_Master_UPC/ScriptCreator.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include <memory>
-
-class GameObject;
-class Script;
-
-using ScriptCreator = std::unique_ptr<Script>(*)(GameObject* owner);
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFactory.cpp b/Engine_Master_UPC/ScriptFactory.cpp
deleted file mode 100644
index ee4cbf66..00000000
--- a/Engine_Master_UPC/ScriptFactory.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "Globals.h"
-#include "ScriptFactory.h"
-#include "Script.h"
-
-std::vector<ScriptRegistry> ScriptFactory::m_registry;
-
-void ScriptFactory::registerScript(const std::string& scriptName, ScriptCreator creator)
-{
-    for (ScriptRegistry& script : m_registry)
-    {
-        if (script.name == scriptName)
-        {
-            script.creator = creator;
-            return;
-        }
-    }
-
-    m_registry.push_back({ scriptName, creator });
-}
-
-std::unique_ptr<Script> ScriptFactory::createScript(const std::string& scriptName, GameObject* owner)
-{
-    for (const ScriptRegistry& script : m_registry)
-    {
-        if (script.name == scriptName)
-        {
-            return script.creator(owner);
-        }
-    }
-
-    return nullptr;
-}
-
-bool ScriptFactory::isScriptRegistered(const std::string& scriptName)
-{
-    for (const ScriptRegistry& script : m_registry)
-    {
-        if (script.name == scriptName)
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void ScriptFactory::clear()
-{
-    m_registry.clear();
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFactory.h b/Engine_Master_UPC/ScriptFactory.h
deleted file mode 100644
index 34ee7ee8..00000000
--- a/Engine_Master_UPC/ScriptFactory.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "ScriptRegistry.h"
-#include <vector>
-
-class ScriptFactory
-{
-public:
-    static void registerScript(const std::string& scriptName, ScriptCreator creator);
-    static std::unique_ptr<Script> createScript(const std::string& scriptName, GameObject* owner);
-    static bool isScriptRegistered(const std::string& scriptName);
-
-    static void clear();
-
-private:
-    static std::vector<ScriptRegistry> m_registry;
-};
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler.h b/Engine_Master_UPC/ScriptFieldHandler.h
deleted file mode 100644
index 2b722c16..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-class Script;
-class ScriptComponent;
-class SceneReferenceResolver;
-class IArchive;
-
-struct ScriptFieldInfo;
-
-struct ScriptFieldHandler
-{
-    void (*drawUi)(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent& owner);
-    void (*serialize)(const ScriptFieldInfo& field, void* data, IArchive& archive);
-    void (*clone)(const ScriptFieldInfo& field, const void* sourceData, void* targetData);
-    void (*fixReferences)(const ScriptFieldInfo& field, void* data, const SceneReferenceResolver& resolver);
-};
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandlerRegistry.h b/Engine_Master_UPC/ScriptFieldHandlerRegistry.h
deleted file mode 100644
index e52a44e4..00000000
--- a/Engine_Master_UPC/ScriptFieldHandlerRegistry.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "ScriptFieldInfo.h"
-#include "EngineAPI.h"
-
-struct ScriptFieldHandler;
-
-ENGINE_API const ScriptFieldHandler* getFloatFieldHandler();
-ENGINE_API const ScriptFieldHandler* getIntFieldHandler();
-ENGINE_API const ScriptFieldHandler* getBoolFieldHandler();
-ENGINE_API const ScriptFieldHandler* getVec3FieldHandler();
-ENGINE_API const ScriptFieldHandler* getEnumIntFieldHandler();
-ENGINE_API const ScriptFieldHandler* getComponentRefFieldHandler();
-ENGINE_API const ScriptFieldHandler* getComponentRefListFieldHandler();
-ENGINE_API const ScriptFieldHandler* getAssetRefFieldHandler();
-ENGINE_API const ScriptFieldHandler* getStringFieldHandler();
-ENGINE_API const ScriptFieldHandler* getListFieldHandler(ScriptFieldType elementType);
-
-ENGINE_API const ScriptFieldHandler* getGroupLabelFieldHandler();
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_AssetRef.cpp b/Engine_Master_UPC/ScriptFieldHandler_AssetRef.cpp
deleted file mode 100644
index cf0b8802..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_AssetRef.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldHandler.h"
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "AssetRef.h"
-#include "AssetReference.h"
-#include "AssetType.h"
-
-#include "Application.h"
-#include "ModuleAssets.h"
-#include "AssetIndex.h"
-
-namespace
-{
-    void drawAssetRefFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        AssetRef<void>* assetRef = reinterpret_cast<AssetRef<void>*>(data);
-
-        const bool hasAsset = assetRef->m_ref.isValid();
-        const char* displayName = field.name;
-
-        ImGui::Text("%s", displayName);
-        ImGui::SameLine();
-
-        if (hasAsset)
-        {
-            ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "Assigned (UID %llu)", assetRef->m_ref.m_uid);
-        }
-        else
-        {
-            ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "None");
-        }
-
-        if (ImGui::BeginDragDropTarget())
-        {
-            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("ASSET"))
-            {
-                const UID droppedUID = *static_cast<const UID*>(payload->Data);
-                AssetReference* resolved = app->getModuleAssets()->findReference(droppedUID);
-                if (resolved)
-                {
-                    if (field.assetRefInfo.assetType == AssetType::UNKNOWN ||
-                        resolved->m_type == field.assetRefInfo.assetType)
-                    {
-                        assetRef->m_ref = *resolved;
-                        script.onFieldEdited(field);
-                    }
-                    delete resolved;
-                }
-            }
-
-            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("PREFAB_ASSET"))
-            {
-                const std::string pathStr(static_cast<const char*>(payload->Data));
-                const UID uid = app->getModuleAssets()->getIndex().findUID(std::filesystem::path(pathStr));
-                AssetReference* resolved = app->getModuleAssets()->findReference(uid);
-                if (resolved)
-                {
-                    if (field.assetRefInfo.assetType == AssetType::UNKNOWN ||
-                        resolved->m_type == field.assetRefInfo.assetType)
-                    {
-                        assetRef->m_ref = *resolved;
-                        script.onFieldEdited(field);
-                    }
-                    delete resolved;
-                }
-            }
-
-            ImGui::EndDragDropTarget();
-        }
-
-        ImGui::SameLine();
-
-        std::string clearLabel = std::string("Clear###") + field.name;
-        if (ImGui::Button(clearLabel.c_str()))
-        {
-            assetRef->m_ref = AssetReference();
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeAssetRefField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        AssetRef<void>* assetRef = reinterpret_cast<AssetRef<void>*>(data);
-        assetRef->m_ref.serialize(archive);
-    }
-
-    void cloneAssetRefField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        const AssetRef<void>* sourceRef = reinterpret_cast<const AssetRef<void>*>(sourceData);
-        AssetRef<void>* targetRef = reinterpret_cast<AssetRef<void>*>(targetData);
-        targetRef->m_ref = sourceRef->m_ref;
-    }
-
-    void fixReferencesAssetRefField(const ScriptFieldInfo&, void* data, const SceneReferenceResolver&)
-    {
-        AssetRef<void>* assetRef = reinterpret_cast<AssetRef<void>*>(data);
-
-        if (!assetRef->m_ref.isValid() && assetRef->m_ref.hasUID())
-        {
-            AssetReference* resolved = app->getModuleAssets()->findReference(assetRef->m_ref.m_uid);
-            if (resolved)
-            {
-                assetRef->m_ref = *resolved;
-                delete resolved;
-            }
-        }
-    }
-
-    const ScriptFieldHandler assetRefFieldHandler = {
-        &drawAssetRefFieldUi,
-        &serializeAssetRefField,
-        &cloneAssetRefField,
-        &fixReferencesAssetRefField
-    };
-}
-
-const ScriptFieldHandler* getAssetRefFieldHandler()
-{
-    return &assetRefFieldHandler;
-}
diff --git a/Engine_Master_UPC/ScriptFieldHandler_Bool.cpp b/Engine_Master_UPC/ScriptFieldHandler_Bool.cpp
deleted file mode 100644
index c93d1ab1..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_Bool.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "IArchive.h"
-
-namespace
-{
-    void drawBoolFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        bool* value = reinterpret_cast<bool*>(data);
-
-        if (ImGui::Checkbox(field.name, value))
-        {
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeBoolField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        bool* value = reinterpret_cast<bool*>(data);
-        archive.serialize(*value, field.name);
-    }
-
-    void cloneBoolField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        *reinterpret_cast<bool*>(targetData) = *reinterpret_cast<const bool*>(sourceData);
-    }
-
-    void fixReferencesBoolField(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler boolFieldHandler ={&drawBoolFieldUi, &serializeBoolField, &cloneBoolField, &fixReferencesBoolField};
-}
-
-const ScriptFieldHandler* getBoolFieldHandler()
-{
-    return &boolFieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_Float.cpp b/Engine_Master_UPC/ScriptFieldHandler_Float.cpp
deleted file mode 100644
index 2d874487..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_Float.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldHandler.h"
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "ScriptComponent.h"
-#include "SceneReferenceResolver.h"
-#include "IArchive.h"
-namespace
-{
-    void drawFloatFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        float* value = reinterpret_cast<float*>(data);
-
-        if (ImGui::DragFloat(field.name, value, field.floatInfo.dragSpeed, field.floatInfo.min, field.floatInfo.max))
-        {
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeFloatField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        float* value = reinterpret_cast<float*>(data);
-        archive.serialize(*value, field.name);
-    }
-
-    void cloneFloatField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        *reinterpret_cast<float*>(targetData) = *reinterpret_cast<const float*>(sourceData);
-    }
-
-    void fixReferencesFloatField(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler floatFieldHandler = { &drawFloatFieldUi, &serializeFloatField, &cloneFloatField, &fixReferencesFloatField};
-}
-
-const ScriptFieldHandler* getFloatFieldHandler()
-{
-    return &floatFieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_GroupLabel.cpp b/Engine_Master_UPC/ScriptFieldHandler_GroupLabel.cpp
deleted file mode 100644
index 1bf564cb..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_GroupLabel.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-
-namespace
-{
-    void drawGroupLabelUi(const ScriptFieldInfo& field, void*, Script&, ScriptComponent&)
-    {
-        ImGui::Spacing();
-        ImGui::SeparatorText(field.name);
-    }
-
-    void serializeGroupLabel(const ScriptFieldInfo&, void*, IArchive&)
-    {
-    }
-
-    void cloneGroupLabel(const ScriptFieldInfo&, const void*, void*)
-    {
-    }
-
-    void fixReferencesGroupLabel(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler groupLabelFieldHandler = {&drawGroupLabelUi, &serializeGroupLabel, &cloneGroupLabel, &fixReferencesGroupLabel};
-}
-
-const ScriptFieldHandler* getGroupLabelFieldHandler()
-{
-    return &groupLabelFieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_Int.cpp b/Engine_Master_UPC/ScriptFieldHandler_Int.cpp
deleted file mode 100644
index 61ba1bc9..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_Int.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "IArchive.h"
-
-namespace
-{
-    void drawIntFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        int* value = reinterpret_cast<int*>(data);
-
-        if (ImGui::DragInt(field.name, value))
-        {
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeIntField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        int* value = reinterpret_cast<int*>(data);
-        uint32_t v = static_cast<uint32_t>(*value);
-        archive.serialize(v, field.name);
-        if (archive.mode() == ArchiveMode::Input)
-            *value = static_cast<int>(v);
-    }
-
-    void cloneIntField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        *reinterpret_cast<int*>(targetData) = *reinterpret_cast<const int*>(sourceData);
-    }
-
-    void fixReferencesIntField(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler intFieldHandler = {&drawIntFieldUi, &serializeIntField, &cloneIntField, &fixReferencesIntField};
-}
-
-const ScriptFieldHandler* getIntFieldHandler()
-{
-    return &intFieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_List.cpp b/Engine_Master_UPC/ScriptFieldHandler_List.cpp
deleted file mode 100644
index e673f75e..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_List.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "ScriptComponentRef.h"
-#include "SceneReferenceResolver.h"
-
-#include "Application.h"
-#include "ModuleScene.h"
-#include "Scene.h"
-#include "GameObject.h"
-#include "Transform.h"
-
-namespace
-{
-    template<typename T>
-    void elementSerialize(T& elem, IArchive& archive)
-    {
-        archive.serialize(elem, "");
-    }
-
-    template<>
-    void elementSerialize<int>(int& elem, IArchive& archive)
-    {
-        uint32_t v = archive.mode() == ArchiveMode::Output ? static_cast<uint32_t>(elem) : 0;
-        archive.serialize(v, "");
-        if (archive.mode() == ArchiveMode::Input)
-            elem = static_cast<int>(v);
-    }
-
-    template<>
-    void elementSerialize<Vector3>(Vector3& elem, IArchive& archive)
-    {
-        DirectX::SimpleMath::Vector3 v(elem.x, elem.y, elem.z);
-        archive.serialize(v, "");
-        if (archive.mode() == ArchiveMode::Input)
-        {
-            elem.x = v.x; elem.y = v.y; elem.z = v.z;
-        }
-    }
-
-    template<>
-    void elementSerialize<std::string>(std::string& elem, IArchive& archive)
-    {
-        archive.serialize(elem, "");
-    }
-
-    template<>
-    void elementSerialize<ScriptComponentRef<Component>>(ScriptComponentRef<Component>& elem, IArchive& archive)
-    {
-        archive.serialize(elem.uid, "");
-        if (archive.mode() == ArchiveMode::Input)
-            elem.component = nullptr;
-    }
-
-    template<typename T>
-    void drawListFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent& owner)
-    {
-        auto* vec = reinterpret_cast<std::vector<T>*>(data);
-        const ScriptFieldHandler* elemHandler = field.listInfo.elementHandler;
-
-        std::string headerLabel = std::string(field.name) + " (" + std::to_string(vec->size()) + ")";
-        ImGui::Text("%s", headerLabel.c_str());
-
-        int removeIndex = -1;
-
-        for (size_t i = 0; i < vec->size(); ++i)
-        {
-            ImGui::PushID(static_cast<int>(i));
-
-            char elementLabel[64];
-            snprintf(elementLabel, sizeof(elementLabel), "[%zu]", i);
-
-            ScriptFieldInfo elementField = field;
-            elementField.name = elementLabel;
-            elementField.type = field.listInfo.elementType;
-            elementField.handler = elemHandler;
-
-            T elemCopy = (*vec)[i];
-            elemHandler->drawUi(elementField, &elemCopy, script, owner);
-            (*vec)[i] = elemCopy;
-
-            ImGui::SameLine();
-
-            if (ImGui::Button("X"))
-            {
-                removeIndex = static_cast<int>(i);
-            }
-
-            ImGui::PopID();
-        }
-
-        if (removeIndex >= 0)
-        {
-            vec->erase(vec->begin() + removeIndex);
-            script.onFieldEdited(field);
-        }
-
-        std::string addLabel = std::string("+ Add Element##") + field.name;
-        if (ImGui::Button(addLabel.c_str()))
-        {
-            vec->push_back(T{});
-            script.onFieldEdited(field);
-        }
-
-        ImGui::SameLine();
-
-        std::string clearLabel = std::string("Clear All##") + field.name;
-        if (ImGui::Button(clearLabel.c_str()))
-        {
-            if (!vec->empty())
-            {
-                vec->clear();
-                script.onFieldEdited(field);
-            }
-        }
-    }
-
-    template<typename T>
-    void serializeListField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        auto* vec = reinterpret_cast<std::vector<T>*>(data);
-        uint32_t count = archive.mode() == ArchiveMode::Output ? static_cast<uint32_t>(vec->size()) : 0;
-        archive.beginArray(count, field.name);
-
-        if (archive.mode() == ArchiveMode::Input)
-        {
-            vec->clear();
-            vec->reserve(count);
-        }
-
-        for (uint32_t i = 0; i < count; ++i)
-        {
-            if (archive.mode() == ArchiveMode::Output)
-            {
-                T elem = (*vec)[i];
-                elementSerialize(elem, archive);
-            }
-            else
-            {
-                T elem{};
-                elementSerialize(elem, archive);
-                vec->push_back(std::move(elem));
-            }
-        }
-
-        archive.endArray();
-    }
-
-    template<typename T>
-    void cloneListField(const ScriptFieldInfo& field, const void* sourceData, void* targetData)
-    {
-        const auto* sourceVec = reinterpret_cast<const std::vector<T>*>(sourceData);
-        auto* targetVec = reinterpret_cast<std::vector<T>*>(targetData);
-        const ScriptFieldHandler* elemHandler = field.listInfo.elementHandler;
-
-        targetVec->clear();
-        targetVec->reserve(sourceVec->size());
-
-        for (const T& sourceElem : *sourceVec)
-        {
-            T targetElem;
-            elemHandler->clone(field, &sourceElem, &targetElem);
-            targetVec->push_back(std::move(targetElem));
-        }
-    }
-
-    template<typename T>
-    void fixReferencesListField(const ScriptFieldInfo& field, void* data, const SceneReferenceResolver& resolver)
-    {
-        auto* vec = reinterpret_cast<std::vector<T>*>(data);
-        const ScriptFieldHandler* elemHandler = field.listInfo.elementHandler;
-
-        for (size_t i = 0; i < vec->size(); ++i)
-        {
-            T elemCopy = (*vec)[i];
-            elemHandler->fixReferences(field, &elemCopy, resolver);
-            (*vec)[i] = elemCopy;
-        }
-    }
-
-    // --- Template instantiations for each supported element type ---
-
-    const ScriptFieldHandler floatListHandler = {
-        &drawListFieldUi<float>,
-        &serializeListField<float>,
-        &cloneListField<float>,
-        &fixReferencesListField<float>
-    };
-
-    const ScriptFieldHandler intListHandler = {
-        &drawListFieldUi<int>,
-        &serializeListField<int>,
-        &cloneListField<int>,
-        &fixReferencesListField<int>
-    };
-
-    const ScriptFieldHandler boolListHandler = {
-        &drawListFieldUi<bool>,
-        &serializeListField<bool>,
-        &cloneListField<bool>,
-        &fixReferencesListField<bool>
-    };
-
-    const ScriptFieldHandler vec3ListHandler = {
-        &drawListFieldUi<Vector3>,
-        &serializeListField<Vector3>,
-        &cloneListField<Vector3>,
-        &fixReferencesListField<Vector3>
-    };
-
-    const ScriptFieldHandler stringListHandler = {
-        &drawListFieldUi<std::string>,
-        &serializeListField<std::string>,
-        &cloneListField<std::string>,
-        &fixReferencesListField<std::string>
-    };
-
-    const ScriptFieldHandler enumIntListHandler = {
-        &drawListFieldUi<int>,
-        &serializeListField<int>,
-        &cloneListField<int>,
-        &fixReferencesListField<int>
-    };
-
-    const ScriptFieldHandler componentRefListHandler = {
-        &drawListFieldUi<ScriptComponentRef<Component>>,
-        &serializeListField<ScriptComponentRef<Component>>,
-        &cloneListField<ScriptComponentRef<Component>>,
-        &fixReferencesListField<ScriptComponentRef<Component>>
-    };
-}
-
-const ScriptFieldHandler* getListFieldHandler(ScriptFieldType elementType)
-{
-    switch (elementType)
-    {
-        case ScriptFieldType::Float:        return &floatListHandler;
-        case ScriptFieldType::Int:          return &intListHandler;
-        case ScriptFieldType::Bool:         return &boolListHandler;
-        case ScriptFieldType::Vec3:         return &vec3ListHandler;
-        case ScriptFieldType::String:       return &stringListHandler;
-        case ScriptFieldType::EnumInt:      return &enumIntListHandler;
-        case ScriptFieldType::ComponentRef: return &componentRefListHandler;
-        default:                            return nullptr;
-    }
-}
diff --git a/Engine_Master_UPC/ScriptFieldHandler_String.cpp b/Engine_Master_UPC/ScriptFieldHandler_String.cpp
deleted file mode 100644
index 0d76dc41..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_String.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "IArchive.h"
-namespace
-{
-    void drawStringFieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        std::string* value = reinterpret_cast<std::string*>(data);
-
-        char buffer[256];
-        std::strncpy(buffer, value->c_str(), sizeof(buffer));
-        buffer[sizeof(buffer) - 1] = '\0';
-
-        if (ImGui::InputText(field.name, buffer, sizeof(buffer)))
-        {
-            *value = buffer;
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeStringField(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        std::string* value = reinterpret_cast<std::string*>(data);
-        archive.serialize(*value, field.name);
-    }
-
-    void cloneStringField(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        *reinterpret_cast<std::string*>(targetData) = *reinterpret_cast<const std::string*>(sourceData);
-    }
-
-    void fixReferencesStringField(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler stringFieldHandler = {&drawStringFieldUi, &serializeStringField, &cloneStringField, &fixReferencesStringField};
-}
-
-const ScriptFieldHandler* getStringFieldHandler()
-{
-    return &stringFieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldHandler_Vec3.cpp b/Engine_Master_UPC/ScriptFieldHandler_Vec3.cpp
deleted file mode 100644
index 8ce472b2..00000000
--- a/Engine_Master_UPC/ScriptFieldHandler_Vec3.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "Globals.h"
-
-#include "ScriptFieldHandlerRegistry.h"
-#include "Script.h"
-#include "IArchive.h"
-
-namespace
-{
-    void drawVec3FieldUi(const ScriptFieldInfo& field, void* data, Script& script, ScriptComponent&)
-    {
-        Vector3* value = reinterpret_cast<Vector3*>(data);
-
-        if (ImGui::DragFloat3(field.name, &value->x, 0.1f))
-        {
-            script.onFieldEdited(field);
-        }
-    }
-
-    void serializeVec3Field(const ScriptFieldInfo& field, void* data, IArchive& archive)
-    {
-        Vector3* value = reinterpret_cast<Vector3*>(data);
-        DirectX::SimpleMath::Vector3 v(value->x, value->y, value->z);
-        archive.serialize(v, field.name);
-        if (archive.mode() == ArchiveMode::Input)
-        {
-            value->x = v.x; value->y = v.y; value->z = v.z;
-        }
-    }
-
-    void cloneVec3Field(const ScriptFieldInfo&, const void* sourceData, void* targetData)
-    {
-        *reinterpret_cast<Vector3*>(targetData) = *reinterpret_cast<const Vector3*>(sourceData);
-    }
-
-    void fixReferencesVec3Field(const ScriptFieldInfo&, void*, const SceneReferenceResolver&)
-    {
-    }
-
-    const ScriptFieldHandler vec3FieldHandler = {&drawVec3FieldUi, &serializeVec3Field, &cloneVec3Field, &fixReferencesVec3Field};
-}
-
-const ScriptFieldHandler* getVec3FieldHandler()
-{
-    return &vec3FieldHandler;
-}
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldInfo.h b/Engine_Master_UPC/ScriptFieldInfo.h
deleted file mode 100644
index 759998e4..00000000
--- a/Engine_Master_UPC/ScriptFieldInfo.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include <vector>
-#include "ComponentType.h"
-#include "AssetType.h"
-#include "ScriptFieldHandler.h"
-
-enum class ScriptFieldType
-{
-    Float,
-    Int,
-    Bool,
-    Vec3,
-    EnumInt,
-    ComponentRef,
-    ComponentRefList,
-    String,
-    List,
-    AssetRef,
-
-    GroupLabel,
-    GroupCollapseBegin,
-    GroupCollapseEnd
-};
-
-struct ScriptFieldFloatInfo
-{
-    float min = 0.0f;
-    float max = 0.0f;
-    float dragSpeed = 0.1f;
-};
-
-struct ScriptFieldEnumInfo
-{
-    const char** names = nullptr;
-    int count = 0;
-};
-
-struct ScriptFieldComponentRefInfo
-{
-    ComponentType componentType;
-};
-
-struct ScriptFieldAssetRefInfo
-{
-    AssetType assetType = AssetType::UNKNOWN;
-};
-
-struct ScriptFieldListInfo
-{
-    ScriptFieldType elementType;
-    const ScriptFieldHandler* elementHandler;
-};
-
-struct ScriptFieldInfo
-{
-    const char* name;
-    ScriptFieldType type;
-    size_t offset;
-
-    const ScriptFieldHandler* handler = nullptr;
-
-    ScriptFieldFloatInfo floatInfo{};
-    ScriptFieldEnumInfo enumInfo{};
-    ScriptFieldComponentRefInfo componentRefInfo{ ComponentType::TRANSFORM };
-    ScriptFieldListInfo listInfo{ ScriptFieldType::Float, nullptr };
-    ScriptFieldAssetRefInfo assetRefInfo{};
-
-    bool editorOnly = false;
-
-    bool isDataField() const
-    {
-        return !editorOnly;
-    }
-};
-
-struct ScriptFieldList
-{
-    std::vector<ScriptFieldInfo> fields;
-
-    ScriptFieldList() = default;
-
-    ScriptFieldList(const ScriptFieldInfo* fieldArray, size_t fieldCount)
-    {
-        append(fieldArray, fieldCount);
-    }
-
-    void append(const ScriptFieldInfo* fieldArray, size_t fieldCount)
-    {
-        fields.insert(fields.end(), fieldArray, fieldArray + fieldCount);
-    }
-};
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptFieldMacros.h b/Engine_Master_UPC/ScriptFieldMacros.h
deleted file mode 100644
index 3e30c646..00000000
--- a/Engine_Master_UPC/ScriptFieldMacros.h
+++ /dev/null
@@ -1,109 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-#include "ScriptFieldInfo.h"
-#include "ScriptFieldHandlerRegistry.h"
-#include "ScriptFieldTypeTraits.h"
-
-#define SCRIPT_FIELD_COUNT(FieldArrayName) \
-    (sizeof(FieldArrayName) / sizeof(ScriptFieldInfo))
-
-
-#define IMPLEMENT_SCRIPT_FIELDS(ScriptType, ...)                              \
-    ScriptFieldList ScriptType::getExposedFields() const                      \
-    {                                                                         \
-        using ThisScript = ScriptType;                                        \
-        static const ScriptFieldInfo ownFields[] = { __VA_ARGS__ };           \
-        return ScriptFieldList(ownFields, SCRIPT_FIELD_COUNT(ownFields));     \
-    }
-
-
-#define IMPLEMENT_SCRIPT_FIELDS_INHERITED(ScriptType, BaseType, ...)          \
-    ScriptFieldList ScriptType::getExposedFields() const                      \
-    {                                                                         \
-        using ThisScript = ScriptType;                                        \
-        ScriptFieldList exposedFields = BaseType::getExposedFields();         \
-        static const ScriptFieldInfo ownFields[] = { __VA_ARGS__ };           \
-        exposedFields.append(ownFields, SCRIPT_FIELD_COUNT(ownFields));       \
-        return exposedFields;                                                 \
-    }
-
-
-// Field helper macros
-
-#define SERIALIZED_FLOAT(MemberName, DisplayName, Min, Max, Speed) \
-    { DisplayName, ScriptFieldType::Float, offsetof(ThisScript, MemberName), getFloatFieldHandler(), { Min, Max, Speed } }
-
-#define SERIALIZED_INT(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::Int, offsetof(ThisScript, MemberName), getIntFieldHandler() }
-
-#define SERIALIZED_BOOL(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::Bool, offsetof(ThisScript, MemberName), getBoolFieldHandler() }
-
-#define SERIALIZED_VEC3(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::Vec3, offsetof(ThisScript, MemberName), getVec3FieldHandler() }
-
-#define SERIALIZED_STRING(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::String, offsetof(ThisScript, MemberName), getStringFieldHandler() }
-
-#define SERIALIZED_ENUM_INT(MemberName, DisplayName, NamesArray, Count) \
-    { DisplayName, ScriptFieldType::EnumInt, offsetof(ThisScript, MemberName), getEnumIntFieldHandler(), {}, { NamesArray, Count } }
-
-#define SERIALIZED_COMPONENT_REF(MemberName, DisplayName, ComponentTypeValue) \
-    { DisplayName, ScriptFieldType::ComponentRef, offsetof(ThisScript, MemberName), getComponentRefFieldHandler(), {}, {}, { ComponentTypeValue } }
-
-#define SERIALIZED_ASSET_REF(MemberName, DisplayName, AssetTypeValue) \
-    { DisplayName, ScriptFieldType::AssetRef, offsetof(ThisScript, MemberName), getAssetRefFieldHandler(), {}, {}, {}, {}, { AssetTypeValue } }
-
-#define SERIALIZED_COMPONENT_REF_LIST(MemberName, DisplayName, ComponentTypeValue) \
-    { DisplayName, ScriptFieldType::ComponentRefList, offsetof(ThisScript, MemberName), getComponentRefListFieldHandler(), {}, {}, { ComponentTypeValue } }
-
-// Vector (std::vector<T>) field macros
-
-// Generic — auto-detects the element type at compile time
-#define SERIALIZED_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), \
-      getListFieldHandler(scriptFieldTypeOf<typename decltype(ThisScript::MemberName)::value_type>()), \
-      {}, {}, {}, \
-      { scriptFieldTypeOf<typename decltype(ThisScript::MemberName)::value_type>(), \
-        scriptFieldHandlerOf<typename decltype(ThisScript::MemberName)::value_type>() } }
-
-// Type-specific convenience macros (no auto-detection needed)
-
-#define SERIALIZED_FLOAT_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::Float), {}, {}, {}, { ScriptFieldType::Float, getFloatFieldHandler() } }
-
-#define SERIALIZED_INT_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::Int), {}, {}, {}, { ScriptFieldType::Int, getIntFieldHandler() } }
-
-#define SERIALIZED_BOOL_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::Bool), {}, {}, {}, { ScriptFieldType::Bool, getBoolFieldHandler() } }
-
-#define SERIALIZED_VEC3_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::Vec3), {}, {}, {}, { ScriptFieldType::Vec3, getVec3FieldHandler() } }
-
-#define SERIALIZED_STRING_VECTOR(MemberName, DisplayName) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::String), {}, {}, {}, { ScriptFieldType::String, getStringFieldHandler() } }
-
-#define SERIALIZED_ENUM_INT_VECTOR(MemberName, DisplayName, NamesArray, Count) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::EnumInt), {}, { NamesArray, Count }, {}, { ScriptFieldType::EnumInt, getEnumIntFieldHandler() } }
-
-#define SERIALIZED_COMPONENT_REF_VECTOR(MemberName, DisplayName, ComponentTypeValue) \
-    { DisplayName, ScriptFieldType::List, offsetof(ThisScript, MemberName), getListFieldHandler(ScriptFieldType::ComponentRef), {}, {}, { ComponentTypeValue }, { ScriptFieldType::ComponentRef, getComponentRefFieldHandler() } }
-
-// Non serializable fields macros
-
-#define FIELD_GROUP_LABEL(DisplayName) \
-    { DisplayName, ScriptFieldType::GroupLabel, 0, getGroupLabelFieldHandler(), {}, {}, {}, {}, {}, true }
-
-#define INTERNAL_FIELD_GROUP_COLLAPSE_BEGIN(DisplayName) \
-    { DisplayName, ScriptFieldType::GroupCollapseBegin, 0, nullptr, {}, {}, {}, {}, {}, true }
-
-#define INTERNAL_FIELD_GROUP_COLLAPSE_END() \
-    { "", ScriptFieldType::GroupCollapseEnd, 0, nullptr, {}, {}, {}, {}, {}, true }
-
-#define FIELD_GROUP_COLLAPSE(DisplayName, ...) \
-    INTERNAL_FIELD_GROUP_COLLAPSE_BEGIN(DisplayName), \
-    __VA_ARGS__, \
-    INTERNAL_FIELD_GROUP_COLLAPSE_END()
\ No newline at end of file
diff --git a/Engine_Master_UPC/ScriptLibraryLoader.cpp b/Engine_Master_UPC/ScriptLibraryLoader.cpp
index a39cf042..6e5b3db0 100644
--- a/Engine_Master_UPC/ScriptLibraryLoader.cpp
+++ b/Engine_Master_UPC/ScriptLibraryLoader.cpp
@@ -1,8 +1,8 @@
 #include "Globals.h"
 #include "ScriptLibraryLoader.h"
+#include "GenericTypeFactory.h"
 
 #include "PdbPatcher.h"
-#include "ScriptFactory.h"
 
 #include <cstdio>
 #include <filesystem>
@@ -68,6 +68,7 @@ bool ScriptLibraryLoader::unload()
     }
 
     ScriptFactory::clear();
+    DataContainerFactory::clear();
 
     if (!FreeLibrary(m_module))
     {
diff --git a/Engine_Master_UPC/ScriptRegistry.h b/Engine_Master_UPC/ScriptRegistry.h
deleted file mode 100644
index 30148190..00000000
--- a/Engine_Master_UPC/ScriptRegistry.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "ScriptCreator.h"
-#include <string>
-
-struct ScriptRegistry
-{
-    std::string name;
-    ScriptCreator creator;
-};
\ No newline at end of file
diff --git a/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.cpp b/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.cpp
index 0f1a6124..e6565e3b 100644
--- a/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.cpp
+++ b/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.cpp
@@ -1,7 +1,7 @@
 #include "pch.h"
 #include "$safeitemname$.h"
 
-IMPLEMENT_SCRIPT_FIELDS($safeitemname$
+IMPLEMENT_FIELDS($safeitemname$
 )
 
 $safeitemname$::$safeitemname$(GameObject* owner)
diff --git a/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.h b/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.h
index e0005048..151656bb 100644
--- a/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.h
+++ b/Engine_Master_UPC/Tools/ScriptsTemplates/GameScript/GameScript.h
@@ -12,5 +12,5 @@ class $safeitemname$ : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 };
\ No newline at end of file
diff --git a/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.cpp b/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.cpp
index ae42039b..030b0ef8 100644
--- a/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.cpp
+++ b/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.cpp
@@ -1,7 +1,7 @@
 #include "pch.h"
 #include "$safeitemname$.h"
 
-IMPLEMENT_SCRIPT_FIELDS($safeitemname$
+IMPLEMENT_FIELDS($safeitemname$
 )
 
 $safeitemname$::$safeitemname$(GameObject* owner)
diff --git a/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.h b/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.h
index 6e58cd3b..45b52357 100644
--- a/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.h
+++ b/Engine_Master_UPC/Tools/ScriptsTemplates/StateMachineScript/StateMachineScript.h
@@ -14,5 +14,5 @@ class $safeitemname$ : public StateMachineScript
     void OnStateUpdate() override;
     void OnStateExit() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 };
\ No newline at end of file
diff --git a/Engine_Master_UPC/WindowDataContainerManager.cpp b/Engine_Master_UPC/WindowDataContainerManager.cpp
new file mode 100644
index 00000000..a0ea7b9a
--- /dev/null
+++ b/Engine_Master_UPC/WindowDataContainerManager.cpp
@@ -0,0 +1,194 @@
+#include "Globals.h"
+#include "WindowDataContainerManager.h"
+
+#include "Application.h"
+#include "ModuleAssets.h"
+#include "AssetsDictionary.h"
+#include "Extensions.h"
+
+#include <rapidjson/document.h>
+#include <rapidjson/filereadstream.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cstdio>
+#include <string>
+
+WindowDataContainerManager::WindowDataContainerManager()
+{
+}
+
+void WindowDataContainerManager::scanFiles()
+{
+    m_entries.clear();
+    m_selected = -1;
+
+    const std::filesystem::path root(ASSETS_FOLDER);
+    if (!std::filesystem::exists(root))
+        return;
+
+    for (const auto& entry : std::filesystem::recursive_directory_iterator(root))
+    {
+        if (!entry.is_regular_file())
+            continue;
+        if (entry.path().extension() != DATA_CONTAINER_EXTENSION)
+            continue;
+
+        Entry e;
+        e.path = entry.path().lexically_normal();
+        e.displayName = e.path.stem().string();
+
+        FILE* fp = std::fopen(e.path.string().c_str(), "rb");
+        if (fp)
+        {
+            char readBuffer[4096];
+            rapidjson::FileReadStream is(fp, readBuffer, sizeof(readBuffer));
+            rapidjson::Document doc;
+            doc.ParseStream(is);
+            std::fclose(fp);
+
+            if (!doc.HasParseError() && doc.IsObject() && doc.HasMember("_typeName") && doc["_typeName"].IsString())
+            {
+                e.typeName = doc["_typeName"].GetString();
+            }
+        }
+
+        if (e.typeName.empty())
+            e.typeName = "DataContainer";
+
+        m_entries.push_back(std::move(e));
+    }
+}
+
+void WindowDataContainerManager::ensureLoaded(int i)
+{
+    if (i < 0 || i >= static_cast<int>(m_entries.size()))
+        return;
+    Entry& e = m_entries[i];
+    if (e.asset)
+        return;
+
+    ModuleAssets* ma = app->getModuleAssets();
+    const UID uid = ma->getIndex().findUID(e.path);
+    if (!isValidUID(uid))
+        return;
+
+    AssetReference* ref = ma->findReference(uid);
+    if (!ref)
+        return;
+
+    e.asset = ma->load<DataContainer>(*ref);
+}
+
+void WindowDataContainerManager::drawList()
+{
+    ImGui::Text("Data Containers (%zu)", m_entries.size());
+    ImGui::Separator();
+
+    if (ImGui::BeginChild("DcList", ImVec2(0, 0), true))
+    {
+        for (int i = 0; i < static_cast<int>(m_entries.size()); ++i)
+        {
+            const Entry& e = m_entries[i];
+
+            if (m_filter[0] != '\0')
+            {
+                std::string lowerFilter = m_filter;
+                std::transform(lowerFilter.begin(), lowerFilter.end(), lowerFilter.begin(), ::tolower);
+                std::string lowerDisplay = e.displayName;
+                std::transform(lowerDisplay.begin(), lowerDisplay.end(), lowerDisplay.begin(), ::tolower);
+                std::string lowerType = e.typeName;
+                std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+                if (lowerDisplay.find(lowerFilter) == std::string::npos &&
+                    lowerType.find(lowerFilter) == std::string::npos)
+                {
+                    continue;
+                }
+            }
+
+            ImGui::PushID(i);
+
+            const bool isSelected = (i == m_selected);
+            if (ImGui::Selectable("", isSelected, ImGuiSelectableFlags_AllowDoubleClick))
+            {
+                m_selected = i;
+                ensureLoaded(i);
+            }
+            ImGui::SameLine();
+
+            ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "[%s]", e.typeName.c_str());
+            ImGui::SameLine();
+            ImGui::TextUnformatted(e.displayName.c_str());
+
+            ImGui::PopID();
+        }
+    }
+    ImGui::EndChild();
+}
+
+void WindowDataContainerManager::drawDetail()
+{
+    if (m_selected < 0 || m_selected >= static_cast<int>(m_entries.size()))
+    {
+        ImGui::TextDisabled("Select a Data Container from the list.");
+        return;
+    }
+
+    Entry& e = m_entries[m_selected];
+    ensureLoaded(m_selected);
+
+    if (!e.asset)
+    {
+        ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Failed to load '%s'.", e.displayName.c_str());
+        return;
+    }
+
+    if (ImGui::BeginChild("DcDetail", ImVec2(0, -ImGui::GetFrameHeightWithSpacing() - 4), true))
+    {
+        e.asset->drawUI();
+    }
+    ImGui::EndChild();
+
+}
+
+void WindowDataContainerManager::drawInternal()
+{
+    if (m_needsScan)
+    {
+        scanFiles();
+        m_needsScan = false;
+    }
+
+    if (ImGui::Button("Refresh"))
+    {
+        m_entries.clear();
+        m_selected = -1;
+        scanFiles();
+    }
+    ImGui::SameLine();
+    ImGui::TextUnformatted("|");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(200);
+    ImGui::InputTextWithHint("##filter", "Filter...", m_filter, sizeof(m_filter));
+
+    ImGui::Separator();
+
+    ImGui::Columns(2, "DcSplit", false);
+    ImGui::SetColumnWidth(0, 300.0f);
+
+    if (ImGui::BeginChild("LeftPanel", ImVec2(0, 0), true))
+    {
+        drawList();
+    }
+    ImGui::EndChild();
+
+    ImGui::NextColumn();
+
+    if (ImGui::BeginChild("RightPanel", ImVec2(0, 0), true))
+    {
+        drawDetail();
+    }
+    ImGui::EndChild();
+
+    ImGui::Columns(1);
+}
diff --git a/Engine_Master_UPC/WindowDataContainerManager.h b/Engine_Master_UPC/WindowDataContainerManager.h
new file mode 100644
index 00000000..e7c37e65
--- /dev/null
+++ b/Engine_Master_UPC/WindowDataContainerManager.h
@@ -0,0 +1,34 @@
+#pragma once
+#include "EditorWindow.h"
+#include "DataContainer.h"
+
+#include <filesystem>
+#include <memory>
+#include <vector>
+
+class WindowDataContainerManager : public EditorWindow
+{
+public:
+    WindowDataContainerManager();
+    const char* getWindowName() const override { return "Data Container Manager"; }
+    void drawInternal() override;
+
+private:
+    struct Entry
+    {
+        std::filesystem::path path;
+        std::string typeName;
+        std::string displayName;
+        std::shared_ptr<DataContainer> asset;
+    };
+
+    void scanFiles();
+    void ensureLoaded(int i);
+    void drawList();
+    void drawDetail();
+
+    std::vector<Entry> m_entries;
+    int m_selected = -1;
+    bool m_needsScan = true;
+    char m_filter[128] = "";
+};
diff --git a/Engine_Master_UPC/WindowFileDialog.cpp b/Engine_Master_UPC/WindowFileDialog.cpp
index d649bd78..8e862dff 100644
--- a/Engine_Master_UPC/WindowFileDialog.cpp
+++ b/Engine_Master_UPC/WindowFileDialog.cpp
@@ -20,6 +20,9 @@
 #include "CommandImportAsset.h"
 #include "CommandPasteFile.h"
 #include "CommandSaveGameObjectAsPrefab.h"
+#include "CommandCreateDataContainer.h"
+
+#include "GenericTypeFactory.h"
 
 #include <algorithm>
 #include <cctype>
@@ -319,6 +322,14 @@ void WindowFileDialog::drawAssetItem(DirectoryEntry* directory, const AssetEntry
             ImGui::CloseCurrentPopup();
         }
 
+        if (ImGui::MenuItem("Rename..."))
+        {
+            m_renamingAsset = true;
+            const std::string srcStr = sourcePath.string();
+            strncpy_s(m_renameSrcBuf, sizeof(m_renameSrcBuf), srcStr.c_str(), sizeof(m_renameSrcBuf) - 1);
+            strncpy_s(m_renameDstBuf, sizeof(m_renameDstBuf), srcStr.c_str(), sizeof(m_renameDstBuf) - 1);
+        }
+
         if (ImGui::MenuItem("Cut", "Ctrl+X"))
         {
             CommandCutItem(m_clipboard, metaPath).run();
@@ -470,6 +481,24 @@ void WindowFileDialog::drawAssetGrid(DirectoryEntry* directory)
             CommandCreateFolder(m_currentDirectory).run();
         }
 
+        const auto& dcRegistry = DataContainerFactory::getAllRegistered();
+        if (!dcRegistry.empty())
+        {
+            ImGui::Spacing();
+            if (ImGui::BeginMenu("New Data Asset"))
+            {
+                for (const auto& entry : dcRegistry)
+                {
+                    if (ImGui::MenuItem(entry.displayName.c_str()))
+                    {
+                        std::string assetName = entry.displayName + "_New";
+                        CommandCreateDataContainer(m_currentDirectory, entry.name, assetName).run();
+                    }
+                }
+                ImGui::EndMenu();
+            }
+        }
+
         ImGui::Spacing();
         ImGui::Spacing();
         ImGui::Text("General");
@@ -567,6 +596,7 @@ void WindowFileDialog::drawAssetGrid(DirectoryEntry* directory)
         m_showVariantModal,
         m_showSavePrefabModal,
         m_renamingPrefab,
+        m_renamingAsset,
         buffers
     );
 }
diff --git a/Engine_Master_UPC/WindowFileDialog.h b/Engine_Master_UPC/WindowFileDialog.h
index 10b38427..eb23e2a2 100644
--- a/Engine_Master_UPC/WindowFileDialog.h
+++ b/Engine_Master_UPC/WindowFileDialog.h
@@ -123,6 +123,7 @@ class WindowFileDialog : public EditorWindow
     bool m_showVariantModal = false;
     bool m_showSavePrefabModal = false;
     bool m_renamingPrefab = false;
+    bool m_renamingAsset = false;
 
     std::filesystem::path m_pendingStateMachinePath;
 
diff --git a/Engine_OUT/GameScripts_runtime_1.dll b/Engine_OUT/GameScripts_runtime_1.dll
new file mode 100644
index 00000000..3bdb6475
Binary files /dev/null and b/Engine_OUT/GameScripts_runtime_1.dll differ
diff --git a/GameScripts/AbilityBase.h b/GameScripts/AbilityBase.h
index 7c5096b7..8bc66291 100644
--- a/GameScripts/AbilityBase.h
+++ b/GameScripts/AbilityBase.h
@@ -15,7 +15,7 @@ class AbilityBase : public Script
 
     void Start() override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     bool isEnabled() const { return m_isEnabled; }
     void setEnabled(bool enabled) { m_isEnabled = enabled; }
diff --git a/GameScripts/AmbientSoundLoop.h b/GameScripts/AmbientSoundLoop.h
index 73e03725..24449bb2 100644
--- a/GameScripts/AmbientSoundLoop.h
+++ b/GameScripts/AmbientSoundLoop.h
@@ -20,7 +20,7 @@ class AmbientSoundLoop : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void stop();
 
diff --git a/GameScripts/AnimationOverrideTester.h b/GameScripts/AnimationOverrideTester.h
index 1aa6dada..f1312fe2 100644
--- a/GameScripts/AnimationOverrideTester.h
+++ b/GameScripts/AnimationOverrideTester.h
@@ -13,13 +13,13 @@ class AnimationOverrideTester : public Script
 
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     AnimationComponent* getTargetAnimation() const;
 
 public:
-    ScriptComponentRef<Transform> m_target;
+    ComponentRef<Transform> m_target;
 
     std::string m_overrideClipName = "Walk";
 
diff --git a/GameScripts/ArcherArrowBarrageState.cpp b/GameScripts/ArcherArrowBarrageState.cpp
index c04bfb86..5e833b4f 100644
--- a/GameScripts/ArcherArrowBarrageState.cpp
+++ b/GameScripts/ArcherArrowBarrageState.cpp
@@ -16,7 +16,6 @@ ArcherArrowBarrageState::ArcherArrowBarrageState(GameObject* owner)
 void ArcherArrowBarrageState::OnStateEnter()
 {
     m_archerController = GameObjectAPI::findScript<RangedEnemyController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArcherAttackConfig>(getOwner());
     m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_archerUI  = GameObjectAPI::findScript<ArcherUI>(getOwner());
@@ -35,12 +34,6 @@ void ArcherArrowBarrageState::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArcherArrowBarrageState] ArcherAttackConfig not found.");
-        return;
-    }
-
     if (!m_attackExecutor)
     {
         Debug::error("[ArcherArrowBarrageState] EnemyAttackExecutor not found.");
@@ -64,14 +57,21 @@ void ArcherArrowBarrageState::OnStateEnter()
 
     m_archerController->updateCurrentTarget();
 
-    m_archerUI->setupArrowBarrageUI(m_attackConfig->m_arrowBarrageRadius);
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        Debug::error("[ArcherArrowBarrageState] ArcherAttackConfig not found.");
+        return;
+    }
+
+    m_archerUI->setupArrowBarrageUI(cfg->m_arrowBarrageRadius);
 
     Debug::log("[ArcherArrowBarrageState] ENTER");
 }
 
 void ArcherArrowBarrageState::OnStateUpdate()
 {
-    if (!m_archerController || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_archerController || !m_attackExecutor || !m_animation)
     {
         return;
     }
@@ -86,9 +86,15 @@ void ArcherArrowBarrageState::OnStateUpdate()
         return;
     }
 
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
     m_stateTimer += Time::getDeltaTime();
 
-    if (!m_hasLockedImpactPosition && m_stateTimer >= m_attackConfig->m_arrowBarrageThrowTime)
+    if (!m_hasLockedImpactPosition && m_stateTimer >= cfg->m_arrowBarrageThrowTime)
     {
         lockImpactPosition();
 
@@ -100,7 +106,7 @@ void ArcherArrowBarrageState::OnStateUpdate()
         m_hasLockedImpactPosition = true;
     }
 
-    const float impactTime = m_attackConfig->m_arrowBarrageThrowTime + m_attackConfig->m_arrowBarrageLandDelay;
+    const float impactTime = cfg->m_arrowBarrageThrowTime + cfg->m_arrowBarrageLandDelay;
 
     if (m_hasLockedImpactPosition && !m_hasAppliedImpact && m_stateTimer >= impactTime)
     {
@@ -116,10 +122,10 @@ void ArcherArrowBarrageState::OnStateUpdate()
 
     if (m_archerUI)
     {
-        m_archerUI->updateArrowBarrageUI(m_stateTimer, m_impactPosition, m_attackConfig->m_arrowBarrageThrowTime, m_attackConfig->m_arrowBarrageLandDelay, m_attackConfig->m_arrowBarrageTotalDuration);
+        m_archerUI->updateArrowBarrageUI(m_stateTimer, m_impactPosition, cfg->m_arrowBarrageThrowTime, cfg->m_arrowBarrageLandDelay, cfg->m_arrowBarrageTotalDuration);
     }
 
-    if (m_stateTimer >= m_attackConfig->m_arrowBarrageTotalDuration)
+    if (m_stateTimer >= cfg->m_arrowBarrageTotalDuration)
     {
         finishArrowBarrage();
         return;
@@ -156,14 +162,26 @@ void ArcherArrowBarrageState::lockImpactPosition()
     m_impactPosition = TransformAPI::getGlobalPosition(targetTransform);
 
     if (m_particles)
-        m_particles->spawnBarrageArrows(m_impactPosition, m_attackConfig->m_arrowBarrageLandDelay);
+    {
+        const ArcherAttackConfig* cfg = m_attackConfig.get();
+        if (cfg)
+        {
+            m_particles->spawnBarrageArrows(m_impactPosition, cfg->m_arrowBarrageLandDelay);
+        }
+    }
 
     Debug::log("[ArcherArrowBarrageState] Impact position locked: %.2f %.2f %.2f", m_impactPosition.x, m_impactPosition.y, m_impactPosition.z);
 }
 
 void ArcherArrowBarrageState::applyImpact()
 {
-    m_attackExecutor->applyDamageInRadius(m_impactPosition, m_attackConfig->m_arrowBarrageRadius, m_attackConfig->m_arrowBarrageDamage, "ArrowBarrage");
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    m_attackExecutor->applyDamageInRadius(m_impactPosition, cfg->m_arrowBarrageRadius, cfg->m_arrowBarrageDamage, "ArrowBarrage");
 
     if (m_particles)
         m_particles->spawnImpactParticle(m_impactPosition);
@@ -185,4 +203,6 @@ void ArcherArrowBarrageState::finishArrowBarrage()
     Debug::log("[ArcherArrowBarrageState] Finished, Chase trigger sent");
 }
 
-IMPLEMENT_SCRIPT(ArcherArrowBarrageState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(ArcherArrowBarrageState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/ArcherArrowBarrageState.h b/GameScripts/ArcherArrowBarrageState.h
index b0501b4e..0aca9da9 100644
--- a/GameScripts/ArcherArrowBarrageState.h
+++ b/GameScripts/ArcherArrowBarrageState.h
@@ -18,6 +18,8 @@ class ArcherArrowBarrageState : public StateMachineScript
 public:
     explicit ArcherArrowBarrageState(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void OnStateEnter() override;
     void OnStateUpdate() override;
     void OnStateExit() override;
@@ -29,7 +31,7 @@ class ArcherArrowBarrageState : public StateMachineScript
 
 private:
     RangedEnemyController* m_archerController = nullptr;
-    ArcherAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArcherAttackConfig> m_attackConfig;
     EnemyAttackExecutor* m_attackExecutor = nullptr;
     AnimationComponent* m_animation = nullptr;
     ArcherUI* m_archerUI = nullptr;
diff --git a/GameScripts/ArcherArrowShooter.cpp b/GameScripts/ArcherArrowShooter.cpp
index e97edab4..c81de795 100644
--- a/GameScripts/ArcherArrowShooter.cpp
+++ b/GameScripts/ArcherArrowShooter.cpp
@@ -6,6 +6,7 @@
 #include "ArcherGuardParticles.h"
 
 IMPLEMENT_SCRIPT_FIELDS(ArcherArrowShooter,
+    SERIALIZED_ASSET_REF(m_config, "Attack Config", AssetType::DATA_CONTAINER),
     SERIALIZED_ASSET_REF(m_arrowPrefab, "Arrow Prefab", AssetType::PREFAB)
 )
 
@@ -13,7 +14,6 @@ ArcherArrowShooter::ArcherArrowShooter(GameObject* owner) : Script(owner) {}
 
 void ArcherArrowShooter::Start()
 {
-    m_config     = GameObjectAPI::findScript<ArcherAttackConfig>(getOwner());
     m_controller = GameObjectAPI::findScript<RangedEnemyController>(getOwner());
     m_animation  = AnimationAPI::getAnimationComponent(getOwner());
     m_particles  = GameObjectAPI::findScript<ArcherGuardParticles>(getOwner());
@@ -22,7 +22,10 @@ void ArcherArrowShooter::Start()
 
 void ArcherArrowShooter::Update()
 {
-    if (!m_animation || !m_config || !m_arrowPrefab.m_ref.isValid()) return;
+    if (!m_animation || !m_arrowPrefab.m_ref.isValid()) return;
+
+    const ArcherAttackConfig* cfg = m_config.get();
+    if (!cfg) return;
 
     const char* state = AnimationAPI::getActiveStateName(m_animation);
     if (!state) return;
@@ -48,7 +51,7 @@ void ArcherArrowShooter::Update()
     m_timer += Time::getDeltaTime();
 
     // ── Fire arrow at windup time ─────────────────────────────────────────────
-    if (!m_fired && m_timer >= m_config->m_basicAttackWindupTime)
+    if (!m_fired && m_timer >= cfg->m_basicAttackWindupTime)
     {
         Transform* archerT = GameObjectAPI::getTransform(getOwner());
         Transform* targetT = m_controller ? m_controller->getCurrentTarget() : nullptr;
diff --git a/GameScripts/ArcherArrowShooter.h b/GameScripts/ArcherArrowShooter.h
index 11bf735f..80cba2e4 100644
--- a/GameScripts/ArcherArrowShooter.h
+++ b/GameScripts/ArcherArrowShooter.h
@@ -1,6 +1,7 @@
 #pragma once
 #include "ScriptAPI.h"
 
+
 class ArcherAttackConfig;
 class RangedEnemyController;
 class AnimationComponent;
@@ -13,12 +14,12 @@ class ArcherArrowShooter : public Script
     explicit ArcherArrowShooter(GameObject* owner);
     void Start()  override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     PrefabRef m_arrowPrefab;
 
 private:
-    ArcherAttackConfig*    m_config     = nullptr;
+    AssetRef<ArcherAttackConfig>    m_config;
     RangedEnemyController* m_controller = nullptr;
     AnimationComponent*    m_animation  = nullptr;
     ArcherGuardParticles*  m_particles  = nullptr;
diff --git a/GameScripts/ArcherAttackConfig.cpp b/GameScripts/ArcherAttackConfig.cpp
index f0c50317..ce7fa4cb 100644
--- a/GameScripts/ArcherAttackConfig.cpp
+++ b/GameScripts/ArcherAttackConfig.cpp
@@ -1,31 +1,2 @@
 #include "pch.h"
 #include "ArcherAttackConfig.h"
-
-#include "Transform2D.h"
-
-IMPLEMENT_SCRIPT_FIELDS_INHERITED(ArcherAttackConfig, EnemyBaseAttackConfig,
-    // Arrow Barrage
-    FIELD_GROUP_COLLAPSE("Arrow Barrage",
-        SERIALIZED_FLOAT(m_arrowBarrageRange, "Arrow Barrage Range", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_arrowBarrageDamage, "Arrow Barrage Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_arrowBarrageRadius, "Arrow Barrage Radius", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_arrowBarrageThrowTime, "Arrow Barrage Throw Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_arrowBarrageLandDelay, "Arrow Barrage Land Delay", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_arrowBarrageTotalDuration, "Arrow Barrage Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_arrowBarrageCooldown, "Arrow Barrage Cooldown", 0.0f, 30.0f, 0.1f)
-    ),
-    // Somersault
-    FIELD_GROUP_COLLAPSE("Somersault",
-        SERIALIZED_FLOAT(m_somersaultTriggerRange, "Somersault Trigger Range", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_somersaultDistance, "Somersault Distance", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_somersaultDuration, "Somersault Duration", 0.0f, 5.0f, 0.05f),
-        SERIALIZED_FLOAT(m_somersaultCooldown, "Somersault Cooldown", 0.0f, 30.0f, 0.1f)
-    )
-)
-
-ArcherAttackConfig::ArcherAttackConfig(GameObject* owner)
-    : EnemyBaseAttackConfig(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(ArcherAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/ArcherAttackConfig.h b/GameScripts/ArcherAttackConfig.h
index 8d5d9482..66f89c54 100644
--- a/GameScripts/ArcherAttackConfig.h
+++ b/GameScripts/ArcherAttackConfig.h
@@ -4,14 +4,15 @@
 
 class ArcherAttackConfig : public EnemyBaseAttackConfig
 {
-    DECLARE_SCRIPT(ArcherAttackConfig)
+    DECLARE_DATACONTAINER(ArcherAttackConfig)
 
 public:
-    explicit ArcherAttackConfig(GameObject* owner);
+    ArcherAttackConfig() = default;
+    explicit ArcherAttackConfig(AssetReference& id)
+        : EnemyBaseAttackConfig(id)
+    {
+    }
 
-    ScriptFieldList getExposedFields() const override;
-
-public:
     // Arrow Barrage
     float m_arrowBarrageRange = 7.0f;
     float m_arrowBarrageDamage = 15.0f;
@@ -27,4 +28,21 @@ class ArcherAttackConfig : public EnemyBaseAttackConfig
     float m_somersaultDuration = 0.35f;
     float m_somersaultCooldown = 9.0f;
 
-};
\ No newline at end of file
+    IMPLEMENT_DATACONTAINER_FIELDS_INHERITED(ArcherAttackConfig, EnemyBaseAttackConfig,
+        FIELD_GROUP_COLLAPSE("Arrow Barrage",
+            SERIALIZED_FLOAT(m_arrowBarrageRange, "Arrow Barrage Range", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_arrowBarrageDamage, "Arrow Barrage Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_arrowBarrageRadius, "Arrow Barrage Radius", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_arrowBarrageThrowTime, "Arrow Barrage Throw Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_arrowBarrageLandDelay, "Arrow Barrage Land Delay", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_arrowBarrageTotalDuration, "Arrow Barrage Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_arrowBarrageCooldown, "Arrow Barrage Cooldown", 0.0f, 30.0f, 0.1f)
+        ),
+        FIELD_GROUP_COLLAPSE("Somersault",
+            SERIALIZED_FLOAT(m_somersaultTriggerRange, "Somersault Trigger Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_somersaultDistance, "Somersault Distance", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_somersaultDuration, "Somersault Duration", 0.0f, 5.0f, 0.05f),
+            SERIALIZED_FLOAT(m_somersaultCooldown, "Somersault Cooldown", 0.0f, 30.0f, 0.1f)
+        )
+    )
+};
diff --git a/GameScripts/ArcherGuardParticles.h b/GameScripts/ArcherGuardParticles.h
index 38cfdf18..4a9e9a5b 100644
--- a/GameScripts/ArcherGuardParticles.h
+++ b/GameScripts/ArcherGuardParticles.h
@@ -8,12 +8,12 @@ class ArcherGuardParticles : public Script
 public:
     explicit ArcherGuardParticles(GameObject* owner);
     void Start() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
-    PrefabRef m_trailPrefab;
-    PrefabRef m_volleyPrefab;
-    PrefabRef m_chargePrefab;
-    PrefabRef m_arrowPrefab;
+    AssetRef<Prefab> m_trailPrefab;
+    AssetRef<Prefab> m_volleyPrefab;
+    AssetRef<Prefab> m_chargePrefab;
+    AssetRef<Prefab> m_arrowPrefab;
 
     // Basic attack trail — called by ArcherArrowShooter
     void spawnBasicAttackTrail(const Vector3& pos);
diff --git a/GameScripts/ArcherSomersaultState.cpp b/GameScripts/ArcherSomersaultState.cpp
index 6a8eb75a..9d6c6493 100644
--- a/GameScripts/ArcherSomersaultState.cpp
+++ b/GameScripts/ArcherSomersaultState.cpp
@@ -13,7 +13,6 @@ ArcherSomersaultState::ArcherSomersaultState(GameObject* owner)
 void ArcherSomersaultState::OnStateEnter()
 {
     m_archerController = GameObjectAPI::findScript<RangedEnemyController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArcherAttackConfig>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_particles = GameObjectAPI::findScript<ArcherGuardParticles>(getOwner());
 
@@ -26,11 +25,6 @@ void ArcherSomersaultState::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArcherSomersaultState] ArcherAttackConfig not found.");
-        return;
-    }
     if (!m_animation)
     {
         Debug::error("[ArcherSomersaultState] AnimationComponent not found.");
@@ -49,7 +43,7 @@ void ArcherSomersaultState::OnStateEnter()
 
 void ArcherSomersaultState::OnStateUpdate()
 {
-    if (!m_archerController || !m_attackConfig || !m_animation)
+    if (!m_archerController || !m_animation)
     {
         return;
     }
@@ -64,12 +58,18 @@ void ArcherSomersaultState::OnStateUpdate()
         return;
     }
 
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
     m_stateTimer += Time::getDeltaTime();
 
     if (m_particles) m_particles->updateChargeParticle();
     moveSomersault();
 
-    if (m_stateTimer >= m_attackConfig->m_somersaultDuration)
+    if (m_stateTimer >= cfg->m_somersaultDuration)
     {
         finishSomersault();
         return;
@@ -84,7 +84,8 @@ void ArcherSomersaultState::OnStateExit()
 
 void ArcherSomersaultState::moveSomersault()
 {
-    if (!m_attackConfig)
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -96,13 +97,13 @@ void ArcherSomersaultState::moveSomersault()
 
     Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 
-    const float duration = m_attackConfig->m_somersaultDuration;
+    const float duration = cfg->m_somersaultDuration;
     if (duration <= 0.0f)
     {
         return;
     }
 
-    const float speed = m_attackConfig->m_somersaultDistance / duration;
+    const float speed = cfg->m_somersaultDistance / duration;
     const float stepDistance = speed * Time::getDeltaTime();
 
     Vector3 currentPosition = TransformAPI::getGlobalPosition(ownerTransform);
@@ -129,4 +130,6 @@ void ArcherSomersaultState::finishSomersault()
     Debug::log("[ArcherSomersaultState] Finished, Chase trigger sent");
 }
 
-IMPLEMENT_SCRIPT(ArcherSomersaultState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(ArcherSomersaultState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/ArcherSomersaultState.h b/GameScripts/ArcherSomersaultState.h
index 0db1c566..c10cdef9 100644
--- a/GameScripts/ArcherSomersaultState.h
+++ b/GameScripts/ArcherSomersaultState.h
@@ -15,6 +15,8 @@ class ArcherSomersaultState : public StateMachineScript
 public:
     explicit ArcherSomersaultState(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void OnStateEnter() override;
     void OnStateUpdate() override;
     void OnStateExit() override;
@@ -25,7 +27,7 @@ class ArcherSomersaultState : public StateMachineScript
 
 private:
     RangedEnemyController* m_archerController = nullptr;
-    ArcherAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArcherAttackConfig> m_attackConfig;
     AnimationComponent* m_animation = nullptr;
     ArcherGuardParticles* m_particles = nullptr;
 
diff --git a/GameScripts/ArcherUI.h b/GameScripts/ArcherUI.h
index f18001a7..6b2d2f8e 100644
--- a/GameScripts/ArcherUI.h
+++ b/GameScripts/ArcherUI.h
@@ -12,7 +12,7 @@ class ArcherUI : public Script
 
 	void Start() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	void setupArrowBarrageUI(float radius);
@@ -20,9 +20,9 @@ class ArcherUI : public Script
 	void hideArrowBarrageUI();
 
 private:
-	ScriptComponentRef<Transform> m_arrowBarrageUICanvas;
-	ScriptComponentRef<Transform2D> m_arrowBarrageUIContainer;
-	ScriptComponentRef<Transform2D> m_arrowBarrageUIGlow;
+	ComponentRef<Transform> m_arrowBarrageUICanvas;
+	ComponentRef<Transform2D> m_arrowBarrageUIContainer;
+	ComponentRef<Transform2D> m_arrowBarrageUIGlow;
 
 	Transform* m_arrowBarrageUICanvasTransform = nullptr;
 	Transform2D* m_arrowBarrageUIContainerTransform2D = nullptr;
diff --git a/GameScripts/ArrowPool.h b/GameScripts/ArrowPool.h
new file mode 100644
index 00000000..fc22f1f9
--- /dev/null
+++ b/GameScripts/ArrowPool.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include <vector>
+
+class LyrielArrowProjectile;
+
+class ArrowPool : public Script
+{
+    DECLARE_SCRIPT(ArrowPool)
+
+public:
+    explicit ArrowPool(GameObject* owner);
+
+    void Start() override;
+
+    LyrielArrowProjectile* acquireArrow();
+    void releaseArrow(LyrielArrowProjectile* arrow);
+
+    FieldList getExposedFields() const override;
+
+private:
+    bool createArrow();
+
+public:
+    int m_maxArrows = 5;
+
+    std::string m_arrowPrefabPath = "";
+
+private:
+    std::vector<LyrielArrowProjectile*> m_arrows;
+
+};
\ No newline at end of file
diff --git a/GameScripts/ArthurAttackConfig.cpp b/GameScripts/ArthurAttackConfig.cpp
index abc11ffe..a384efe6 100644
--- a/GameScripts/ArthurAttackConfig.cpp
+++ b/GameScripts/ArthurAttackConfig.cpp
@@ -1,70 +1,2 @@
 #include "pch.h"
 #include "ArthurAttackConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS(ArthurAttackConfig,
-    // Heavy Swipe
-    FIELD_GROUP_COLLAPSE("Heavy Swipe",
-        SERIALIZED_FLOAT(m_heavySwipeDamage, "Heavy Swipe Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_heavySwipeRange, "Heavy Swipe Range", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_heavySwipeHalfAngleDegrees, "Heavy Swipe Half Angle Degrees", 0.0f, 180.0f, 1.0f),
-        SERIALIZED_FLOAT(m_heavySwipeTotalDuration, "Heavy Swipe Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipeHit1Time, "Heavy Swipe Hit 1 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipeHit2Time, "Heavy Swipe Hit 2 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipeHit3Time, "Heavy Swipe Hit 3 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipeRecoveryDuration, "Heavy Swipe Recovery Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipePhase2Hit1Time, "Heavy Swipe Phase 2 Hit 1 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipePhase2Hit2Time, "Heavy Swipe Phase 2 Hit 2 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipePhase2Hit3Time, "Heavy Swipe Phase 2 Hit 3 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipePhase2Hit4Time, "Heavy Swipe Phase 2 Hit 4 Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_heavySwipePhase2RecoveryDuration, "Heavy Swipe Phase 2 Recovery Duration", 0.0f, 10.0f, 0.05f)
-    ),
-    // Side Sweep
-    FIELD_GROUP_COLLAPSE("Side Sweep",
-        SERIALIZED_FLOAT(m_sideSweepDamage, "Side Sweep Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_sideSweepRange, "Side Sweep Range", 0.0f, 30.0f, 0.1f),
-        SERIALIZED_FLOAT(m_sideSweepHalfAngleDegrees, "Side Sweep Half Angle Degrees", 0.0f, 180.0f, 1.0f),
-        SERIALIZED_FLOAT(m_sideSweepHitTime, "Side Sweep Hit Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_sideSweepTotalDuration, "Side Sweep Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_sideSweepRecoveryDuration, "Side Sweep Recovery Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_sideSweepCooldown, "Side Sweep Cooldown", 0.0f, 10.0f, 0.1f),
-        SERIALIZED_FLOAT(m_sideSweepPhase2HitTime, "Side Sweep Phase 2 Hit Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_sideSweepPhase2TotalDuration, "Side Sweep Phase 2 Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_sideSweepPhase2RecoveryDuration, "Side Sweep Phase 2 Recovery Duration", 0.0f, 10.0f, 0.05f)
-    ),
-    // Charging Slam
-    FIELD_GROUP_COLLAPSE("Charging Slam",
-        SERIALIZED_FLOAT(m_chargingSlamDashDamage, "Charging Slam Dash Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_chargingSlamFinalAreaImpactDamage, "Charging Slam Final Area Impact Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_chargingSlamHitTime, "Charging Slam Hit Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_chargingSlamDashSpeed, "Charging Slam Dash Speed", 0.0f, 50.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamDashHitRadius, "Charging Slam Dash Hit Radius", 0.0f, 10.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamImpactRadius, "Charging Slam Impact Radius", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamTotalDuration, "Charging Slam Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_chargingSlamRecoveryDuration, "Charging Slam Recovery Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_chargingSlamImpactStunDuration, "Charging Slam Impact Stun Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_chargingSlamCooldown, "Charging Slam Cooldown", 0.0f, 10.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamPhase2HitTime, "Charging Slam Phase 2 Hit Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_chargingSlamPhase2DashSpeed, "Charging Slam Phase 2 Dash Speed", 0.0f, 50.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamMinRange, "Charging Slam Min Range", 0.0f, 20.0f, 0.1f),
-        SERIALIZED_FLOAT(m_chargingSlamMaxRange, "Charging Slam Max Range", 0.0f, 20.0f, 0.1f)
-    ),
-    // Earth Hammer
-    FIELD_GROUP_COLLAPSE("Earth Hammer",
-        SERIALIZED_FLOAT(m_earthHammerDamage, "Earth Hammer Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_earthHammerRadius, "Earth Hammer Radius", 0.0f, 30.0f, 0.1f),
-        SERIALIZED_FLOAT(m_earthHammerTotalDuration, "Earth Hammer Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_earthHammerHitTime, "Earth Hammer Hit Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_earthHammerRecoveryDuration, "Earth Hammer Recovery Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_earthHammerStunDuration, "Earth Hammer Stun Duration", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_earthHammerCooldown, "Earth Hammer Cooldown", 0.0f, 10.0f, 0.1f),
-        SERIALIZED_FLOAT(m_earthHammerPhase2Damage, "Earth Hammer Phase 2 Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_earthHammerPhase2StunDuration, "Earth Hammer Phase 2 Stun Duration", 0.0f, 10.0f, 0.05f)
-    )
-)
-
-ArthurAttackConfig::ArthurAttackConfig(GameObject* owner)
-    : Script(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(ArthurAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/ArthurAttackConfig.h b/GameScripts/ArthurAttackConfig.h
index 2a14268a..31c29e1f 100644
--- a/GameScripts/ArthurAttackConfig.h
+++ b/GameScripts/ArthurAttackConfig.h
@@ -1,19 +1,20 @@
 #pragma once
 
-#include "ScriptAPI.h"
+#include "DataContainerAPI.h"
 #include "Transform2D.h"
 #include "UISlider.h"
 
-class ArthurAttackConfig : public Script
+class ArthurAttackConfig : public DataContainer
 {
-    DECLARE_SCRIPT(ArthurAttackConfig)
+    DECLARE_DATACONTAINER(ArthurAttackConfig)
 
 public:
-    explicit ArthurAttackConfig(GameObject* owner);
+    ArthurAttackConfig() = default;
+    explicit ArthurAttackConfig(AssetReference& id)
+        : DataContainer(id)
+    {
+    }
 
-    ScriptFieldList getExposedFields() const override;
-
-public:
     // Heavy Swipe
     float m_heavySwipeDamage = 10.0f;
     float m_heavySwipeRange = 3.0f;
@@ -86,4 +87,61 @@ class ArthurAttackConfig : public Script
 
     float m_earthHammerPhase2Damage = 25.0f;
     float m_earthHammerPhase2StunDuration = 1.75f;
-};
\ No newline at end of file
+
+    IMPLEMENT_DATACONTAINER_FIELDS(ArthurAttackConfig,
+        FIELD_GROUP_COLLAPSE("Heavy Swipe",
+            SERIALIZED_FLOAT(m_heavySwipeDamage, "Heavy Swipe Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_heavySwipeRange, "Heavy Swipe Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_heavySwipeHalfAngleDegrees, "Heavy Swipe Half Angle Degrees", 0.0f, 180.0f, 1.0f),
+            SERIALIZED_FLOAT(m_heavySwipeTotalDuration, "Heavy Swipe Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipeHit1Time, "Heavy Swipe Hit 1 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipeHit2Time, "Heavy Swipe Hit 2 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipeHit3Time, "Heavy Swipe Hit 3 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipeRecoveryDuration, "Heavy Swipe Recovery Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipePhase2Hit1Time, "Heavy Swipe Phase 2 Hit 1 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipePhase2Hit2Time, "Heavy Swipe Phase 2 Hit 2 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipePhase2Hit3Time, "Heavy Swipe Phase 2 Hit 3 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipePhase2Hit4Time, "Heavy Swipe Phase 2 Hit 4 Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_heavySwipePhase2RecoveryDuration, "Heavy Swipe Phase 2 Recovery Duration", 0.0f, 10.0f, 0.05f)
+        ),
+        FIELD_GROUP_COLLAPSE("Side Sweep",
+            SERIALIZED_FLOAT(m_sideSweepDamage, "Side Sweep Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_sideSweepRange, "Side Sweep Range", 0.0f, 30.0f, 0.1f),
+            SERIALIZED_FLOAT(m_sideSweepHalfAngleDegrees, "Side Sweep Half Angle Degrees", 0.0f, 180.0f, 1.0f),
+            SERIALIZED_FLOAT(m_sideSweepHitTime, "Side Sweep Hit Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_sideSweepTotalDuration, "Side Sweep Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_sideSweepRecoveryDuration, "Side Sweep Recovery Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_sideSweepCooldown, "Side Sweep Cooldown", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_sideSweepPhase2HitTime, "Side Sweep Phase 2 Hit Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_sideSweepPhase2TotalDuration, "Side Sweep Phase 2 Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_sideSweepPhase2RecoveryDuration, "Side Sweep Phase 2 Recovery Duration", 0.0f, 10.0f, 0.05f)
+        ),
+        FIELD_GROUP_COLLAPSE("Charging Slam",
+            SERIALIZED_FLOAT(m_chargingSlamDashDamage, "Charging Slam Dash Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_chargingSlamFinalAreaImpactDamage, "Charging Slam Final Area Impact Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_chargingSlamHitTime, "Charging Slam Hit Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargingSlamDashSpeed, "Charging Slam Dash Speed", 0.0f, 50.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamDashHitRadius, "Charging Slam Dash Hit Radius", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamImpactRadius, "Charging Slam Impact Radius", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamTotalDuration, "Charging Slam Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargingSlamRecoveryDuration, "Charging Slam Recovery Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargingSlamImpactStunDuration, "Charging Slam Impact Stun Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargingSlamCooldown, "Charging Slam Cooldown", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamPhase2HitTime, "Charging Slam Phase 2 Hit Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargingSlamPhase2DashSpeed, "Charging Slam Phase 2 Dash Speed", 0.0f, 50.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamMinRange, "Charging Slam Min Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargingSlamMaxRange, "Charging Slam Max Range", 0.0f, 20.0f, 0.1f)
+        ),
+        FIELD_GROUP_COLLAPSE("Earth Hammer",
+            SERIALIZED_FLOAT(m_earthHammerDamage, "Earth Hammer Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_earthHammerRadius, "Earth Hammer Radius", 0.0f, 30.0f, 0.1f),
+            SERIALIZED_FLOAT(m_earthHammerTotalDuration, "Earth Hammer Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_earthHammerHitTime, "Earth Hammer Hit Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_earthHammerRecoveryDuration, "Earth Hammer Recovery Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_earthHammerStunDuration, "Earth Hammer Stun Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_earthHammerCooldown, "Earth Hammer Cooldown", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_earthHammerPhase2Damage, "Earth Hammer Phase 2 Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_earthHammerPhase2StunDuration, "Earth Hammer Phase 2 Stun Duration", 0.0f, 10.0f, 0.05f)
+        )
+    )
+};
diff --git a/GameScripts/ArthurAttackDebugDraw.cpp b/GameScripts/ArthurAttackDebugDraw.cpp
index d980ce5e..ceb88f84 100644
--- a/GameScripts/ArthurAttackDebugDraw.cpp
+++ b/GameScripts/ArthurAttackDebugDraw.cpp
@@ -6,6 +6,7 @@
 #include <cmath>
 
 IMPLEMENT_SCRIPT_FIELDS(ArthurAttackDebugDraw,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Arthur Attack Config", AssetType::DATA_CONTAINER),
     SERIALIZED_BOOL(m_debugEnabled, "Debug Enabled"),
     SERIALIZED_BOOL(m_drawHeavySwipe, "Draw Heavy Swipe"),
     SERIALIZED_BOOL(m_drawSideSweepRight, "Draw Side Sweep Right"),
@@ -22,12 +23,6 @@ ArthurAttackDebugDraw::ArthurAttackDebugDraw(GameObject* owner)
 
 void ArthurAttackDebugDraw::Start()
 {
-    m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
-
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArthurAttackDebugDraw] ArthurAttackConfig not found.");
-    }
 }
 
 void ArthurAttackDebugDraw::drawGizmo()
@@ -37,12 +32,8 @@ void ArthurAttackDebugDraw::drawGizmo()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
-    }
-
-    if (!m_attackConfig)
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -75,6 +66,12 @@ void ArthurAttackDebugDraw::drawGizmo()
 
 void ArthurAttackDebugDraw::drawHeavySwipeCone() const
 {
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
     Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
     if (!ownerTransform)
     {
@@ -99,8 +96,8 @@ void ArthurAttackDebugDraw::drawHeavySwipeCone() const
 
     constexpr float degreesToRadians = 3.14159265f / 180.0f;
 
-    const float range = m_attackConfig->m_heavySwipeRange;
-    const float halfAngleRadians = m_attackConfig->m_heavySwipeHalfAngleDegrees * degreesToRadians;
+    const float range = cfg->m_heavySwipeRange;
+    const float halfAngleRadians = cfg->m_heavySwipeHalfAngleDegrees * degreesToRadians;
 
     const Vector3 heavySwipeColor = { 0.6f, 0.0f, 1.0f };
 
@@ -134,6 +131,12 @@ void ArthurAttackDebugDraw::drawHeavySwipeCone() const
 
 void ArthurAttackDebugDraw::drawEarthHammerRadius() const
 {
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
     Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
     if (!ownerTransform)
     {
@@ -145,11 +148,17 @@ void ArthurAttackDebugDraw::drawEarthHammerRadius() const
 
     const Vector3 earthHammerColor = { 0.6f, 0.0f, 1.0f };
 
-    DebugDrawAPI::drawCircle(ownerPosition, Vector3(0.0f, 1.0f, 0.0f), earthHammerColor, m_attackConfig->m_earthHammerRadius, 48.0f, 0, true);
+    DebugDrawAPI::drawCircle(ownerPosition, Vector3(0.0f, 1.0f, 0.0f), earthHammerColor, cfg->m_earthHammerRadius, 48.0f, 0, true);
 }
 
 void ArthurAttackDebugDraw::drawSideSweepCone(int side) const
 {
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
     Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
     if (!ownerTransform)
     {
@@ -175,8 +184,8 @@ void ArthurAttackDebugDraw::drawSideSweepCone(int side) const
     Vector3 sideDirection = rotateAroundY(forward, halfPi * static_cast<float>(side));
     sideDirection.Normalize();
 
-    const float range = m_attackConfig->m_sideSweepRange;
-    const float halfAngleRadians = m_attackConfig->m_sideSweepHalfAngleDegrees * degreesToRadians;
+    const float range = cfg->m_sideSweepRange;
+    const float halfAngleRadians = cfg->m_sideSweepHalfAngleDegrees * degreesToRadians;
 
     const Vector3 sideSweepColor = { 0.6f, 0.0f, 1.0f };
 
@@ -210,7 +219,8 @@ void ArthurAttackDebugDraw::drawSideSweepCone(int side) const
 
 void ArthurAttackDebugDraw::drawChargingSlamPreview() const
 {
-    if (!m_attackConfig)
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -249,7 +259,7 @@ void ArthurAttackDebugDraw::drawChargingSlamPreview() const
         startPosition,
         Vector3(0.0f, 1.0f, 0.0f),
         purple,
-        m_attackConfig->m_chargingSlamDashHitRadius,
+        cfg->m_chargingSlamDashHitRadius,
         24.0f,
         0,
         true
@@ -259,7 +269,7 @@ void ArthurAttackDebugDraw::drawChargingSlamPreview() const
         endPosition,
         Vector3(0.0f, 1.0f, 0.0f),
         purple,
-        m_attackConfig->m_chargingSlamImpactRadius,
+        cfg->m_chargingSlamImpactRadius,
         48.0f,
         0,
         true
diff --git a/GameScripts/ArthurAttackDebugDraw.h b/GameScripts/ArthurAttackDebugDraw.h
index c8594036..7e2ef214 100644
--- a/GameScripts/ArthurAttackDebugDraw.h
+++ b/GameScripts/ArthurAttackDebugDraw.h
@@ -14,7 +14,7 @@ class ArthurAttackDebugDraw : public Script
     void Start() override;
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     bool m_debugEnabled = true;
@@ -27,7 +27,7 @@ class ArthurAttackDebugDraw : public Script
     float m_heightOffset = 0.15f;
 
 private:
-    ArthurAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArthurAttackConfig> m_attackConfig;
 
 private:
     void drawHeavySwipeCone() const;
diff --git a/GameScripts/ArthurBossController.cpp b/GameScripts/ArthurBossController.cpp
index 98533cf4..6847bdac 100644
--- a/GameScripts/ArthurBossController.cpp
+++ b/GameScripts/ArthurBossController.cpp
@@ -12,6 +12,7 @@
 #include <cmath>
 
 IMPLEMENT_SCRIPT_FIELDS_INHERITED(ArthurBossController, EnemyBaseController,
+	SERIALIZED_ASSET_REF(m_attackConfig, "Arthur Attack Config", AssetType::DATA_CONTAINER),
 	SERIALIZED_FLOAT(m_combatRange, "Combat Range", 0.0f, 50.0f, 0.1f)
 )
 
@@ -28,13 +29,6 @@ void ArthurBossController::Start()
 		Debug::error("ArthurDetectionAggro script not found!");
 	}
 
-	m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
-
-	if (!m_attackConfig)
-	{
-		Debug::error("ArthurAttackConfig script not found!");
-	}
-
 	m_arthurUI = GameObjectAPI::findScript<ArthurUI>(getOwner());
 
 	if (!m_arthurUI)
@@ -202,35 +196,38 @@ void ArthurBossController::updateAttackCooldowns(float dt)
 
 void ArthurBossController::consumeChargingSlamCooldown()
 {
-	if (!m_attackConfig)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg)
 	{
 		Debug::error("[ArthurBossController] AtrhurAttackConfig not found.");
 		return;
 	}
 
-	m_chargingSlamCooldownTimer = m_attackConfig->m_chargingSlamCooldown;
+	m_chargingSlamCooldownTimer = cfg->m_chargingSlamCooldown;
 }
 
 void ArthurBossController::consumeSideSweepCooldown()
 {
-	if (!m_attackConfig)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg)
 	{
 		Debug::error("[ArthurBossController] AtrhurAttackConfig not found.");
 		return;
 	}
 
-	m_sideSweepCooldownTimer = m_attackConfig->m_sideSweepCooldown;
+	m_sideSweepCooldownTimer = cfg->m_sideSweepCooldown;
 }
 
 void ArthurBossController::consumeEarthHammerCooldown()
 {
-	if (!m_attackConfig)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg)
 	{
 		Debug::error("[ArthurBossController] AtrhurAttackConfig not found.");
 		return;
 	}
 
-	m_earthHammerCooldownTimer = m_attackConfig->m_earthHammerCooldown;
+	m_earthHammerCooldownTimer = cfg->m_earthHammerCooldown;
 }
 
 Transform* ArthurBossController::getNonFocusTarget() const
@@ -263,7 +260,8 @@ Transform* ArthurBossController::getNonFocusTarget() const
 
 bool ArthurBossController::areBothPlayersInEarthHammerRange() const
 {
-	if (!m_attackConfig || !m_arthurDetectionAggro)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg || !m_arthurDetectionAggro)
 	{
 		return false;
 	}
@@ -285,7 +283,7 @@ bool ArthurBossController::areBothPlayersInEarthHammerRange() const
 	Vector3 lyrielPosition = TransformAPI::getGlobalPosition(lyriel);
 	Vector3 deathPosition = TransformAPI::getGlobalPosition(death);
 
-	float earthHammerRange = m_attackConfig->m_earthHammerRadius;
+	float earthHammerRange = cfg->m_earthHammerRadius;
 	float lyrielDistance = (lyrielPosition - ownerPosition).Length();
 	float deathDistance = (deathPosition - ownerPosition).Length();
 
@@ -294,14 +292,15 @@ bool ArthurBossController::areBothPlayersInEarthHammerRange() const
 
 bool ArthurBossController::isTargetInChargingSlamRange() const
 {
-	if (!m_attackConfig)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg)
 	{
 		return false;
 	}
 	
 	float distance = getDistanceToCurrentTarget();
 
-	return distance >= m_attackConfig->m_chargingSlamMinRange && distance <= m_attackConfig->m_chargingSlamMaxRange;
+	return distance >= cfg->m_chargingSlamMinRange && distance <= cfg->m_chargingSlamMaxRange;
 }
 
 bool ArthurBossController::isCurrentTargetInsideHeavySwipeArea(float range, float halfAngleDegrees) const
@@ -350,7 +349,8 @@ bool ArthurBossController::isCurrentTargetInsideHeavySwipeArea(float range, floa
 
 bool ArthurBossController::isTargetInsideSideSweepZone(Transform* targetTransform, int side) const
 {
-	if (!m_attackConfig)
+	const ArthurAttackConfig* cfg = m_attackConfig.get();
+	if (!cfg)
 	{
 		return false;
 	}
@@ -373,7 +373,7 @@ bool ArthurBossController::isTargetInsideSideSweepZone(Transform* targetTransfor
 	toTarget.y = 0.0f;
 
 	float distanceSquared = toTarget.LengthSquared();
-	float rangeSquared = m_attackConfig->m_sideSweepRange * m_attackConfig->m_sideSweepRange;
+	float rangeSquared = cfg->m_sideSweepRange * cfg->m_sideSweepRange;
 
 	if (distanceSquared > rangeSquared)
 	{
@@ -407,7 +407,7 @@ bool ArthurBossController::isTargetInsideSideSweepZone(Transform* targetTransfor
 	}
 
 	constexpr float degreesToRadians = 3.14159265f / 180.0f;
-	float minDot = std::cos(m_attackConfig->m_sideSweepHalfAngleDegrees * degreesToRadians);
+	float minDot = std::cos(cfg->m_sideSweepHalfAngleDegrees * degreesToRadians);
 
 	return dot >= minDot;
 }
@@ -450,7 +450,7 @@ bool ArthurBossController::trySelectSideSweepSide()
 		m_arthurDetectionAggro = GameObjectAPI::findScript<ArthurDetectionAggro>(getOwner());
 	}
 
-	if (!m_arthurDetectionAggro || !m_attackConfig)
+	if (!m_arthurDetectionAggro || !m_attackConfig.get())
 	{
 		return false;
 	}
diff --git a/GameScripts/ArthurBossController.h b/GameScripts/ArthurBossController.h
index c74a7a3b..433c4732 100644
--- a/GameScripts/ArthurBossController.h
+++ b/GameScripts/ArthurBossController.h
@@ -25,7 +25,7 @@ class ArthurBossController : public EnemyBaseController
 	void drawGizmo() override;
 	void Update() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	// Phase helpers
 	void setPhase(ArthurBossPhase phase);
@@ -71,7 +71,7 @@ class ArthurBossController : public EnemyBaseController
 
 private:
 	ArthurDetectionAggro* m_arthurDetectionAggro = nullptr;
-	ArthurAttackConfig* m_attackConfig = nullptr;
+	AssetRef<ArthurAttackConfig> m_attackConfig;
 	ArthurUI* m_arthurUI = nullptr;
 
 	ArthurBossPhase m_phase = ArthurBossPhase::Phase1;
diff --git a/GameScripts/ArthurChargingSlam.cpp b/GameScripts/ArthurChargingSlam.cpp
index bf3e1270..4e258bf1 100644
--- a/GameScripts/ArthurChargingSlam.cpp
+++ b/GameScripts/ArthurChargingSlam.cpp
@@ -10,6 +10,7 @@
 #include "Transform2D.h"
 
 IMPLEMENT_SCRIPT_FIELDS(ArthurChargingSlam,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Arthur Attack Config", AssetType::DATA_CONTAINER),
     SERIALIZED_FLOAT(m_animPrepStartTime, "Anim Prep Start Time", 0.0f, 20.0f, 0.01f),
     SERIALIZED_FLOAT(m_animDashStartTime, "Anim Dash Start Time", 0.0f, 20.0f, 0.01f),
     SERIALIZED_FLOAT(m_animImpactStartTime, "Anim Impact Start Time", 0.0f, 20.0f, 0.01f),
@@ -24,7 +25,6 @@ ArthurChargingSlam::ArthurChargingSlam(GameObject* owner)
 void ArthurChargingSlam::OnStateEnter()
 {
     m_arthurController = GameObjectAPI::findScript<ArthurBossController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
     m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_arthurUI = GameObjectAPI::findScript<ArthurUI>(getOwner());
@@ -49,12 +49,6 @@ void ArthurChargingSlam::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArthurChargingSlam] ArthurAttackConfig not found.");
-        return;
-    }
-
     if (!m_attackExecutor)
     {
         Debug::error("[ArthurChargingSlam] EnemyAttackExecutor not found.");
@@ -97,7 +91,13 @@ void ArthurChargingSlam::OnStateEnter()
 
 void ArthurChargingSlam::OnStateUpdate()
 {
-    if (!m_arthurController || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_arthurController || !m_attackExecutor || !m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -109,11 +109,11 @@ void ArthurChargingSlam::OnStateUpdate()
 
     m_stateTimer += Time::getDeltaTime();
 
-    float chargingDuration = m_attackConfig->m_chargingSlamHitTime;
+    float chargingDuration = cfg->m_chargingSlamHitTime;
 
     if (m_arthurController->isPhase2())
     {
-        chargingDuration = m_attackConfig->m_chargingSlamPhase2HitTime;
+        chargingDuration = cfg->m_chargingSlamPhase2HitTime;
     }
 
     if (!m_hasStartedDash)
@@ -137,7 +137,7 @@ void ArthurChargingSlam::OnStateUpdate()
         m_hasAppliedImpact = true;
     }
 
-    if (m_hasAppliedImpact && m_stateTimer >= m_attackConfig->m_chargingSlamTotalDuration)
+    if (m_hasAppliedImpact && m_stateTimer >= cfg->m_chargingSlamTotalDuration)
     {
         goToRecover();
         return;
@@ -219,8 +219,9 @@ void ArthurChargingSlam::startDash()
 
 void ArthurChargingSlam::updateDash()
 {
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
     Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
-    if (!ownerTransform)
+    if (!ownerTransform || !cfg)
     {
         return;
     }
@@ -232,11 +233,11 @@ void ArthurChargingSlam::updateDash()
 
     const float remainingDistance = toDestination.Length();
 
-    float dashSpeed = m_attackConfig->m_chargingSlamDashSpeed;
+    float dashSpeed = cfg->m_chargingSlamDashSpeed;
 
     if (m_arthurController->isPhase2())
     {
-        dashSpeed = m_attackConfig->m_chargingSlamPhase2DashSpeed;
+        dashSpeed = cfg->m_chargingSlamPhase2DashSpeed;
     }
 
     const float stepDistance = dashSpeed * Time::getDeltaTime();
@@ -272,7 +273,13 @@ void ArthurChargingSlam::tryApplyDashDamage(Transform* targetTransform, bool& ha
         return;
     }
 
-    if (!m_attackExecutor || !m_attackConfig)
+    if (!m_attackExecutor)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -285,7 +292,7 @@ void ArthurChargingSlam::tryApplyDashDamage(Transform* targetTransform, bool& ha
 
     Vector3 center = TransformAPI::getGlobalPosition(ownerTransform);
 
-    const bool damaged = m_attackExecutor->tryDamageTargetInRadius(targetTransform, center, m_attackConfig->m_chargingSlamDashHitRadius, m_attackConfig->m_chargingSlamDashDamage, "ChargingSlamDash");
+    const bool damaged = m_attackExecutor->tryDamageTargetInRadius(targetTransform, center, cfg->m_chargingSlamDashHitRadius, cfg->m_chargingSlamDashDamage, "ChargingSlamDash");
 
     if (damaged)
     {
@@ -295,7 +302,13 @@ void ArthurChargingSlam::tryApplyDashDamage(Transform* targetTransform, bool& ha
 
 void ArthurChargingSlam::applyImpact()
 {
-    if (!m_attackExecutor || !m_attackConfig)
+    if (!m_attackExecutor)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -307,7 +320,7 @@ void ArthurChargingSlam::applyImpact()
         m_arthurUI->startChargingSlamImpactUI();
     }
 
-    m_attackExecutor->applyDamageAndStunInRadius(m_lockedTargetPosition, m_attackConfig->m_chargingSlamImpactRadius, m_attackConfig->m_chargingSlamFinalAreaImpactDamage, m_attackConfig->m_chargingSlamImpactStunDuration, "ChargingSlamImpact");
+    m_attackExecutor->applyDamageAndStunInRadius(m_lockedTargetPosition, cfg->m_chargingSlamImpactRadius, cfg->m_chargingSlamFinalAreaImpactDamage, cfg->m_chargingSlamImpactStunDuration, "ChargingSlamImpact");
 
     if (m_arthurSound)
     {
@@ -320,14 +333,20 @@ void ArthurChargingSlam::applyImpact()
 
 void ArthurChargingSlam::goToRecover()
 {
-    if (!m_attackConfig || !m_animation)
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
     if (m_arthurController)
     {
-        m_arthurController->setRecoveryDuration(m_attackConfig->m_chargingSlamRecoveryDuration);
+        m_arthurController->setRecoveryDuration(cfg->m_chargingSlamRecoveryDuration);
     }
 
     Debug::log("[ArthurChargingSlam] Going to Recover.");
@@ -337,16 +356,17 @@ void ArthurChargingSlam::goToRecover()
 
 float ArthurChargingSlam::getChargingDuration() const
 {
-    if (!m_attackConfig)
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return 0.0f;
     }
 
-    float chargingDuration = m_attackConfig->m_chargingSlamHitTime;
+    float chargingDuration = cfg->m_chargingSlamHitTime;
 
     if (m_arthurController && m_arthurController->isPhase2())
     {
-        chargingDuration = m_attackConfig->m_chargingSlamPhase2HitTime;
+        chargingDuration = cfg->m_chargingSlamPhase2HitTime;
     }
 
     return chargingDuration;
@@ -354,16 +374,17 @@ float ArthurChargingSlam::getChargingDuration() const
 
 float ArthurChargingSlam::getDashSpeed() const
 {
-    if (!m_attackConfig)
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return 0.0f;
     }
 
-    float dashSpeed = m_attackConfig->m_chargingSlamDashSpeed;
+    float dashSpeed = cfg->m_chargingSlamDashSpeed;
 
     if (m_arthurController && m_arthurController->isPhase2())
     {
-        dashSpeed = m_attackConfig->m_chargingSlamPhase2DashSpeed;
+        dashSpeed = cfg->m_chargingSlamPhase2DashSpeed;
     }
 
     return dashSpeed;
@@ -427,13 +448,19 @@ void ArthurChargingSlam::setupAnimationDashSection()
 
 void ArthurChargingSlam::setupAnimationImpactSection()
 {
-    if (!m_animation || !m_attackConfig)
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
     const float animationImpactDuration = m_animEndTime - m_animImpactStartTime;
-    const float gameplayImpactDuration = m_attackConfig->m_chargingSlamTotalDuration - m_stateTimer;
+    const float gameplayImpactDuration = cfg->m_chargingSlamTotalDuration - m_stateTimer;
 
     const float speed = getSafeSectionSpeed(animationImpactDuration, gameplayImpactDuration);
 
diff --git a/GameScripts/ArthurChargingSlam.h b/GameScripts/ArthurChargingSlam.h
index a90e5336..ba3a4e0c 100644
--- a/GameScripts/ArthurChargingSlam.h
+++ b/GameScripts/ArthurChargingSlam.h
@@ -21,7 +21,7 @@ class ArthurChargingSlam : public StateMachineScript
     void OnStateUpdate() override;
     void OnStateExit() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void lockTargetPosition();
@@ -46,7 +46,7 @@ class ArthurChargingSlam : public StateMachineScript
 
 private:
     ArthurBossController* m_arthurController = nullptr;
-    ArthurAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArthurAttackConfig> m_attackConfig;
     EnemyAttackExecutor* m_attackExecutor = nullptr;
     AnimationComponent* m_animation = nullptr;
     ArthurUI* m_arthurUI = nullptr;
diff --git a/GameScripts/ArthurChase.cpp b/GameScripts/ArthurChase.cpp
index 6becf0a0..8ae4b511 100644
--- a/GameScripts/ArthurChase.cpp
+++ b/GameScripts/ArthurChase.cpp
@@ -12,7 +12,6 @@ ArthurChase::ArthurChase(GameObject* owner)
 void ArthurChase::OnStateEnter()
 {
 	m_arthurController = GameObjectAPI::findScript<ArthurBossController>(getOwner());
-	m_arthurAttackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
 	m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
 	if (!m_arthurController)
@@ -21,12 +20,6 @@ void ArthurChase::OnStateEnter()
 		return;
 	}
 
-	if (!m_arthurAttackConfig)
-	{
-		Debug::error("[ArthurChase] ArthurAttackConfig not found.");
-		return;
-	}
-
 	if (!m_animation)
 	{
 		Debug::error("[ArthurChase] AnimationComponent not found.");
@@ -41,7 +34,13 @@ void ArthurChase::OnStateEnter()
 
 void ArthurChase::OnStateUpdate()
 {
-	if (!m_arthurController || !m_arthurAttackConfig || !m_animation)
+	if (!m_arthurController || !m_animation)
+	{
+		return;
+	}
+
+	const ArthurAttackConfig* cfg = m_arthurAttackConfig.get();
+	if (!cfg)
 	{
 		return;
 	}
@@ -99,11 +98,11 @@ void ArthurChase::OnStateUpdate()
 	}
 
 	// Heavy Swipe
-	if (m_arthurController->getDistanceToCurrentTarget() <= m_arthurAttackConfig->m_heavySwipeRange)
+	if (m_arthurController->getDistanceToCurrentTarget() <= cfg->m_heavySwipeRange)
 	{
 		if (m_arthurController->isCurrentTargetInsideHeavySwipeArea(
-			m_arthurAttackConfig->m_heavySwipeRange,
-			m_arthurAttackConfig->m_heavySwipeHalfAngleDegrees))
+			cfg->m_heavySwipeRange,
+			cfg->m_heavySwipeHalfAngleDegrees))
 		{
 			m_arthurController->faceCurrentTarget();
 			AnimationAPI::sendTrigger(m_animation, "ToHeavySwipe");
diff --git a/GameScripts/ArthurChase.h b/GameScripts/ArthurChase.h
index a2ac0d42..1c6de5cc 100644
--- a/GameScripts/ArthurChase.h
+++ b/GameScripts/ArthurChase.h
@@ -21,6 +21,6 @@ class ArthurChase : public StateMachineScript
 
 private:
 	ArthurBossController* m_arthurController = nullptr;
-	ArthurAttackConfig* m_arthurAttackConfig = nullptr;
+	AssetRef<ArthurAttackConfig> m_arthurAttackConfig;
 	AnimationComponent* m_animation = nullptr;
 };
\ No newline at end of file
diff --git a/GameScripts/ArthurEarthHammer.cpp b/GameScripts/ArthurEarthHammer.cpp
index 738986a8..e1d7d58a 100644
--- a/GameScripts/ArthurEarthHammer.cpp
+++ b/GameScripts/ArthurEarthHammer.cpp
@@ -15,7 +15,6 @@ ArthurEarthHammer::ArthurEarthHammer(GameObject* owner)
 void ArthurEarthHammer::OnStateEnter()
 {
     m_arthurController = GameObjectAPI::findScript<ArthurBossController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
     m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_arthurUI = GameObjectAPI::findScript<ArthurUI>(getOwner());
@@ -30,12 +29,6 @@ void ArthurEarthHammer::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArthurEarthHammer] ArthurAttackConfig not found.");
-        return;
-    }
-
     if (!m_attackExecutor)
     {
         Debug::error("[ArthurEarthHammer] EnemyAttackExecutor not found.");
@@ -72,7 +65,13 @@ void ArthurEarthHammer::OnStateEnter()
 
 void ArthurEarthHammer::OnStateUpdate()
 {
-    if (!m_arthurController || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_arthurController || !m_attackExecutor || !m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -86,16 +85,16 @@ void ArthurEarthHammer::OnStateUpdate()
 
     if (m_arthurUI)
     {
-        m_arthurUI->updateEarthHammerUI(m_stateTimer, m_hasAppliedImpact, m_attackConfig->m_earthHammerHitTime, m_attackConfig->m_earthHammerRecoveryDuration);
+        m_arthurUI->updateEarthHammerUI(m_stateTimer, m_hasAppliedImpact, cfg->m_earthHammerHitTime, cfg->m_earthHammerRecoveryDuration);
     }
 
-    if (!m_hasAppliedImpact && m_stateTimer >= m_attackConfig->m_earthHammerHitTime)
+    if (!m_hasAppliedImpact && m_stateTimer >= cfg->m_earthHammerHitTime)
     {
         applyImpact();
         m_hasAppliedImpact = true;
     }
 
-    if (m_stateTimer >= m_attackConfig->m_earthHammerTotalDuration)
+    if (m_stateTimer >= cfg->m_earthHammerTotalDuration)
     {
         goToRecover();
         return;
@@ -114,7 +113,13 @@ void ArthurEarthHammer::OnStateExit()
 
 void ArthurEarthHammer::applyImpact()
 {
-    if (!m_arthurController || !m_attackExecutor || !m_attackConfig)
+    if (!m_arthurController || !m_attackExecutor)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -129,16 +134,16 @@ void ArthurEarthHammer::applyImpact()
 
     const bool isPhase2 = m_arthurController->isPhase2();
 
-    float damage = m_attackConfig->m_earthHammerDamage;
-    float stunDuration = m_attackConfig->m_earthHammerStunDuration;
+    float damage = cfg->m_earthHammerDamage;
+    float stunDuration = cfg->m_earthHammerStunDuration;
 
     if (isPhase2)
     {
-        damage = m_attackConfig->m_earthHammerPhase2Damage;
-        stunDuration = m_attackConfig->m_earthHammerPhase2StunDuration;
+        damage = cfg->m_earthHammerPhase2Damage;
+        stunDuration = cfg->m_earthHammerPhase2StunDuration;
     }
 
-    m_attackExecutor->applyDamageAndStunInRadius(center, m_attackConfig->m_earthHammerRadius, damage, stunDuration, "EarthHammer");
+    m_attackExecutor->applyDamageAndStunInRadius(center, cfg->m_earthHammerRadius, damage, stunDuration, "EarthHammer");
 
     if (m_arthurSound)
     {
@@ -148,14 +153,20 @@ void ArthurEarthHammer::applyImpact()
 
 void ArthurEarthHammer::goToRecover()
 {
-    if (!m_attackConfig || !m_animation)
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
     if (m_arthurController)
     {
-        m_arthurController->setRecoveryDuration(m_attackConfig->m_earthHammerRecoveryDuration);
+        m_arthurController->setRecoveryDuration(cfg->m_earthHammerRecoveryDuration);
     }
 
     Debug::log("[ArthurEarthHammer] Going to Recover.");
diff --git a/GameScripts/ArthurEarthHammer.h b/GameScripts/ArthurEarthHammer.h
index 28557cdc..56663868 100644
--- a/GameScripts/ArthurEarthHammer.h
+++ b/GameScripts/ArthurEarthHammer.h
@@ -27,7 +27,7 @@ class ArthurEarthHammer : public StateMachineScript
 
 private:
     ArthurBossController* m_arthurController = nullptr;
-    ArthurAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArthurAttackConfig> m_attackConfig;
     EnemyAttackExecutor* m_attackExecutor = nullptr;
     AnimationComponent* m_animation = nullptr;
     ArthurUI* m_arthurUI = nullptr;
diff --git a/GameScripts/ArthurHeavySwipe.cpp b/GameScripts/ArthurHeavySwipe.cpp
index 935bf993..8449dfb3 100644
--- a/GameScripts/ArthurHeavySwipe.cpp
+++ b/GameScripts/ArthurHeavySwipe.cpp
@@ -15,7 +15,6 @@ ArthurHeavySwipe::ArthurHeavySwipe(GameObject* owner)
 void ArthurHeavySwipe::OnStateEnter()
 {
     m_arthurController = GameObjectAPI::findScript<ArthurBossController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
     m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_arthurUI = GameObjectAPI::findScript<ArthurUI>(getOwner());
@@ -34,12 +33,6 @@ void ArthurHeavySwipe::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArthurHeavySwipe] ArthurAttackConfig not found.");
-        return;
-    }
-
     if (!m_attackExecutor)
     {
         Debug::error("[ArthurHeavySwipe] EnemyAttackExecutor not found.");
@@ -81,7 +74,13 @@ void ArthurHeavySwipe::OnStateEnter()
 
 void ArthurHeavySwipe::OnStateUpdate()
 {
-    if (!m_arthurController || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_arthurController || !m_attackExecutor || !m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -95,21 +94,21 @@ void ArthurHeavySwipe::OnStateUpdate()
 
     const bool isPhase2 = m_arthurController->isPhase2();
 
-    float hit1Time = m_attackConfig->m_heavySwipeHit1Time;
-    float hit2Time = m_attackConfig->m_heavySwipeHit2Time;
-    float hit3Time = m_attackConfig->m_heavySwipeHit3Time;
-    float hit4Time = m_attackConfig->m_heavySwipePhase2Hit4Time;
+    float hit1Time = cfg->m_heavySwipeHit1Time;
+    float hit2Time = cfg->m_heavySwipeHit2Time;
+    float hit3Time = cfg->m_heavySwipeHit3Time;
+    float hit4Time = cfg->m_heavySwipePhase2Hit4Time;
 
     if (isPhase2)
     {
-        hit1Time = m_attackConfig->m_heavySwipePhase2Hit1Time;
-        hit2Time = m_attackConfig->m_heavySwipePhase2Hit2Time;
-        hit3Time = m_attackConfig->m_heavySwipePhase2Hit3Time;
+        hit1Time = cfg->m_heavySwipePhase2Hit1Time;
+        hit2Time = cfg->m_heavySwipePhase2Hit2Time;
+        hit3Time = cfg->m_heavySwipePhase2Hit3Time;
     }
 
     if (m_arthurUI)
     {
-        m_arthurUI->updateHeavySwipeUI(m_stateTimer, isPhase2, hit1Time, hit2Time, hit3Time, hit4Time, m_attackConfig->m_heavySwipeTotalDuration, m_attackConfig->m_heavySwipeRange);
+        m_arthurUI->updateHeavySwipeUI(m_stateTimer, isPhase2, hit1Time, hit2Time, hit3Time, hit4Time, cfg->m_heavySwipeTotalDuration, cfg->m_heavySwipeRange);
     }
 
     if (!m_hit1Applied && m_stateTimer >= hit1Time)
@@ -136,7 +135,7 @@ void ArthurHeavySwipe::OnStateUpdate()
         m_hit4Applied = true;
     }
 
-    if (m_stateTimer >= m_attackConfig->m_heavySwipeTotalDuration)
+    if (m_stateTimer >= cfg->m_heavySwipeTotalDuration)
     {
         goToRecover();
         return;
@@ -161,7 +160,8 @@ void ArthurHeavySwipe::OnStateExit()
 
 void ArthurHeavySwipe::tryApplyHit(int hitIndex)
 {
-    if (!m_attackConfig || !m_attackExecutor)
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg || !m_attackExecutor)
     {
         return;
     }
@@ -175,7 +175,7 @@ void ArthurHeavySwipe::tryApplyHit(int hitIndex)
     Vector3 center = TransformAPI::getGlobalPosition(ownerTransform);
     Vector3 forward = TransformAPI::getForward(ownerTransform);
 
-    const int hits = m_attackExecutor->applyDamageInCone(center, forward, m_attackConfig->m_heavySwipeRange, m_attackConfig->m_heavySwipeHalfAngleDegrees, m_attackConfig->m_heavySwipeDamage, "HeavySwipe");
+    const int hits = m_attackExecutor->applyDamageInCone(center, forward, cfg->m_heavySwipeRange, cfg->m_heavySwipeHalfAngleDegrees, cfg->m_heavySwipeDamage, "HeavySwipe");
 
     if (m_arthurSound)
     {
@@ -191,18 +191,24 @@ void ArthurHeavySwipe::tryApplyHit(int hitIndex)
 
 void ArthurHeavySwipe::goToRecover()
 {
-    if (!m_attackConfig || !m_animation)
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
     if (m_arthurController)
     {
-        float recoveryDuration = m_attackConfig->m_heavySwipeRecoveryDuration;
+        float recoveryDuration = cfg->m_heavySwipeRecoveryDuration;
 
         if (m_arthurController->isPhase2())
         {
-            recoveryDuration = m_attackConfig->m_heavySwipePhase2RecoveryDuration;
+            recoveryDuration = cfg->m_heavySwipePhase2RecoveryDuration;
         }
 
         m_arthurController->setRecoveryDuration(recoveryDuration);
diff --git a/GameScripts/ArthurHeavySwipe.h b/GameScripts/ArthurHeavySwipe.h
index a17d806e..32e53ceb 100644
--- a/GameScripts/ArthurHeavySwipe.h
+++ b/GameScripts/ArthurHeavySwipe.h
@@ -27,7 +27,7 @@ class ArthurHeavySwipe : public StateMachineScript
 
 private:
     ArthurBossController* m_arthurController = nullptr;
-    ArthurAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArthurAttackConfig> m_attackConfig;
     EnemyAttackExecutor* m_attackExecutor = nullptr;
     AnimationComponent* m_animation = nullptr;
     ArthurUI* m_arthurUI = nullptr;
diff --git a/GameScripts/ArthurSideSweep.cpp b/GameScripts/ArthurSideSweep.cpp
index 19495418..37ce3f82 100644
--- a/GameScripts/ArthurSideSweep.cpp
+++ b/GameScripts/ArthurSideSweep.cpp
@@ -8,6 +8,7 @@
 #include "ArthurSound.h"
 
 IMPLEMENT_SCRIPT_FIELDS(ArthurSideSweep,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Arthur Attack Config", AssetType::DATA_CONTAINER),
     SERIALIZED_INT(m_sweepSide, "Sweep Side")
 )
 
@@ -19,7 +20,6 @@ ArthurSideSweep::ArthurSideSweep(GameObject* owner)
 void ArthurSideSweep::OnStateEnter()
 {
     m_arthurController = GameObjectAPI::findScript<ArthurBossController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArthurAttackConfig>(getOwner());
     m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_arthurUI = GameObjectAPI::findScript<ArthurUI>(getOwner());
@@ -34,12 +34,6 @@ void ArthurSideSweep::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[ArthurSideSweep] ArthurAttackConfig not found.");
-        return;
-    }
-
     if (!m_attackExecutor)
     {
         Debug::error("[ArthurSideSweep] EnemyAttackExecutor not found.");
@@ -73,7 +67,13 @@ void ArthurSideSweep::OnStateEnter()
 
 void ArthurSideSweep::OnStateUpdate()
 {
-    if (!m_arthurController || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_arthurController || !m_attackExecutor || !m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -85,13 +85,13 @@ void ArthurSideSweep::OnStateUpdate()
 
     m_stateTimer += Time::getDeltaTime();
 
-    float hitTime = m_attackConfig->m_sideSweepHitTime;
-    float totalDuration = m_attackConfig->m_sideSweepTotalDuration;
+    float hitTime = cfg->m_sideSweepHitTime;
+    float totalDuration = cfg->m_sideSweepTotalDuration;
 
     if (m_arthurController->isPhase2())
     {
-        hitTime = m_attackConfig->m_sideSweepPhase2HitTime;
-        totalDuration = m_attackConfig->m_sideSweepPhase2TotalDuration;
+        hitTime = cfg->m_sideSweepPhase2HitTime;
+        totalDuration = cfg->m_sideSweepPhase2TotalDuration;
     }
 
     if (m_arthurUI)
@@ -124,7 +124,13 @@ void ArthurSideSweep::OnStateExit()
 
 void ArthurSideSweep::applyHit()
 {
-    if (!m_arthurController || !m_attackConfig || !m_attackExecutor)
+    if (!m_arthurController || !m_attackExecutor)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -138,7 +144,7 @@ void ArthurSideSweep::applyHit()
     Vector3 center = TransformAPI::getGlobalPosition(ownerTransform);
     Vector3 sweepDirection = m_arthurController->getSideSweepDirection(m_sweepSide);
 
-    m_attackExecutor->applyDamageInCone(center, sweepDirection, m_attackConfig->m_sideSweepRange, m_attackConfig->m_sideSweepHalfAngleDegrees, m_attackConfig->m_sideSweepDamage, "SideSweep");
+    m_attackExecutor->applyDamageInCone(center, sweepDirection, cfg->m_sideSweepRange, cfg->m_sideSweepHalfAngleDegrees, cfg->m_sideSweepDamage, "SideSweep");
 
     if (m_arthurSound)
     {
@@ -150,18 +156,24 @@ void ArthurSideSweep::applyHit()
 
 void ArthurSideSweep::goToRecover()
 {
-    if (!m_attackConfig || !m_animation)
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const ArthurAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
     if (m_arthurController)
     {
-        float recoveryDuration = m_attackConfig->m_sideSweepRecoveryDuration;
+        float recoveryDuration = cfg->m_sideSweepRecoveryDuration;
 
         if (m_arthurController->isPhase2())
         {
-            recoveryDuration = m_attackConfig->m_sideSweepPhase2RecoveryDuration;
+            recoveryDuration = cfg->m_sideSweepPhase2RecoveryDuration;
         }
 
         m_arthurController->setRecoveryDuration(recoveryDuration);
diff --git a/GameScripts/ArthurSideSweep.h b/GameScripts/ArthurSideSweep.h
index 36086ac0..2421d5f1 100644
--- a/GameScripts/ArthurSideSweep.h
+++ b/GameScripts/ArthurSideSweep.h
@@ -21,7 +21,7 @@ class ArthurSideSweep : public StateMachineScript
     void OnStateUpdate() override;
     void OnStateExit() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void applyHit();
@@ -33,7 +33,7 @@ class ArthurSideSweep : public StateMachineScript
 
 private:
     ArthurBossController* m_arthurController = nullptr;
-    ArthurAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArthurAttackConfig> m_attackConfig;
     EnemyAttackExecutor* m_attackExecutor = nullptr;
     AnimationComponent* m_animation = nullptr;
     ArthurUI* m_arthurUI = nullptr;
diff --git a/GameScripts/ArthurUI.h b/GameScripts/ArthurUI.h
index 19e83311..2be71671 100644
--- a/GameScripts/ArthurUI.h
+++ b/GameScripts/ArthurUI.h
@@ -14,7 +14,7 @@ class ArthurUI : public Script
 	void Start() override;
 	void Update() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	// Health
@@ -52,9 +52,9 @@ class ArthurUI : public Script
 
 private:
 	// Health
-	ScriptComponentRef<Transform> m_healthBarCanvas;
-	ScriptComponentRef<Transform2D> m_healthBarContainer;
-	ScriptComponentRef<Transform2D> m_healthBarPhase2;
+	ComponentRef<Transform> m_healthBarCanvas;
+	ComponentRef<Transform2D> m_healthBarContainer;
+	ComponentRef<Transform2D> m_healthBarPhase2;
 
 	Transform* m_healthBarCanvasTransform = nullptr;
 	Transform2D* m_healthBarContainerTransform2D = nullptr;
@@ -67,13 +67,13 @@ class ArthurUI : public Script
 	bool m_healthBarPhase2Visible = false;
 
 	// Heavy Swipe
-	ScriptComponentRef<Transform> m_heavySwipeUICanvas;
-	ScriptComponentRef<Transform2D> m_heavySwipeUIContainer;
-	ScriptComponentRef<Transform2D> m_heavySwipeUIBackground;
-	ScriptComponentRef<Transform2D> m_heavySwipeUIBorder;
-	ScriptComponentRef<Transform2D> m_heavySwipeUIGlow;
-	ScriptComponentRef<Transform2D> m_heavySwipeUIRightClaw;
-	ScriptComponentRef<Transform2D> m_heavySwipeUILeftClaw;
+	ComponentRef<Transform> m_heavySwipeUICanvas;
+	ComponentRef<Transform2D> m_heavySwipeUIContainer;
+	ComponentRef<Transform2D> m_heavySwipeUIBackground;
+	ComponentRef<Transform2D> m_heavySwipeUIBorder;
+	ComponentRef<Transform2D> m_heavySwipeUIGlow;
+	ComponentRef<Transform2D> m_heavySwipeUIRightClaw;
+	ComponentRef<Transform2D> m_heavySwipeUILeftClaw;
 
 	Transform* m_heavySwipeUICanvasTransform = nullptr;
 	Transform2D* m_heavySwipeUIContainerTransform2D = nullptr;
@@ -84,10 +84,10 @@ class ArthurUI : public Script
 	Transform2D* m_heavySwipeUILeftClawTransform2D = nullptr;
 
 	//Side Sweep
-	ScriptComponentRef<Transform> m_sideSweepUICanvas;
-	ScriptComponentRef<Transform2D> m_sideSweepUIContainer;
-	ScriptComponentRef<Transform2D> m_sideSweepUIBackground;
-	ScriptComponentRef<Transform2D> m_sideSweepUIShadow;
+	ComponentRef<Transform> m_sideSweepUICanvas;
+	ComponentRef<Transform2D> m_sideSweepUIContainer;
+	ComponentRef<Transform2D> m_sideSweepUIBackground;
+	ComponentRef<Transform2D> m_sideSweepUIShadow;
 
 	Transform* m_sideSweepUICanvasTransform = nullptr;
 	Transform2D* m_sideSweepUIContainerTransform2D = nullptr;
@@ -95,14 +95,14 @@ class ArthurUI : public Script
 	Transform2D* m_sideSweepUIShadowTransform2D = nullptr;
 
 	// Charging Slam
-	ScriptComponentRef<Transform> m_chargingSlamUICanvas;
-	ScriptComponentRef<Transform2D> m_chargingSlamUIContainer;
-	ScriptComponentRef<Transform2D> m_chargingSlamUIBackground;
-	ScriptComponentRef<Transform2D> m_chargingSlamUIBorders;
-	ScriptComponentRef<Transform2D> m_chargingSlamUIShadow;
-	ScriptComponentRef<Transform2D> m_chargingSlamUISpikes;
-	ScriptComponentRef<UISlider> m_chargingSlamUIBordersSlider;
-	ScriptComponentRef<UISlider> m_chargingSlamUIShadowSlider;
+	ComponentRef<Transform> m_chargingSlamUICanvas;
+	ComponentRef<Transform2D> m_chargingSlamUIContainer;
+	ComponentRef<Transform2D> m_chargingSlamUIBackground;
+	ComponentRef<Transform2D> m_chargingSlamUIBorders;
+	ComponentRef<Transform2D> m_chargingSlamUIShadow;
+	ComponentRef<Transform2D> m_chargingSlamUISpikes;
+	ComponentRef<UISlider> m_chargingSlamUIBordersSlider;
+	ComponentRef<UISlider> m_chargingSlamUIShadowSlider;
 
 	Transform* m_chargingSlamUICanvasTransform = nullptr;
 	Transform2D* m_chargingSlamUIContainerTransform2D = nullptr;
@@ -113,10 +113,10 @@ class ArthurUI : public Script
 	UISlider* m_chargingSlamUIBordersSliderComponent = nullptr;
 	UISlider* m_chargingSlamUIShadowSliderComponent = nullptr;
 
-	ScriptComponentRef<Transform> m_chargingSlamImpactUICanvas;
-	ScriptComponentRef<Transform2D> m_chargingSlamImpactUIContainer;
-	ScriptComponentRef<Transform2D> m_chargingSlamImpactUICenter;
-	ScriptComponentRef<Transform2D> m_chargingSlamImpactUIGlow;
+	ComponentRef<Transform> m_chargingSlamImpactUICanvas;
+	ComponentRef<Transform2D> m_chargingSlamImpactUIContainer;
+	ComponentRef<Transform2D> m_chargingSlamImpactUICenter;
+	ComponentRef<Transform2D> m_chargingSlamImpactUIGlow;
 
 	Transform* m_chargingSlamImpactUICanvasTransform = nullptr;
 	Transform2D* m_chargingSlamImpactUIContainerTransform2D = nullptr;
@@ -133,12 +133,12 @@ class ArthurUI : public Script
 	float m_chargingSlamImpactUIFadeTimer = 0.0f;
 
 	// Earth Hammer UI
-	ScriptComponentRef<Transform> m_earthHammerUICanvas;
-	ScriptComponentRef<Transform2D> m_earthHammerUIContainer;
-	ScriptComponentRef<Transform2D> m_earthHammerUIInner;
-	ScriptComponentRef<Transform2D> m_earthHammerUISpikes;
-	ScriptComponentRef<Transform2D> m_earthHammerUIGlow;
-	ScriptComponentRef<Transform2D> m_earthHammerUIRing;
+	ComponentRef<Transform> m_earthHammerUICanvas;
+	ComponentRef<Transform2D> m_earthHammerUIContainer;
+	ComponentRef<Transform2D> m_earthHammerUIInner;
+	ComponentRef<Transform2D> m_earthHammerUISpikes;
+	ComponentRef<Transform2D> m_earthHammerUIGlow;
+	ComponentRef<Transform2D> m_earthHammerUIRing;
 
 	Transform* m_earthHammerUICanvasTransform = nullptr;
 	Transform2D* m_earthHammerUIContainerTransform2D = nullptr;
diff --git a/GameScripts/AudioListenerFollow.h b/GameScripts/AudioListenerFollow.h
index e2c99a02..8a531332 100644
--- a/GameScripts/AudioListenerFollow.h
+++ b/GameScripts/AudioListenerFollow.h
@@ -24,11 +24,11 @@ class AudioListenerFollow : public Script
 
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     // Los dos jugadores. El listener se sitúa en su punto medio cada frame.
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
     // Orientación del listener. Por defecto = Fixed Rotation de la cámara, para que el
     // paneo 3D izquierda/derecha cuadre con la pantalla (enemigo a la izquierda → suena
diff --git a/GameScripts/BarrierEnemyDamageable.h b/GameScripts/BarrierEnemyDamageable.h
index 202c355f..9a1159fc 100644
--- a/GameScripts/BarrierEnemyDamageable.h
+++ b/GameScripts/BarrierEnemyDamageable.h
@@ -11,7 +11,7 @@ class BarrierEnemyDamageable : public EnemyDamageable
     explicit BarrierEnemyDamageable(GameObject* owner);
 
     void Start() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void takeDamage(float amount) override;
     void takeDamage(const HitContext& ctx) override;
diff --git a/GameScripts/Bound.cpp b/GameScripts/Bound.cpp
index bce2c5fe..5fd11a6b 100644
--- a/GameScripts/Bound.cpp
+++ b/GameScripts/Bound.cpp
@@ -1,5 +1,6 @@
 #include "pch.h"
 #include "Bound.h"
+#include "BoundConfig.h"
 #include "Damageable.h"
 #include "HeartbeatHaptic.h"
 #include "CooperativeSound.h"
@@ -8,13 +9,7 @@ IMPLEMENT_SCRIPT_FIELDS(Bound,
     SERIALIZED_COMPONENT_REF(m_firstTarget, "Player 1 Transform", ComponentType::TRANSFORM),
     SERIALIZED_COMPONENT_REF(m_secondTarget, "Player 2 Transform", ComponentType::TRANSFORM),
     SERIALIZED_COMPONENT_REF(m_BoundUI, "Bound UI", ComponentType::TRANSFORM),
-    SERIALIZED_FLOAT(m_minDistance, "Min Distance", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(m_distanceDamage, "Damage Distance", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(m_distanceInstaKill, "InstaKill Distance", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(m_radiusThreshold, "Radius Threshold", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(baseDamage, "Base Damage", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(maxDamage, "Max Damage", 0.0f, 0.0f, 0.1f),
-    SERIALIZED_FLOAT(m_separationHapticHpGate, "Separation Haptic HP Gate", 0.5f, 0.25f, 0.01f)
+    SERIALIZED_ASSET_REF(m_config, "Bound Config", AssetType::DATA_CONTAINER)
 )
 
 Bound::Bound(GameObject* owner) : Script(owner)
@@ -24,6 +19,18 @@ Bound::Bound(GameObject* owner) : Script(owner)
 
 void Bound::Start()
 {
+    if (m_config.get())
+    {
+        const BoundConfig* cfg = m_config.get();
+        m_minDistance = cfg->m_minDistance;
+        m_distanceDamage = cfg->m_distanceDamage;
+        m_distanceInstaKill = cfg->m_distanceInstaKill;
+        baseDamage = cfg->m_baseDamage;
+        maxDamage = cfg->m_maxDamage;
+        m_radiusThreshold = cfg->m_radiusThreshold;
+        m_separationHapticHpGate = cfg->m_separationHapticHpGate;
+    }
+
     GameObject* player1 = ComponentAPI::getOwner(m_firstTarget.getReferencedComponent());
     GameObject* player2 = ComponentAPI::getOwner(m_secondTarget.getReferencedComponent());
 
diff --git a/GameScripts/Bound.h b/GameScripts/Bound.h
index dfcf908b..0a6e3412 100644
--- a/GameScripts/Bound.h
+++ b/GameScripts/Bound.h
@@ -6,6 +6,7 @@ class Transform;
 class Damageable;
 class HeartbeatHaptic;
 class CooperativeSound;
+class BoundConfig;
 
 class Bound : public Script
 {
@@ -19,13 +20,15 @@ class Bound : public Script
 
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
-    ScriptComponentRef<Transform> m_BoundUI;
+    ComponentRef<Transform> m_BoundUI;
+
+    AssetRef<BoundConfig> m_config;
 
     Damageable* m_firstDamageable = nullptr;
     Damageable* m_secondDamageable = nullptr;
diff --git a/GameScripts/BoundConfig.h b/GameScripts/BoundConfig.h
new file mode 100644
index 00000000..dc370d6c
--- /dev/null
+++ b/GameScripts/BoundConfig.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "DataContainerAPI.h"
+
+class BoundConfig : public DataContainer
+{
+    DECLARE_DATACONTAINER(BoundConfig)
+
+public:
+    BoundConfig() = default;
+    explicit BoundConfig(AssetReference& id)
+        : DataContainer(id)
+    {
+    }
+
+    float m_minDistance = 70.0f;
+    float m_distanceDamage = 80.0f;
+    float m_distanceInstaKill = 100.0f;
+    float m_baseDamage = 20.0f;
+    float m_maxDamage = 40.0f;
+    float m_radiusThreshold = 2.0f;
+    float m_separationHapticHpGate = 0.5f;
+
+    IMPLEMENT_DATACONTAINER_FIELDS(BoundConfig,
+        SERIALIZED_FLOAT(m_minDistance, "Min Distance", 0.0f, 200.0f, 1.0f),
+        SERIALIZED_FLOAT(m_distanceDamage, "Damage Distance", 0.0f, 200.0f, 1.0f),
+        SERIALIZED_FLOAT(m_distanceInstaKill, "Insta Kill Distance", 0.0f, 200.0f, 1.0f),
+        SERIALIZED_FLOAT(m_baseDamage, "Base Damage", 0.0f, 100.0f, 1.0f),
+        SERIALIZED_FLOAT(m_maxDamage, "Max Damage", 0.0f, 100.0f, 1.0f),
+        SERIALIZED_FLOAT(m_radiusThreshold, "Radius Threshold", 0.0f, 10.0f, 0.1f),
+        SERIALIZED_FLOAT(m_separationHapticHpGate, "Separation Haptic HP Gate", 0.0f, 1.0f, 0.01f)
+    )
+};
+
diff --git a/GameScripts/BreakableExplosive.h b/GameScripts/BreakableExplosive.h
index 6ba02631..acb3811b 100644
--- a/GameScripts/BreakableExplosive.h
+++ b/GameScripts/BreakableExplosive.h
@@ -16,7 +16,7 @@ class BreakableExplosive : public BreakableObject
 
 	void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     float m_explosionRadius = 5.0f;
diff --git a/GameScripts/BreakableHealingDrop.h b/GameScripts/BreakableHealingDrop.h
index 7dfbaf99..7dbe4359 100644
--- a/GameScripts/BreakableHealingDrop.h
+++ b/GameScripts/BreakableHealingDrop.h
@@ -14,7 +14,7 @@ class BreakableHealingDrop : public BreakableObject
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     PrefabRef m_healthPickupPrefab;
diff --git a/GameScripts/BreakableObject.h b/GameScripts/BreakableObject.h
index 6bbcbc2a..b3b12eee 100644
--- a/GameScripts/BreakableObject.h
+++ b/GameScripts/BreakableObject.h
@@ -14,7 +14,7 @@ class BreakableObject : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     virtual void onBreak();
     bool isBroken() const { return m_isBroken; }
diff --git a/GameScripts/CameraFollow.h b/GameScripts/CameraFollow.h
index 0721965f..7e7206e4 100644
--- a/GameScripts/CameraFollow.h
+++ b/GameScripts/CameraFollow.h
@@ -14,7 +14,7 @@ class CameraFollow : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void setFollowEnabled(bool enabled) { m_followEnabled = enabled; }
     bool isFollowEnabled() const { return m_followEnabled; }
@@ -22,8 +22,8 @@ class CameraFollow : public Script
     bool getDesiredCameraTransform(Vector3& outPosition, Vector3& outRotation);
 
 public:
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
     Vector3 m_transformOffset = Vector3(0.0f, 0.0f, 0.0f);
     Vector3 m_rotationOffset = Vector3(0.0f, 0.0f, 0.0f);
diff --git a/GameScripts/CameraTransitionEvent.h b/GameScripts/CameraTransitionEvent.h
index 7136cca4..055d1c4c 100644
--- a/GameScripts/CameraTransitionEvent.h
+++ b/GameScripts/CameraTransitionEvent.h
@@ -25,7 +25,7 @@ class CameraTransitionEvent : public GameplayEventAction
     void executeEvent(GameplayEventTrigger* trigger) override;
     void stopEvent(GameplayEventTrigger* trigger) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     const std::vector<Transform*>& getTargetPoints() const { return m_targetPoints; }
     Transform* getTargetPoint(int index) const;
diff --git a/GameScripts/CameraTransitionStep.h b/GameScripts/CameraTransitionStep.h
index ae2aa323..416886d9 100644
--- a/GameScripts/CameraTransitionStep.h
+++ b/GameScripts/CameraTransitionStep.h
@@ -21,7 +21,7 @@ class CameraTransitionStep : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     CameraStepMoveMode getMoveMode() const { return static_cast<CameraStepMoveMode>(m_moveMode); }
 
diff --git a/GameScripts/CameraTransitionStepAction.h b/GameScripts/CameraTransitionStepAction.h
index ea2afd34..8c3bb21f 100644
--- a/GameScripts/CameraTransitionStepAction.h
+++ b/GameScripts/CameraTransitionStepAction.h
@@ -20,7 +20,7 @@ class CameraTransitionStepAction : public Script
     void Update() override;
 
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void onStepStarted(CameraTransitionController* controller, CameraTransitionStep* step);
     void onStepReached(CameraTransitionController* controller, CameraTransitionStep* step);
diff --git a/GameScripts/CharacterUI.h b/GameScripts/CharacterUI.h
index 08ea65c9..5002a9c5 100644
--- a/GameScripts/CharacterUI.h
+++ b/GameScripts/CharacterUI.h
@@ -37,7 +37,7 @@ class CharacterUI : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     void showAbilityCooldown(AbilityUISlot slot);
@@ -49,10 +49,10 @@ class CharacterUI : public Script
     int getSlotIndex(AbilityUISlot slot) const;
 
 private:
-    ScriptComponentRef<Transform> m_basicAttackCooldownUI;
-    ScriptComponentRef<Transform> m_chargedAttackCooldownUI;
-    ScriptComponentRef<Transform> m_abilityCooldownUI;
-    ScriptComponentRef<Transform> m_dashCooldownUI;
+    ComponentRef<Transform> m_basicAttackCooldownUI;
+    ComponentRef<Transform> m_chargedAttackCooldownUI;
+    ComponentRef<Transform> m_abilityCooldownUI;
+    ComponentRef<Transform> m_dashCooldownUI;
 
     float m_cooldownEndTime = 1.0f;
 
diff --git a/GameScripts/CombatAreaEvent.cpp b/GameScripts/CombatAreaEvent.cpp
index c021c093..170f6d2c 100644
--- a/GameScripts/CombatAreaEvent.cpp
+++ b/GameScripts/CombatAreaEvent.cpp
@@ -68,7 +68,7 @@ void CombatAreaEvent::openArea()
 	setVisualsState(m_exitVisuals, false);
 }
 
-void CombatAreaEvent::setBlockerState(const ScriptComponentRef<Transform>& blockerTransformRef, bool blocked)
+void CombatAreaEvent::setBlockerState(const ComponentRef<Transform>& blockerTransformRef, bool blocked)
 {
     Transform* blockerTransform = blockerTransformRef.getReferencedComponent();
 
@@ -96,7 +96,7 @@ void CombatAreaEvent::setBlockerState(const ScriptComponentRef<Transform>& block
     NavigationAPI::setBlocked(runtimeBlocker, blocked);
 }
 
-void CombatAreaEvent::setVisualsState(const ScriptComponentRef<Transform>& visualsTransformRef, bool active)
+void CombatAreaEvent::setVisualsState(const ComponentRef<Transform>& visualsTransformRef, bool active)
 {
     Transform* visualsTransform = visualsTransformRef.getReferencedComponent();
     if (visualsTransform == nullptr)
@@ -127,7 +127,7 @@ void CombatAreaEvent::removeDeadEnemies()
     }
 }
 
-bool CombatAreaEvent::shouldRemoveEnemy(const ScriptComponentRef<Transform>& enemyTransformRef) const
+bool CombatAreaEvent::shouldRemoveEnemy(const ComponentRef<Transform>& enemyTransformRef) const
 {
     Transform* enemyTransform = enemyTransformRef.getReferencedComponent();
 
diff --git a/GameScripts/CombatAreaEvent.h b/GameScripts/CombatAreaEvent.h
index 8878f8ba..1ab2b563 100644
--- a/GameScripts/CombatAreaEvent.h
+++ b/GameScripts/CombatAreaEvent.h
@@ -16,30 +16,30 @@ class CombatAreaEvent : public GameplayEventAction
 
     void executeEvent(GameplayEventTrigger* trigger) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void closeArea();
     void openArea();
 
-    void setBlockerState(const ScriptComponentRef<Transform>& blockerTransformRef, bool blocked);
+    void setBlockerState(const ComponentRef<Transform>& blockerTransformRef, bool blocked);
 
-	void setVisualsState(const ScriptComponentRef<Transform>& visualsTransformRef, bool active);
+	void setVisualsState(const ComponentRef<Transform>& visualsTransformRef, bool active);
 
     void removeDeadEnemies();
-    bool shouldRemoveEnemy(const ScriptComponentRef<Transform>& enemyTransformRef) const;
+    bool shouldRemoveEnemy(const ComponentRef<Transform>& enemyTransformRef) const;
 
 public:
-    std::vector<ScriptComponentRef<Transform>> m_enemies;
+    std::vector<ComponentRef<Transform>> m_enemies;
 
-    ScriptComponentRef<Transform> m_entranceBlocker;
-    ScriptComponentRef<Transform> m_exitBlocker;
+    ComponentRef<Transform> m_entranceBlocker;
+    ComponentRef<Transform> m_exitBlocker;
 
-	ScriptComponentRef<Transform> m_entranceVisuals;
-	ScriptComponentRef<Transform> m_exitVisuals;
+	ComponentRef<Transform> m_entranceVisuals;
+	ComponentRef<Transform> m_exitVisuals;
 
 private:
-    std::vector<ScriptComponentRef<Transform>> m_remainingEnemies;
+    std::vector<ComponentRef<Transform>> m_remainingEnemies;
 
     bool m_isActive = false;
     bool m_hasCompleted = false;
diff --git a/GameScripts/CrystalShadowMark.h b/GameScripts/CrystalShadowMark.h
index e4f70200..a6433850 100644
--- a/GameScripts/CrystalShadowMark.h
+++ b/GameScripts/CrystalShadowMark.h
@@ -20,7 +20,7 @@ class CrystalShadowMark : public EnemyShadowMark
 
     void updateUI();
 
-    ScriptComponentRef<Transform> m_puzzleManager;
+    ComponentRef<Transform> m_puzzleManager;
 
 	int m_puzzleID = 0;
 
@@ -43,6 +43,6 @@ class CrystalShadowMark : public EnemyShadowMark
 	GameObject* managerObject = nullptr;
 	PuzzleManagerLVL1* managerScript = nullptr;
 
-ScriptFieldList getExposedFields() const override;
+FieldList getExposedFields() const override;
 };
 
diff --git a/GameScripts/Damageable.h b/GameScripts/Damageable.h
index 58bf7cdf..d4f532d3 100644
--- a/GameScripts/Damageable.h
+++ b/GameScripts/Damageable.h
@@ -23,7 +23,7 @@ class Damageable : public Script
     void Start()     override;
 	void Update()	 override;
     void drawGizmo() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     virtual void takeDamage(float amount);
     virtual void takeDamage(const HitContext& ctx);
@@ -60,9 +60,9 @@ class Damageable : public Script
 
 public:
     float m_maxHp = 100.0f;
-	ScriptComponentRef<UISlider> m_healthBar;
-    ScriptComponentRef<UISlider> m_healthBar2;
-    ScriptComponentRef<UISlider> m_healthGlow;
+	ComponentRef<UISlider> m_healthBar;
+    ComponentRef<UISlider> m_healthBar2;
+    ComponentRef<UISlider> m_healthGlow;
     float m_uiWaitTime = 0.6f;
     float m_uiUpdateTime = 1.0f;
 
diff --git a/GameScripts/DeathAbilityBase.cpp b/GameScripts/DeathAbilityBase.cpp
index c3f7ebb0..7181f72e 100644
--- a/GameScripts/DeathAbilityBase.cpp
+++ b/GameScripts/DeathAbilityBase.cpp
@@ -15,12 +15,6 @@ void DeathAbilityBase::Start()
     AbilityBase::Start();
 
     m_deathCharacter = dynamic_cast<DeathCharacter*>(m_character);
-    m_config = GameObjectAPI::findScript<DeathConfig>(getOwner());
-
-    if (!m_config)
-    {
-        Debug::error("[DeathAbilityBase] DeathConfig not found. This character requires DeathConfig.");
-    }
 }
 
 void DeathAbilityBase::releaseComboMoveLock()
diff --git a/GameScripts/DeathAbilityBase.h b/GameScripts/DeathAbilityBase.h
index 029c736d..6fcfa509 100644
--- a/GameScripts/DeathAbilityBase.h
+++ b/GameScripts/DeathAbilityBase.h
@@ -17,7 +17,7 @@ class DeathAbilityBase : public AbilityBase
 
 protected:
     DeathCharacter* m_deathCharacter = nullptr;
-    DeathConfig* m_config = nullptr;
+    AssetRef<DeathConfig> m_config;
 
     bool m_movementLockedForCombo = false;
 };
diff --git a/GameScripts/DeathBasicAttack.cpp b/GameScripts/DeathBasicAttack.cpp
index 10095323..2f3e117b 100644
--- a/GameScripts/DeathBasicAttack.cpp
+++ b/GameScripts/DeathBasicAttack.cpp
@@ -83,8 +83,10 @@ void DeathBasicAttack::startAbility()
 
     m_deathCharacter->advanceCombo(false);
 
+    const DeathConfig* cfg = m_config.get();
+
     const bool  isFinalHit  = (comboStep >= 2);
-    const float lockDuration = isFinalHit ? m_config->m_basicFinalHitLockDuration : m_config->m_basicAttackLockDuration;
+    const float lockDuration = isFinalHit ? cfg->m_basicFinalHitLockDuration : cfg->m_basicAttackLockDuration;
 
     beginAttackPresentation();
     beginAttackWindow(lockDuration);
@@ -133,7 +135,9 @@ void DeathBasicAttack::onAttackWindowFinished()
 
 float DeathBasicAttack::getCooldown() const
 {
-    return m_config->m_basicCooldown;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_basicCooldown;
 }
 
 void DeathBasicAttack::dealDamageToTarget(GameObject* target) const
@@ -154,8 +158,12 @@ void DeathBasicAttack::dealDamageToTarget(GameObject* target) const
     }
 
     constexpr float k_degToRad = 3.14159265f / 180.0f;
-    const float halfHitCos = cosf(m_config->m_basicAttackHitAngle * 0.5f * k_degToRad);
-    const float rangeSq = m_config->m_basicAttackRange * m_config->m_basicAttackRange;
+
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
+    const float halfHitCos = cosf(cfg->m_basicAttackHitAngle * 0.5f * k_degToRad);
+    const float rangeSq = cfg->m_basicAttackRange * cfg->m_basicAttackRange;
 
     auto isInHitZone = [&](GameObject* enemy) -> bool
         {
@@ -198,7 +206,7 @@ void DeathBasicAttack::dealDamageToTarget(GameObject* target) const
                 {
                     return;
                 }
-                breakableDamageable->takeDamage(m_config->m_basicAttackDamage);
+                breakableDamageable->takeDamage(cfg->m_basicAttackDamage);
                 if (sound != nullptr)
                 {
                     sound->playLightImpact();
@@ -208,7 +216,7 @@ void DeathBasicAttack::dealDamageToTarget(GameObject* target) const
 
             {
                 EnemyHitContext ctx;
-                ctx.damage = m_config->m_basicAttackDamage;
+                ctx.damage = cfg->m_basicAttackDamage;
                 ctx.attacker = GameObjectAPI::getTransform(getOwner());
                 ctx.attackType = EnemyAttackType::DeathBasic;
                 damageable->takeDamage(ctx);
@@ -216,7 +224,7 @@ void DeathBasicAttack::dealDamageToTarget(GameObject* target) const
 
             Debug::log("[BASIC] hit '%s'  dmg=%.1f  hp=%.1f/%.1f",
                 GameObjectAPI::getName(enemy),
-                m_config->m_basicAttackDamage,
+                cfg->m_basicAttackDamage,
                 damageable->getCurrentHp(),
                 damageable->getMaxHp());
 
@@ -291,8 +299,11 @@ void DeathBasicAttack::drawGizmo()
     const Vector3 fwd      = TransformAPI::getForward(t);
     const float   fill     = m_deathCharacter->getComboFillRatio();
 
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     constexpr float k_degToRad = 3.14159265f / 180.0f;
-    const float hitHalfRad     = m_config->m_basicAttackHitAngle * 0.5f * k_degToRad;
+    const float hitHalfRad     = cfg->m_basicAttackHitAngle * 0.5f * k_degToRad;
 
     const Vector3 posFlat = { pos.x, pos.y, pos.z };
 
@@ -316,24 +327,24 @@ void DeathBasicAttack::drawGizmo()
     {
         const float a0 = circleStep * static_cast<float>(i);
         const float a1 = a0 + circleStep;
-        DebugDrawAPI::drawLine(posFlat + radialDir(a0) * m_config->m_basicAttackRange,
-                               posFlat + radialDir(a1) * m_config->m_basicAttackRange, colGrey);
+        DebugDrawAPI::drawLine(posFlat + radialDir(a0) * cfg->m_basicAttackRange,
+                               posFlat + radialDir(a1) * cfg->m_basicAttackRange, colGrey);
     }
 
     // Hit zone: narrow arc with edge lines
     const Vector3 hitLeft  = radialDir(-hitHalfRad);
     const Vector3 hitRight = radialDir( hitHalfRad);
-    DebugDrawAPI::drawLine(posFlat, posFlat + hitLeft  * m_config->m_basicAttackRange, colGrey);
-    DebugDrawAPI::drawLine(posFlat, posFlat + hitRight * m_config->m_basicAttackRange, colGrey);
+    DebugDrawAPI::drawLine(posFlat, posFlat + hitLeft  * cfg->m_basicAttackRange, colGrey);
+    DebugDrawAPI::drawLine(posFlat, posFlat + hitRight * cfg->m_basicAttackRange, colGrey);
 
     const int   arcSegs = 12;
-    const float arcStep = (m_config->m_basicAttackHitAngle * k_degToRad) / static_cast<float>(arcSegs);
+    const float arcStep = (cfg->m_basicAttackHitAngle * k_degToRad) / static_cast<float>(arcSegs);
     for (int i = 0; i < arcSegs; ++i)
     {
         const float a0 = -hitHalfRad + arcStep * static_cast<float>(i);
         const float a1 = a0 + arcStep;
-        DebugDrawAPI::drawLine(posFlat + radialDir(a0) * m_config->m_basicAttackRange,
-                               posFlat + radialDir(a1) * m_config->m_basicAttackRange, colGrey);
+        DebugDrawAPI::drawLine(posFlat + radialDir(a0) * cfg->m_basicAttackRange,
+                               posFlat + radialDir(a1) * cfg->m_basicAttackRange, colGrey);
     }
 
     // Combo fill: purple (R1 last) or orange (R2 last) on hit zone arc
@@ -346,10 +357,10 @@ void DeathBasicAttack::drawGizmo()
         {
             const float t2 = static_cast<float>(i) / static_cast<float>(fillLines);
             const float a  = -hitHalfRad + t2 * filledAngle;
-            DebugDrawAPI::drawLine(posFlat, posFlat + radialDir(a) * m_config->m_basicAttackRange, colFill);
+            DebugDrawAPI::drawLine(posFlat, posFlat + radialDir(a) * cfg->m_basicAttackRange, colFill);
         }
 
-        DebugDrawAPI::drawLine(posFlat, posFlat + hitLeft * m_config->m_basicAttackRange, colFill);
+        DebugDrawAPI::drawLine(posFlat, posFlat + hitLeft * cfg->m_basicAttackRange, colFill);
     }
 }
 
@@ -360,6 +371,9 @@ void DeathBasicAttack::snapFaceTarget(GameObject* target)
         return;
     }
 
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     Transform* myTransform     = GameObjectAPI::getTransform(getOwner());
     Transform* targetTransform = GameObjectAPI::getTransform(target);
     if (myTransform == nullptr || targetTransform == nullptr)
@@ -367,7 +381,7 @@ void DeathBasicAttack::snapFaceTarget(GameObject* target)
         return;
     }
 
-    const float rangeSq = m_config->m_basicAttackRange * m_config->m_basicAttackRange;
+    const float rangeSq = cfg->m_basicAttackRange * cfg->m_basicAttackRange;
 
     Vector3 myPos     = TransformAPI::getGlobalPosition(myTransform);
     Vector3 targetPos = TransformAPI::getGlobalPosition(targetTransform);
@@ -395,6 +409,9 @@ void DeathBasicAttack::faceTarget(GameObject* target)
         return;
     }
 
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     Transform* myTransform     = GameObjectAPI::getTransform(getOwner());
     Transform* targetTransform = GameObjectAPI::getTransform(target);
 
@@ -404,7 +421,7 @@ void DeathBasicAttack::faceTarget(GameObject* target)
     Vector3 dir = targetPos - myPos;
     dir.y = 0.0f;
 
-    const float rangeSq = m_config->m_basicAttackRange * m_config->m_basicAttackRange;
+    const float rangeSq = cfg->m_basicAttackRange * cfg->m_basicAttackRange;
     if (dir.LengthSquared() > rangeSq)
     {
         return;
@@ -425,8 +442,14 @@ void DeathBasicAttack::updateUI()
 
     if (m_deathUI)
     {
-        m_deathUI->updateBasicSlashUI(m_attackStateTimer, m_config->m_basicAttackLockDuration);
+        const DeathConfig* cfg = m_config.get();
+        if (!cfg) return;
+        m_deathUI->updateBasicSlashUI(m_attackStateTimer, cfg->m_basicAttackLockDuration);
     }
 }
 
+IMPLEMENT_SCRIPT_FIELDS_INHERITED(DeathBasicAttack, DeathAbilityBase,
+    SERIALIZED_ASSET_REF(m_config, "Death Config", AssetType::DATA_CONTAINER)
+)
+
 IMPLEMENT_SCRIPT(DeathBasicAttack)
diff --git a/GameScripts/DeathBasicAttack.h b/GameScripts/DeathBasicAttack.h
index 3a47c309..f9eac8cb 100644
--- a/GameScripts/DeathBasicAttack.h
+++ b/GameScripts/DeathBasicAttack.h
@@ -12,6 +12,8 @@ class DeathBasicAttack : public DeathAbilityBase
 public:
     explicit DeathBasicAttack(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start()      override;
     void Update()     override;
     void drawGizmo()  override;
diff --git a/GameScripts/DeathCharacter.cpp b/GameScripts/DeathCharacter.cpp
index 52940fd2..f7944208 100644
--- a/GameScripts/DeathCharacter.cpp
+++ b/GameScripts/DeathCharacter.cpp
@@ -26,7 +26,6 @@ void DeathCharacter::Start()
     m_specialAbility = GameObjectAPI::findScript<DeathTaunt>(getOwner());
     m_sound    = GameObjectAPI::findScript<DeathSound>(getOwner());
     m_movement = GameObjectAPI::findScript<PlayerMovement>(getOwner());
-    m_config = GameObjectAPI::findScript<DeathConfig>(getOwner());
 
     if (m_basicAttack == nullptr)
     {
@@ -52,11 +51,6 @@ void DeathCharacter::Start()
     {
         Debug::log("[DeathCharacter] PlayerMovement not found on owner '%s'.", GameObjectAPI::getName(getOwner()));
     }
-
-    if (m_config == nullptr)
-    {
-        Debug::error("[DeathCharacter] DeathConfig not found on owner '%s'.", GameObjectAPI::getName(getOwner()));
-    }
 }
 
 void DeathCharacter::Update()
@@ -81,12 +75,16 @@ void DeathCharacter::Update()
 
 float DeathCharacter::getComboWindowR2() const
 {
-    return m_config->m_comboWindowR2;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_comboWindowR2;
 }
 
 float DeathCharacter::getComboWindowMaxCharge() const
 {
-    return m_config->m_comboWindowMaxCharge;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_comboWindowMaxCharge;
 }
 
 void DeathCharacter::tickCombo(float dt)
@@ -119,8 +117,11 @@ void DeathCharacter::tickCombo(float dt)
 
 void DeathCharacter::advanceCombo(bool isR2, float comboWindowOverride)
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     m_comboTimer        = 0.0f;
-    m_activeComboWindow = (comboWindowOverride > 0.0f) ? comboWindowOverride : m_config->m_comboWindow;
+    m_activeComboWindow = (comboWindowOverride > 0.0f) ? comboWindowOverride : cfg->m_comboWindow;
 
     if (isR2)
     {
@@ -136,7 +137,7 @@ void DeathCharacter::advanceCombo(bool isR2, float comboWindowOverride)
     if (m_comboStep >= 3)
     {
         resetCombo();
-        m_comboCooldownTimer = m_config->m_comboCooldown;
+        m_comboCooldownTimer = cfg->m_comboCooldown;
     }
 }
 
@@ -147,4 +148,8 @@ void DeathCharacter::resetCombo()
     m_comboTimer         = 0.0f;
 }
 
+IMPLEMENT_SCRIPT_FIELDS(DeathCharacter,
+    SERIALIZED_ASSET_REF(m_config, "Death Config", AssetType::DATA_CONTAINER)
+)
+
 IMPLEMENT_SCRIPT(DeathCharacter)
diff --git a/GameScripts/DeathCharacter.h b/GameScripts/DeathCharacter.h
index 1b379cce..406e5f60 100644
--- a/GameScripts/DeathCharacter.h
+++ b/GameScripts/DeathCharacter.h
@@ -13,11 +13,12 @@ class DeathCharacter : public CharacterBase
 public:
     explicit DeathCharacter(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start()  override;
     void Update() override;
 
     DeathSound* getSound() const { return m_sound; }
-    DeathConfig* getConfig() const { return m_config; }
 
     float getComboWindowR2() const;
     float getComboWindowMaxCharge() const;
@@ -48,5 +49,5 @@ class DeathCharacter : public CharacterBase
 
     DeathSound*     m_sound     = nullptr;
     PlayerMovement* m_movement  = nullptr;
-    DeathConfig* m_config       = nullptr;
+    AssetRef<DeathConfig> m_config;
 };
diff --git a/GameScripts/DeathChargedAttack.cpp b/GameScripts/DeathChargedAttack.cpp
index 6940337b..bf9c12bf 100644
--- a/GameScripts/DeathChargedAttack.cpp
+++ b/GameScripts/DeathChargedAttack.cpp
@@ -62,7 +62,8 @@ void DeathChargedAttack::Update()
             }
         }
 
-        const bool maxReached = m_chargeTime >= m_config->m_chargedMaxChargeTime;
+        const DeathConfig* cfg = m_config.get();
+        const bool maxReached = (cfg != nullptr) && (m_chargeTime >= cfg->m_chargedMaxChargeTime);
         const bool released = Input::isRightTriggerReleased(getPlayerIndex());
 
         if (maxReached || released)
@@ -114,31 +115,34 @@ void DeathChargedAttack::startCharging()
 
 void DeathChargedAttack::fireAttack()
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     // Snap to the aim direction sampled during the hold, then deal damage in that direction
     snapFaceAimDirection();
 
     const int   comboStep   = m_deathCharacter->getComboStep();
-    const bool  isMaxCharge = (m_chargeTime >= m_config->m_chargedMaxChargeTime);
+    const bool  isMaxCharge = (m_chargeTime >= cfg->m_chargedMaxChargeTime);
 
     // Charged-mode shot: only valid as combo starter (step 0), needs min charge time
-    const bool isChargedShot = (m_chargeTime >= m_config->m_chargedMinChargeTime) && (comboStep == 0);
+    const bool isChargedShot = (m_chargeTime >= cfg->m_chargedMinChargeTime) && (comboStep == 0);
 
     float damage;
     if (isChargedShot)
     {
-        const float rawRatio    = m_chargeTime / m_config->m_chargedMaxChargeTime;
+        const float rawRatio    = m_chargeTime / cfg->m_chargedMaxChargeTime;
         const float chargeRatio = rawRatio > 1.0f ? 1.0f : rawRatio;
-        damage = m_config->m_chargedAttackDamage * (1.0f + chargeRatio);
+        damage = cfg->m_chargedAttackDamage * (1.0f + chargeRatio);
 
         if (isMaxCharge)
             Debug::log("[COMBO] R2 CARGA MAXIMA  step %d/3  dmg=%.1f", comboStep + 1, damage);
         else
             Debug::log("[COMBO] R2 CARGADO  step %d/3  ratio=%.0f%%  dmg=%.1f",
-                comboStep + 1, (m_chargeTime / m_config->m_chargedMaxChargeTime) * 100.0f, damage);
+                comboStep + 1, (m_chargeTime / cfg->m_chargedMaxChargeTime) * 100.0f, damage);
     }
     else
     {
-        damage = m_config->m_chargedAttackDamage;
+        damage = cfg->m_chargedAttackDamage;
         Debug::log("[COMBO] R2  step %d/3  dmg=%.1f", comboStep + 1, damage);
     }
 
@@ -158,8 +162,8 @@ void DeathChargedAttack::fireAttack()
         }
     }
 
-    const float range = isChargedShot ? m_config->m_chargedShotArcRange : m_config->m_chargedArcRange;
-    const float angle = isChargedShot ? m_config->m_chargedShotArcAngle : m_config->m_chargedArcAngle;
+    const float range = isChargedShot ? cfg->m_chargedShotArcRange : cfg->m_chargedArcRange;
+    const float angle = isChargedShot ? cfg->m_chargedShotArcAngle : cfg->m_chargedArcAngle;
 
     dealDamageInArc(damage, range, angle, isChargedShot, isMaxCharge);
     notifyAbilitySuccessfullyStarted();
@@ -177,7 +181,7 @@ void DeathChargedAttack::fireAttack()
     m_chargeTime = 0.0f;
     m_isCharging = false;
 
-    const float lockDuration = (comboStep >= 2) ? m_config->m_chargedFinalHitLockDuration : m_config->m_chargedAttackLockDuration;
+    const float lockDuration = (comboStep >= 2) ? cfg->m_chargedFinalHitLockDuration : cfg->m_chargedAttackLockDuration;
 
     // Trigger attack animation and start the post-fire movement lock window
     beginAttackPresentation();
@@ -372,7 +376,9 @@ void DeathChargedAttack::onAttackWindowFinished()
 
 float DeathChargedAttack::getCooldown() const
 {
-    return m_config->m_chargedCooldown;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_chargedCooldown;
 }
 
 void DeathChargedAttack::drawGizmo()
@@ -384,8 +390,11 @@ void DeathChargedAttack::drawGizmo()
     if (t == nullptr)
         return;
 
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     const Vector3 pos   = TransformAPI::getGlobalPosition(t);
-    const float   range = m_config->m_chargedArcRange;
+    const float   range = cfg->m_chargedArcRange;
 
     // While charging with stick input, show arc in aim direction; otherwise use character forward
     Vector3 fwd;
@@ -398,7 +407,7 @@ void DeathChargedAttack::drawGizmo()
     {
         fwd = TransformAPI::getForward(t);
     }
-    const float   angle   = m_config->m_chargedArcAngle;
+    const float   angle   = cfg->m_chargedArcAngle;
     const Vector3 posFlat = { pos.x, pos.y, pos.z };
 
     constexpr float k_degToRad = 3.14159265f / 180.0f;
@@ -432,9 +441,9 @@ void DeathChargedAttack::drawGizmo()
     }
 
     // Charge fill: yellow overlay that grows with charge ratio
-    if (m_isCharging && m_config->m_chargedMaxChargeTime > 0.0f)
+    if (m_isCharging && cfg->m_chargedMaxChargeTime > 0.0f)
     {
-        const float ratio   = m_chargeTime / m_config->m_chargedMaxChargeTime;
+        const float ratio   = m_chargeTime / cfg->m_chargedMaxChargeTime;
         const float clamped = ratio > 1.0f ? 1.0f : ratio;
         const int   fillEnd = static_cast<int>(clamped * static_cast<float>(arcSegs));
 
@@ -454,8 +463,14 @@ void DeathChargedAttack::updateUI()
 
     if (m_deathUI)
     {
-        m_deathUI->updateChargedSlashUI(m_attackStateTimer, m_config->m_chargedAttackLockDuration);
+        const DeathConfig* cfg = m_config.get();
+        if (!cfg) return;
+        m_deathUI->updateChargedSlashUI(m_attackStateTimer, cfg->m_chargedAttackLockDuration);
     }
 }
 
+IMPLEMENT_SCRIPT_FIELDS_INHERITED(DeathChargedAttack, DeathAbilityBase,
+    SERIALIZED_ASSET_REF(m_config, "Death Config", AssetType::DATA_CONTAINER)
+)
+
 IMPLEMENT_SCRIPT(DeathChargedAttack)
diff --git a/GameScripts/DeathChargedAttack.h b/GameScripts/DeathChargedAttack.h
index 1dd8d281..8cf80960 100644
--- a/GameScripts/DeathChargedAttack.h
+++ b/GameScripts/DeathChargedAttack.h
@@ -12,6 +12,8 @@ class DeathChargedAttack : public DeathAbilityBase
 public:
     explicit DeathChargedAttack(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start()     override;
     void Update()    override;
     void drawGizmo() override;
diff --git a/GameScripts/DeathConfig.cpp b/GameScripts/DeathConfig.cpp
index 6690d5fa..d814192f 100644
--- a/GameScripts/DeathConfig.cpp
+++ b/GameScripts/DeathConfig.cpp
@@ -1,56 +1,2 @@
 #include "pch.h"
 #include "DeathConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS(DeathConfig,
-	FIELD_GROUP_COLLAPSE("Combo",
-		SERIALIZED_FLOAT(m_comboWindow, "Combo Window R1", 0.1f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_comboWindowR2, "Combo Window R2", 0.1f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_comboWindowMaxCharge, "Combo Window Max Charge", 0.1f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_comboCooldown, "Combo Cooldown", 0.0f, 5.0f, 0.1f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Basic Attack",
-		SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 200.0f, 1.0f),
-		SERIALIZED_FLOAT(m_basicAttackRange, "Basic Attack Range", 0.5f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_basicAttackHitAngle, "Basic Attack Hit Angle", 5.0f, 180.0f, 5.0f),
-		SERIALIZED_FLOAT(m_basicAttackLockDuration, "Basic Attack Lock Duration", 0.05f, 2.0f, 0.05f),
-		SERIALIZED_FLOAT(m_basicFinalHitLockDuration, "Basic Final Hit Lock Duration", 0.05f, 3.0f, 0.05f),
-		SERIALIZED_FLOAT(m_basicCooldown, "Basic Cooldown", 0.0f, 10.0f, 0.01f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Charged Attack",
-		SERIALIZED_FLOAT(m_chargedAttackDamage, "Charged Attack Damage", 0.0f, 200.0f, 1.0f),
-		SERIALIZED_FLOAT(m_chargedArcRange, "Arc Range", 0.5f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargedArcAngle, "Arc Angle", 10.0f, 360.0f, 5.0f),
-		SERIALIZED_FLOAT(m_chargedMaxChargeTime, "Max Charge Time", 0.5f, 5.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargedMinChargeTime, "Min Charge Time", 0.0f, 3.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargedAttackLockDuration, "Charged Attack Lock Duration", 0.05f, 2.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargedFinalHitLockDuration, "Charged Final Hit Lock Duration", 0.05f, 3.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargedShotArcRange, "Charged Arc Range", 0.5f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargedShotArcAngle, "Charged Arc Angle", 10.0f, 360.0f, 5.0f),
-		SERIALIZED_FLOAT(m_chargedCooldown, "Charged Cooldown", 0.0f, 10.0f, 0.01f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Taunt",
-		SERIALIZED_FLOAT(m_tauntDuration, "Taunt Duration", 1.0f, 10.0f, 0.05f),
-		SERIALIZED_FLOAT(m_tauntRange, "Cone Range", 1.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_tauntHalfAngleDegrees, "Cone Angle", 1.0f, 180.0f, 1.0f),
-		SERIALIZED_FLOAT(m_tauntLockDuration, "Taunt Lock Duration", 0.05f, 2.0f, 0.05f),
-		SERIALIZED_FLOAT(m_tauntCooldown, "Taunt Cooldown", 0.0f, 10.0f, 0.01f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Dash",
-		SERIALIZED_FLOAT(m_dashDuration, "Dash Duration", 0.0f, 1.0f, 0.01f),
-		SERIALIZED_FLOAT(m_dashDistance, "Dash Distance", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_dashHitWidth, "Dash Hit Width", 0.1f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_dashDamage, "Dash Damage", 0.0f, 100.0f, 1.0f),
-		SERIALIZED_FLOAT(m_dashCooldown, "Dash Cooldown", 0.0f, 10.0f, 0.01f)
-	)
-)
-
-DeathConfig::DeathConfig(GameObject* owner)
-	: Script(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(DeathConfig)
\ No newline at end of file
diff --git a/GameScripts/DeathConfig.h b/GameScripts/DeathConfig.h
index 452299f2..83f108f7 100644
--- a/GameScripts/DeathConfig.h
+++ b/GameScripts/DeathConfig.h
@@ -1,17 +1,18 @@
 #pragma once
 
-#include "ScriptAPI.h"
+#include "DataContainerAPI.h"
 
-class DeathConfig : public Script
+class DeathConfig : public DataContainer
 {
-	DECLARE_SCRIPT(DeathConfig)
+	DECLARE_DATACONTAINER(DeathConfig)
 
 public:
-	explicit DeathConfig(GameObject* owner);
+	DeathConfig() = default;
+	explicit DeathConfig(AssetReference& id)
+		: DataContainer(id)
+	{
+	}
 
-	ScriptFieldList getExposedFields() const override;
-
-public:
 	// Combo
 	float m_comboWindow = 1.0f;
 	float m_comboWindowR2 = 2.0f;
@@ -51,4 +52,51 @@ class DeathConfig : public Script
 	float m_dashHitWidth = 2.0f;
 	float m_dashDamage = 20.0f;
 	float m_dashCooldown = 0.0f;
-};
\ No newline at end of file
+
+	IMPLEMENT_DATACONTAINER_FIELDS(DeathConfig,
+		FIELD_GROUP_COLLAPSE("Combo",
+			SERIALIZED_FLOAT(m_comboWindow, "Combo Window R1", 0.1f, 5.0f, 0.05f),
+			SERIALIZED_FLOAT(m_comboWindowR2, "Combo Window R2", 0.1f, 5.0f, 0.05f),
+			SERIALIZED_FLOAT(m_comboWindowMaxCharge, "Combo Window Max Charge", 0.1f, 5.0f, 0.05f),
+			SERIALIZED_FLOAT(m_comboCooldown, "Combo Cooldown", 0.0f, 5.0f, 0.1f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Basic Attack",
+			SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 200.0f, 1.0f),
+			SERIALIZED_FLOAT(m_basicAttackRange, "Basic Attack Range", 0.5f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_basicAttackHitAngle, "Basic Attack Hit Angle", 5.0f, 180.0f, 5.0f),
+			SERIALIZED_FLOAT(m_basicAttackLockDuration, "Basic Attack Lock Duration", 0.05f, 2.0f, 0.05f),
+			SERIALIZED_FLOAT(m_basicFinalHitLockDuration, "Basic Final Hit Lock Duration", 0.05f, 3.0f, 0.05f),
+			SERIALIZED_FLOAT(m_basicCooldown, "Basic Cooldown", 0.0f, 10.0f, 0.01f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Charged Attack",
+			SERIALIZED_FLOAT(m_chargedAttackDamage, "Charged Attack Damage", 0.0f, 200.0f, 1.0f),
+			SERIALIZED_FLOAT(m_chargedArcRange, "Arc Range", 0.5f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_chargedArcAngle, "Arc Angle", 10.0f, 360.0f, 5.0f),
+			SERIALIZED_FLOAT(m_chargedMaxChargeTime, "Max Charge Time", 0.5f, 5.0f, 0.1f),
+			SERIALIZED_FLOAT(m_chargedMinChargeTime, "Min Charge Time", 0.0f, 3.0f, 0.05f),
+			SERIALIZED_FLOAT(m_chargedAttackLockDuration, "Charged Attack Lock Duration", 0.05f, 2.0f, 0.05f),
+			SERIALIZED_FLOAT(m_chargedFinalHitLockDuration, "Charged Final Hit Lock Duration", 0.05f, 3.0f, 0.05f),
+			SERIALIZED_FLOAT(m_chargedShotArcRange, "Charged Arc Range", 0.5f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_chargedShotArcAngle, "Charged Arc Angle", 10.0f, 360.0f, 5.0f),
+			SERIALIZED_FLOAT(m_chargedCooldown, "Charged Cooldown", 0.0f, 10.0f, 0.01f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Taunt",
+			SERIALIZED_FLOAT(m_tauntDuration, "Taunt Duration", 1.0f, 10.0f, 0.05f),
+			SERIALIZED_FLOAT(m_tauntRange, "Cone Range", 1.0f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_tauntHalfAngleDegrees, "Cone Angle", 1.0f, 180.0f, 1.0f),
+			SERIALIZED_FLOAT(m_tauntLockDuration, "Taunt Lock Duration", 0.05f, 2.0f, 0.05f),
+			SERIALIZED_FLOAT(m_tauntCooldown, "Taunt Cooldown", 0.0f, 10.0f, 0.01f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Dash",
+			SERIALIZED_FLOAT(m_dashDuration, "Dash Duration", 0.0f, 1.0f, 0.01f),
+			SERIALIZED_FLOAT(m_dashDistance, "Dash Distance", 0.0f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_dashHitWidth, "Dash Hit Width", 0.1f, 5.0f, 0.05f),
+			SERIALIZED_FLOAT(m_dashDamage, "Dash Damage", 0.0f, 100.0f, 1.0f),
+			SERIALIZED_FLOAT(m_dashCooldown, "Dash Cooldown", 0.0f, 10.0f, 0.01f)
+		)
+	)
+};
diff --git a/GameScripts/DeathDash.cpp b/GameScripts/DeathDash.cpp
index 6aaf786e..66a1005c 100644
--- a/GameScripts/DeathDash.cpp
+++ b/GameScripts/DeathDash.cpp
@@ -24,14 +24,6 @@ void DeathDash::Start()
         return;
     }
 
-    m_config = GameObjectAPI::findScript<DeathConfig>(getOwner());
-
-    if (!m_config)
-    {
-        Debug::error("[DeathDash] DeathConfig not found.");
-        return;
-    }
-
     m_sound = GameObjectAPI::findScript<DeathSound>(getOwner());
 
     if (!m_sound)
@@ -51,17 +43,23 @@ void DeathDash::Start()
 
 float DeathDash::getCooldown() const
 {
-    return m_config->m_dashCooldown;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_dashCooldown;
 }
 
 float DeathDash::getDashDuration() const
 {
-    return m_config->m_dashDuration;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_dashDuration;
 }
 
 float DeathDash::getDashDistance() const
 {
-    return m_config->m_dashDistance;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_dashDistance;
 }
 
 void DeathDash::onDashStarted()
@@ -133,6 +131,9 @@ bool DeathDash::anyEnemyInsideDashRectangle() const
 
 bool DeathDash::isInsideDashRectangle(const Vector3& point) const
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return false;
+
     Transform* t = GameObjectAPI::getTransform(getOwner());
     Vector3    endPos = (t != nullptr) ? TransformAPI::getGlobalPosition(t) : Vector3::Zero;
 
@@ -156,11 +157,14 @@ bool DeathDash::isInsideDashRectangle(const Vector3& point) const
     float   longitudinal = toPoint.Dot(fwd);
     float   lateral = toPoint.Dot(side);
 
-    return (longitudinal >= 0.0f && longitudinal <= length) && (lateral >= -m_config->m_dashHitWidth && lateral <= m_config->m_dashHitWidth);
+    return (longitudinal >= 0.0f && longitudinal <= length) && (lateral >= -cfg->m_dashHitWidth && lateral <= cfg->m_dashHitWidth);
 }
 
 void DeathDash::applyDashDamage()
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     if (m_dashDamageDealt)
     {
         return;
@@ -198,7 +202,7 @@ void DeathDash::applyDashDamage()
         {
             {
                 EnemyHitContext ctx;
-                ctx.damage = m_config->m_dashDamage;
+                ctx.damage = cfg->m_dashDamage;
                 ctx.attacker = GameObjectAPI::getTransform(getOwner());
                 ctx.attackType = EnemyAttackType::DeathDash;
                 damageable->takeDamage(ctx);
@@ -220,4 +224,8 @@ void DeathDash::applyDashDamage()
     }
 }
 
+IMPLEMENT_SCRIPT_FIELDS_INHERITED(DeathDash, AbilityDash,
+    SERIALIZED_ASSET_REF(m_config, "Death Config", AssetType::DATA_CONTAINER)
+)
+
 IMPLEMENT_SCRIPT(DeathDash)
diff --git a/GameScripts/DeathDash.h b/GameScripts/DeathDash.h
index bed8217b..2f82dcbf 100644
--- a/GameScripts/DeathDash.h
+++ b/GameScripts/DeathDash.h
@@ -14,6 +14,8 @@ class DeathDash : public AbilityDash
 public:
     explicit DeathDash(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start() override;
 
 protected:
@@ -31,7 +33,7 @@ class DeathDash : public AbilityDash
 
 private:
     DeathCharacter* m_deathCharacter = nullptr;
-    DeathConfig* m_config = nullptr;
+    AssetRef<DeathConfig> m_config;
     DeathSound* m_sound = nullptr;
     DeathParticles* m_particles = nullptr;
 
diff --git a/GameScripts/DeathParticles.cpp b/GameScripts/DeathParticles.cpp
index 740e5d3c..eba72d90 100644
--- a/GameScripts/DeathParticles.cpp
+++ b/GameScripts/DeathParticles.cpp
@@ -29,7 +29,7 @@ void DeathParticles::Update()
     }
 }
 
-Transform* DeathParticles::getTransform(ScriptComponentRef<Transform> controller)
+Transform* DeathParticles::getTransform(ComponentRef<Transform> controller)
 {
     Transform* particleTransform = controller.getReferencedComponent();
 
diff --git a/GameScripts/DeathParticles.h b/GameScripts/DeathParticles.h
index 6bad7846..2f21582e 100644
--- a/GameScripts/DeathParticles.h
+++ b/GameScripts/DeathParticles.h
@@ -11,8 +11,8 @@ class DeathParticles : public Script
 
 	void Update() override;
 
-	ScriptComponentRef<Transform> m_dashTrail;
-	ScriptComponentRef<Transform> m_scytheTrail;
+	ComponentRef<Transform> m_dashTrail;
+	ComponentRef<Transform> m_scytheTrail;
 	PrefabRef m_tauntParticle;
 
 	GameObject* m_activeTauntParticle = nullptr;
@@ -21,7 +21,7 @@ class DeathParticles : public Script
 	Transform* m_dashTrailController = nullptr;
 	Transform* m_scytheTrailController = nullptr;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	void SetDashActive();
 	void SetDashInactive();
@@ -34,6 +34,6 @@ class DeathParticles : public Script
 
 private:
 
-	Transform* getTransform(ScriptComponentRef<Transform> controller);
+	Transform* getTransform(ComponentRef<Transform> controller);
 };
 
diff --git a/GameScripts/DeathTargetIndicatorUI.cpp b/GameScripts/DeathTargetIndicatorUI.cpp
index 37f876c0..cff69cbc 100644
--- a/GameScripts/DeathTargetIndicatorUI.cpp
+++ b/GameScripts/DeathTargetIndicatorUI.cpp
@@ -4,6 +4,7 @@
 #include "DeathConfig.h"
 
 IMPLEMENT_SCRIPT_FIELDS_INHERITED(DeathTargetIndicatorUI, TargetIndicatorUI,
+    SERIALIZED_ASSET_REF(m_deathConfig, "Death Config", AssetType::DATA_CONTAINER),
     FIELD_GROUP_LABEL("Range Indicator"),
     SERIALIZED_COMPONENT_REF(m_rangeIndicatorTransform, "Range Indicator Transform", ComponentType::TRANSFORM),
     SERIALIZED_FLOAT(m_heightOffset, "Height Offset", -1.0f, 1.0f, 0.01f),
@@ -23,15 +24,6 @@ void DeathTargetIndicatorUI::onStart()
     {
         return;
     }
-
-    GameObject* player = ComponentAPI::getOwner(playerTransform);
-
-    m_deathConfig = GameObjectAPI::findScript<DeathConfig>(player);
-
-    if (m_deathConfig == nullptr)
-    {
-        Debug::warn("[DeathTargetIndicatorUI] DeathConfig not found on player '%s'.", GameObjectAPI::getName(player));
-    }
 }
 
 void DeathTargetIndicatorUI::updateDirectionIndicator(GameObject* currentTarget)
@@ -43,7 +35,8 @@ void DeathTargetIndicatorUI::updateDirectionIndicator(GameObject* currentTarget)
         return;
     }
 
-    if (m_deathConfig == nullptr)
+    const DeathConfig* deathCfg = m_deathConfig.get();
+    if (deathCfg == nullptr)
     {
         hideDirectionIndicator();
         return;
@@ -70,7 +63,8 @@ void DeathTargetIndicatorUI::hideDirectionIndicator()
 
 void DeathTargetIndicatorUI::updateRangeIndicatorTransform(Transform* rangeTransform, const Vector3& playerPosition, const Vector3& direction) const
 {
-    if (rangeTransform == nullptr || m_deathConfig == nullptr)
+    const DeathConfig* deathCfg = m_deathConfig.get();
+    if (rangeTransform == nullptr || deathCfg == nullptr)
     {
         return;
     }
@@ -85,7 +79,7 @@ void DeathTargetIndicatorUI::updateRangeIndicatorTransform(Transform* rangeTrans
 
     flatDirection.Normalize();
 
-    const float attackRange = m_deathConfig->m_basicAttackRange;
+    const float attackRange = deathCfg->m_basicAttackRange;
 
     Vector3 rangePosition = playerPosition + flatDirection * (attackRange * 0.5f);
     rangePosition.y = playerPosition.y + m_heightOffset;
diff --git a/GameScripts/DeathTargetIndicatorUI.h b/GameScripts/DeathTargetIndicatorUI.h
index fc7ef489..0be80bc5 100644
--- a/GameScripts/DeathTargetIndicatorUI.h
+++ b/GameScripts/DeathTargetIndicatorUI.h
@@ -11,7 +11,7 @@ class DeathTargetIndicatorUI : public TargetIndicatorUI
 public:
     explicit DeathTargetIndicatorUI(GameObject* owner);
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 protected:
     void onStart() override;
@@ -22,7 +22,7 @@ class DeathTargetIndicatorUI : public TargetIndicatorUI
     void updateRangeIndicatorTransform(Transform* rangeTransform, const Vector3& playerPosition, const Vector3& direction) const;
 
 public:
-    ScriptComponentRef<Transform> m_rangeIndicatorTransform;
+    ComponentRef<Transform> m_rangeIndicatorTransform;
 
     float m_heightOffset = 0.05f;
     float m_rotationOffsetDegrees = -90.0f;
@@ -30,5 +30,5 @@ class DeathTargetIndicatorUI : public TargetIndicatorUI
     Vector3 m_rangeIndicatorFullScale = Vector3(1.0f, 1.0f, 1.0f);
 
 private:
-    DeathConfig* m_deathConfig = nullptr;
+    AssetRef<DeathConfig> m_deathConfig;
 };
\ No newline at end of file
diff --git a/GameScripts/DeathTaunt.cpp b/GameScripts/DeathTaunt.cpp
index fd60d019..bedb8c43 100644
--- a/GameScripts/DeathTaunt.cpp
+++ b/GameScripts/DeathTaunt.cpp
@@ -96,7 +96,9 @@ void DeathTaunt::onAttackWindowFinished()
 
 float DeathTaunt::getCooldown() const
 {
-    return m_config->m_tauntCooldown;
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return 0.0f;
+    return cfg->m_tauntCooldown;
 }
 
 void DeathTaunt::startAbility()
@@ -111,6 +113,9 @@ void DeathTaunt::drawGizmo()
         return;
     }
 
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     Transform* ownerTransform = GameObjectAPI::getTransform(m_owner);
     if (ownerTransform == nullptr)
     {
@@ -132,7 +137,7 @@ void DeathTaunt::drawGizmo()
 
     ownerForward.Normalize();
 
-    const float clampedHalfAngle = (m_config->m_tauntHalfAngleDegrees < 0.1f) ? 0.1f : ((m_config->m_tauntHalfAngleDegrees > 89.9f) ? 89.9f : m_config->m_tauntHalfAngleDegrees);
+    const float clampedHalfAngle = (cfg->m_tauntHalfAngleDegrees < 0.1f) ? 0.1f : ((cfg->m_tauntHalfAngleDegrees > 89.9f) ? 89.9f : cfg->m_tauntHalfAngleDegrees);
     const float halfAngleRadians = clampedHalfAngle * (3.14159265f / 180.0f);
 
     const int numSteps = 16;
@@ -149,7 +154,7 @@ void DeathTaunt::drawGizmo()
             direction.x * std::sin(angle) + direction.z * std::cos(angle)
         );
         direction.Normalize();
-        Vector3 arcPoint = ownerPosition + direction * m_config->m_tauntRange;
+        Vector3 arcPoint = ownerPosition + direction * cfg->m_tauntRange;
         DebugDrawAPI::drawLine(ownerPosition, arcPoint, color, 0, false);
     }
 }
@@ -230,9 +235,10 @@ void DeathTaunt::releaseAimAndCast()
         notifyAbilitySuccessfullyStarted();
         m_debugConeTimer = 0.25f;
 
+        const DeathConfig* cfg = m_config.get();
         m_movementLockedForCombo = true;
         beginAttackPresentation();
-        beginAttackWindow(m_config->m_tauntLockDuration);
+        beginAttackWindow(cfg ? cfg->m_tauntLockDuration : 0.0f);
     }
 
     m_currentAimDirection = Vector3::Zero;
@@ -243,6 +249,9 @@ void DeathTaunt::releaseAimAndCast()
 
 void DeathTaunt::applyTauntToEnemiesInCone(const Vector3& ownerForward) const
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return;
+
     Transform* ownerTransform = GameObjectAPI::getTransform(m_owner);
     if (ownerTransform == nullptr)
     {
@@ -271,8 +280,8 @@ void DeathTaunt::applyTauntToEnemiesInCone(const Vector3& ownerForward) const
             continue;
         }
 
-        enemyAggro->applyTaunt(ownerTransform, m_config->m_tauntDuration);
-        Debug::log("[DeathTaunt] Taunt applied to '%s' for %.1fs.", GameObjectAPI::getName(enemy), m_config->m_tauntDuration);
+        enemyAggro->applyTaunt(ownerTransform, cfg->m_tauntDuration);
+        Debug::log("[DeathTaunt] Taunt applied to '%s' for %.1fs.", GameObjectAPI::getName(enemy), cfg->m_tauntDuration);
 
         if (PersistingPowerupState::isUnlocked(PowerupId::DeathPowerup1))
         {
@@ -332,6 +341,9 @@ bool DeathTaunt::isAimStickValid(const Vector3& direction) const
 
 bool DeathTaunt::isEnemyInsideTauntCone(GameObject* enemy, const Vector3& ownerPosition, const Vector3& ownerForward) const
 {
+    const DeathConfig* cfg = m_config.get();
+    if (!cfg) return false;
+
     if (enemy == nullptr)
     {
         return false;
@@ -347,7 +359,7 @@ bool DeathTaunt::isEnemyInsideTauntCone(GameObject* enemy, const Vector3& ownerP
     directionToEnemy.y = 0.0f;
 
     const float distanceToEnemy = directionToEnemy.Length();
-    if (distanceToEnemy <= 0.0f || distanceToEnemy > m_config->m_tauntRange)
+    if (distanceToEnemy <= 0.0f || distanceToEnemy > cfg->m_tauntRange)
     {
         return false;
     }
@@ -361,11 +373,15 @@ bool DeathTaunt::isEnemyInsideTauntCone(GameObject* enemy, const Vector3& ownerP
     flattenedForward.Normalize();
     directionToEnemy.Normalize();
 
-    const float halfAngleRadians = m_config->m_tauntHalfAngleDegrees * (3.14159265f / 180.0f);
+    const float halfAngleRadians = cfg->m_tauntHalfAngleDegrees * (3.14159265f / 180.0f);
     const float coneThreshold = std::cos(halfAngleRadians);
 
     // TODO: Add a line-of-sight / wall check before confirming the taunt hit.
     return flattenedForward.Dot(directionToEnemy) >= coneThreshold;
 }
 
+IMPLEMENT_SCRIPT_FIELDS_INHERITED(DeathTaunt, DeathAbilityBase,
+    SERIALIZED_ASSET_REF(m_config, "Death Config", AssetType::DATA_CONTAINER)
+)
+
 IMPLEMENT_SCRIPT(DeathTaunt)
diff --git a/GameScripts/DeathTaunt.h b/GameScripts/DeathTaunt.h
index d086a567..7f239de2 100644
--- a/GameScripts/DeathTaunt.h
+++ b/GameScripts/DeathTaunt.h
@@ -13,6 +13,8 @@ class DeathTaunt : public DeathAbilityBase
 public:
     explicit DeathTaunt(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start()  override;
     void Update() override;
 
diff --git a/GameScripts/DeathUI.h b/GameScripts/DeathUI.h
index cefd1e98..e9bbee56 100644
--- a/GameScripts/DeathUI.h
+++ b/GameScripts/DeathUI.h
@@ -13,7 +13,7 @@ class DeathUI : public CharacterUI
 
 	void Start() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	// Taunt
@@ -37,19 +37,19 @@ class DeathUI : public CharacterUI
 
 private:
 	// Taunt
-	ScriptComponentRef<Transform> m_tauntUI;
+	ComponentRef<Transform> m_tauntUI;
 	Transform* m_tauntUITransform = nullptr;
 
 	// Charged Attack
-	ScriptComponentRef<Transform> m_chargedAttackUI;
+	ComponentRef<Transform> m_chargedAttackUI;
 	Transform* m_chargedAttackUITransform = nullptr;
 
 	// Slash Combo
-	ScriptComponentRef<Transform> m_basicSlashUI;
-	ScriptComponentRef<UISlider> m_basicSlashSlider;
+	ComponentRef<Transform> m_basicSlashUI;
+	ComponentRef<UISlider> m_basicSlashSlider;
 
-	ScriptComponentRef<Transform> m_chargedSlashUI;
-	ScriptComponentRef<UISlider> m_chargedSlashSlider;
+	ComponentRef<Transform> m_chargedSlashUI;
+	ComponentRef<UISlider> m_chargedSlashSlider;
 
 	Transform* m_basicSlashUITransform = nullptr;
 	UISlider* m_basicSlashUISlider = nullptr;
diff --git a/GameScripts/DebugDamageTrigger.h b/GameScripts/DebugDamageTrigger.h
index a94000af..37c42637 100644
--- a/GameScripts/DebugDamageTrigger.h
+++ b/GameScripts/DebugDamageTrigger.h
@@ -13,7 +13,7 @@ class DebugDamageTrigger : public Script
 
     void Start() override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     float m_damageAmount = 25.0f;
diff --git a/GameScripts/DebugDrawTest.h b/GameScripts/DebugDrawTest.h
index 2f48e981..49c28ded 100644
--- a/GameScripts/DebugDrawTest.h
+++ b/GameScripts/DebugDrawTest.h
@@ -14,7 +14,7 @@ class DebugDrawTest : public Script
 
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     Vector3 m_origin = { 0.0f, 0.0f, 0.0f };
diff --git a/GameScripts/DebugGetObjectsArea.h b/GameScripts/DebugGetObjectsArea.h
new file mode 100644
index 00000000..3440ee2e
--- /dev/null
+++ b/GameScripts/DebugGetObjectsArea.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class DebugGetObjectsArea : public Script
+{
+    DECLARE_SCRIPT(DebugGetObjectsArea)
+
+public:
+    explicit DebugGetObjectsArea(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+	void drawGizmo() override;
+
+    FieldList getExposedFields() const override;
+
+public:
+    float m_radius = 5.0f;
+
+};
\ No newline at end of file
diff --git a/GameScripts/DefeatConditionManager.h b/GameScripts/DefeatConditionManager.h
index 1e95bf31..53c4ba5f 100644
--- a/GameScripts/DefeatConditionManager.h
+++ b/GameScripts/DefeatConditionManager.h
@@ -16,7 +16,7 @@ class DefeatConditionManager : public Script
 
     void Start() override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     bool hasTriggeredDefeat() const { return m_hasTriggeredDefeat; }
 
@@ -27,8 +27,8 @@ class DefeatConditionManager : public Script
     void triggerDefeat();
 
 public:
-    ScriptComponentRef<Transform> m_player1Transform;
-    ScriptComponentRef<Transform> m_player2Transform;
+    ComponentRef<Transform> m_player1Transform;
+    ComponentRef<Transform> m_player2Transform;
 
 private:
     PlayerState* m_player1State = nullptr;
diff --git a/GameScripts/DestroyParticles.h b/GameScripts/DestroyParticles.h
index 4c490a16..4579a523 100644
--- a/GameScripts/DestroyParticles.h
+++ b/GameScripts/DestroyParticles.h
@@ -12,7 +12,7 @@ class DestroyParticles : public Script
     void Start()  override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     float m_lifetime = 2.0f;
diff --git a/GameScripts/EnemyATTACK.h b/GameScripts/EnemyATTACK.h
new file mode 100644
index 00000000..6072df29
--- /dev/null
+++ b/GameScripts/EnemyATTACK.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemyATTACK : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemyATTACK)
+
+public:
+	explicit EnemyATTACK(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	void performAttack();
+
+private:
+	EnemyController* m_enemyController = nullptr;
+	float m_attackTimer = 0.0f;
+
+public:
+	float m_attackDamage = 10.0f;
+	float m_attackCooldown = 1.0f;
+	float m_attackCommitDuration = 0.35f;
+	float m_attackCommitTimer = 0.0f;
+	bool m_debugEnabled = true;
+	bool m_attackTimerInitialized = false;
+	float m_attackTotalDuration = 0.75f;
+	float m_damageTriggerTime = 0.25f;
+	float m_stateTimer = 0.0f;
+	bool m_hasAppliedDamage = false;
+};
diff --git a/GameScripts/EnemyAttackState.cpp b/GameScripts/EnemyAttackState.cpp
index 1c740523..ce28e649 100644
--- a/GameScripts/EnemyAttackState.cpp
+++ b/GameScripts/EnemyAttackState.cpp
@@ -17,7 +17,6 @@ EnemyAttackState::EnemyAttackState(GameObject* owner)
 void EnemyAttackState::OnStateEnter()
 {
     m_controller = GameObjectAPI::findScript<EnemyBaseController>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<EnemyBaseAttackConfig>(getOwner());
     m_animation = AnimationAPI::getAnimationComponent(getOwner());
     m_paladinVFX = GameObjectAPI::findScript<PaladinVFX>(getOwner());
 
@@ -31,12 +30,6 @@ void EnemyAttackState::OnStateEnter()
         return;
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::error("[EnemyAttackState] AttackConfig not found.");
-        return;
-    }
-
     if (!m_animation)
     {
         Debug::error("[EnemyAttackState] AnimationComponent not found.");
@@ -60,7 +53,7 @@ void EnemyAttackState::OnStateEnter()
 
 void EnemyAttackState::OnStateUpdate()
 {
-    if (!m_controller || !m_attackConfig || !m_animation)
+    if (!m_controller || !m_animation)
     {
         return;
     }
@@ -79,7 +72,13 @@ void EnemyAttackState::OnStateUpdate()
 
     m_stateTimer += Time::getDeltaTime();
 
-    if (!m_hasAppliedDamage && m_stateTimer >= m_attackConfig->m_basicAttackWindupTime)
+    const EnemyBaseAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    if (!m_hasAppliedDamage && m_stateTimer >= cfg->m_basicAttackWindupTime)
     {
         playBasicAttackEffect();
         tryDamageTarget(m_committedTarget);
@@ -92,7 +91,7 @@ void EnemyAttackState::OnStateUpdate()
         m_hasAppliedDamage = true;
     }
 
-    if (m_stateTimer >= m_attackConfig->m_basicAttackTotalDuration)
+    if (m_stateTimer >= cfg->m_basicAttackTotalDuration)
     {
         m_controller->updateCurrentTarget();
 
@@ -118,7 +117,8 @@ void EnemyAttackState::OnStateExit()
 
 void EnemyAttackState::tryDamageTarget(Transform* targetTransform)
 {
-    if (!m_attackConfig)
+    const EnemyBaseAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
@@ -146,9 +146,9 @@ void EnemyAttackState::tryDamageTarget(Transform* targetTransform)
         return;
     }
 
-    damageable->takeDamage(m_attackConfig->m_basicAttackDamage);
+    damageable->takeDamage(cfg->m_basicAttackDamage);
 
-    Debug::log("[EnemyAttackState] Damaged '%s' for %.2f.", GameObjectAPI::getName(targetObject), m_attackConfig->m_basicAttackDamage);
+    Debug::log("[EnemyAttackState] Damaged '%s' for %.2f.", GameObjectAPI::getName(targetObject), cfg->m_basicAttackDamage);
 }
 
 void EnemyAttackState::playBasicAttackEffect()
@@ -159,4 +159,6 @@ void EnemyAttackState::playBasicAttackEffect()
     }
 }
 
-IMPLEMENT_SCRIPT(EnemyAttackState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(EnemyAttackState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/EnemyAttackState.h b/GameScripts/EnemyAttackState.h
index 2deefbab..eab91f3b 100644
--- a/GameScripts/EnemyAttackState.h
+++ b/GameScripts/EnemyAttackState.h
@@ -16,6 +16,8 @@ class EnemyAttackState : public StateMachineScript
 public:
     explicit EnemyAttackState(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void OnStateEnter() override;
     void OnStateUpdate() override;
     void OnStateExit() override;
@@ -26,7 +28,7 @@ class EnemyAttackState : public StateMachineScript
 
 private:
     EnemyBaseController* m_controller = nullptr;
-    EnemyBaseAttackConfig* m_attackConfig = nullptr;
+    AssetRef<EnemyBaseAttackConfig> m_attackConfig;
     AnimationComponent* m_animation = nullptr;
     PaladinVFX* m_paladinVFX = nullptr;
     EnemySound* m_enemySound = nullptr;
diff --git a/GameScripts/EnemyBaseAttackConfig.cpp b/GameScripts/EnemyBaseAttackConfig.cpp
index c3e8a398..d00451e5 100644
--- a/GameScripts/EnemyBaseAttackConfig.cpp
+++ b/GameScripts/EnemyBaseAttackConfig.cpp
@@ -1,22 +1,2 @@
 #include "pch.h"
 #include "EnemyBaseAttackConfig.h"
-
-#include "Transform2D.h"
-
-IMPLEMENT_SCRIPT_FIELDS(EnemyBaseAttackConfig,
-    // Basic Attack
-    FIELD_GROUP_COLLAPSE("Basic Attack",
-        SERIALIZED_FLOAT(m_basicAttackRange, "Basic Attack Range", 0.0f, 100.0f, 0.1f),
-        SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 9999.0f, 1.0f),
-        SERIALIZED_FLOAT(m_basicAttackWindupTime, "Basic Attack Windup Time", 0.0f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_basicAttackTotalDuration, "Basic Attack Total Duration", 0.1f, 10.0f, 0.05f),
-        SERIALIZED_FLOAT(m_basicAttackCooldown, "Basic Attack Cooldown", 0.0f, 10.0f, 0.05f)
-    )
-)
-
-EnemyBaseAttackConfig::EnemyBaseAttackConfig(GameObject* owner)
-    : Script(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(EnemyBaseAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/EnemyBaseAttackConfig.h b/GameScripts/EnemyBaseAttackConfig.h
index 6b401987..a6192eeb 100644
--- a/GameScripts/EnemyBaseAttackConfig.h
+++ b/GameScripts/EnemyBaseAttackConfig.h
@@ -1,21 +1,31 @@
 #pragma once
 
-#include "ScriptAPI.h"
+#include "EnemyBaseDataConfig.h"
 
-class EnemyBaseAttackConfig : public Script
+class EnemyBaseAttackConfig : public EnemyBaseDataConfig
 {
-    DECLARE_SCRIPT(EnemyBaseAttackConfig)
+    DECLARE_DATACONTAINER(EnemyBaseAttackConfig)
 
 public:
-    explicit EnemyBaseAttackConfig(GameObject* owner);
+    EnemyBaseAttackConfig() = default;
+    explicit EnemyBaseAttackConfig(AssetReference& id)
+        : EnemyBaseDataConfig(id)
+    {
+    }
 
-    ScriptFieldList getExposedFields() const override;
-
-public:
-    // Basic attack
     float m_basicAttackRange = 4.0f;
     float m_basicAttackDamage = 10.0f;
     float m_basicAttackWindupTime = 0.35f;
     float m_basicAttackTotalDuration = 0.8f;
     float m_basicAttackCooldown = 1.2f;
-};
\ No newline at end of file
+
+    IMPLEMENT_DATACONTAINER_FIELDS_INHERITED(EnemyBaseAttackConfig, EnemyBaseDataConfig,
+        FIELD_GROUP_COLLAPSE("Basic Attack",
+            SERIALIZED_FLOAT(m_basicAttackRange, "Basic Attack Range", 0.0f, 100.0f, 0.1f),
+            SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 9999.0f, 1.0f),
+            SERIALIZED_FLOAT(m_basicAttackWindupTime, "Basic Attack Windup Time", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_basicAttackTotalDuration, "Basic Attack Total Duration", 0.1f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_basicAttackCooldown, "Basic Attack Cooldown", 0.0f, 10.0f, 0.05f)
+        )
+    )
+};
diff --git a/GameScripts/EnemyBaseController.h b/GameScripts/EnemyBaseController.h
index 239729b9..b21511a3 100644
--- a/GameScripts/EnemyBaseController.h
+++ b/GameScripts/EnemyBaseController.h
@@ -12,7 +12,7 @@ class EnemyBaseController : public Script
     explicit EnemyBaseController(GameObject* owner);
     virtual ~EnemyBaseController() = default;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     // Target helpers
     virtual void updateCurrentTarget();
diff --git a/GameScripts/EnemyBaseDataConfig.cpp b/GameScripts/EnemyBaseDataConfig.cpp
new file mode 100644
index 00000000..2308267d
--- /dev/null
+++ b/GameScripts/EnemyBaseDataConfig.cpp
@@ -0,0 +1,2 @@
+#include "pch.h"
+#include "EnemyBaseDataConfig.h"
diff --git a/GameScripts/EnemyBaseDataConfig.h b/GameScripts/EnemyBaseDataConfig.h
new file mode 100644
index 00000000..b2228dd0
--- /dev/null
+++ b/GameScripts/EnemyBaseDataConfig.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "DataContainerAPI.h"
+
+class EnemyBaseDataConfig : public DataContainer
+{
+    DECLARE_DATACONTAINER(EnemyBaseDataConfig)
+
+public:
+    EnemyBaseDataConfig() = default;
+    explicit EnemyBaseDataConfig(AssetReference& id)
+        : DataContainer(id)
+    {
+    }
+
+    float m_maxHp = 100.0f;
+    float m_recoveryDuration = 0.75f;
+    float m_stunnedDuration = 2.0f;
+    float m_moveSpeed = 3.5f;
+
+    IMPLEMENT_DATACONTAINER_FIELDS(EnemyBaseDataConfig,
+        FIELD_GROUP_COLLAPSE("Health",
+            SERIALIZED_FLOAT(m_maxHp, "Max HP", 1.0f, 9999.0f, 1.0f)
+        ),
+        FIELD_GROUP_COLLAPSE("Combat",
+            SERIALIZED_FLOAT(m_recoveryDuration, "Recovery Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_stunnedDuration, "Stunned Duration", 0.0f, 10.0f, 0.05f)
+        ),
+        FIELD_GROUP_COLLAPSE("Movement",
+            SERIALIZED_FLOAT(m_moveSpeed, "Move Speed", 0.0f, 50.0f, 0.1f)
+        )
+    )
+};
diff --git a/GameScripts/EnemyCHARGE.h b/GameScripts/EnemyCHARGE.h
new file mode 100644
index 00000000..a17cbc7e
--- /dev/null
+++ b/GameScripts/EnemyCHARGE.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemyCHARGE : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemyCHARGE)
+
+public:
+	explicit EnemyCHARGE(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	EnemyController* m_enemyController = nullptr;
+	Vector3 m_chargeDirection = Vector3(0.0f, 0.0f, 1.0f);
+	float m_elapsedTime = 0.0f;
+
+public:
+	float m_chargeDuration = 0.5f;
+	float m_chargeSpeed = 6.0f;
+	float m_chargeCooldown = 3.0f;
+	bool m_debugEnabled = true;
+	
+};
diff --git a/GameScripts/EnemyCHASE.h b/GameScripts/EnemyCHASE.h
new file mode 100644
index 00000000..5090ff1d
--- /dev/null
+++ b/GameScripts/EnemyCHASE.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemyCHASE : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemyCHASE)
+
+public:
+	explicit EnemyCHASE(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	EnemyController* m_enemyController = nullptr;
+
+public:
+	bool m_debugEnabled = true;
+	bool m_useCharge = false;
+	float m_chargeTriggerRange = 4.0f;
+};
\ No newline at end of file
diff --git a/GameScripts/EnemyController.h b/GameScripts/EnemyController.h
new file mode 100644
index 00000000..c8dfc0d7
--- /dev/null
+++ b/GameScripts/EnemyController.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class EnemyDetectionAggro;
+
+class EnemyController : public Script
+{
+    DECLARE_SCRIPT(EnemyController)
+
+public:
+    explicit EnemyController(GameObject* owner);
+
+    void Start() override;
+    void drawGizmo() override;
+
+    FieldList getExposedFields() const override;
+
+public:
+    int m_enemyType = static_cast<int>(NavAgentProfile::EnemyGround);
+    float m_combatRange = 2.0f;
+    float m_moveSpeed = 1.0f;
+    float m_turnSpeed = 2.0f;
+    float m_intervalRepath = 0.4f;
+    bool m_debugEnabled = true;
+    float m_attackEnterRangeBonus = 0.45f;
+    float m_attackExitRangeBonus = 0.80f;
+
+    bool isTargetInAttackEnterRange() const;
+    bool isTargetInAttackExitRange() const;
+
+private:
+    EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
+    Transform* m_currentTarget = nullptr;
+    float m_repathTimer = 0.0f;
+    float m_chargeCooldownTimer = 0.0f;
+    std::vector<Vector3> m_path;
+    bool m_hasPath = false;
+    size_t m_currentIndex = 0;
+    size_t m_maxPathPoints = 32;
+    Vector3 m_searchExtents = Vector3(5.0f, 5.0f, 5.0f);
+    const float RADIANS_TO_DEGREES = 180.0f / 3.14159265f;
+
+public:
+    bool hasValidTarget() const;
+    void updateCurrentTarget();
+    bool isTargetInCombatRange() const;
+    Transform* getCurrentTarget() const { return m_currentTarget; }
+    void clearPath();
+    bool buildPathToTarget();
+    void followPath();
+    void faceCurrentTarget();
+    void resetRepathTimer();
+    void addToRepathTimer(float dt);
+    bool shouldRepath() const;
+    void tickChargeCooldown(float dt);
+    bool isChargeReady() const;
+    void consumeChargeCooldown(float cooldownDuration);
+    bool isDead() const;
+
+private:
+    Vector3 getChasePosition() const;
+    void rotateTowardsDirection(const Vector3& direction);
+};
\ No newline at end of file
diff --git a/GameScripts/EnemyDeathHandler.h b/GameScripts/EnemyDeathHandler.h
new file mode 100644
index 00000000..c13a074c
--- /dev/null
+++ b/GameScripts/EnemyDeathHandler.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class Damageable;
+
+class EnemyDeathHandler : public Script
+{
+    DECLARE_SCRIPT(EnemyDeathHandler)
+
+public:
+    explicit EnemyDeathHandler(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+private:
+    void playDeathAnimation();
+    void startDestroyCountdown(float delay);
+    void destroyEnemyNow();
+    void processDeath();
+
+public:
+    float m_destroyDelay = 2.0f;
+    std::string m_deathStateName = "";
+
+private:
+    Damageable* m_damageable = nullptr;
+    bool m_hasProcessedDeath = false;
+    bool m_waitingToDestroy = false;
+    float m_deathTimer = 0.0f;
+};
\ No newline at end of file
diff --git a/GameScripts/EnemyDeathState.h b/GameScripts/EnemyDeathState.h
index 4ff6b41d..a24d6ceb 100644
--- a/GameScripts/EnemyDeathState.h
+++ b/GameScripts/EnemyDeathState.h
@@ -14,7 +14,7 @@ class EnemyDeathState : public StateMachineScript
 	void OnStateUpdate() override;
 	void OnStateExit() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	void pauseDeathCountdown();
 	void resumeDeathCountdown();
diff --git a/GameScripts/EnemyDetectionAggro.h b/GameScripts/EnemyDetectionAggro.h
index a4c76c7f..e8a9f0de 100644
--- a/GameScripts/EnemyDetectionAggro.h
+++ b/GameScripts/EnemyDetectionAggro.h
@@ -22,15 +22,15 @@ class EnemyDetectionAggro : public Script
 	void Update() override;
 	void drawGizmo() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	float m_detectionRadius = 10.0f;
 	float m_targetLockDuration = 5.0f;
 	bool m_debugEnabled = true;
 
-	ScriptComponentRef<Transform> m_lyrielTransform;
-	ScriptComponentRef<Transform> m_deathTransform;
+	ComponentRef<Transform> m_lyrielTransform;
+	ComponentRef<Transform> m_deathTransform;
 
 public:
 	void notifyPlayerAttackedEnemy(Transform* playerTransform);
diff --git a/GameScripts/EnemyIDLE.h b/GameScripts/EnemyIDLE.h
new file mode 100644
index 00000000..cac9a067
--- /dev/null
+++ b/GameScripts/EnemyIDLE.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemyIDLE : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemyIDLE)
+
+public:
+	explicit EnemyIDLE(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	EnemyController* m_enemyController = nullptr;
+
+public:
+	bool m_debugEnabled = true;
+};
\ No newline at end of file
diff --git a/GameScripts/EnemyRECOVER.h b/GameScripts/EnemyRECOVER.h
new file mode 100644
index 00000000..7d9e9e2b
--- /dev/null
+++ b/GameScripts/EnemyRECOVER.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemyRECOVER : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemyRECOVER)
+
+public:
+	explicit EnemyRECOVER(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	EnemyController* m_enemyController = nullptr;
+	float m_recoverTimer = 0.0f;
+
+public:
+	float m_recoverDuration = 0.6f;
+	bool m_debugEnabled = true;
+	bool m_goToStunAfterRecover = false;
+};
diff --git a/GameScripts/EnemySTUN.h b/GameScripts/EnemySTUN.h
new file mode 100644
index 00000000..94c99815
--- /dev/null
+++ b/GameScripts/EnemySTUN.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class EnemyController;
+
+class EnemySTUN : public StateMachineScript
+{
+	DECLARE_SCRIPT(EnemySTUN)
+
+public:
+	explicit EnemySTUN(GameObject* owner);
+
+	void OnStateEnter() override;
+	void OnStateUpdate() override;
+	void OnStateExit() override;
+
+	FieldList getExposedFields() const override;
+
+private:
+	EnemyController* m_enemyController = nullptr;
+	float m_elapsedTime = 0.0f;
+
+public:
+	float m_stunDuration = 1.0f;
+	bool m_debugEnabled = true;
+};
diff --git a/GameScripts/EnemyShadowMark.h b/GameScripts/EnemyShadowMark.h
index f8ae975c..50a7cd98 100644
--- a/GameScripts/EnemyShadowMark.h
+++ b/GameScripts/EnemyShadowMark.h
@@ -16,7 +16,7 @@ class EnemyShadowMark : public Script
     void Update()    override;
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void notifyDeathHit();
     bool isExploitable() const { return m_phase == 3; }
@@ -28,10 +28,10 @@ class EnemyShadowMark : public Script
     float m_markDuration              = 3.0f;
     float m_markUITargetScale = 1.0f;
 	float m_markUIHeightOffset = 1.0f;
-    ScriptComponentRef<Transform2D> m_canvas;
-    ScriptComponentRef<Transform> m_mark_1;
-    ScriptComponentRef<Transform> m_mark_2;
-    ScriptComponentRef<Transform> m_mark_3;
+    ComponentRef<Transform2D> m_canvas;
+    ComponentRef<Transform> m_mark_1;
+    ComponentRef<Transform> m_mark_2;
+    ComponentRef<Transform> m_mark_3;
     
     float m_volleyCooldownReduction   = 0.20f;  // % of base cooldown removed per exploit
 
diff --git a/GameScripts/EnemyStunParticles.h b/GameScripts/EnemyStunParticles.h
index 745b9071..434233e7 100644
--- a/GameScripts/EnemyStunParticles.h
+++ b/GameScripts/EnemyStunParticles.h
@@ -7,7 +7,7 @@ class EnemyStunParticles : public Script
 public:
     explicit EnemyStunParticles(GameObject* owner);
     void Start() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     PrefabRef m_stunPrefab;
     float       m_heightOffset = 2.0f;
diff --git a/GameScripts/ExportListTest.h b/GameScripts/ExportListTest.h
new file mode 100644
index 00000000..8aaa11b4
--- /dev/null
+++ b/GameScripts/ExportListTest.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class ExportListTest : public Script
+{
+    DECLARE_SCRIPT(ExportListTest)
+
+public:
+    explicit ExportListTest(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+private:
+    ComponentRefList m_transforms;
+    int m_test1 = 0;
+    float m_test2 = 0.0;
+};
\ No newline at end of file
diff --git a/GameScripts/GameScripts.vcxproj b/GameScripts/GameScripts.vcxproj
index fd5d4ecb..f6ecbbef 100644
--- a/GameScripts/GameScripts.vcxproj
+++ b/GameScripts/GameScripts.vcxproj
@@ -275,6 +275,7 @@
     <ClInclude Include="AudioListenerFollow.h" />
     <ClInclude Include="BarrierEnemyDamageable.h" />
     <ClInclude Include="Bound.h" />
+    <ClInclude Include="BoundConfig.h" />
     <ClInclude Include="BreakableDamageable.h" />
     <ClInclude Include="BreakableExplosive.h" />
     <ClInclude Include="BreakableHealingDrop.h" />
diff --git a/GameScripts/GameScripts.vcxproj.filters b/GameScripts/GameScripts.vcxproj.filters
index cd2b12d1..b62d8899 100644
--- a/GameScripts/GameScripts.vcxproj.filters
+++ b/GameScripts/GameScripts.vcxproj.filters
@@ -327,6 +327,7 @@
     <ClInclude Include="PlayAnimationAction.h" />
     <ClInclude Include="PopUpController.h" />
     <ClInclude Include="PopUpEvent.h" />
+    <ClInclude Include="BoundConfig.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="SimpleMath.inl" />
diff --git a/GameScripts/GameplayEventTrigger.h b/GameScripts/GameplayEventTrigger.h
index 4a9f130b..e987bbf5 100644
--- a/GameScripts/GameplayEventTrigger.h
+++ b/GameScripts/GameplayEventTrigger.h
@@ -16,7 +16,7 @@ class GameplayEventTrigger : public Script
     void OnTriggerEnter(GameObject* gameObject) override;
     void OnTriggerExit(GameObject* gameObject) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void findPlayers();
diff --git a/GameScripts/HapticTester.h b/GameScripts/HapticTester.h
index 48457a9d..7719135e 100644
--- a/GameScripts/HapticTester.h
+++ b/GameScripts/HapticTester.h
@@ -14,7 +14,7 @@ class HapticTester : public Script
     void Update() override;
     void registerTestEffects();
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 protected:
     virtual std::vector<HapticEffectDefinition> defineEffects();
diff --git a/GameScripts/HealthPickup.h b/GameScripts/HealthPickup.h
index 185b4bec..c948aef6 100644
--- a/GameScripts/HealthPickup.h
+++ b/GameScripts/HealthPickup.h
@@ -17,7 +17,7 @@ class HealthPickup : public Pickup
     void Update() override;
     void OnTriggerEnter(GameObject* player) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void setupDrop(float healAmount, const Vector3& landingPosition);
 
diff --git a/GameScripts/HeartbeatHaptic.h b/GameScripts/HeartbeatHaptic.h
index 383c7daf..38d980e3 100644
--- a/GameScripts/HeartbeatHaptic.h
+++ b/GameScripts/HeartbeatHaptic.h
@@ -13,7 +13,7 @@ class HeartbeatHaptic : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     float m_hapticIntensity = 1.0f;
 
diff --git a/GameScripts/HeartbeatTester.h b/GameScripts/HeartbeatTester.h
new file mode 100644
index 00000000..23c12c5f
--- /dev/null
+++ b/GameScripts/HeartbeatTester.h
@@ -0,0 +1,29 @@
+#pragma once
+#include "ScriptAPI.h"
+#include "HapticEffectDefinition.h"
+
+class HeartbeatTester : public Script
+{
+    DECLARE_SCRIPT(HeartbeatTester)
+
+public:
+    explicit HeartbeatTester(GameObject* owner);
+
+    void Start()  override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+public:
+    int   m_playerIndex = 0;
+    int   m_hapticDeviceIndex = 0;
+    float m_dangerValue = 0.5f;  // 0 = safe, 1 = critical
+    bool  m_useHealthMode = true; 
+
+private:
+    float m_dubTimer = -1.0f;  
+    float m_dubScale = 0.0f;   
+    float m_lubTimer = -1.0f; 
+
+    void fireLub();
+};
\ No newline at end of file
diff --git a/GameScripts/LightZoneManager.h b/GameScripts/LightZoneManager.h
index 6ffb5d3e..304f33a4 100644
--- a/GameScripts/LightZoneManager.h
+++ b/GameScripts/LightZoneManager.h
@@ -11,12 +11,12 @@ class LightZoneManager : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void onBothPlayersCrossed();
 
-    ScriptComponentRef<Transform> InteriorLight;
-    ScriptComponentRef<Transform> ExteriorLight;
+    ComponentRef<Transform> InteriorLight;
+    ComponentRef<Transform> ExteriorLight;
 
 private:
     GameObject* m_interiorLight = nullptr;
diff --git a/GameScripts/LightZoneTrigger.h b/GameScripts/LightZoneTrigger.h
index 8fe73f9a..f58fec4c 100644
--- a/GameScripts/LightZoneTrigger.h
+++ b/GameScripts/LightZoneTrigger.h
@@ -14,7 +14,7 @@ class LightZoneTrigger : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     float m_xWidth = 2.0f;
     float m_zWidth = 2.0f;
diff --git a/GameScripts/LinkedDeathController.h b/GameScripts/LinkedDeathController.h
index 21065975..705455f8 100644
--- a/GameScripts/LinkedDeathController.h
+++ b/GameScripts/LinkedDeathController.h
@@ -14,12 +14,12 @@ class LinkedDeathController : public Script
 	void Start() override;
 	void Update() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	void notifyLinkedDeath();
 
 public:
-	ScriptComponentRef<Transform> m_linkedPartner;
+	ComponentRef<Transform> m_linkedPartner;
 	float m_graceWindow = 3.0f;
 	float m_reviveHpPercent = 0.5f;
 
diff --git a/GameScripts/LinkedDeathEnemyState.h b/GameScripts/LinkedDeathEnemyState.h
index 17e69d87..97ab2e58 100644
--- a/GameScripts/LinkedDeathEnemyState.h
+++ b/GameScripts/LinkedDeathEnemyState.h
@@ -13,12 +13,12 @@ class LinkedDeathEnemyState : public EnemyDeathState
     void OnStateUpdate() override;
     void OnStateExit() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void notifyLinkedDeath();
 
 public:
-    ScriptComponentRef<Transform> m_linkedPartner;
+    ComponentRef<Transform> m_linkedPartner;
     float m_graceWindow = 3.0f;
     float m_reviveHpPercent = 0.5f;
 
diff --git a/GameScripts/LocalMultiplayerSetup.h b/GameScripts/LocalMultiplayerSetup.h
index 956db6ec..9fabc06b 100644
--- a/GameScripts/LocalMultiplayerSetup.h
+++ b/GameScripts/LocalMultiplayerSetup.h
@@ -11,11 +11,11 @@ class LocalMultiplayerSetup : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
     ScriptMethodList getExposedMethods() const override;
 
-    ScriptComponentRef<Transform> keyboardGamepadButton;
-	ScriptComponentRef<Transform> twoGamepadButton;
+    ComponentRef<Transform> keyboardGamepadButton;
+	ComponentRef<Transform> twoGamepadButton;
 
     void setKeyboardGamepad();
     void setTwoGamepad();
diff --git a/GameScripts/LyrielAbilityBase.cpp b/GameScripts/LyrielAbilityBase.cpp
index cde8f204..64e69b8f 100644
--- a/GameScripts/LyrielAbilityBase.cpp
+++ b/GameScripts/LyrielAbilityBase.cpp
@@ -17,12 +17,6 @@ void LyrielAbilityBase::Start()
     AbilityBase::Start();
 
     m_lyrielCharacter = dynamic_cast<LyrielCharacter*>(m_character);
-    m_config = GameObjectAPI::findScript<LyrielConfig>(getOwner());
-
-    if (!m_config)
-    {
-        Debug::error("[LyrielAbilityBase] LyrielConfig not found. This character requires LyrielConfig.");
-    }
 }
 
 Transform* LyrielAbilityBase::findArrowSpawnTransform() const
diff --git a/GameScripts/LyrielAbilityBase.h b/GameScripts/LyrielAbilityBase.h
index d29a1386..08218890 100644
--- a/GameScripts/LyrielAbilityBase.h
+++ b/GameScripts/LyrielAbilityBase.h
@@ -18,5 +18,5 @@ class LyrielAbilityBase : public AbilityBase
 
 protected:
     LyrielCharacter* m_lyrielCharacter = nullptr;
-    LyrielConfig* m_config = nullptr;
+    AssetRef<LyrielConfig> m_config;
 };
\ No newline at end of file
diff --git a/GameScripts/LyrielArrowProjectile.h b/GameScripts/LyrielArrowProjectile.h
index d9e084a5..cfd49063 100644
--- a/GameScripts/LyrielArrowProjectile.h
+++ b/GameScripts/LyrielArrowProjectile.h
@@ -11,7 +11,7 @@ class LyrielArrowProjectile : public ProjectileBase
     explicit LyrielArrowProjectile(GameObject* owner);
 
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void launch(const Vector3& start_position, const Vector3& direction, float speed, float lifetime, GameObject* target, float damage);
     void resetProjectile() override;
diff --git a/GameScripts/LyrielArrowVolley.cpp b/GameScripts/LyrielArrowVolley.cpp
index 41c19e42..61d9f5c7 100644
--- a/GameScripts/LyrielArrowVolley.cpp
+++ b/GameScripts/LyrielArrowVolley.cpp
@@ -14,6 +14,10 @@
 #include "LyrielUI.h"
 #include "LyrielConfig.h"
 
+IMPLEMENT_SCRIPT_FIELDS(LyrielArrowVolley,
+    SERIALIZED_ASSET_REF(m_config, "Lyriel Config", AssetType::DATA_CONTAINER)
+)
+
 #include <cmath>
 
 LyrielArrowVolley::LyrielArrowVolley(GameObject* owner)
@@ -98,7 +102,8 @@ void LyrielArrowVolley::onAttackWindowFinished()
 
 float LyrielArrowVolley::getCooldown() const
 {
-    return m_config->m_volleyCooldown;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_volleyCooldown : 0.0f;
 }
 
 bool LyrielArrowVolley::canCast() const
@@ -206,7 +211,11 @@ void LyrielArrowVolley::releaseAimAndCast()
 
     beginAttackPresentation();
 
-    beginAttackWindow(m_config->m_volleyAttackLockDuration);
+    const LyrielConfig* cfgLock = m_config.get();
+    if (cfgLock)
+    {
+        beginAttackWindow(cfgLock->m_volleyAttackLockDuration);
+    }
     startCooldown();
 
     Debug::log("[LyrielArrowVolley] Cast Arrow Volley. Targets hit: %d", static_cast<int>(targets.size()));
@@ -228,11 +237,10 @@ void LyrielArrowVolley::collectEnemiesInCone(const Vector3& origin, const Vector
 {
     outTargets.clear();
 
-    //std::vector<GameObject*> allEnemies = SceneAPI::findAllGameObjectsByTag(Tag::ENEMY, true); //cambiar, esto no pilla los damageables
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return;
 
-    //detectar enemigos en cono
-
-	const std::vector<GameObject*> objectsInCircularRange = SceneAPI::getObjectsInCircularArea(Vector2(origin.x, origin.z), m_config->m_volleyRange);
+    const std::vector<GameObject*> objectsInCircularRange = SceneAPI::getObjectsInCircularArea(Vector2(origin.x, origin.z), cfg->m_volleyRange);
 
     std::vector<Damageable*> damageables;
 
@@ -260,7 +268,7 @@ void LyrielArrowVolley::collectEnemiesInCone(const Vector3& origin, const Vector
 
     flatForward.Normalize();
 
-    const float halfAngleRadians = DirectX::XMConvertToRadians(m_config->m_volleyConeAngleDegrees * 0.5f);
+    const float halfAngleRadians = DirectX::XMConvertToRadians(cfg->m_volleyConeAngleDegrees * 0.5f);
     const float minDot = std::cos(halfAngleRadians);
 
     for (Damageable* damageable : damageables)
@@ -287,7 +295,7 @@ void LyrielArrowVolley::collectEnemiesInCone(const Vector3& origin, const Vector
             continue;
         }
 
-        if (distanceSq > (m_config->m_volleyRange * m_config->m_volleyRange))
+        if (distanceSq > (cfg->m_volleyRange * cfg->m_volleyRange))
         {
             continue;
         }
@@ -306,6 +314,9 @@ bool LyrielArrowVolley::applyVolleyDamage(const std::vector<Damageable*>& target
 {
     bool anyMarkExploited = false;
 
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return false;
+
     for (Damageable* target : targets)
     {
         if (target == nullptr)
@@ -316,7 +327,7 @@ bool LyrielArrowVolley::applyVolleyDamage(const std::vector<Damageable*>& target
         if(EnemyDamageable* enemyDamageable = dynamic_cast<EnemyDamageable*>(target))
         {
             EnemyHitContext ctx;
-            ctx.damage = m_config->m_volleyDamage;
+            ctx.damage = cfg->m_volleyDamage;
             ctx.attacker = GameObjectAPI::getTransform(getOwner());
 
             if (PersistingPowerupState::isUnlocked(PowerupId::LyrielPowerup1))
@@ -342,7 +353,7 @@ bool LyrielArrowVolley::applyVolleyDamage(const std::vector<Damageable*>& target
         }
         else if(BreakableDamageable* breakableDamageable = dynamic_cast<BreakableDamageable*>(target))
         {
-            breakableDamageable->takeDamage(m_config->m_volleyDamage);
+            breakableDamageable->takeDamage(cfg->m_volleyDamage);
 		} 
     }
 
@@ -351,7 +362,8 @@ bool LyrielArrowVolley::applyVolleyDamage(const std::vector<Damageable*>& target
 
 void LyrielArrowVolley::spawnVolleyArrows(const Vector3& origin, const Vector3& forward)
 {
-    if (m_lyrielCharacter == nullptr || m_config->m_volleyNumVisualArrows <= 0)
+    const LyrielConfig* cfg = m_config.get();
+    if (m_lyrielCharacter == nullptr || !cfg || cfg->m_volleyNumVisualArrows <= 0)
     {
         return;
     }
@@ -372,15 +384,15 @@ void LyrielArrowVolley::spawnVolleyArrows(const Vector3& origin, const Vector3&
 
     flatForward.Normalize();
 
-    const float totalAngle = m_config->m_volleyConeAngleDegrees;
+    const float totalAngle = cfg->m_volleyConeAngleDegrees;
 
     float lifetime = 0.0f;
-    if (m_config->m_volleyArrowSpeed > 0.0001f)
+    if (cfg->m_volleyArrowSpeed > 0.0001f)
     {
-        lifetime = m_config->m_volleyRange / m_config->m_volleyArrowSpeed;
+        lifetime = cfg->m_volleyRange / cfg->m_volleyArrowSpeed;
     }
 
-    for (int i = 0; i < m_config->m_volleyNumVisualArrows; ++i)
+    for (int i = 0; i < cfg->m_volleyNumVisualArrows; ++i)
     {
         ProjectileBase* projectile = projectilePool->acquireProjectile();
         if (!projectile)
@@ -392,9 +404,9 @@ void LyrielArrowVolley::spawnVolleyArrows(const Vector3& origin, const Vector3&
         LyrielArrowProjectile* arrow = static_cast<LyrielArrowProjectile*>(projectile);
 
         float t = 0.5f;
-        if (m_config->m_volleyNumVisualArrows > 1)
+        if (cfg->m_volleyNumVisualArrows > 1)
         {
-            t = static_cast<float>(i) / static_cast<float>(m_config->m_volleyNumVisualArrows - 1);
+            t = static_cast<float>(i) / static_cast<float>(cfg->m_volleyNumVisualArrows - 1);
         }
 
         const float angleOffset = -totalAngle * 0.5f + totalAngle * t;
@@ -417,7 +429,7 @@ void LyrielArrowVolley::spawnVolleyArrows(const Vector3& origin, const Vector3&
             dir.Normalize();
         }
 
-        arrow->launch(origin, dir, m_config->m_volleyArrowSpeed, lifetime, nullptr, 0.0f);
+        arrow->launch(origin, dir, cfg->m_volleyArrowSpeed, lifetime, nullptr, 0.0f);
     }
 }
 
@@ -433,7 +445,10 @@ void LyrielArrowVolley::drawAimPreview(const Vector3& origin, const Vector3& for
 
     flatForward.Normalize();
 
-    const float halfAngleRad = DirectX::XMConvertToRadians(m_config->m_volleyConeAngleDegrees * 0.5f);
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return;
+
+    const float halfAngleRad = DirectX::XMConvertToRadians(cfg->m_volleyConeAngleDegrees * 0.5f);
     const int arcSteps = 16;
 
     const Vector3 previewColor(0.2f, 1.0f, 0.2f);
@@ -456,10 +471,10 @@ void LyrielArrowVolley::drawAimPreview(const Vector3& origin, const Vector3& for
     leftDir.Normalize();
     rightDir.Normalize();
 
-    DebugDrawAPI::drawLine(origin, origin + leftDir * m_config->m_volleyRange, previewColor, 0, true);
-    DebugDrawAPI::drawLine(origin, origin + rightDir * m_config->m_volleyRange, previewColor, 0, true);
+    DebugDrawAPI::drawLine(origin, origin + leftDir * cfg->m_volleyRange, previewColor, 0, true);
+    DebugDrawAPI::drawLine(origin, origin + rightDir * cfg->m_volleyRange, previewColor, 0, true);
 
-    Vector3 previousPoint = origin + leftDir * m_config->m_volleyRange;
+    Vector3 previousPoint = origin + leftDir * cfg->m_volleyRange;
 
     for (int i = 1; i <= arcSteps; ++i)
     {
@@ -469,7 +484,7 @@ void LyrielArrowVolley::drawAimPreview(const Vector3& origin, const Vector3& for
         Vector3 arcDir = rotateXZ(flatForward, angle);
         arcDir.Normalize();
 
-        Vector3 currentPoint = origin + arcDir * m_config->m_volleyRange;
+        Vector3 currentPoint = origin + arcDir * cfg->m_volleyRange;
 
         DebugDrawAPI::drawLine(previousPoint, currentPoint, previewColor, 0, true);
         previousPoint = currentPoint;
diff --git a/GameScripts/LyrielArrowVolley.h b/GameScripts/LyrielArrowVolley.h
index 520c3713..1e193c74 100644
--- a/GameScripts/LyrielArrowVolley.h
+++ b/GameScripts/LyrielArrowVolley.h
@@ -13,6 +13,8 @@ class LyrielArrowVolley : public LyrielAbilityBase
 public:
     explicit LyrielArrowVolley(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start() override;
     void Update() override;
     void drawGizmo() override;
diff --git a/GameScripts/LyrielBasicAttack.cpp b/GameScripts/LyrielBasicAttack.cpp
index 6ef16f7d..4967d991 100644
--- a/GameScripts/LyrielBasicAttack.cpp
+++ b/GameScripts/LyrielBasicAttack.cpp
@@ -11,6 +11,10 @@
 #include "LyrielArrowProjectile.h"
 #include "LyrielConfig.h"
 
+IMPLEMENT_SCRIPT_FIELDS(LyrielBasicAttack,
+    SERIALIZED_ASSET_REF(m_config, "Lyriel Config", AssetType::DATA_CONTAINER)
+)
+
 LyrielBasicAttack::LyrielBasicAttack(GameObject* owner)
     : LyrielAbilityBase(owner)
 {
@@ -76,7 +80,11 @@ void LyrielBasicAttack::startAbility()
 
     beginAttackPresentation();
 
-    beginAttackWindow(m_config->m_basicAttackLockDuration);
+    const LyrielConfig* cfg = m_config.get();
+    if (cfg)
+    {
+        beginAttackWindow(cfg->m_basicAttackLockDuration);
+    }
     startCooldown();
 
     Debug::log("[LyrielBasicAttack] Shot arrow to target '%s'.", GameObjectAPI::getName(target));
@@ -126,8 +134,11 @@ bool LyrielBasicAttack::spawnArrowToTarget(GameObject* target)
         direction.Normalize();
     }
 
-    const float arrowLifetime = distance / m_config->m_basicArrowSpeed;
-    arrow->launch(startPosition, direction, m_config->m_basicArrowSpeed, arrowLifetime, target, m_config->m_basicAttackDamage);
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return false;
+
+    const float arrowLifetime = distance / cfg->m_basicArrowSpeed;
+    arrow->launch(startPosition, direction, cfg->m_basicArrowSpeed, arrowLifetime, target, cfg->m_basicAttackDamage);
 
     return true;
 }
@@ -170,7 +181,8 @@ void LyrielBasicAttack::faceTarget(GameObject* target)
 
 float LyrielBasicAttack::getCooldown() const
 {
-    return m_config->m_basicCooldown;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_basicCooldown : 0.0f;
 }
 
 IMPLEMENT_SCRIPT(LyrielBasicAttack)
\ No newline at end of file
diff --git a/GameScripts/LyrielBasicAttack.h b/GameScripts/LyrielBasicAttack.h
index 36506d11..baa3e324 100644
--- a/GameScripts/LyrielBasicAttack.h
+++ b/GameScripts/LyrielBasicAttack.h
@@ -11,6 +11,8 @@ class LyrielBasicAttack : public LyrielAbilityBase
 public:
     explicit LyrielBasicAttack(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start() override;
     void Update() override;
 
diff --git a/GameScripts/LyrielCharacter.cpp b/GameScripts/LyrielCharacter.cpp
index 805c7f01..208d0e18 100644
--- a/GameScripts/LyrielCharacter.cpp
+++ b/GameScripts/LyrielCharacter.cpp
@@ -10,6 +10,7 @@
 #include "LyrielChargedAttack.h"
 
 IMPLEMENT_SCRIPT_FIELDS(LyrielCharacter,
+    SERIALIZED_ASSET_REF(m_config, "Lyriel Config", AssetType::DATA_CONTAINER),
     SERIALIZED_STRING(m_arrowSpawnChildName, "Arrow Spawn Child Name")
 )
 
@@ -29,9 +30,6 @@ void LyrielCharacter::Start()
     m_specialAbility   = GameObjectAPI::findScript<LyrielArrowVolley>(getOwner());
     m_sound         = GameObjectAPI::findScript<LyrielSound>(getOwner());
     m_movement      = GameObjectAPI::findScript<PlayerMovement>(getOwner());
-    m_config        = GameObjectAPI::findScript<LyrielConfig>(getOwner());
-
-
     if (m_arrowPool == nullptr)
     {
         Debug::log("[LyrielCharacter] ArrowPool not found on owner '%s'.", GameObjectAPI::getName(getOwner()));
@@ -67,10 +65,6 @@ void LyrielCharacter::Start()
         Debug::log("[LyrielCharacter] PlayerMovement not found on owner '%s'.", GameObjectAPI::getName(getOwner()));
     }
 
-    if (m_config == nullptr)
-    {
-        Debug::log("[LyrielCharacter] LyrielConfig not found on owner '%s'.", GameObjectAPI::getName(getOwner()));
-    }
 }
 
 void LyrielCharacter::Update()
@@ -99,9 +93,10 @@ void LyrielCharacter::onMarkExploited()
         m_dash->recoverCharge();
     }
 
-    if (m_specialAbility != nullptr && m_config != nullptr)
+    const LyrielConfig* cfg = m_config.get();
+    if (m_specialAbility != nullptr && cfg != nullptr)
     {
-        m_specialAbility->reduceCooldown(m_config->m_volleyCooldownReductionPerExploit);
+        m_specialAbility->reduceCooldown(cfg->m_volleyCooldownReductionPerExploit);
     }
 }
 
diff --git a/GameScripts/LyrielCharacter.h b/GameScripts/LyrielCharacter.h
index 10f429b5..d2fdec2d 100644
--- a/GameScripts/LyrielCharacter.h
+++ b/GameScripts/LyrielCharacter.h
@@ -18,12 +18,10 @@ class LyrielCharacter : public CharacterBase
 
     void Start()  override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     ProjectilePool*   getArrowPool() const { return m_arrowPool; }
     LyrielSound* getSound()     const { return m_sound; }
-    LyrielConfig* getConfig() const { return m_config; }
-
     // Called by Lyriel's offensive scripts after they exploit a Phase 3 mark.
     // Grants the two design-defined rewards: +1 dash charge and -20% of base
     // Arrow Volley cooldown.
@@ -37,5 +35,5 @@ class LyrielCharacter : public CharacterBase
     LyrielDash*        m_dash        = nullptr;
     LyrielSound*       m_sound       = nullptr;
     PlayerMovement*    m_movement    = nullptr;
-    LyrielConfig*      m_config = nullptr;
+    AssetRef<LyrielConfig> m_config;
 };
\ No newline at end of file
diff --git a/GameScripts/LyrielChargedAttack.cpp b/GameScripts/LyrielChargedAttack.cpp
index 53d19701..855c4137 100644
--- a/GameScripts/LyrielChargedAttack.cpp
+++ b/GameScripts/LyrielChargedAttack.cpp
@@ -13,6 +13,10 @@
 #include "LyrielUI.h"
 #include "LyrielConfig.h"
 
+IMPLEMENT_SCRIPT_FIELDS(LyrielChargedAttack,
+    SERIALIZED_ASSET_REF(m_config, "Lyriel Config", AssetType::DATA_CONTAINER)
+)
+
 #include <cmath>
 
 static const float PI = 3.1415926535897931f;
@@ -94,7 +98,8 @@ void LyrielChargedAttack::onAttackWindowFinished()
 
 float LyrielChargedAttack::getCooldown() const
 {
-    return m_config->m_chargedCooldown;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_chargedCooldown : 0.0f;
 }
 
 void LyrielChargedAttack::startAbility()
@@ -140,9 +145,10 @@ void LyrielChargedAttack::beginCharge()
 void LyrielChargedAttack::updateCharge()
 {
     m_chargeTimer += Time::getDeltaTime();
-    if (m_chargeTimer > m_config->m_chargedMaxChargeTime)
+    const LyrielConfig* cfg = m_config.get();
+    if (cfg && m_chargeTimer > cfg->m_chargedMaxChargeTime)
     {
-        m_chargeTimer = m_config->m_chargedMaxChargeTime;
+        m_chargeTimer = cfg->m_chargedMaxChargeTime;
     }
 
     Vector3 aimDirection = computeAimDirection();
@@ -236,7 +242,11 @@ void LyrielChargedAttack::releaseChargeAndShoot()
 
     beginAttackPresentation();
 
-    beginAttackWindow(m_config->m_chargedAttackLockDuration);
+    const LyrielConfig* cfgLock = m_config.get();
+    if (cfgLock)
+    {
+        beginAttackWindow(cfgLock->m_chargedAttackLockDuration);
+    }
     startCooldown();
     m_chargeTimer = 0.0f;
 
@@ -253,28 +263,30 @@ float LyrielChargedAttack::computeChargedDamage() const
 {
     float chargeRatio = 0.0f;
 
-    if (m_config->m_chargedMaxChargeTime > 0.0001f)
+    const LyrielConfig* cfg = m_config.get();
+    if (cfg && cfg->m_chargedMaxChargeTime > 0.0001f)
     {
-        chargeRatio = m_chargeTimer / m_config->m_chargedMaxChargeTime;
+        chargeRatio = m_chargeTimer / cfg->m_chargedMaxChargeTime;
     }
 
     chargeRatio = std::clamp(chargeRatio, 0.0f, 1.0f);
 
-    return m_config->m_chargedMinDamage + (m_config->m_chargedMaxDamage - m_config->m_chargedMinDamage) * chargeRatio;
+    return cfg ? (cfg->m_chargedMinDamage + (cfg->m_chargedMaxDamage - cfg->m_chargedMinDamage) * chargeRatio) : 0.0f;
 }
 
 float LyrielChargedAttack::computeChargedRange() const
 {
     float chargeRatio = 0.0f;
 
-    if (m_config->m_chargedMaxChargeTime > 0.0001f)
+    const LyrielConfig* cfg = m_config.get();
+    if (cfg && cfg->m_chargedMaxChargeTime > 0.0001f)
     {
-        chargeRatio = m_chargeTimer / m_config->m_chargedMaxChargeTime;
+        chargeRatio = m_chargeTimer / cfg->m_chargedMaxChargeTime;
     }
 
     chargeRatio = std::clamp(chargeRatio, 0.0f, 1.0f);
 
-    return m_config->m_chargedMinAttackRange + (m_config->m_chargedMaxAttackRange - m_config->m_chargedMinAttackRange) * chargeRatio;
+    return cfg ? (cfg->m_chargedMinAttackRange + (cfg->m_chargedMaxAttackRange - cfg->m_chargedMinAttackRange) * chargeRatio) : 0.0f;
 }
 
 bool LyrielChargedAttack::isAimStickValid(const Vector3& direction) const
@@ -306,7 +318,8 @@ void LyrielChargedAttack::collectEnemiesInLine(const Vector3& origin, const Vect
     flatForward.Normalize();
 
     const float currentRange = computeChargedRange();
-    const float lineHalfWidthSq = m_config->m_chargedLineHalfWidth * m_config->m_chargedLineHalfWidth;
+    const LyrielConfig* cfg = m_config.get();
+    const float lineHalfWidthSq = cfg ? (cfg->m_chargedLineHalfWidth * cfg->m_chargedLineHalfWidth) : 0.0f;
 
     for (GameObject* target : potentialTargets)
     {
@@ -429,9 +442,12 @@ void LyrielChargedAttack::spawnChargedArrow(const Vector3& origin, const Vector3
 
     const float range = computeChargedRange();
 
-    const float lifetime = range / m_config->m_chargedArrowSpeed;
+    const LyrielConfig* cfgArrow = m_config.get();
+    if (!cfgArrow) return;
 
-    arrow->launch(origin, flatForward, m_config->m_chargedArrowSpeed, lifetime, nullptr, 0.0f);
+    const float lifetime = range / cfgArrow->m_chargedArrowSpeed;
+
+    arrow->launch(origin, flatForward, cfgArrow->m_chargedArrowSpeed, lifetime, nullptr, 0.0f);
 }
 
 void LyrielChargedAttack::drawChargePreview(const Vector3& origin, const Vector3& forward) const
@@ -457,8 +473,11 @@ void LyrielChargedAttack::drawChargePreview(const Vector3& origin, const Vector3
 
     const Vector3 previewColor(0.2f, 1.0f, 1.0f);
 
-    const Vector3 leftStart = origin - right * m_config->m_chargedLineHalfWidth;
-    const Vector3 rightStart = origin + right * m_config->m_chargedLineHalfWidth;
+    const LyrielConfig* cfgPreview = m_config.get();
+    if (!cfgPreview) return;
+
+    const Vector3 leftStart = origin - right * cfgPreview->m_chargedLineHalfWidth;
+    const Vector3 rightStart = origin + right * cfgPreview->m_chargedLineHalfWidth;
 
     const Vector3 leftEnd = leftStart + flatForward * previewRange;
     const Vector3 rightEnd = rightStart + flatForward * previewRange;
diff --git a/GameScripts/LyrielChargedAttack.h b/GameScripts/LyrielChargedAttack.h
index 80a57f46..309b6b75 100644
--- a/GameScripts/LyrielChargedAttack.h
+++ b/GameScripts/LyrielChargedAttack.h
@@ -12,6 +12,8 @@ class LyrielChargedAttack : public LyrielAbilityBase
 public:
     explicit LyrielChargedAttack(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start() override;
     void Update() override;
     void drawGizmo() override;
diff --git a/GameScripts/LyrielConfig.cpp b/GameScripts/LyrielConfig.cpp
index fb3effac..cabeef78 100644
--- a/GameScripts/LyrielConfig.cpp
+++ b/GameScripts/LyrielConfig.cpp
@@ -1,49 +1,2 @@
 #include "pch.h"
 #include "LyrielConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS(LyrielConfig,
-	FIELD_GROUP_COLLAPSE("Basic Attack",
-		SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_basicArrowSpeed, "Basic Arrow Speed", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_basicAttackLockDuration, "Basic Attack Lock Duration", 0.0f, 2.0f, 0.01f),
-		SERIALIZED_FLOAT(m_basicCooldown, "Basic Cooldown", 0.0f, 10.0f, 0.01f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Charged Attack",
-		SERIALIZED_FLOAT(m_chargedMinDamage, "Charged Min Damage", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_chargedMaxDamage, "Charged Max Damage", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_chargedMaxChargeTime, "Charged Max Charge Time", 0.1f, 10.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargedMinAttackRange, "Charged Min Attack Range", 0.0f, 50.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargedMaxAttackRange, "Charged Max Attack Range", 0.0f, 50.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargedLineHalfWidth, "Charged Line Half Width", 0.0f, 10.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargedAttackLockDuration, "Charged Attack Lock Duration", 0.0f, 2.0f, 0.01f),
-		SERIALIZED_FLOAT(m_chargedArrowSpeed, "Charged Arrow Speed", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_chargedCooldown, "Charged Cooldown", 0.0f, 10.0f, 0.01f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Arrow Volley",
-		SERIALIZED_FLOAT(m_volleyDamage, "Volley Damage", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_volleyRange, "Volley Range", 0.0f, 50.0f, 0.1f),
-		SERIALIZED_FLOAT(m_volleyConeAngleDegrees, "Volley Cone Angle Degrees", 1.0f, 180.0f, 1.0f),
-		SERIALIZED_INT(m_volleyNumVisualArrows, "Volley Num Visual Arrows"),
-		SERIALIZED_FLOAT(m_volleyArrowSpeed, "Volley Arrow Speed", 0.0f, 100.0f, 0.5f),
-		SERIALIZED_FLOAT(m_volleyAttackLockDuration, "Volley Attack Lock Duration", 0.0f, 2.0f, 0.01f),
-		SERIALIZED_FLOAT(m_volleyCooldown, "Volley Cooldown", 0.0f, 10.0f, 0.01f),
-		SERIALIZED_FLOAT(m_volleyCooldownReductionPerExploit, "Volley CD Reduction Per Shadow Mark Exploit", 0.0f, 1.0f, 0.05f)
-	),
-
-	FIELD_GROUP_COLLAPSE("Dash",
-		SERIALIZED_FLOAT(m_dashDuration, "Dash Duration", 0.0f, 1.0f, 0.01f),
-		SERIALIZED_FLOAT(m_dashDistance, "Dash Distance", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_dashRechargeTime, "Dash Recharge Time", 0.1f, 10.0f, 0.1f),
-		SERIALIZED_INT(m_dashMaxCharges, "Dash Max Charges"),
-		SERIALIZED_FLOAT(m_dashCooldown, "Dash Cooldown", 0.0f, 10.0f, 0.01f)
-	)
-)
-
-LyrielConfig::LyrielConfig(GameObject* owner)
-	: Script(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(LyrielConfig)
\ No newline at end of file
diff --git a/GameScripts/LyrielConfig.h b/GameScripts/LyrielConfig.h
index cc99f07f..c276e295 100644
--- a/GameScripts/LyrielConfig.h
+++ b/GameScripts/LyrielConfig.h
@@ -1,17 +1,18 @@
 #pragma once
 
-#include "ScriptAPI.h"
+#include "DataContainerAPI.h"
 
-class LyrielConfig : public Script
+class LyrielConfig : public DataContainer
 {
-	DECLARE_SCRIPT(LyrielConfig)
+	DECLARE_DATACONTAINER(LyrielConfig)
 
 public:
-	explicit LyrielConfig(GameObject* owner);
+	LyrielConfig() = default;
+	explicit LyrielConfig(AssetReference& id)
+		: DataContainer(id)
+	{
+	}
 
-	ScriptFieldList getExposedFields() const override;
-
-public:
 	// Basic Attack
 	float m_basicAttackDamage = 10.0f;
 	float m_basicArrowSpeed = 18.0f;
@@ -47,4 +48,44 @@ class LyrielConfig : public Script
 
 	// Passive / Powerup
 	float m_volleyCooldownReductionPerExploit = 0.20f;
-};
\ No newline at end of file
+
+	IMPLEMENT_DATACONTAINER_FIELDS(LyrielConfig,
+		FIELD_GROUP_COLLAPSE("Basic Attack",
+			SERIALIZED_FLOAT(m_basicAttackDamage, "Basic Attack Damage", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_basicArrowSpeed, "Basic Arrow Speed", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_basicAttackLockDuration, "Basic Attack Lock Duration", 0.0f, 2.0f, 0.01f),
+			SERIALIZED_FLOAT(m_basicCooldown, "Basic Cooldown", 0.0f, 10.0f, 0.01f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Charged Attack",
+			SERIALIZED_FLOAT(m_chargedMinDamage, "Charged Min Damage", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_chargedMaxDamage, "Charged Max Damage", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_chargedMaxChargeTime, "Charged Max Charge Time", 0.1f, 10.0f, 0.05f),
+			SERIALIZED_FLOAT(m_chargedMinAttackRange, "Charged Min Attack Range", 0.0f, 50.0f, 0.1f),
+			SERIALIZED_FLOAT(m_chargedMaxAttackRange, "Charged Max Attack Range", 0.0f, 50.0f, 0.1f),
+			SERIALIZED_FLOAT(m_chargedLineHalfWidth, "Charged Line Half Width", 0.0f, 10.0f, 0.05f),
+			SERIALIZED_FLOAT(m_chargedAttackLockDuration, "Charged Attack Lock Duration", 0.0f, 2.0f, 0.01f),
+			SERIALIZED_FLOAT(m_chargedArrowSpeed, "Charged Arrow Speed", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_chargedCooldown, "Charged Cooldown", 0.0f, 10.0f, 0.01f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Arrow Volley",
+			SERIALIZED_FLOAT(m_volleyDamage, "Volley Damage", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_volleyRange, "Volley Range", 0.0f, 50.0f, 0.1f),
+			SERIALIZED_FLOAT(m_volleyConeAngleDegrees, "Volley Cone Angle Degrees", 1.0f, 180.0f, 1.0f),
+			SERIALIZED_INT(m_volleyNumVisualArrows, "Volley Num Visual Arrows"),
+			SERIALIZED_FLOAT(m_volleyArrowSpeed, "Volley Arrow Speed", 0.0f, 100.0f, 0.5f),
+			SERIALIZED_FLOAT(m_volleyAttackLockDuration, "Volley Attack Lock Duration", 0.0f, 2.0f, 0.01f),
+			SERIALIZED_FLOAT(m_volleyCooldown, "Volley Cooldown", 0.0f, 10.0f, 0.01f),
+			SERIALIZED_FLOAT(m_volleyCooldownReductionPerExploit, "Volley CD Reduction Per Shadow Mark Exploit", 0.0f, 1.0f, 0.05f)
+		),
+
+		FIELD_GROUP_COLLAPSE("Dash",
+			SERIALIZED_FLOAT(m_dashDuration, "Dash Duration", 0.0f, 1.0f, 0.01f),
+			SERIALIZED_FLOAT(m_dashDistance, "Dash Distance", 0.0f, 10.0f, 0.1f),
+			SERIALIZED_FLOAT(m_dashRechargeTime, "Dash Recharge Time", 0.1f, 10.0f, 0.1f),
+			SERIALIZED_INT(m_dashMaxCharges, "Dash Max Charges"),
+			SERIALIZED_FLOAT(m_dashCooldown, "Dash Cooldown", 0.0f, 10.0f, 0.01f)
+		)
+	)
+};
diff --git a/GameScripts/LyrielDash.cpp b/GameScripts/LyrielDash.cpp
index 56930473..9bf257ab 100644
--- a/GameScripts/LyrielDash.cpp
+++ b/GameScripts/LyrielDash.cpp
@@ -8,6 +8,10 @@
 #include "LyrielParticles.h"
 #include "PlayerMovement.h"
 
+IMPLEMENT_SCRIPT_FIELDS(LyrielDash,
+    SERIALIZED_ASSET_REF(m_config, "Lyriel Config", AssetType::DATA_CONTAINER)
+)
+
 LyrielDash::LyrielDash(GameObject* owner)
     : AbilityDash(owner)
 {
@@ -25,9 +29,9 @@ void LyrielDash::Start()
         return;
     }
 
-    m_config = GameObjectAPI::findScript<LyrielConfig>(getOwner());
+    const LyrielConfig* cfg = m_config.get();
 
-    m_currentCharges = m_config->m_dashMaxCharges;
+    m_currentCharges = cfg->m_dashMaxCharges;
 
     m_lyrielUI = GameObjectAPI::findScript<LyrielUI>(getOwner());
 
@@ -37,7 +41,7 @@ void LyrielDash::Start()
     }
     else
     {
-        m_lyrielUI->setupDashCharges(m_config->m_dashMaxCharges);
+        m_lyrielUI->setupDashCharges(cfg->m_dashMaxCharges);
     }
 
     m_sound = GameObjectAPI::findScript<LyrielSound>(getOwner());
@@ -53,11 +57,14 @@ void LyrielDash::Start()
 
 void LyrielDash::recoverCharge()
 {
-    if (m_currentCharges < m_config->m_dashMaxCharges)
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return;
+
+    if (m_currentCharges < cfg->m_dashMaxCharges)
     {
         ++m_currentCharges;
 
-        if (m_currentCharges == m_config->m_dashMaxCharges)
+        if (m_currentCharges == cfg->m_dashMaxCharges)
         {
             m_chargeRecoveryTimer = 0.0f;
         }
@@ -66,17 +73,20 @@ void LyrielDash::recoverCharge()
 
 float LyrielDash::getCooldown() const
 {
-    return m_config->m_dashCooldown;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_dashCooldown : 0.0f;
 }
 
 float LyrielDash::getDashDuration() const
 {
-    return m_config->m_dashDuration;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_dashDuration : 0.0f;
 }
 
 float LyrielDash::getDashDistance() const
 {
-    return m_config->m_dashDistance;
+    const LyrielConfig* cfg = m_config.get();
+    return cfg ? cfg->m_dashDistance : 0.0f;
 }
 
 bool LyrielDash::canDash() const
@@ -106,26 +116,29 @@ void LyrielDash::onDashStarted()
 
 void LyrielDash::onDashUpdate(float dt)
 {
-    if (m_currentCharges < m_config->m_dashMaxCharges)
+    const LyrielConfig* cfg = m_config.get();
+    if (!cfg) return;
+
+    if (m_currentCharges < cfg->m_dashMaxCharges)
     {
         m_chargeRecoveryTimer += dt;
 
-        while (m_chargeRecoveryTimer >= m_config->m_dashRechargeTime && m_currentCharges < m_config->m_dashMaxCharges)
+        while (m_chargeRecoveryTimer >= cfg->m_dashRechargeTime && m_currentCharges < cfg->m_dashMaxCharges)
         {
             ++m_currentCharges;
-            m_chargeRecoveryTimer -= m_config->m_dashRechargeTime;
+            m_chargeRecoveryTimer -= cfg->m_dashRechargeTime;
         }
 
-        if (m_currentCharges >= m_config->m_dashMaxCharges)
+        if (m_currentCharges >= cfg->m_dashMaxCharges)
         {
-            m_currentCharges = m_config->m_dashMaxCharges;
+            m_currentCharges = cfg->m_dashMaxCharges;
             m_chargeRecoveryTimer = 0.0f;
         }
     }
 
     if (m_lyrielUI)
     {
-        m_lyrielUI->updateDashChargesUI(m_currentCharges, m_config->m_dashMaxCharges, dt);
+        m_lyrielUI->updateDashChargesUI(m_currentCharges, cfg->m_dashMaxCharges, dt);
     }
 }
 
diff --git a/GameScripts/LyrielDash.h b/GameScripts/LyrielDash.h
index 77560e74..159efc6c 100644
--- a/GameScripts/LyrielDash.h
+++ b/GameScripts/LyrielDash.h
@@ -15,6 +15,8 @@ class LyrielDash : public AbilityDash
 public:
     explicit LyrielDash(GameObject* owner);
 
+    FieldList getExposedFields() const override;
+
     void Start() override;
 
     void recoverCharge();
@@ -33,7 +35,7 @@ class LyrielDash : public AbilityDash
 
 private:
     LyrielCharacter* m_lyrielCharacter = nullptr;
-    LyrielConfig* m_config = nullptr;
+    AssetRef<LyrielConfig> m_config;
     LyrielUI* m_lyrielUI = nullptr;
 
     int m_currentCharges = 0;
diff --git a/GameScripts/LyrielParticles.cpp b/GameScripts/LyrielParticles.cpp
index 4a1f4c09..41846ca4 100644
--- a/GameScripts/LyrielParticles.cpp
+++ b/GameScripts/LyrielParticles.cpp
@@ -10,7 +10,7 @@ LyrielParticles::LyrielParticles(GameObject* owner) : Script(owner)
 {
 }
 
-Transform* LyrielParticles::getTransform(ScriptComponentRef<Transform> controller)
+Transform* LyrielParticles::getTransform(ComponentRef<Transform> controller)
 {
     Transform* particleTransform = controller.getReferencedComponent();
 
diff --git a/GameScripts/LyrielParticles.h b/GameScripts/LyrielParticles.h
index 5fe74db4..12e6528e 100644
--- a/GameScripts/LyrielParticles.h
+++ b/GameScripts/LyrielParticles.h
@@ -10,17 +10,17 @@ class LyrielParticles : public Script
 
 	explicit LyrielParticles(GameObject* owner);
 
-	ScriptComponentRef<Transform> m_dashTrail;
+	ComponentRef<Transform> m_dashTrail;
 
 	Transform* m_dashTrailController = nullptr;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	void SetDashActive();
 	void SetDashInactive();
 
 private:
 
-	Transform* getTransform(ScriptComponentRef<Transform> controller);
+	Transform* getTransform(ComponentRef<Transform> controller);
 
 };
\ No newline at end of file
diff --git a/GameScripts/LyrielTargetIndicatorUI.h b/GameScripts/LyrielTargetIndicatorUI.h
index 2a131413..35e69063 100644
--- a/GameScripts/LyrielTargetIndicatorUI.h
+++ b/GameScripts/LyrielTargetIndicatorUI.h
@@ -11,7 +11,7 @@ class LyrielTargetIndicatorUI : public TargetIndicatorUI
 public:
     explicit LyrielTargetIndicatorUI(GameObject* owner);
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 protected:
     void updateDirectionIndicator(GameObject* currentTarget) override;
@@ -24,7 +24,7 @@ class LyrielTargetIndicatorUI : public TargetIndicatorUI
     Transform2D* getDirectionArrowTransform2D() const;
 
 public:
-    ScriptComponentRef<Transform> m_directionArrowTransform;
+    ComponentRef<Transform> m_directionArrowTransform;
 
     float m_forwardOffset = 1.0f;
     float m_heightOffset = 0.05f;
diff --git a/GameScripts/LyrielUI.h b/GameScripts/LyrielUI.h
index aa4ffbbc..c4183649 100644
--- a/GameScripts/LyrielUI.h
+++ b/GameScripts/LyrielUI.h
@@ -13,7 +13,7 @@ class LyrielUI : public CharacterUI
 
 	void Start() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	// Charged Attack
@@ -40,17 +40,17 @@ class LyrielUI : public CharacterUI
 
 private:
 	// Charged Attack
-	ScriptComponentRef<Transform> m_chargedAttackUI;
+	ComponentRef<Transform> m_chargedAttackUI;
 	Transform* m_chargedAttackUITransform = nullptr;
 
 	// Arrow Volley
-	ScriptComponentRef<Transform> m_arrowVolleyUI;
+	ComponentRef<Transform> m_arrowVolleyUI;
 	Transform* m_arrowVolleyUITransform = nullptr;
 
 	// Dash Charges
-	ScriptComponentRef<Transform2D> m_charge1UI;
-	ScriptComponentRef<Transform2D> m_charge2UI;
-	ScriptComponentRef<Transform2D> m_charge3UI;
+	ComponentRef<Transform2D> m_charge1UI;
+	ComponentRef<Transform2D> m_charge2UI;
+	ComponentRef<Transform2D> m_charge3UI;
 
 	Transform2D* m_charge1Transform2D = nullptr;
 	Transform2D* m_charge2Transform2D = nullptr;
diff --git a/GameScripts/MeleeEnemyController.cpp b/GameScripts/MeleeEnemyController.cpp
index 7599df8f..881e515c 100644
--- a/GameScripts/MeleeEnemyController.cpp
+++ b/GameScripts/MeleeEnemyController.cpp
@@ -13,20 +13,14 @@ MeleeEnemyController::MeleeEnemyController(GameObject* owner)
 
 void MeleeEnemyController::Start()
 {
-	m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<PaladinAttackConfig>(getOwner());
+    m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
 
-	if (!m_enemyDetectionAggro)
-	{
-		Debug::warn("[MeleeEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
+    if (!m_enemyDetectionAggro)
+    {
+        Debug::warn("[MeleeEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
+    }
 
-	if (!m_attackConfig)
-	{
-		Debug::warn("[MeleeEnemyController] PaladinAttackConfig not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
-
-	m_currentTarget = nullptr;
+    m_currentTarget = nullptr;
 	m_deathTriggerSent = false;
 
 	resetRepathTimer();
@@ -69,22 +63,34 @@ bool MeleeEnemyController::isTargetDowned(Transform* target) const
 
 bool MeleeEnemyController::isTargetInAttackRange() const
 {
-	if (!hasValidTarget() || !m_attackConfig)
-	{
-		return false;
-	}
-
-	return isCurrentTargetInRange(m_attackConfig->m_basicAttackRange);
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const PaladinAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
+
+    return isCurrentTargetInRange(cfg->m_basicAttackRange);
 }
 
 bool MeleeEnemyController::playerInChargeRange() const
 {
-	if (!m_enemyDetectionAggro || !m_attackConfig)
-	{
-		return false;
-	}
-
-	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
+    if (!m_enemyDetectionAggro)
+    {
+        return false;
+    }
+
+    const PaladinAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
+
+    Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	if (!ownerTransform)
 	{
 		return false;
@@ -101,9 +107,9 @@ bool MeleeEnemyController::playerInChargeRange() const
 	Vector3 difference = targetPosition - ownerPosition;
 	difference.y = 0.0f;
 
-	const float distanceToTargetSquared = difference.LengthSquared();
-	const float chargeDistanceSquared = m_attackConfig->m_chargeRange * m_attackConfig->m_chargeRange;
-	const float attackRangeSquared = m_attackConfig->m_basicAttackRange * m_attackConfig->m_basicAttackRange;
+    const float distanceToTargetSquared = difference.LengthSquared();
+    const float chargeDistanceSquared = cfg->m_chargeRange * cfg->m_chargeRange;
+    const float attackRangeSquared = cfg->m_basicAttackRange * cfg->m_basicAttackRange;
 
 	return distanceToTargetSquared <= chargeDistanceSquared && distanceToTargetSquared > attackRangeSquared;
 }
@@ -115,12 +121,13 @@ bool MeleeEnemyController::isChargeReady() const
 
 void MeleeEnemyController::consumeChargeCooldown()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const PaladinAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_chargeCooldownTimer = m_attackConfig->m_chargeCooldown;
+    m_chargeCooldownTimer = cfg->m_chargeCooldown;
 }
 
 void MeleeEnemyController::updateChargeCooldown(float dt)
@@ -161,4 +168,6 @@ Vector3 MeleeEnemyController::getChargeDirection() const
 	return direction;
 }
 
-IMPLEMENT_SCRIPT(MeleeEnemyController)
+IMPLEMENT_SCRIPT_FIELDS(MeleeEnemyController,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
diff --git a/GameScripts/MeleeEnemyController.h b/GameScripts/MeleeEnemyController.h
index b0040e64..96523775 100644
--- a/GameScripts/MeleeEnemyController.h
+++ b/GameScripts/MeleeEnemyController.h
@@ -11,6 +11,7 @@ class MeleeEnemyController : public EnemyBaseController
 
 public:
 	explicit MeleeEnemyController(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void Start() override;
 	void Update() override;
@@ -32,7 +33,7 @@ class MeleeEnemyController : public EnemyBaseController
 
 private:
 	EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
-	PaladinAttackConfig* m_attackConfig = nullptr;
+    AssetRef<PaladinAttackConfig> m_attackConfig;
 
 	float m_chargeCooldownTimer = 0.0f;
 };
\ No newline at end of file
diff --git a/GameScripts/MoveObjectAlongPathAction.h b/GameScripts/MoveObjectAlongPathAction.h
index a6a8c0bd..2bac30f4 100644
--- a/GameScripts/MoveObjectAlongPathAction.h
+++ b/GameScripts/MoveObjectAlongPathAction.h
@@ -18,7 +18,7 @@ class MoveObjectAlongPathAction : public CameraTransitionStepAction
 
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void executeAction(CameraTransitionController* controller, CameraTransitionStep* step) override;
@@ -40,8 +40,8 @@ class MoveObjectAlongPathAction : public CameraTransitionStepAction
     void clearOverrideClip(float transitionTimeSeconds);
 
 public:
-    ScriptComponentRef<Transform> m_objectToMove;
-    ScriptComponentRef<Transform> m_pathRoot;
+    ComponentRef<Transform> m_objectToMove;
+    ComponentRef<Transform> m_pathRoot;
 
     float m_moveDuration = 3.0f;
     bool m_faceMovementDirection = true;
diff --git a/GameScripts/MoveObjectToTransformAction.h b/GameScripts/MoveObjectToTransformAction.h
index 17bbaf05..52aa25d9 100644
--- a/GameScripts/MoveObjectToTransformAction.h
+++ b/GameScripts/MoveObjectToTransformAction.h
@@ -14,7 +14,7 @@ class MoveObjectToTransformAction : public CameraTransitionStepAction
 
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void executeAction(CameraTransitionController* controller, CameraTransitionStep* step) override;
@@ -27,8 +27,8 @@ class MoveObjectToTransformAction : public CameraTransitionStepAction
     void clearOverrideClip(float transitionTimeSeconds);
 
 public:
-    ScriptComponentRef<Transform> m_objectToMove;
-    ScriptComponentRef<Transform> m_targetTransform;
+    ComponentRef<Transform> m_objectToMove;
+    ComponentRef<Transform> m_targetTransform;
 
     float m_moveDuration = 1.0f;
 
diff --git a/GameScripts/MusicManager.h b/GameScripts/MusicManager.h
index 2936f4d3..81d3c60f 100644
--- a/GameScripts/MusicManager.h
+++ b/GameScripts/MusicManager.h
@@ -26,7 +26,7 @@ class MusicManager : public Script
 
     void Start() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     // --- Único punto que arranca / para la música ---
     void PlayMusic();
diff --git a/GameScripts/MusicStateEvent.h b/GameScripts/MusicStateEvent.h
index a39158a7..28a67869 100644
--- a/GameScripts/MusicStateEvent.h
+++ b/GameScripts/MusicStateEvent.h
@@ -23,7 +23,7 @@ class MusicStateEvent : public GameplayEventAction
     void executeEvent(GameplayEventTrigger* trigger) override;
     void stopEvent(GameplayEventTrigger* trigger) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     // �ndices en kMusicStateNames (mismo dropdown que el MusicManager).
     int  m_stateOnEnter = 0;
diff --git a/GameScripts/MusicSystemTester.h b/GameScripts/MusicSystemTester.h
new file mode 100644
index 00000000..fc121525
--- /dev/null
+++ b/GameScripts/MusicSystemTester.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class ComponentSoundSource;
+
+class MusicSystemTester : public Script
+{
+    DECLARE_SCRIPT(MusicSystemTester)
+
+public:
+    explicit MusicSystemTester(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+private:
+    enum class TestStep
+    {
+        None,
+        Playing,
+        Paused,
+        Resumed,
+        Stopped
+    };
+
+private:
+    void playMusicEvent();
+    void pauseMusicEvent();
+    void resumeMusicEvent();
+    void stopMusicEvent();
+
+private:
+    ComponentSoundSource* m_soundSource = nullptr;
+
+    std::string m_bankName = "YourBankName";
+    std::string m_eventName = "YourEventName";
+
+    uint32_t m_playingID = 0;
+
+    float m_timer = 0.0f;
+
+    float m_pauseAfterSeconds = 3.0f;
+    float m_resumeAfterSeconds = 6.0f;
+    float m_stopAfterSeconds = 9.0f;
+
+    bool m_playOnStart = true;
+
+    TestStep m_currentStep = TestStep::None;
+};
\ No newline at end of file
diff --git a/GameScripts/ObjectiveEvent.h b/GameScripts/ObjectiveEvent.h
index c8963dd5..b54898e0 100644
--- a/GameScripts/ObjectiveEvent.h
+++ b/GameScripts/ObjectiveEvent.h
@@ -23,7 +23,7 @@ class ObjectiveEvent : public GameplayEventAction
 
     void executeEvent(GameplayEventTrigger* trigger) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     bool isObjectiveCompleted() const;
diff --git a/GameScripts/PaladinAttackConfig.cpp b/GameScripts/PaladinAttackConfig.cpp
index 788f005e..2e7e7976 100644
--- a/GameScripts/PaladinAttackConfig.cpp
+++ b/GameScripts/PaladinAttackConfig.cpp
@@ -1,19 +1,2 @@
 #include "pch.h"
 #include "PaladinAttackConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS_INHERITED(PaladinAttackConfig, EnemyBaseAttackConfig,
-	// Charge
-	FIELD_GROUP_COLLAPSE("Charge",
-		SERIALIZED_FLOAT(m_chargeRange, "Charge Range", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_chargeDuration, "Charge Duration", 0.0f, 10.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargeSpeed, "Charge Speed", 0.0f, 10.0f, 0.05f),
-		SERIALIZED_FLOAT(m_chargeCooldown, "Charge Cooldown", 0.0f, 10.0f, 0.05f)
-	)
-)
-
-PaladinAttackConfig::PaladinAttackConfig(GameObject* owner)
-	: EnemyBaseAttackConfig(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(PaladinAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/PaladinAttackConfig.h b/GameScripts/PaladinAttackConfig.h
index 28678aac..99638d66 100644
--- a/GameScripts/PaladinAttackConfig.h
+++ b/GameScripts/PaladinAttackConfig.h
@@ -4,17 +4,27 @@
 
 class PaladinAttackConfig : public EnemyBaseAttackConfig
 {
-	DECLARE_SCRIPT(PaladinAttackConfig)
+    DECLARE_DATACONTAINER(PaladinAttackConfig)
 
 public:
-	explicit PaladinAttackConfig(GameObject* owner);
+    PaladinAttackConfig() = default;
+    explicit PaladinAttackConfig(AssetReference& id)
+        : EnemyBaseAttackConfig(id)
+    {
+    }
 
-	ScriptFieldList getExposedFields() const override;
+    // Charge
+    float m_chargeRange = 5.0f;
+    float m_chargeDuration = 0.5f;
+    float m_chargeSpeed = 10.0f;
+    float m_chargeCooldown = 3.0f;
 
-public:
-	// Charge
-	float m_chargeRange = 5.0f;
-	float m_chargeDuration = 0.5f;
-	float m_chargeSpeed = 10.0f;
-	float m_chargeCooldown = 3.0f;
-};
\ No newline at end of file
+    IMPLEMENT_DATACONTAINER_FIELDS_INHERITED(PaladinAttackConfig, EnemyBaseAttackConfig,
+        FIELD_GROUP_COLLAPSE("Charge",
+            SERIALIZED_FLOAT(m_chargeRange, "Charge Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_chargeDuration, "Charge Duration", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargeSpeed, "Charge Speed", 0.0f, 10.0f, 0.05f),
+            SERIALIZED_FLOAT(m_chargeCooldown, "Charge Cooldown", 0.0f, 10.0f, 0.05f)
+        )
+    )
+};
diff --git a/GameScripts/PaladinChargeState.cpp b/GameScripts/PaladinChargeState.cpp
index 6ecf920f..19b0b615 100644
--- a/GameScripts/PaladinChargeState.cpp
+++ b/GameScripts/PaladinChargeState.cpp
@@ -13,26 +13,19 @@ PaladinChargeState::PaladinChargeState(GameObject* owner)
 
 void PaladinChargeState::OnStateEnter()
 {
-	m_paladinController = GameObjectAPI::findScript<MeleeEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<PaladinAttackConfig>(getOwner());
-	m_animation = AnimationAPI::getAnimationComponent(getOwner());
+    m_paladinController = GameObjectAPI::findScript<MeleeEnemyController>(getOwner());
+    m_animation = AnimationAPI::getAnimationComponent(getOwner());
 	m_paladinVFX = GameObjectAPI::findScript<PaladinVFX>(getOwner());
 
 	m_stateTimer = 0.0f;
 
-	if (!m_paladinController)
-	{
-		Debug::error("[PaladinChargeState] MeleeEnemyController not found.");
-		return;
-	}
-
-	if (!m_attackConfig)
-	{
-		Debug::error("[PaladinChargeState] PaladinAttackConfig not found.");
-		return;
-	}
+    if (!m_paladinController)
+    {
+        Debug::error("[PaladinChargeState] MeleeEnemyController not found.");
+        return;
+    }
 
-	if (!m_animation)
+    if (!m_animation)
 	{
 		Debug::error("[PaladinChargeState] AnimationComponent not found.");
 		return;
@@ -65,29 +58,36 @@ void PaladinChargeState::OnStateEnter()
 
 void PaladinChargeState::OnStateUpdate()
 {
-	if (!m_paladinController || !m_attackConfig || !m_animation)
-	{
-		stopChargeAttackEffect();
-		return;
-	}
+    if (!m_paladinController || !m_animation)
+    {
+        stopChargeAttackEffect();
+        return;
+    }
 
-	if (m_paladinController->trySendDeathTrigger(m_animation))
-	{
-		stopChargeAttackEffect();
-		return;
-	}
+    if (m_paladinController->trySendDeathTrigger(m_animation))
+    {
+        stopChargeAttackEffect();
+        return;
+    }
 
-	if (m_paladinController->trySendStunTrigger(m_animation))
-	{
-		stopChargeAttackEffect();
-		return;
-	}
+    if (m_paladinController->trySendStunTrigger(m_animation))
+    {
+        stopChargeAttackEffect();
+        return;
+    }
 
-	m_stateTimer += Time::getDeltaTime();
+    const PaladinAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        stopChargeAttackEffect();
+        return;
+    }
 
-	moveCharge();
+    m_stateTimer += Time::getDeltaTime();
+
+    moveCharge();
 
-	if (m_stateTimer >= m_attackConfig->m_chargeDuration || m_paladinController->isTargetInAttackRange())
+    if (m_stateTimer >= cfg->m_chargeDuration || m_paladinController->isTargetInAttackRange())
 	{
 		finishCharge();
 		return;
@@ -97,7 +97,7 @@ void PaladinChargeState::OnStateUpdate()
 
 	moveCharge();
 
-	if (m_stateTimer >= m_attackConfig->m_chargeDuration || m_paladinController->isTargetInAttackRange())
+	if (m_stateTimer >= cfg->m_chargeDuration || m_paladinController->isTargetInAttackRange())
 	{
 		finishCharge();
 		return;
@@ -119,12 +119,13 @@ void PaladinChargeState::OnStateExit()
 
 void PaladinChargeState::moveCharge()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const PaladinAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	if (m_chargeDirection.LengthSquared() <= 0.0001f)
+    if (m_chargeDirection.LengthSquared() <= 0.0001f)
 	{
 		return;
 	}
@@ -139,7 +140,7 @@ void PaladinChargeState::moveCharge()
 	Vector3 ownerPosition = TransformAPI::getGlobalPosition(ownerTransform);
 	Vector3 desiredPosition = ownerPosition;
 
-	desiredPosition += m_chargeDirection * m_attackConfig->m_chargeSpeed * Time::getDeltaTime();
+	desiredPosition += m_chargeDirection * cfg->m_chargeSpeed * Time::getDeltaTime();
 
 	Vector3 nextPosition;
 
@@ -180,4 +181,6 @@ void PaladinChargeState::stopChargeAttackEffect()
 	}
 }
 
-IMPLEMENT_SCRIPT(PaladinChargeState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(PaladinChargeState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/PaladinChargeState.h b/GameScripts/PaladinChargeState.h
index e5d6578e..f12d04e5 100644
--- a/GameScripts/PaladinChargeState.h
+++ b/GameScripts/PaladinChargeState.h
@@ -16,6 +16,8 @@ class PaladinChargeState : public StateMachineScript
 public:
 	explicit PaladinChargeState(GameObject* owner);
 
+	FieldList getExposedFields() const override;
+
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
 	void OnStateExit() override;
@@ -28,7 +30,7 @@ class PaladinChargeState : public StateMachineScript
 
 private:
 	MeleeEnemyController* m_paladinController = nullptr;
-	PaladinAttackConfig* m_attackConfig = nullptr;
+    AssetRef<PaladinAttackConfig> m_attackConfig;
 	AnimationComponent* m_animation = nullptr;
 	PaladinSound* m_paladinSound = nullptr;
 	PaladinVFX* m_paladinVFX = nullptr;
diff --git a/GameScripts/PaladinVFX.h b/GameScripts/PaladinVFX.h
index 873a57a5..77584545 100644
--- a/GameScripts/PaladinVFX.h
+++ b/GameScripts/PaladinVFX.h
@@ -13,7 +13,7 @@ class PaladinVFX : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void setWalkingDustActive(bool active);
     void stopWalkingDust();
diff --git a/GameScripts/ParticleManager.h b/GameScripts/ParticleManager.h
index 6a3e1728..ee17731f 100644
--- a/GameScripts/ParticleManager.h
+++ b/GameScripts/ParticleManager.h
@@ -21,10 +21,10 @@ class ParticleManager : public Script
 
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
-    ScriptComponentRef<Transform> m_playerTransform;
+    ComponentRef<Transform> m_playerTransform;
     float                         m_activationDistance   = 50.0f;
     float                         m_checkIntervalSeconds = 1.0f;
 
diff --git a/GameScripts/Pickup.h b/GameScripts/Pickup.h
index 671aa784..9ed7f79c 100644
--- a/GameScripts/Pickup.h
+++ b/GameScripts/Pickup.h
@@ -13,7 +13,7 @@ class Pickup : public Script
     void Update() override;
 	void OnTriggerEnter(GameObject* gameObject) override;
 
-    //ScriptFieldList getExposedFields() const override;
+    //FieldList getExposedFields() const override;
 //
 //public:
 //    float m_idleSpeed = 0.5f;
diff --git a/GameScripts/PlayAnimationAction.h b/GameScripts/PlayAnimationAction.h
index efa30ee0..0d514cf3 100644
--- a/GameScripts/PlayAnimationAction.h
+++ b/GameScripts/PlayAnimationAction.h
@@ -15,7 +15,7 @@ class PlayAnimationAction : public CameraTransitionStepAction
 
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     void executeAction(CameraTransitionController* controller, CameraTransitionStep* step) override;
@@ -24,7 +24,7 @@ class PlayAnimationAction : public CameraTransitionStepAction
     AnimationComponent* findAnimationComponent() const;
 
 public:
-    ScriptComponentRef<Transform> m_animationTarget;
+    ComponentRef<Transform> m_animationTarget;
 
     std::string m_clipName = "";
     bool m_loop = false;
diff --git a/GameScripts/PlayerAnimationController.h b/GameScripts/PlayerAnimationController.h
index 33b81f14..6b2d3c1a 100644
--- a/GameScripts/PlayerAnimationController.h
+++ b/GameScripts/PlayerAnimationController.h
@@ -25,7 +25,7 @@ class PlayerAnimationController : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void setMoving(bool moving);
     void setDashing(bool dashing);
diff --git a/GameScripts/PlayerController.h b/GameScripts/PlayerController.h
index fcf122d2..3255dd98 100644
--- a/GameScripts/PlayerController.h
+++ b/GameScripts/PlayerController.h
@@ -17,7 +17,7 @@ class PlayerController : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void setGameplayInputLocked(bool locked) { m_gameplayInputLocked = locked; }
     bool isGameplayInputLocked() const { return m_gameplayInputLocked; }
diff --git a/GameScripts/PlayerDamageable.h b/GameScripts/PlayerDamageable.h
index 71e04c1b..40f2b22d 100644
--- a/GameScripts/PlayerDamageable.h
+++ b/GameScripts/PlayerDamageable.h
@@ -17,7 +17,7 @@ class PlayerDamageable : public Damageable
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     float m_heartbeatThreshold = 0.5f;
 
@@ -34,7 +34,7 @@ class PlayerDamageable : public Damageable
     LyrielSound* m_lyrielSound = nullptr;
     PlayerRenderBufferComponent* m_playerRenderBuffer = nullptr;
 
-    ScriptComponentRef<Transform> m_renderer;
+    ComponentRef<Transform> m_renderer;
 
     bool  m_damageHighlightActive = false;
     float m_damageHighlightTimer = 0.0f;
diff --git a/GameScripts/PlayerDownState.h b/GameScripts/PlayerDownState.h
index 20ea70bc..de859036 100644
--- a/GameScripts/PlayerDownState.h
+++ b/GameScripts/PlayerDownState.h
@@ -16,7 +16,7 @@ class PlayerDownState : public Script
 
     void Start() override;
     void Update() override;
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void drawGizmo() override;
 
@@ -42,7 +42,7 @@ class PlayerDownState : public Script
     float m_assistSpeedMultiplier = 2.0f;
     float m_reviveHp = 50.0f;
 
-    ScriptComponentRef<Transform> m_teammateTransform;
+    ComponentRef<Transform> m_teammateTransform;
 
 private:
     PlayerState* m_playerState = nullptr;
@@ -56,7 +56,7 @@ class PlayerDownState : public Script
     ReviveAudioState m_reviveAudioState = ReviveAudioState::None;
 
 public:
-    ScriptComponentRef<Transform> m_downedSprite;
+    ComponentRef<Transform> m_downedSprite;
 
 private:
     Transform* m_downedSpriteTransform = nullptr;
diff --git a/GameScripts/PlayerMovement.h b/GameScripts/PlayerMovement.h
index 5dc7c5a8..b7b13ee7 100644
--- a/GameScripts/PlayerMovement.h
+++ b/GameScripts/PlayerMovement.h
@@ -14,7 +14,7 @@ class PlayerMovement : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     inline void playerMovement(GameObject* owner, const Vector3& timeStep) const 
     { 
diff --git a/GameScripts/PlayerRotation.h b/GameScripts/PlayerRotation.h
index e5ef62dd..26910efc 100644
--- a/GameScripts/PlayerRotation.h
+++ b/GameScripts/PlayerRotation.h
@@ -12,7 +12,7 @@ class PlayerRotation : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void onAfterDeserialize() override;
 
diff --git a/GameScripts/PlayerTargetController.h b/GameScripts/PlayerTargetController.h
index 3dfa7ef5..eeb0f208 100644
--- a/GameScripts/PlayerTargetController.h
+++ b/GameScripts/PlayerTargetController.h
@@ -19,7 +19,7 @@ class PlayerTargetController : public Script
     void Update() override;
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     GameObject* getCurrentTarget() const { return m_currentTarget; }
 
diff --git a/GameScripts/PopUpEvent.h b/GameScripts/PopUpEvent.h
index ed1824de..cc49419f 100644
--- a/GameScripts/PopUpEvent.h
+++ b/GameScripts/PopUpEvent.h
@@ -30,7 +30,7 @@ class PopUpEvent : public GameplayEventAction
 
     void executeEvent(GameplayEventTrigger* trigger) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     Transform2D* getPopUpImageTransform2D(int index) const;
     int getPopUpImageCount() const;
@@ -47,7 +47,7 @@ class PopUpEvent : public GameplayEventAction
     PopUpController* findPopUpController() const;
 
 public:
-    std::vector<ScriptComponentRef<Transform2D>> m_popUpImages;
+    std::vector<ComponentRef<Transform2D>> m_popUpImages;
 
     int m_transitionType = static_cast<int>(PopUpTransitionType::Fade);
     int m_closeMode = static_cast<int>(PopUpCloseMode::BothPlayersConfirm);
diff --git a/GameScripts/PowerupCollectible.h b/GameScripts/PowerupCollectible.h
index 52228a1e..55d502b1 100644
--- a/GameScripts/PowerupCollectible.h
+++ b/GameScripts/PowerupCollectible.h
@@ -13,7 +13,7 @@ class PowerupCollectible : public Script
     void Update() override;
     void OnTriggerEnter(GameObject* player) override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 private:
     bool canBeCollectedBy(GameObject* player) const;
diff --git a/GameScripts/ProjectileController.h b/GameScripts/ProjectileController.h
new file mode 100644
index 00000000..da4b95f0
--- /dev/null
+++ b/GameScripts/ProjectileController.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class ProjectileController : public Script
+{
+    DECLARE_SCRIPT(ProjectileController)
+
+public:
+    explicit ProjectileController(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+    float m_minSpeed = 1; //
+    float m_maxSpeed = 5; // m_minSpeed <= m_maxSpeed!
+
+    float m_scale = 0; // determines the amount of speed that the projectile object will start with ([0,1], between minSpeed and maxSpeed)
+
+    ComponentRef<Transform> m_target; // the object to hit (will ignore the rest)
+
+    std::string m_prefabToInstantiate = "";
+
+private:
+
+    bool hit(); // temporary, to determine if we have hit our target
+
+    Transform* m_objectTransform;
+
+    float m_speed;
+    bool m_canPierce;
+
+    bool pressed = false;
+};
\ No newline at end of file
diff --git a/GameScripts/ProjectilePool.h b/GameScripts/ProjectilePool.h
index 07b24748..a541de95 100644
--- a/GameScripts/ProjectilePool.h
+++ b/GameScripts/ProjectilePool.h
@@ -15,7 +15,7 @@ class ProjectilePool : public Script
 
 	void Start() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	ProjectileBase* acquireProjectile();
 	void releaseProjectile(ProjectileBase* projectile);
diff --git a/GameScripts/PuzzleManagerLVL1.cpp b/GameScripts/PuzzleManagerLVL1.cpp
index f18bf062..ab2774c9 100644
--- a/GameScripts/PuzzleManagerLVL1.cpp
+++ b/GameScripts/PuzzleManagerLVL1.cpp
@@ -7,7 +7,7 @@ namespace
     constexpr const char* k_openDoor = "Play_Environment_Open_Door";
 
     // Plays the door-open SFX from the door's own GameObject (positional 3D).
-    void playDoorOpen(const ScriptComponentRef<Transform>& doorRef)
+    void playDoorOpen(const ComponentRef<Transform>& doorRef)
     {
         Transform* doorTransform = doorRef.getReferencedComponent();
         if (doorTransform != nullptr)
diff --git a/GameScripts/PuzzleManagerLVL1.h b/GameScripts/PuzzleManagerLVL1.h
index 96adab90..c9751700 100644
--- a/GameScripts/PuzzleManagerLVL1.h
+++ b/GameScripts/PuzzleManagerLVL1.h
@@ -19,15 +19,15 @@ struct PuzzleData
     void Start() override;
     void Update() override;
 
-	ScriptComponentRef<Transform> m_door1;
-	ScriptComponentRef<Transform> m_bridge1;
-	ScriptComponentRef<Transform> m_bridge2;
-	ScriptComponentRef<Transform> m_door2;
-	ScriptComponentRef<Transform> m_door3;
-	ScriptComponentRef<Transform> m_navBlocker1;
-	ScriptComponentRef<Transform> m_navBlocker2;
-	ScriptComponentRef<Transform> m_navBlocker3;
-	ScriptComponentRef<Transform> m_navBlocker4;
+	ComponentRef<Transform> m_door1;
+	ComponentRef<Transform> m_bridge1;
+	ComponentRef<Transform> m_bridge2;
+	ComponentRef<Transform> m_door2;
+	ComponentRef<Transform> m_door3;
+	ComponentRef<Transform> m_navBlocker1;
+	ComponentRef<Transform> m_navBlocker2;
+	ComponentRef<Transform> m_navBlocker3;
+	ComponentRef<Transform> m_navBlocker4;
 
 	GameObject* blocker1;
 	GameObject* blocker2;
@@ -59,6 +59,6 @@ struct PuzzleData
 	GameObject* m_bridgeSoundEmitter = nullptr;
 	void updateBridgeLowering(float dt);
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 };
 
diff --git a/GameScripts/RangedEnemyController.cpp b/GameScripts/RangedEnemyController.cpp
index 1d9a530f..048adcfb 100644
--- a/GameScripts/RangedEnemyController.cpp
+++ b/GameScripts/RangedEnemyController.cpp
@@ -13,18 +13,12 @@ RangedEnemyController::RangedEnemyController(GameObject* owner) : EnemyBaseContr
 void RangedEnemyController::Start()
 {
     m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
-    m_attackConfig = GameObjectAPI::findScript<ArcherAttackConfig>(getOwner());
 
     if (!m_enemyDetectionAggro)
     {
         Debug::warn("[RangedEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
     }
 
-    if (!m_attackConfig)
-    {
-        Debug::warn("[RangedEnemyController] ArcherAttackConfig not found on '%s'.", GameObjectAPI::getName(getOwner()));
-    }
-
     m_currentTarget = nullptr;
     m_deathTriggerSent = false;
 
@@ -69,17 +63,29 @@ bool RangedEnemyController::isTargetDowned(Transform* target) const
 
 bool RangedEnemyController::isTargetInAttackRange() const
 {
-    if (!hasValidTarget() || !m_attackConfig)
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return false;
     }
 
-    return isCurrentTargetInRange(m_attackConfig->m_basicAttackRange);
+    return isCurrentTargetInRange(cfg->m_basicAttackRange);
 }
 
 bool RangedEnemyController::playerInSomersaultRange() const
 {
-    if (!m_enemyDetectionAggro || !m_attackConfig)
+    if (!m_enemyDetectionAggro)
+    {
+        return false;
+    }
+
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return false;
     }
@@ -98,7 +104,7 @@ bool RangedEnemyController::playerInSomersaultRange() const
         m_enemyDetectionAggro->getDeathTransform()
     };
 
-    const float triggerRangeSquared = m_attackConfig->m_somersaultTriggerRange * m_attackConfig->m_somersaultTriggerRange;
+    const float triggerRangeSquared = cfg->m_somersaultTriggerRange * cfg->m_somersaultTriggerRange;
 
     for (Transform* playerTransform : playerTransforms)
     {
@@ -133,12 +139,13 @@ bool RangedEnemyController::isSomersaultReady() const
 
 void RangedEnemyController::consumeSomersaultCooldown()
 {
-    if (!m_attackConfig)
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
-    m_somersaultCooldownTimer = m_attackConfig->m_somersaultCooldown;
+    m_somersaultCooldownTimer = cfg->m_somersaultCooldown;
 }
 
 void RangedEnemyController::updateSomersaultCooldown(float dt)
@@ -241,12 +248,13 @@ bool RangedEnemyController::isArrowBarrageReady() const
 
 void RangedEnemyController::consumeArrowBarrageCooldown()
 {
-    if (!m_attackConfig)
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return;
     }
 
-    m_arrowBarrageCooldownTimer = m_attackConfig->m_arrowBarrageCooldown;
+    m_arrowBarrageCooldownTimer = cfg->m_arrowBarrageCooldown;
 }
 
 void RangedEnemyController::updateArrowBarrageCooldown(float dt)
@@ -266,12 +274,20 @@ void RangedEnemyController::updateArrowBarrageCooldown(float dt)
 
 bool RangedEnemyController::isTargetInArrowBarrageRange() const
 {
-    if (!hasValidTarget() || !m_attackConfig)
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const ArcherAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
     {
         return false;
     }
 
-    return isCurrentTargetInRange(m_attackConfig->m_arrowBarrageRange);
+    return isCurrentTargetInRange(cfg->m_arrowBarrageRange);
 }
 
-IMPLEMENT_SCRIPT(RangedEnemyController)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(RangedEnemyController,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/RangedEnemyController.h b/GameScripts/RangedEnemyController.h
index b2f3185f..c8bb7c29 100644
--- a/GameScripts/RangedEnemyController.h
+++ b/GameScripts/RangedEnemyController.h
@@ -12,6 +12,7 @@ class RangedEnemyController : public EnemyBaseController
 
 public:
     explicit RangedEnemyController(GameObject* owner);
+    FieldList getExposedFields() const override;
 
     void Start() override;
     void Update() override;
@@ -40,7 +41,7 @@ class RangedEnemyController : public EnemyBaseController
 
 private:
     EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
-    ArcherAttackConfig* m_attackConfig = nullptr;
+    AssetRef<ArcherAttackConfig> m_attackConfig;
 
     float m_somersaultCooldownTimer = 0.0f;
     float m_arrowBarrageCooldownTimer = 0.0f;
diff --git a/GameScripts/ReaperGauge.h b/GameScripts/ReaperGauge.h
index eb1826ca..52f48e59 100644
--- a/GameScripts/ReaperGauge.h
+++ b/GameScripts/ReaperGauge.h
@@ -18,7 +18,7 @@ class ReaperGauge : public Script
     void drawGizmo() override;
     void updateUI();
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     void  onMarkExploited();
     void  consume();
@@ -34,9 +34,9 @@ class ReaperGauge : public Script
     float m_gracePeriod      = 10.0f;
     float m_decayPerSecond   = 2.0f;
 
-    ScriptComponentRef<UISlider> m_reaperGaugeUI;
-	ScriptComponentRef<Transform2D> m_glowUI;
-    ScriptComponentRef<Transform2D> m_blinkAlphaUI;
+    ComponentRef<UISlider> m_reaperGaugeUI;
+	ComponentRef<Transform2D> m_glowUI;
+    ComponentRef<Transform2D> m_blinkAlphaUI;
 
 	float m_blinkSpeed = 5.0f;
     float m_blinkAlpha = 0.25f;
diff --git a/GameScripts/ShadowExecution.h b/GameScripts/ShadowExecution.h
index 3b41244b..4d626fa9 100644
--- a/GameScripts/ShadowExecution.h
+++ b/GameScripts/ShadowExecution.h
@@ -25,7 +25,7 @@ class ShadowExecution : public Script
     void Update()    override;
     void drawGizmo() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     bool isActive() const { return m_isActive; }
 
@@ -66,9 +66,9 @@ class ShadowExecution : public Script
     std::vector<SpawnedPrefab> m_temporaryPrefabs;
 
 public:
-    ScriptComponentRef<UISlider> m_reaperGaugeBar;
-    ScriptComponentRef<Transform> m_executionCanvas;
-    ScriptComponentRef<Transform2D> m_executionSprite;
+    ComponentRef<UISlider> m_reaperGaugeBar;
+    ComponentRef<Transform> m_executionCanvas;
+    ComponentRef<Transform2D> m_executionSprite;
 
 private:
     UISlider* m_reaperGaugeSlider = nullptr;
diff --git a/GameScripts/SkeletonAttackConfig.cpp b/GameScripts/SkeletonAttackConfig.cpp
index db2ca7c7..d35feff9 100644
--- a/GameScripts/SkeletonAttackConfig.cpp
+++ b/GameScripts/SkeletonAttackConfig.cpp
@@ -1,39 +1,2 @@
 #include "pch.h"
 #include "SkeletonAttackConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS_INHERITED(SkeletonAttackConfig, EnemyBaseAttackConfig,
-	// Scimitar Strike
-	FIELD_GROUP_COLLAPSE("Scimitar Strike",
-		SERIALIZED_FLOAT(m_scimitarStartRange, "Scimitar Start Range", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarDashStopRange, "Scimitar Dash Stop Range", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarDashDuration, "Scimitar Dash Duration", 0.0f, 5.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarDashSpeed, "Scimitar Dash Speed", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_attackClipDuration, "Attack Clip Duration", 0.0f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_attackHitTime, "Attack Hit Time", 0.0f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_attackAnimationSpeed, "Attack Animation Speed", 0.0f, 5.0f, 0.05f),
-		SERIALIZED_FLOAT(m_stepBackDuration, "Step Back Duration", 0.0f, 5.0f, 0.1f),
-		SERIALIZED_FLOAT(m_stepBackSpeed, "Step Back Speed", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarStunHitRange, "Scimitar Stun Hit Range", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarStunDuration, "Scimitar Stun Duration", 0.0f, 5.0f, 0.1f),
-		SERIALIZED_FLOAT(m_scimitarHalfAngleDegrees, "Scimitar Half Angle Degrees", 0.0f, 18.0f, 1.0f)
-	),
-	// Guard
-	FIELD_GROUP_COLLAPSE("Guard",
-		SERIALIZED_FLOAT(m_guardDuration, "Guard Duration", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_guardCooldown, "Guard Cooldown", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_guardRange, "Guard Range", 0.0f, 20.0f, 0.1f),
-		SERIALIZED_FLOAT(m_guardHealPerSecond, "Guard Heal Per Second", 0.0f, 100.0f, 1.0f),
-		SERIALIZED_FLOAT(m_guardBlockHalfAngleDegrees, "Guard Half Angle Degrees", 0.0f, 180.0f, 1.0f)
-	),
-	FIELD_GROUP_COLLAPSE("Revive",
-		SERIALIZED_FLOAT(m_reviveDuration, "Revive Duration", 0.0f, 20.0f, 0.01f),
-		SERIALIZED_FLOAT(m_downedHP, "Downed HP", 1.0f, 150.0f, 1.0f)
-	)
-)
-
-SkeletonAttackConfig::SkeletonAttackConfig(GameObject* owner)
-	: EnemyBaseAttackConfig(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(SkeletonAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/SkeletonAttackConfig.h b/GameScripts/SkeletonAttackConfig.h
index 8f6d89c9..ce10ef34 100644
--- a/GameScripts/SkeletonAttackConfig.h
+++ b/GameScripts/SkeletonAttackConfig.h
@@ -4,43 +4,68 @@
 
 class SkeletonAttackConfig : public EnemyBaseAttackConfig
 {
-	DECLARE_SCRIPT(SkeletonAttackConfig)
+    DECLARE_DATACONTAINER(SkeletonAttackConfig)
 
 public:
-	explicit SkeletonAttackConfig(GameObject* owner);
+    SkeletonAttackConfig() = default;
+    explicit SkeletonAttackConfig(AssetReference& id)
+        : EnemyBaseAttackConfig(id)
+    {
+    }
 
-	ScriptFieldList getExposedFields() const override;
+    // --- Scimitar Strike --- //
+    float m_scimitarStartRange = 4.5f;
+    float m_scimitarDashStopRange = 1.5f;
+    float m_scimitarDashDuration = 2.0f;
+    float m_scimitarDashSpeed = 10.0f;
+    float m_scimitarHalfAngleDegrees = 55.0f;
 
-public:
-	// --- Scimitar Strike --- //
-	// Dash
-	float m_scimitarStartRange = 4.5f;
-	float m_scimitarDashStopRange = 1.5f;
-	float m_scimitarDashDuration = 2.0f;
-	float m_scimitarDashSpeed = 10.0f;
-	float m_scimitarHalfAngleDegrees = 55.0f;
-
-	// Attack
-	float m_attackClipDuration = 1.33f;
-	float m_attackHitTime = 0.45f;
-	float m_attackAnimationSpeed = 1.3f;
-
-	// Backstep
-	float m_stepBackDuration = 0.15f;
-	float m_stepBackSpeed = 4.0f;
-
-	// Final Strike
-	float m_scimitarStunHitRange = 1.5f;
-	float m_scimitarStunDuration = 3.0f;
-
-	// --- Guard --- //
-	float m_guardDuration = 5.0f;
-	float m_guardCooldown = 10.0f;
-	float m_guardRange = 3.5f;
-	float m_guardHealPerSecond = 2.5f;
-	float m_guardBlockHalfAngleDegrees = 60.0f;
-
-	// Revive
-	float m_reviveDuration = 4.0f;
-	float m_downedHP = 40.0f;
-};
\ No newline at end of file
+    float m_attackClipDuration = 1.33f;
+    float m_attackHitTime = 0.45f;
+    float m_attackAnimationSpeed = 1.3f;
+
+    float m_stepBackDuration = 0.15f;
+    float m_stepBackSpeed = 4.0f;
+
+    float m_scimitarStunHitRange = 1.5f;
+    float m_scimitarStunDuration = 3.0f;
+
+    // --- Guard --- //
+    float m_guardDuration = 5.0f;
+    float m_guardCooldown = 10.0f;
+    float m_guardRange = 3.5f;
+    float m_guardHealPerSecond = 2.5f;
+    float m_guardBlockHalfAngleDegrees = 60.0f;
+
+    // Revive
+    float m_reviveDuration = 4.0f;
+    float m_downedHP = 40.0f;
+
+    IMPLEMENT_DATACONTAINER_FIELDS_INHERITED(SkeletonAttackConfig, EnemyBaseAttackConfig,
+        FIELD_GROUP_COLLAPSE("Scimitar Strike",
+            SERIALIZED_FLOAT(m_scimitarStartRange, "Scimitar Start Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarDashStopRange, "Scimitar Dash Stop Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarDashDuration, "Scimitar Dash Duration", 0.0f, 5.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarDashSpeed, "Scimitar Dash Speed", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_attackClipDuration, "Attack Clip Duration", 0.0f, 5.0f, 0.05f),
+            SERIALIZED_FLOAT(m_attackHitTime, "Attack Hit Time", 0.0f, 5.0f, 0.05f),
+            SERIALIZED_FLOAT(m_attackAnimationSpeed, "Attack Animation Speed", 0.0f, 5.0f, 0.05f),
+            SERIALIZED_FLOAT(m_stepBackDuration, "Step Back Duration", 0.0f, 5.0f, 0.1f),
+            SERIALIZED_FLOAT(m_stepBackSpeed, "Step Back Speed", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarStunHitRange, "Scimitar Stun Hit Range", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarStunDuration, "Scimitar Stun Duration", 0.0f, 5.0f, 0.1f),
+            SERIALIZED_FLOAT(m_scimitarHalfAngleDegrees, "Scimitar Half Angle Degrees", 0.0f, 18.0f, 1.0f)
+        ),
+        FIELD_GROUP_COLLAPSE("Guard",
+            SERIALIZED_FLOAT(m_guardDuration, "Guard Duration", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_guardCooldown, "Guard Cooldown", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_guardRange, "Guard Range", 0.0f, 20.0f, 0.1f),
+            SERIALIZED_FLOAT(m_guardHealPerSecond, "Guard Heal Per Second", 0.0f, 100.0f, 1.0f),
+            SERIALIZED_FLOAT(m_guardBlockHalfAngleDegrees, "Guard Half Angle Degrees", 0.0f, 180.0f, 1.0f)
+        ),
+        FIELD_GROUP_COLLAPSE("Revive",
+            SERIALIZED_FLOAT(m_reviveDuration, "Revive Duration", 0.0f, 20.0f, 0.01f),
+            SERIALIZED_FLOAT(m_downedHP, "Downed HP", 1.0f, 150.0f, 1.0f)
+        )
+    )
+};
diff --git a/GameScripts/SkeletonAttackDebugDraw.cpp b/GameScripts/SkeletonAttackDebugDraw.cpp
index de625484..22d2712e 100644
--- a/GameScripts/SkeletonAttackDebugDraw.cpp
+++ b/GameScripts/SkeletonAttackDebugDraw.cpp
@@ -4,7 +4,8 @@
 #include "SkeletonAttackConfig.h"
 
 IMPLEMENT_SCRIPT_FIELDS(SkeletonAttackDebugDraw,
-	SERIALIZED_BOOL(m_debugEnabled, "Debug Enabled"),
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER),
+    SERIALIZED_BOOL(m_debugEnabled, "Debug Enabled"),
 	SERIALIZED_BOOL(m_drawScimitarStartRange, "Draw Scimitar Start Range"),
 	SERIALIZED_BOOL(m_drawDashStopRange, "Draw Dash Stop Range"),
 	SERIALIZED_BOOL(m_drawScimitarAttackArea, "Draw Attack Area"),
@@ -19,30 +20,20 @@ SkeletonAttackDebugDraw::SkeletonAttackDebugDraw(GameObject* owner)
 
 void SkeletonAttackDebugDraw::Start()
 {
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-
-	if (!m_attackConfig)
-	{
-		Debug::warn("[SkeletonAttackDebugDraw] SkeletonAttackConfig not found.");
-	}
 }
 
 void SkeletonAttackDebugDraw::drawGizmo()
 {
-	if (!m_debugEnabled)
-	{
-		return;
-	}
+    if (!m_debugEnabled)
+    {
+        return;
+    }
 
-	if (!m_attackConfig)
-	{
-		m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-	}
-
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
 	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	if (!ownerTransform)
@@ -64,7 +55,7 @@ void SkeletonAttackDebugDraw::drawGizmo()
 			position,
 			up,
 			startRangeColor,
-			m_attackConfig->m_scimitarStartRange,
+            cfg->m_scimitarStartRange,
 			32.0f,
 			0,
 			true
@@ -77,7 +68,7 @@ void SkeletonAttackDebugDraw::drawGizmo()
 			position,
 			up,
 			dashStopColor,
-			m_attackConfig->m_scimitarDashStopRange,
+            cfg->m_scimitarDashStopRange,
 			32.0f,
 			0,
 			true
@@ -97,18 +88,30 @@ void SkeletonAttackDebugDraw::drawGizmo()
 
 void SkeletonAttackDebugDraw::drawScimitarAttackCone() const
 {
-	drawScimitarCone(
-		m_attackConfig->m_basicAttackRange,
-		m_attackConfig->m_scimitarHalfAngleDegrees,
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    drawScimitarCone(
+        cfg->m_basicAttackRange,
+        cfg->m_scimitarHalfAngleDegrees,
 		Vector3(1.0f, 0.0f, 0.0f)
 	);
 }
 
 void SkeletonAttackDebugDraw::drawScimitarStunCone() const
 {
-	drawScimitarCone(
-		m_attackConfig->m_scimitarStunHitRange,
-		m_attackConfig->m_scimitarHalfAngleDegrees,
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    drawScimitarCone(
+        cfg->m_scimitarStunHitRange,
+        cfg->m_scimitarHalfAngleDegrees,
 		Vector3(0.0f, 0.0f, 1.0f)
 	);
 }
diff --git a/GameScripts/SkeletonAttackDebugDraw.h b/GameScripts/SkeletonAttackDebugDraw.h
index ecab0c65..7637f5f3 100644
--- a/GameScripts/SkeletonAttackDebugDraw.h
+++ b/GameScripts/SkeletonAttackDebugDraw.h
@@ -14,7 +14,7 @@ class SkeletonAttackDebugDraw : public Script
 	void Start() override;
 	void drawGizmo() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 public:
 	bool m_debugEnabled = true;
@@ -27,7 +27,7 @@ class SkeletonAttackDebugDraw : public Script
 	float m_heightOffset = 0.15f;
 
 private:
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 
 private:
 	void drawScimitarAttackCone() const;
diff --git a/GameScripts/SkeletonDamageable.cpp b/GameScripts/SkeletonDamageable.cpp
index b9301492..930dc969 100644
--- a/GameScripts/SkeletonDamageable.cpp
+++ b/GameScripts/SkeletonDamageable.cpp
@@ -7,7 +7,8 @@
 #include <cmath>
 
 IMPLEMENT_SCRIPT_FIELDS_INHERITED(SkeletonDamageable, EnemyDamageable,
-	SERIALIZED_FLOAT(m_downedHealthBarScale.x, "Downed Health Bar Scale X", 0.0f, 10.0f, 0.1f),
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER),
+    SERIALIZED_FLOAT(m_downedHealthBarScale.x, "Downed Health Bar Scale X", 0.0f, 10.0f, 0.1f),
 	SERIALIZED_FLOAT(m_downedHealthBarScale.y, "Downed Health Bar Scale Y", 0.0f, 10.0f, 0.1f)
 )
 
@@ -20,20 +21,14 @@ void SkeletonDamageable::Start()
 {
 	EnemyDamageable::Start();
 
-	m_skeletonController = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
+    m_skeletonController = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
 
-	if (!m_skeletonController)
-	{
-		Debug::warn("[SkeletonDamageable] SkeletonEnemyController not found.");
-	}
-
-	if (!m_attackConfig)
-	{
-		Debug::warn("[SkeletonDamageable] SkeletonAttackConfig not found.");
-	}
+    if (!m_skeletonController)
+    {
+        Debug::warn("[SkeletonDamageable] SkeletonEnemyController not found.");
+    }
 
-	cacheHealthBarBackgroundTransform();
+    cacheHealthBarBackgroundTransform();
 	applyHealthBarScaleForState();
 }
 
@@ -79,10 +74,16 @@ bool SkeletonDamageable::isPermanentlyDead() const
 
 void SkeletonDamageable::startDowned()
 {
-	m_lifeState = SkeletonLifeState::Downed;
-	m_previousMaxHp = getMaxHp();
-	m_maxHp = m_attackConfig->m_downedHP;
-	m_currentHp = m_attackConfig->m_downedHP;
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    m_lifeState = SkeletonLifeState::Downed;
+    m_previousMaxHp = getMaxHp();
+    m_maxHp = cfg->m_downedHP;
+    m_currentHp = cfg->m_downedHP;
 	m_isDead = false;
 
 	applyHealthBarScaleForState();
@@ -172,17 +173,18 @@ void SkeletonDamageable::applyHealthBarScaleForState()
 
 bool SkeletonDamageable::shouldBlockDamage(const EnemyHitContext& enemyCtx) const
 {
-	if (!m_skeletonController)
-	{
-		return false;
-	}
+    if (!m_skeletonController)
+    {
+        return false;
+    }
 
-	if (!m_attackConfig)
-	{
-		return false;
-	}
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
 
-	if (!m_skeletonController->isGuarding())
+    if (!m_skeletonController->isGuarding())
 	{
 		return false;
 	}
@@ -224,7 +226,7 @@ bool SkeletonDamageable::shouldBlockDamage(const EnemyHitContext& enemyCtx) cons
 	const float dot = forward.Dot(toAttacker);
 
 	constexpr float degreesToRadians = 3.14159265f / 180.0f;
-	const float minDot = std::cos(m_attackConfig->m_guardBlockHalfAngleDegrees * degreesToRadians);
+    const float minDot = std::cos(cfg->m_guardBlockHalfAngleDegrees * degreesToRadians);
 
 	return dot >= minDot; // if dot >= minDot - attacker is in front | if dot < minDot - attacker is side/back
 }
diff --git a/GameScripts/SkeletonDamageable.h b/GameScripts/SkeletonDamageable.h
index fd659d52..2d16da76 100644
--- a/GameScripts/SkeletonDamageable.h
+++ b/GameScripts/SkeletonDamageable.h
@@ -15,7 +15,7 @@ class SkeletonDamageable final : public EnemyDamageable
 
 	void Start() override;
 
-	ScriptFieldList getExposedFields() const override;
+	FieldList getExposedFields() const override;
 
 	void takeDamage(const HitContext& ctx) override;
 	
@@ -44,7 +44,7 @@ class SkeletonDamageable final : public EnemyDamageable
 
 private:
 	SkeletonEnemyController* m_skeletonController = nullptr;
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 
 	Transform2D* m_healthBarBackgroundTransform2D = nullptr;
 	Vector2 m_originalHealthBarScale = Vector2(1.0f, 1.0f);
diff --git a/GameScripts/SkeletonEnemyController.cpp b/GameScripts/SkeletonEnemyController.cpp
index bbd146dd..3873fd03 100644
--- a/GameScripts/SkeletonEnemyController.cpp
+++ b/GameScripts/SkeletonEnemyController.cpp
@@ -14,21 +14,15 @@ SkeletonEnemyController::SkeletonEnemyController(GameObject* owner)
 
 void SkeletonEnemyController::Start()
 {
-	m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-	m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
+    m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
+    m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
 
-	if (!m_enemyDetectionAggro)
-	{
-		Debug::warn("[SkeletonEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
+    if (!m_enemyDetectionAggro)
+    {
+        Debug::warn("[SkeletonEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
+    }
 
-	if (!m_attackConfig)
-	{
-		Debug::warn("[SkeletonEnemyController] SkeletonAttackConfig not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
-
-	if (!m_damageable)
+    if (!m_damageable)
 	{
 		Debug::warn("[SkeletonEnemyController] SkeletonDamageable not found on '%s'.", GameObjectAPI::getName(getOwner()));
 	}
@@ -76,12 +70,18 @@ bool SkeletonEnemyController::isTargetDowned(Transform* target) const
 
 bool SkeletonEnemyController::isTargetInScimitarRange() const
 {
-	if (!hasValidTarget() || !m_attackConfig)
-	{
-		return false;
-	}
-
-	return isCurrentTargetInRange(m_attackConfig->m_scimitarStartRange);
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
+
+    return isCurrentTargetInRange(cfg->m_scimitarStartRange);
 }
 
 bool SkeletonEnemyController::isGuardReady() const
@@ -91,12 +91,13 @@ bool SkeletonEnemyController::isGuardReady() const
 
 void SkeletonEnemyController::consumeGuardCooldown()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_guardCooldownTimer = m_attackConfig->m_guardCooldown;
+    m_guardCooldownTimer = cfg->m_guardCooldown;
 }
 
 void SkeletonEnemyController::updateGuardCooldown(float dt)
@@ -116,17 +117,23 @@ void SkeletonEnemyController::updateGuardCooldown(float dt)
 
 bool SkeletonEnemyController::shouldUseGuard() const
 {
-	if (!hasValidTarget() || !m_attackConfig)
-	{
-		return false;
-	}
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
 
-	if (!isGuardReady())
+    if (!isGuardReady())
 	{
 		return false;
 	}
 
-	if (!isCurrentTargetInRange(m_attackConfig->m_guardRange))
+    if (!isCurrentTargetInRange(cfg->m_guardRange))
 	{
 		return false;
 	}
@@ -162,7 +169,7 @@ bool SkeletonEnemyController::shouldUseGuard() const
 	float dot = forward.Dot(toTarget);
 
 	constexpr float degreesToRadians = 3.14159265f / 180.0f;
-	const float minDot = std::cos(m_attackConfig->m_guardBlockHalfAngleDegrees * degreesToRadians);
+    const float minDot = std::cos(cfg->m_guardBlockHalfAngleDegrees * degreesToRadians);
 
 	return dot >= minDot;
 }
@@ -212,4 +219,6 @@ bool SkeletonEnemyController::trySendReviveTrigger(AnimationComponent* animation
 	return true;
 }
 
-IMPLEMENT_SCRIPT(SkeletonEnemyController)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SkeletonEnemyController,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SkeletonEnemyController.h b/GameScripts/SkeletonEnemyController.h
index b74f0a80..c40ab48d 100644
--- a/GameScripts/SkeletonEnemyController.h
+++ b/GameScripts/SkeletonEnemyController.h
@@ -12,6 +12,7 @@ class SkeletonEnemyController : public EnemyBaseController
 
 public:
 	explicit SkeletonEnemyController(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void Start() override;
 	void Update() override;
@@ -36,7 +37,7 @@ class SkeletonEnemyController : public EnemyBaseController
 
 private:
 	EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 	SkeletonDamageable* m_damageable = nullptr;
 
 	float m_guardCooldownTimer = 0.0f;
diff --git a/GameScripts/SkeletonGuardState.cpp b/GameScripts/SkeletonGuardState.cpp
index 20bd51fe..c5842bd5 100644
--- a/GameScripts/SkeletonGuardState.cpp
+++ b/GameScripts/SkeletonGuardState.cpp
@@ -12,24 +12,17 @@ SkeletonGuardState::SkeletonGuardState(GameObject* owner)
 
 void SkeletonGuardState::OnStateEnter()
 {
-	m_skeletonController = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-	m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
+    m_skeletonController = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
+    m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
 	m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
-	if (!m_skeletonController)
-	{
-		Debug::error("[SkeletonGuardState] SkeletonEnemyController not found.");
-		return;
-	}
+    if (!m_skeletonController)
+    {
+        Debug::error("[SkeletonGuardState] SkeletonEnemyController not found.");
+        return;
+    }
 
-	if (!m_attackConfig)
-	{
-		Debug::error("[SkeletonGuardState] SkeletonAttackConfig not found.");
-		return;
-	}
-
-	if (!m_damageable)
+    if (!m_damageable)
 	{
 		Debug::error("[SkeletonGuardState] SkeletonDamageable not found.");
 		return;
@@ -52,32 +45,38 @@ void SkeletonGuardState::OnStateEnter()
 
 void SkeletonGuardState::OnStateUpdate()
 {
-	if (!m_skeletonController || !m_attackConfig || !m_damageable || !m_animation)
-	{
-		return;
-	}
-
-	// Go into Revive State
-	if (m_skeletonController->trySendReviveTrigger(m_animation))
-	{
-		return;
-	}
-
-	m_skeletonController->faceCurrentTarget();
-
-	const float dt = Time::getDeltaTime();
-
-	m_stateTimer += dt;
-
-	// Heal over time
-	if (m_damageable->getCurrentHp() < m_damageable->getMaxHp())
-	{
-		const float healAmount = m_attackConfig->m_guardHealPerSecond * dt;
-		m_damageable->heal(healAmount);
-	}
-
-	// End GuardState
-	if (m_stateTimer >= m_attackConfig->m_guardDuration)
+    if (!m_skeletonController || !m_damageable || !m_animation)
+    {
+        return;
+    }
+
+    // Go into Revive State
+    if (m_skeletonController->trySendReviveTrigger(m_animation))
+    {
+        return;
+    }
+
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    m_skeletonController->faceCurrentTarget();
+
+    const float dt = Time::getDeltaTime();
+
+    m_stateTimer += dt;
+
+    // Heal over time
+    if (m_damageable->getCurrentHp() < m_damageable->getMaxHp())
+    {
+        const float healAmount = cfg->m_guardHealPerSecond * dt;
+        m_damageable->heal(healAmount);
+    }
+
+    // End GuardState
+    if (m_stateTimer >= cfg->m_guardDuration)
 	{
 		m_skeletonController->consumeGuardCooldown();
 		AnimationAPI::sendTrigger(m_animation, "ToChase");
@@ -97,4 +96,6 @@ void SkeletonGuardState::OnStateExit()
 	Debug::log("[SkeletonGuardState] EXIT");
 }
 
-IMPLEMENT_SCRIPT(SkeletonGuardState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SkeletonGuardState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SkeletonGuardState.h b/GameScripts/SkeletonGuardState.h
index b6b5c013..9e6ef976 100644
--- a/GameScripts/SkeletonGuardState.h
+++ b/GameScripts/SkeletonGuardState.h
@@ -14,6 +14,7 @@ class SkeletonGuardState : public StateMachineScript
 
 public:
 	explicit SkeletonGuardState(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
@@ -21,7 +22,7 @@ class SkeletonGuardState : public StateMachineScript
 
 private:
 	SkeletonEnemyController* m_skeletonController = nullptr;
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 	SkeletonDamageable* m_damageable = nullptr;
 	AnimationComponent* m_animation = nullptr;
 
diff --git a/GameScripts/SkeletonReviveState.cpp b/GameScripts/SkeletonReviveState.cpp
index b21f72da..0f3ae8b8 100644
--- a/GameScripts/SkeletonReviveState.cpp
+++ b/GameScripts/SkeletonReviveState.cpp
@@ -12,10 +12,9 @@ SkeletonReviveState::SkeletonReviveState(GameObject* owner)
 
 void SkeletonReviveState::OnStateEnter()
 {
-	m_controller = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
-	m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-	m_animation = AnimationAPI::getAnimationComponent(getOwner());
+    m_controller = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
+    m_damageable = GameObjectAPI::findScript<SkeletonDamageable>(getOwner());
+    m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
 	if (!m_controller)
 	{
@@ -23,19 +22,13 @@ void SkeletonReviveState::OnStateEnter()
 		return;
 	}
 
-	if (!m_damageable)
-	{
-		Debug::error("[SkeletonReviveState] SkeletonDamageable not found.");
-		return;
-	}
+    if (!m_damageable)
+    {
+        Debug::error("[SkeletonReviveState] SkeletonDamageable not found.");
+        return;
+    }
 
-	if (!m_attackConfig)
-	{
-		Debug::error("[SkeletonReviveState] SkeletonAttackConfig not found.");
-		return;
-	}
-
-	if (!m_animation)
+    if (!m_animation)
 	{
 		Debug::error("[SkeletonReviveState] AnimationComponent not found.");
 		return;
@@ -54,7 +47,7 @@ void SkeletonReviveState::OnStateEnter()
 
 void SkeletonReviveState::OnStateUpdate()
 {
-	if (!m_controller || !m_damageable || !m_attackConfig || !m_animation)
+    if (!m_controller || !m_damageable || !m_animation)
 	{
 		return;
 	}
@@ -139,7 +132,13 @@ void SkeletonReviveState::updateReviveStart()
 
 void SkeletonReviveState::updateReviveIdle()
 {
-	if (m_phaseTimer >= m_attackConfig->m_reviveDuration)
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    if (m_phaseTimer >= cfg->m_reviveDuration)
 	{
 		changePhase(Phase::ReviveEnd);
 		return;
@@ -178,4 +177,6 @@ void SkeletonReviveState::goToChase()
 	AnimationAPI::sendTrigger(m_animation, "ToChase");
 }
 
-IMPLEMENT_SCRIPT(SkeletonReviveState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SkeletonReviveState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SkeletonReviveState.h b/GameScripts/SkeletonReviveState.h
index 9da37a5c..801c6cee 100644
--- a/GameScripts/SkeletonReviveState.h
+++ b/GameScripts/SkeletonReviveState.h
@@ -14,6 +14,7 @@ class SkeletonReviveState : public StateMachineScript
 
 public:
 	explicit SkeletonReviveState(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
@@ -39,7 +40,7 @@ class SkeletonReviveState : public StateMachineScript
 private:
 	SkeletonEnemyController* m_controller = nullptr;
 	SkeletonDamageable* m_damageable = nullptr;
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 	AnimationComponent* m_animation = nullptr;
 
 	Phase m_phase = Phase::ReviveStart;
diff --git a/GameScripts/SkeletonScimitarState.cpp b/GameScripts/SkeletonScimitarState.cpp
index e4ef6873..a0a32d5a 100644
--- a/GameScripts/SkeletonScimitarState.cpp
+++ b/GameScripts/SkeletonScimitarState.cpp
@@ -12,9 +12,8 @@ SkeletonScimitarState::SkeletonScimitarState(GameObject* owner)
 
 void SkeletonScimitarState::OnStateEnter()
 {
-	m_controller = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SkeletonAttackConfig>(getOwner());
-	m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
+    m_controller = GameObjectAPI::findScript<SkeletonEnemyController>(getOwner());
+    m_attackExecutor = GameObjectAPI::findScript<EnemyAttackExecutor>(getOwner());
 	m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
 	if (!m_controller)
@@ -23,13 +22,7 @@ void SkeletonScimitarState::OnStateEnter()
 		return;
 	}
 
-	if (!m_attackConfig)
-	{
-		Debug::error("[SkeletonScimitarState] SkeletonAttackConfig not found.");
-		return;
-	}
-
-	if (!m_attackExecutor)
+    if (!m_attackExecutor)
 	{
 		Debug::error("[SkeletonScimitarState] EnemyAttackExecutor not found.");
 		return;
@@ -45,8 +38,16 @@ void SkeletonScimitarState::OnStateEnter()
 	m_controller->resetRepathTimer();
 	m_controller->updateCurrentTarget();
 
-	m_previousAnimationSpeed = AnimationAPI::getSpeedMultiplier(m_animation);
-	AnimationAPI::setSpeedMultiplier(m_animation, m_attackConfig->m_attackAnimationSpeed);
+    m_previousAnimationSpeed = AnimationAPI::getSpeedMultiplier(m_animation);
+
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        Debug::error("[SkeletonScimitarState] SkeletonAttackConfig not found.");
+        return;
+    }
+
+    AnimationAPI::setSpeedMultiplier(m_animation, cfg->m_attackAnimationSpeed);
 
 	changePhase(Phase::Dash);
 
@@ -55,7 +56,7 @@ void SkeletonScimitarState::OnStateEnter()
 
 void SkeletonScimitarState::OnStateUpdate()
 {
-	if (!m_controller || !m_attackConfig || !m_attackExecutor || !m_animation)
+    if (!m_controller || !m_attackExecutor || !m_animation)
 	{
 		return;
 	}
@@ -115,12 +116,18 @@ void SkeletonScimitarState::changePhase(Phase phase)
 	m_phaseTimer = 0.0f;
 	m_hasAppliedHit = false;
 
-	if (!m_animation || !m_attackConfig)
-	{
-		return;
-	}
+    if (!m_animation)
+    {
+        return;
+    }
+
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	if (phase == Phase::Attack1 || phase == Phase::Attack2 || phase == Phase::Attack3)
+    if (phase == Phase::Attack1 || phase == Phase::Attack2 || phase == Phase::Attack3)
 	{
 		AnimationAPI::playOverrideClip(m_animation, "Skeleton_Attak", 0.05, false);
 	}
@@ -128,7 +135,13 @@ void SkeletonScimitarState::changePhase(Phase phase)
 
 void SkeletonScimitarState::updateDash()
 {
-	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	if (!ownerTransform)
 	{
 		return;
@@ -137,10 +150,10 @@ void SkeletonScimitarState::updateDash()
 	Vector3 forward = TransformAPI::getForward(ownerTransform);
 	forward.y = 0.0f;
 
-	moveInDirection(forward, m_attackConfig->m_scimitarDashSpeed);
+    moveInDirection(forward, cfg->m_scimitarDashSpeed);
 
-	if (m_controller->isCurrentTargetInRange(m_attackConfig->m_scimitarDashStopRange) ||
-		m_phaseTimer >= m_attackConfig->m_scimitarDashDuration)
+    if (m_controller->isCurrentTargetInRange(cfg->m_scimitarDashStopRange) ||
+        m_phaseTimer >= cfg->m_scimitarDashDuration)
 	{
 		changePhase(Phase::Attack1);
 		return;
@@ -183,7 +196,13 @@ void SkeletonScimitarState::updateAttack()
 
 void SkeletonScimitarState::updateBackstep()
 {
-	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	if (!ownerTransform)
 	{
 		return;
@@ -192,9 +211,9 @@ void SkeletonScimitarState::updateBackstep()
 	Vector3 backward = -TransformAPI::getForward(ownerTransform);
 	backward.y = 0.0f;
 
-	moveInDirection(backward, m_attackConfig->m_stepBackSpeed);
+    moveInDirection(backward, cfg->m_stepBackSpeed);
 
-	if (m_phaseTimer >= m_attackConfig->m_stepBackDuration)
+    if (m_phaseTimer >= cfg->m_stepBackDuration)
 	{
 		changePhase(Phase::Attack3);
 		return;
@@ -203,7 +222,13 @@ void SkeletonScimitarState::updateBackstep()
 
 void SkeletonScimitarState::applyHit(bool shouldStun)
 {
-	Transform* currentTarget = m_controller->getCurrentTarget();
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    Transform* currentTarget = m_controller->getCurrentTarget();
 	if (!currentTarget)
 	{
 		return;
@@ -220,28 +245,28 @@ void SkeletonScimitarState::applyHit(bool shouldStun)
 
 	if (shouldStun)
 	{
-		m_attackExecutor->tryDamageAndStunSingleTargetInCone(
-			currentTarget,
-			center,
-			forward,
-			m_attackConfig->m_scimitarStunHitRange,
-			m_attackConfig->m_scimitarHalfAngleDegrees,
-			m_attackConfig->m_basicAttackDamage,
-			m_attackConfig->m_scimitarStunDuration,
-			"SkeletonScimitar"
-		);
-	}
-	else
-	{
-		m_attackExecutor->tryDamageTargetInCone(
-			currentTarget,
-			center,
-			forward,
-			m_attackConfig->m_basicAttackRange,
-			m_attackConfig->m_scimitarHalfAngleDegrees,
-			m_attackConfig->m_basicAttackDamage,
-			"SkeletonScimitar"
-		);
+        m_attackExecutor->tryDamageAndStunSingleTargetInCone(
+            currentTarget,
+            center,
+            forward,
+            cfg->m_scimitarStunHitRange,
+            cfg->m_scimitarHalfAngleDegrees,
+            cfg->m_basicAttackDamage,
+            cfg->m_scimitarStunDuration,
+            "SkeletonScimitar"
+        );
+    }
+    else
+    {
+        m_attackExecutor->tryDamageTargetInCone(
+            currentTarget,
+            center,
+            forward,
+            cfg->m_basicAttackRange,
+            cfg->m_scimitarHalfAngleDegrees,
+            cfg->m_basicAttackDamage,
+            "SkeletonScimitar"
+        );
 	}
 }
 
@@ -285,12 +310,26 @@ void SkeletonScimitarState::goToChase()
 
 float SkeletonScimitarState::getScimitarAttackClipDuration() const
 {
-	return m_attackConfig->m_attackClipDuration / m_attackConfig->m_attackAnimationSpeed;
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return 0.0f;
+    }
+
+    return cfg->m_attackClipDuration / cfg->m_attackAnimationSpeed;
 }
 
 float SkeletonScimitarState::getScimitarAttackHitTime() const
 {
-	return getScimitarAttackClipDuration() * m_attackConfig->m_attackHitTime;
+    const SkeletonAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return 0.0f;
+    }
+
+    return getScimitarAttackClipDuration() * cfg->m_attackHitTime;
 }
 
-IMPLEMENT_SCRIPT(SkeletonScimitarState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SkeletonScimitarState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SkeletonScimitarState.h b/GameScripts/SkeletonScimitarState.h
index 45f8542c..09cbe5b7 100644
--- a/GameScripts/SkeletonScimitarState.h
+++ b/GameScripts/SkeletonScimitarState.h
@@ -14,6 +14,7 @@ class SkeletonScimitarState : public StateMachineScript
 
 public:
 	explicit SkeletonScimitarState(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
@@ -45,7 +46,7 @@ class SkeletonScimitarState : public StateMachineScript
 
 private:
 	SkeletonEnemyController* m_controller = nullptr;
-	SkeletonAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SkeletonAttackConfig> m_attackConfig;
 	EnemyAttackExecutor* m_attackExecutor = nullptr;
 	AnimationComponent* m_animation = nullptr;
 
diff --git a/GameScripts/SliderTest.h b/GameScripts/SliderTest.h
new file mode 100644
index 00000000..d3d25d75
--- /dev/null
+++ b/GameScripts/SliderTest.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "UISlider.h"
+
+class SliderTest : public Script
+{
+    DECLARE_SCRIPT(SliderTest)
+
+public:
+    explicit SliderTest(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+    FieldList getExposedFields() const override;
+
+public:
+    ComponentRef<UISlider> m_slider;
+
+    float m_fillSpeed = 0.5f;
+    float m_stepAmount = 0.1f;
+    bool m_autoTest = false;
+
+private:
+    float m_currentFill = 1.0f;
+    bool m_increasing = false;
+};
\ No newline at end of file
diff --git a/GameScripts/SpiderEnemyController.cpp b/GameScripts/SpiderEnemyController.cpp
index 2f2be09c..2613c532 100644
--- a/GameScripts/SpiderEnemyController.cpp
+++ b/GameScripts/SpiderEnemyController.cpp
@@ -13,20 +13,14 @@ SpiderEnemyController::SpiderEnemyController(GameObject* owner)
 
 void SpiderEnemyController::Start()
 {
-	m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<EnemyBaseAttackConfig>(getOwner());
+    m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
 
-	if (!m_enemyDetectionAggro)
-	{
-		Debug::warn("[SpiderEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
-
-	if (!m_attackConfig)
-	{
-		Debug::warn("[SpiderEnemyController] EnemyBaseAttackConfig not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
+    if (!m_enemyDetectionAggro)
+    {
+        Debug::warn("[SpiderEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
+    }
 
-	m_currentTarget = nullptr;
+    m_currentTarget = nullptr;
 	m_deathTriggerSent = false;
 
 	resetRepathTimer();
@@ -65,12 +59,20 @@ bool SpiderEnemyController::isTargetDowned(Transform* target) const
 
 bool SpiderEnemyController::isTargetInAttackRange() const
 {
-	if (!hasValidTarget() || !m_attackConfig)
-	{
-		return false;
-	}
-	
-	return isCurrentTargetInRange(m_attackConfig->m_basicAttackRange);
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const EnemyBaseAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
+    
+    return isCurrentTargetInRange(cfg->m_basicAttackRange);
 }
 
-IMPLEMENT_SCRIPT(SpiderEnemyController)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SpiderEnemyController,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SpiderEnemyController.h b/GameScripts/SpiderEnemyController.h
index 80d7afd6..39629a9c 100644
--- a/GameScripts/SpiderEnemyController.h
+++ b/GameScripts/SpiderEnemyController.h
@@ -11,6 +11,7 @@ class SpiderEnemyController : public EnemyBaseController
 
 public:
 	explicit SpiderEnemyController(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void Start() override;
 	void Update() override;
@@ -23,5 +24,5 @@ class SpiderEnemyController : public EnemyBaseController
 
 private:
 	EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
-	EnemyBaseAttackConfig* m_attackConfig = nullptr;
+    AssetRef<EnemyBaseAttackConfig> m_attackConfig;
 };
\ No newline at end of file
diff --git a/GameScripts/SpikeTrap.h b/GameScripts/SpikeTrap.h
index a364d995..ac050c23 100644
--- a/GameScripts/SpikeTrap.h
+++ b/GameScripts/SpikeTrap.h
@@ -19,7 +19,7 @@ class SpikeTrap : public Script
         ACTIVE
     };
     
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
     float a_duration = 2.0;
 	float p_duration = 1.0;
@@ -30,8 +30,8 @@ class SpikeTrap : public Script
 
 	bool alternativeMode = false;
 
-    /*ScriptComponentRef<Transform> m_normalSpike;
-    ScriptComponentRef<Transform> m_spectralSpike;*/
+    /*ComponentRef<Transform> m_normalSpike;
+    ComponentRef<Transform> m_spectralSpike;*/
 
 	Vector3 normalSpikePosition = Vector3(0.0f, -1.0f, 0.0f);
 	Vector3 spectralSpikePosition = Vector3(0.0f, -1.0f, 0.0f);
@@ -51,8 +51,8 @@ class SpikeTrap : public Script
 	float waitPositionY = -0.7f;
 	float activePositionY = 0.0f;
 
-    ScriptComponentRef<Transform> m_spikeShineT;
-    ScriptComponentRef<Transform> m_spectralAuraT;
+    ComponentRef<Transform> m_spikeShineT;
+    ComponentRef<Transform> m_spectralAuraT;
 
 private:
     
diff --git a/GameScripts/StateMachineTest.h b/GameScripts/StateMachineTest.h
new file mode 100644
index 00000000..fcc1098e
--- /dev/null
+++ b/GameScripts/StateMachineTest.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "ScriptAPI.h"
+#include "StateMachineScript.h"
+
+class StateMachineTest : public StateMachineScript
+{
+    DECLARE_SCRIPT(StateMachineTest)
+
+public:
+    explicit StateMachineTest(GameObject* owner);
+
+    void OnStateEnter() override;
+    void OnStateUpdate() override;
+    void OnStateExit() override;
+
+    FieldList getExposedFields() const override;
+
+public:
+    float m_speed = 5.0f;
+    bool m_debugEnabled = true;
+};
diff --git a/GameScripts/SummonerAttackConfig.cpp b/GameScripts/SummonerAttackConfig.cpp
index 18f57774..2728d302 100644
--- a/GameScripts/SummonerAttackConfig.cpp
+++ b/GameScripts/SummonerAttackConfig.cpp
@@ -1,33 +1,2 @@
 #include "pch.h"
 #include "SummonerAttackConfig.h"
-
-IMPLEMENT_SCRIPT_FIELDS_INHERITED(SummonerAttackConfig, EnemyBaseAttackConfig,
-	// Teleport
-	FIELD_GROUP_COLLAPSE("Teleport",
-		SERIALIZED_FLOAT(m_teleportCooldown, "Teleport Cooldown", 0.0f, 30.0f, 0.1f),
-		SERIALIZED_FLOAT(m_teleportRadius, "Teleport Radius", 0.0f, 30.0f, 0.1f),
-		SERIALIZED_FLOAT(m_teleportMinPlayerDistance, "Min Player Distance", 0.0f, 20.0f, 0.1f)
-	),
-	// Energy Ball
-	FIELD_GROUP_COLLAPSE("Energy Ball",
-		SERIALIZED_FLOAT(m_energyBallSpeed, "Energy Ball Speed", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_energyBallLifetime, "Energy Ball Lifetime", 0.1f, 10.0f, 0.1f)
-	),
-	// Summon
-	FIELD_GROUP_COLLAPSE("Summon",
-		SERIALIZED_ASSET_REF(m_spiderPrefab, "Spider Prefab", AssetType::PREFAB),
-		SERIALIZED_INT(m_summonCount, "Summon Count"),
-		SERIALIZED_FLOAT(m_summonRadius, "Summon Radius", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_summonCastTime, "Summon Cast Time", 0.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_summonTotalDuration, "Summon Total Duration", 1.0f, 10.0f, 0.1f),
-		SERIALIZED_FLOAT(m_summonCooldown, "Summon Cooldown", 0.0f, 30.0f, 0.1f),
-		SERIALIZED_FLOAT(m_summonRecoverDuration, "Summon Recover Duration", 0.0f, 10.0f, 0.1f)
-	)
-)
-
-SummonerAttackConfig::SummonerAttackConfig(GameObject* owner)
-	: EnemyBaseAttackConfig(owner)
-{
-}
-
-IMPLEMENT_SCRIPT(SummonerAttackConfig)
\ No newline at end of file
diff --git a/GameScripts/SummonerAttackConfig.h b/GameScripts/SummonerAttackConfig.h
index 933f90b7..5f8f9e88 100644
--- a/GameScripts/SummonerAttackConfig.h
+++ b/GameScripts/SummonerAttackConfig.h
@@ -2,31 +2,54 @@
 
 #include "EnemyBaseAttackConfig.h"
 
+class Prefab;
+
 class SummonerAttackConfig : public EnemyBaseAttackConfig
 {
-	DECLARE_SCRIPT(SummonerAttackConfig)
+    DECLARE_DATACONTAINER(SummonerAttackConfig)
 
 public:
-	explicit SummonerAttackConfig(GameObject* owner);
+    SummonerAttackConfig() = default;
+    explicit SummonerAttackConfig(AssetReference& id)
+        : EnemyBaseAttackConfig(id)
+    {
+    }
 
-	ScriptFieldList getExposedFields() const override;
+    // Teleport
+    float m_teleportCooldown = 12.0f;
+    float m_teleportRadius = 6.0f;
+    float m_teleportMinPlayerDistance = 5.0f;
 
-public:
-	// Teleport
-	float m_teleportCooldown = 12.0f;
-	float m_teleportRadius = 6.0f;
-	float m_teleportMinPlayerDistance = 5.0f;
-
-	// Energy Ball
-	float m_energyBallSpeed = 6.0f;
-	float m_energyBallLifetime = 2.0f;
-
-	// Summon
-	PrefabRef m_spiderPrefab;
-	int m_summonCount = 3;
-	float m_summonRadius = 2.0f;
-	float m_summonCastTime = 0.5f;
-	float m_summonTotalDuration = 1.0f;
-	float m_summonCooldown = 8.0f;
-	float m_summonRecoverDuration = 3.0f;
-};
\ No newline at end of file
+    // Energy Ball
+    float m_energyBallSpeed = 6.0f;
+    float m_energyBallLifetime = 2.0f;
+
+    // Summon
+    AssetRef<Prefab> m_spiderPrefab;
+    int m_summonCount = 3;
+    float m_summonRadius = 2.0f;
+    float m_summonCastTime = 0.5f;
+    float m_summonTotalDuration = 1.0f;
+    float m_summonCooldown = 8.0f;
+    float m_summonRecoverDuration = 3.0f;
+
+    IMPLEMENT_DATACONTAINER_FIELDS_INHERITED(SummonerAttackConfig, EnemyBaseAttackConfig,
+        FIELD_GROUP_COLLAPSE("Teleport",
+            SERIALIZED_FLOAT(m_teleportCooldown, "Teleport Cooldown", 0.0f, 30.0f, 0.1f),
+            SERIALIZED_FLOAT(m_teleportRadius, "Teleport Radius", 0.0f, 30.0f, 0.1f),
+            SERIALIZED_FLOAT(m_teleportMinPlayerDistance, "Min Player Distance", 0.0f, 20.0f, 0.1f)
+        ),
+        FIELD_GROUP_COLLAPSE("Energy Ball",
+            SERIALIZED_FLOAT(m_energyBallSpeed, "Energy Ball Speed", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_energyBallLifetime, "Energy Ball Lifetime", 0.1f, 10.0f, 0.1f)
+        ),
+        FIELD_GROUP_COLLAPSE("Summon",
+            SERIALIZED_INT(m_summonCount, "Summon Count"),
+            SERIALIZED_FLOAT(m_summonRadius, "Summon Radius", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_summonCastTime, "Summon Cast Time", 0.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_summonTotalDuration, "Summon Total Duration", 1.0f, 10.0f, 0.1f),
+            SERIALIZED_FLOAT(m_summonCooldown, "Summon Cooldown", 0.0f, 30.0f, 0.1f),
+            SERIALIZED_FLOAT(m_summonRecoverDuration, "Summon Recover Duration", 0.0f, 10.0f, 0.1f)
+        )
+    )
+};
diff --git a/GameScripts/SummonerEnemyController.cpp b/GameScripts/SummonerEnemyController.cpp
index 100478ae..82910029 100644
--- a/GameScripts/SummonerEnemyController.cpp
+++ b/GameScripts/SummonerEnemyController.cpp
@@ -11,20 +11,14 @@ SummonerEnemyController::SummonerEnemyController(GameObject* owner)
 
 void SummonerEnemyController::Start()
 {
-	m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SummonerAttackConfig>(getOwner());
+    m_enemyDetectionAggro = GameObjectAPI::findScript<EnemyDetectionAggro>(getOwner());
 
-	if (!m_enemyDetectionAggro)
-	{
-		Debug::warn("[SummonerEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
+    if (!m_enemyDetectionAggro)
+    {
+        Debug::warn("[SummonerEnemyController] EnemyDetectionAggro not found on '%s'.", GameObjectAPI::getName(getOwner()));
+    }
 
-	if (!m_attackConfig)
-	{
-		Debug::warn("[SummonerEnemyController] SummonerAttackConfig not found on '%s'.", GameObjectAPI::getName(getOwner()));
-	}
-
-	m_currentTarget = nullptr;
+    m_currentTarget = nullptr;
 	m_deathTriggerSent = false;
 
 	resetRepathTimer();
@@ -71,12 +65,18 @@ bool SummonerEnemyController::isTargetDowned(Transform* target) const
 
 bool SummonerEnemyController::isTargetInAttackRange() const
 {
-	if (!hasValidTarget() || !m_attackConfig)
-	{
-		return false;
-	}
-
-	return isCurrentTargetInRange(m_attackConfig->m_basicAttackRange);
+    if (!hasValidTarget())
+    {
+        return false;
+    }
+
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return false;
+    }
+
+    return isCurrentTargetInRange(cfg->m_basicAttackRange);
 }
 
 bool SummonerEnemyController::isTeleportReady() const
@@ -86,19 +86,21 @@ bool SummonerEnemyController::isTeleportReady() const
 
 void SummonerEnemyController::consumeTeleportCooldown()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_teleportCooldownTimer = m_attackConfig->m_teleportCooldown;
+    m_teleportCooldownTimer = cfg->m_teleportCooldown;
 }
 
 bool SummonerEnemyController::tryGetTeleportPosition(Vector3& outPosition) const
 {
-	constexpr int MaxTeleportAttempts = 20;
+    constexpr int MaxTeleportAttempts = 20;
 
-	if (!m_attackConfig || !hasValidTarget())
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg || !hasValidTarget())
 	{
 		return false;
 	}
@@ -115,7 +117,7 @@ bool SummonerEnemyController::tryGetTeleportPosition(Vector3& outPosition) const
 	const Vector3 targetPosition = TransformAPI::getGlobalPosition(targetTransform);
 
 	const bool targetInAttackRange =
-		isCurrentTargetInRange(m_attackConfig->m_basicAttackRange);
+        isCurrentTargetInRange(cfg->m_basicAttackRange);
 
 	const Vector3 searchCenter =
 		targetInAttackRange ? ownerPosition : targetPosition;
@@ -124,8 +126,8 @@ bool SummonerEnemyController::tryGetTeleportPosition(Vector3& outPosition) const
 	Transform* deathTransform = m_enemyDetectionAggro->getDeathTransform();
 
 	const Vector3 searchExtents = Vector3(5.0f, 5.0f, 5.0f);
-	const float attackRangeSquared =
-		m_attackConfig->m_basicAttackRange * m_attackConfig->m_basicAttackRange;
+    const float attackRangeSquared =
+        cfg->m_basicAttackRange * cfg->m_basicAttackRange;
 
 	float bestScore = -FLT_MAX;
 	bool foundPosition = false;
@@ -135,9 +137,9 @@ bool SummonerEnemyController::tryGetTeleportPosition(Vector3& outPosition) const
 	{
 		Vector3 candidatePosition;
 
-		const bool found = NavigationAPI::findRandomReachablePointAround(
-			searchCenter,
-			m_attackConfig->m_teleportRadius,
+        const bool found = NavigationAPI::findRandomReachablePointAround(
+            searchCenter,
+            cfg->m_teleportRadius,
 			candidatePosition,
 			searchExtents,
 			1);
@@ -192,8 +194,8 @@ bool SummonerEnemyController::tryGetTeleportPosition(Vector3& outPosition) const
 			continue;
 		}
 
-		if (!targetInAttackRange &&
-			closestPlayerDistance < m_attackConfig->m_teleportMinPlayerDistance)
+        if (!targetInAttackRange &&
+            closestPlayerDistance < cfg->m_teleportMinPlayerDistance)
 		{
 			continue;
 		}
@@ -248,22 +250,24 @@ bool SummonerEnemyController::isSummonReady() const
 
 void SummonerEnemyController::consumeSummonCooldown()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_summonCooldownTimer = m_attackConfig->m_summonCooldown;
+    m_summonCooldownTimer = cfg->m_summonCooldown;
 }
 
 void SummonerEnemyController::summonSpidersAroundSelf()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
+    Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	if (!ownerTransform)
 	{
 		return;
@@ -272,13 +276,13 @@ void SummonerEnemyController::summonSpidersAroundSelf()
 	const Vector3 ownerPosition = TransformAPI::getPosition(ownerTransform);
 	const Vector3 searchExtents = Vector3(5.0f, 5.0f, 5.0f);
 
-	for (int i = 0; i < m_attackConfig->m_summonCount; ++i)
-	{
-		Vector3 spawnPosition;
+    for (int i = 0; i < cfg->m_summonCount; ++i)
+    {
+        Vector3 spawnPosition;
 
-		const bool found = NavigationAPI::findRandomReachablePointAround(
-			ownerPosition,
-			m_attackConfig->m_summonRadius,
+        const bool found = NavigationAPI::findRandomReachablePointAround(
+            ownerPosition,
+            cfg->m_summonRadius,
 			spawnPosition,
 			searchExtents,
 			10
@@ -289,8 +293,8 @@ void SummonerEnemyController::summonSpidersAroundSelf()
 			continue;
 		}
 
-		GameObjectAPI::instantiatePrefab(
-			m_attackConfig->m_spiderPrefab.m_ref,
+        GameObjectAPI::instantiatePrefab(
+            cfg->m_spiderPrefab.m_ref,
 			spawnPosition,
 			Vector3(0.0f, 0.0f, 0.0f)
 		);
@@ -314,12 +318,13 @@ void SummonerEnemyController::updateSummonCooldown(float dt)
 
 float SummonerEnemyController::getRecoveryDuration() const
 {
-	if (!m_attackConfig)
-	{
-		return 0.0f;
-	}
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return 0.0f;
+    }
 
-	return m_attackConfig->m_summonRecoverDuration;
+    return cfg->m_summonRecoverDuration;
 }
 
 bool SummonerEnemyController::isAttackReady() const
@@ -329,12 +334,13 @@ bool SummonerEnemyController::isAttackReady() const
 
 void SummonerEnemyController::consumeAttackCooldown()
 {
-	if (!m_attackConfig)
-	{
-		return;
-	}
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_attackCooldownTimer = m_attackConfig->m_basicAttackCooldown;
+    m_attackCooldownTimer = cfg->m_basicAttackCooldown;
 }
 
 void SummonerEnemyController::updateAttackCooldown(float dt)
@@ -352,4 +358,6 @@ void SummonerEnemyController::updateAttackCooldown(float dt)
 	}
 }
 
-IMPLEMENT_SCRIPT(SummonerEnemyController)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SummonerEnemyController,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SummonerEnemyController.h b/GameScripts/SummonerEnemyController.h
index 8a478c88..5cdde821 100644
--- a/GameScripts/SummonerEnemyController.h
+++ b/GameScripts/SummonerEnemyController.h
@@ -12,6 +12,7 @@ class SummonerEnemyController : public EnemyBaseController
 
 public:
 	explicit SummonerEnemyController(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void Start() override;
 	void Update() override;
@@ -42,7 +43,7 @@ class SummonerEnemyController : public EnemyBaseController
 
 private:
 	EnemyDetectionAggro* m_enemyDetectionAggro = nullptr;
-	SummonerAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SummonerAttackConfig> m_attackConfig;
 
 	float m_attackCooldownTimer = 0.0f;
 	float m_teleportCooldownTimer = 0.0f;
diff --git a/GameScripts/SummonerEnergyBallState.cpp b/GameScripts/SummonerEnergyBallState.cpp
index 1565dab3..cc5221f2 100644
--- a/GameScripts/SummonerEnergyBallState.cpp
+++ b/GameScripts/SummonerEnergyBallState.cpp
@@ -13,9 +13,8 @@ SummonerEnergyBallState::SummonerEnergyBallState(GameObject* owner)
 
 void SummonerEnergyBallState::OnStateEnter()
 {
-	m_controller = GameObjectAPI::findScript<SummonerEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SummonerAttackConfig>(getOwner());
-	m_animation = AnimationAPI::getAnimationComponent(getOwner());
+    m_controller = GameObjectAPI::findScript<SummonerEnemyController>(getOwner());
+    m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
 	m_stateTimer = 0.0f;
 	m_hasFiredEnergyBall = false;
@@ -26,13 +25,7 @@ void SummonerEnergyBallState::OnStateEnter()
 		return;
 	}
 
-	if (!m_attackConfig)
-	{
-		Debug::error("[SummonerEnergyBallState] AttackConfig not found.");
-		return;
-	}
-
-	if (!m_animation)
+    if (!m_animation)
 	{
 		Debug::error("[SummonerEnergyBallState] AnimationComponent not found.");
 		return;
@@ -46,28 +39,34 @@ void SummonerEnergyBallState::OnStateEnter()
 
 void SummonerEnergyBallState::OnStateUpdate()
 {
-	if (!m_controller || !m_attackConfig || !m_animation)
-	{
-		return;
-	}
+    if (!m_controller || !m_animation)
+    {
+        return;
+    }
 
-	if (m_controller->trySendDeathTrigger(m_animation))
-	{
-		return;
-	}
+    if (m_controller->trySendDeathTrigger(m_animation))
+    {
+        return;
+    }
 
-	m_controller->faceCurrentTarget();
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
 
-	m_stateTimer += Time::getDeltaTime();
+    m_controller->faceCurrentTarget();
 
-	if (!m_hasFiredEnergyBall && m_stateTimer >= m_attackConfig->m_basicAttackWindupTime)
+    m_stateTimer += Time::getDeltaTime();
+
+    if (!m_hasFiredEnergyBall && m_stateTimer >= cfg->m_basicAttackWindupTime)
 	{
 		spawnEnergyBall();
 		m_controller->consumeAttackCooldown();
 		m_hasFiredEnergyBall = true;
 	}
 
-	if (m_stateTimer >= m_attackConfig->m_basicAttackTotalDuration)
+    if (m_stateTimer >= cfg->m_basicAttackTotalDuration)
 	{
 		AnimationAPI::sendTrigger(m_animation, "ToIdle");
 		return;
@@ -84,12 +83,18 @@ void SummonerEnergyBallState::OnStateExit()
 
 void SummonerEnergyBallState::spawnEnergyBall()
 {
-	if (!m_controller || !m_attackConfig)
-	{
-		return;
-	}
-
-	Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
+    if (!m_controller)
+    {
+        return;
+    }
+
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    Transform* ownerTransform = GameObjectAPI::getTransform(getOwner());
 	Transform* targetTransform = m_controller->getCurrentTarget();
 
 	if (!ownerTransform || !targetTransform)
@@ -130,14 +135,16 @@ void SummonerEnergyBallState::spawnEnergyBall()
 
 	GameObject* targetObject = targetTransform->getOwner();
 
-	projectile->launch(
-		spawnPosition,
-		direction,
-		m_attackConfig->m_energyBallSpeed,
-		m_attackConfig->m_energyBallLifetime,
-		targetObject,
-		m_attackConfig->m_basicAttackDamage
-	);
+    projectile->launch(
+        spawnPosition,
+        direction,
+        cfg->m_energyBallSpeed,
+        cfg->m_energyBallLifetime,
+        targetObject,
+        cfg->m_basicAttackDamage
+    );
 }
 
-IMPLEMENT_SCRIPT(SummonerEnergyBallState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SummonerEnergyBallState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SummonerEnergyBallState.h b/GameScripts/SummonerEnergyBallState.h
index efbcb5e4..58c29a59 100644
--- a/GameScripts/SummonerEnergyBallState.h
+++ b/GameScripts/SummonerEnergyBallState.h
@@ -13,6 +13,7 @@ class SummonerEnergyBallState : public StateMachineScript
 
 public:
 	explicit SummonerEnergyBallState(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
@@ -23,7 +24,7 @@ class SummonerEnergyBallState : public StateMachineScript
 
 private:
 	SummonerEnemyController* m_controller = nullptr;
-	SummonerAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SummonerAttackConfig> m_attackConfig;
 	AnimationComponent* m_animation = nullptr;
 
 	Transform* m_committedTarget = nullptr;
diff --git a/GameScripts/SummonerSummonState.cpp b/GameScripts/SummonerSummonState.cpp
index 27ca2555..2bdbe5b5 100644
--- a/GameScripts/SummonerSummonState.cpp
+++ b/GameScripts/SummonerSummonState.cpp
@@ -11,9 +11,8 @@ SummonerSummonState::SummonerSummonState(GameObject* owner)
 
 void SummonerSummonState::OnStateEnter()
 {
-	m_controller = GameObjectAPI::findScript<SummonerEnemyController>(getOwner());
-	m_attackConfig = GameObjectAPI::findScript<SummonerAttackConfig>(getOwner());
-	m_animation = AnimationAPI::getAnimationComponent(getOwner());
+    m_controller = GameObjectAPI::findScript<SummonerEnemyController>(getOwner());
+    m_animation = AnimationAPI::getAnimationComponent(getOwner());
 
 	if (!m_controller)
 	{
@@ -21,12 +20,6 @@ void SummonerSummonState::OnStateEnter()
 		return;
 	}
 
-	if (!m_attackConfig)
-	{
-		Debug::error("[SummonerSummonState] AttackConfig not found.");
-		return;
-	}
-
 	if (!m_animation)
 	{
 		Debug::error("[SummonerSummonState] AnimationComponent not found.");
@@ -41,26 +34,32 @@ void SummonerSummonState::OnStateEnter()
 
 void SummonerSummonState::OnStateUpdate()
 {
-	if (!m_controller || !m_attackConfig || !m_animation)
-	{
-		return;
-	}
-
-	if (m_controller->trySendDeathTrigger(m_animation))
-	{
-		return;
-	}
-
-	m_stateTimer += Time::getDeltaTime();
-
-	if (!m_hasSummoned && m_stateTimer >= m_attackConfig->m_summonCastTime)
-	{
-		m_controller->summonSpidersAroundSelf();
-		m_controller->consumeSummonCooldown();
-		m_hasSummoned = true;
-	}
-
-	if (m_stateTimer >= m_attackConfig->m_summonTotalDuration)
+    if (!m_controller || !m_animation)
+    {
+        return;
+    }
+
+    if (m_controller->trySendDeathTrigger(m_animation))
+    {
+        return;
+    }
+
+    const SummonerAttackConfig* cfg = m_attackConfig.get();
+    if (!cfg)
+    {
+        return;
+    }
+
+    m_stateTimer += Time::getDeltaTime();
+
+    if (!m_hasSummoned && m_stateTimer >= cfg->m_summonCastTime)
+    {
+        m_controller->summonSpidersAroundSelf();
+        m_controller->consumeSummonCooldown();
+        m_hasSummoned = true;
+    }
+
+    if (m_stateTimer >= cfg->m_summonTotalDuration)
 	{
 		AnimationAPI::sendTrigger(m_animation, "ToRecover");
 	}
@@ -74,4 +73,6 @@ void SummonerSummonState::OnStateExit()
 	Debug::log("[SummonerSummonState] EXIT");
 }
 
-IMPLEMENT_SCRIPT(SummonerSummonState)
\ No newline at end of file
+IMPLEMENT_SCRIPT_FIELDS(SummonerSummonState,
+    SERIALIZED_ASSET_REF(m_attackConfig, "Attack Config", AssetType::DATA_CONTAINER)
+)
\ No newline at end of file
diff --git a/GameScripts/SummonerSummonState.h b/GameScripts/SummonerSummonState.h
index f052b4e2..bd625331 100644
--- a/GameScripts/SummonerSummonState.h
+++ b/GameScripts/SummonerSummonState.h
@@ -13,6 +13,7 @@ class SummonerSummonState : public StateMachineScript
 
 public:
 	explicit SummonerSummonState(GameObject* owner);
+	FieldList getExposedFields() const override;
 
 	void OnStateEnter() override;
 	void OnStateUpdate() override;
@@ -20,7 +21,7 @@ class SummonerSummonState : public StateMachineScript
 
 private:
 	SummonerEnemyController* m_controller = nullptr;
-	SummonerAttackConfig* m_attackConfig = nullptr;
+    AssetRef<SummonerAttackConfig> m_attackConfig;
 	AnimationComponent* m_animation = nullptr;
 
 	float m_stateTimer = 0.0f;
diff --git a/GameScripts/TargetIndicatorUI.h b/GameScripts/TargetIndicatorUI.h
index 7454a17f..05aeb4a3 100644
--- a/GameScripts/TargetIndicatorUI.h
+++ b/GameScripts/TargetIndicatorUI.h
@@ -15,7 +15,7 @@ class TargetIndicatorUI : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 protected:
     virtual void onStart() {}
@@ -40,8 +40,8 @@ class TargetIndicatorUI : public Script
     float getDirectionAngleDegrees(const Vector3& direction, float rotationOffsetDegrees) const;
 
 protected:
-    ScriptComponentRef<Transform> m_playerTransform;
-    ScriptComponentRef<Transform> m_targetIndicatorTransform;
+    ComponentRef<Transform> m_playerTransform;
+    ComponentRef<Transform> m_targetIndicatorTransform;
 
     Vector3 m_positionOffset = Vector3(0.0f, 0.05f, 0.0f);
     float m_followSharpness = 20.0f;
diff --git a/GameScripts/TestingButton.cpp b/GameScripts/TestingButton.cpp
index 6b113019..9abf9aeb 100644
--- a/GameScripts/TestingButton.cpp
+++ b/GameScripts/TestingButton.cpp
@@ -37,7 +37,7 @@ void TestingButton::Update()
 
 }
 
-void TestingButton::onFieldEdited(const ScriptFieldInfo& field)
+void TestingButton::onFieldEdited(const FieldInfo& field)
 {
 
 }
diff --git a/GameScripts/TestingButton.h b/GameScripts/TestingButton.h
index b0f1704d..06077a17 100644
--- a/GameScripts/TestingButton.h
+++ b/GameScripts/TestingButton.h
@@ -14,7 +14,7 @@ class TestingButton : public Script
 
     ScriptMethodList getExposedMethods() const override;
 
-    void onFieldEdited(const ScriptFieldInfo& field) override;
+    void onFieldEdited(const FieldInfo& field) override;
     void onAfterDeserialize() override;
 
 public:
diff --git a/GameScripts/TransformGlobalTest.h b/GameScripts/TransformGlobalTest.h
new file mode 100644
index 00000000..0bc6083b
--- /dev/null
+++ b/GameScripts/TransformGlobalTest.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "ScriptAPI.h"
+
+class TransformGlobalTest : public Script
+{
+    DECLARE_SCRIPT(TransformGlobalTest)
+
+public:
+    explicit TransformGlobalTest(GameObject* owner);
+
+    void Start() override;
+    void Update() override;
+
+    FieldList getExposedFields() const override;
+
+public:
+    bool m_runSetGlobalPositionTest = false;
+    bool m_runTranslateGlobalTest = false;
+    bool m_runSetGlobalRotationTest = false;
+    bool m_runLookAtTest = false;
+
+    Vector3 m_targetGlobalPosition = Vector3(10.0f, 0.0f, 0.0f);
+    Vector3 m_translateDelta = Vector3(0.0f, 0.0f, 2.0f);
+    Vector3 m_targetGlobalEuler = Vector3(0.0f, 90.0f, 0.0f);
+    Vector3 m_lookAtTargetWorldPosition = Vector3(10.0f, 0.0f, 10.0f);
+
+private:
+    bool m_loggedInitialState = false;
+};
\ No newline at end of file
diff --git a/GameScripts/TriggerArea.h b/GameScripts/TriggerArea.h
index 0384e0bb..5e729c1b 100644
--- a/GameScripts/TriggerArea.h
+++ b/GameScripts/TriggerArea.h
@@ -16,7 +16,7 @@ class TriggerArea final : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
     float m_xWidth = 2.0f;
@@ -24,8 +24,8 @@ class TriggerArea final : public Script
 
     std::string m_sceneToLoad;
 
-    ScriptComponentRef<Transform> m_firstTarget;
-    ScriptComponentRef<Transform> m_secondTarget;
+    ComponentRef<Transform> m_firstTarget;
+    ComponentRef<Transform> m_secondTarget;
 
 private:
     bool containsPoint(const Vector3& triggerCenter, const Vector3& point) const;
diff --git a/GameScripts/UIPause.h b/GameScripts/UIPause.h
index c65f00f8..92001cb5 100644
--- a/GameScripts/UIPause.h
+++ b/GameScripts/UIPause.h
@@ -17,12 +17,12 @@ class UIPause : public Script
     void ChangeScene(const std::string& sceneName);
     void ToggleControls(bool isOpen);
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
     ScriptMethodList getExposedMethods() const override;
 
 public:
-    ScriptComponentRef<Transform> m_pausePanel;
-    ScriptComponentRef<Transform> m_controlsPanel;
+    ComponentRef<Transform> m_pausePanel;
+    ComponentRef<Transform> m_controlsPanel;
 
 private:
     bool m_isPause = false;
diff --git a/GameScripts/UISplashScreen.h b/GameScripts/UISplashScreen.h
index 7fe42c74..e2c9ae0f 100644
--- a/GameScripts/UISplashScreen.h
+++ b/GameScripts/UISplashScreen.h
@@ -12,14 +12,14 @@ class UISplashScreen : public Script
     void Start() override;
     void Update() override;
 
-    ScriptFieldList getExposedFields() const override;
+    FieldList getExposedFields() const override;
 
 public:
-    ScriptComponentRef<Transform2D> buttonGlow;
-    ScriptComponentRef<Transform2D> logoGlow;
-    ScriptComponentRef<Transform2D> lyrielDeath;
-    ScriptComponentRef<Transform2D> particles1;
-    ScriptComponentRef<Transform2D> particles2;
+    ComponentRef<Transform2D> buttonGlow;
+    ComponentRef<Transform2D> logoGlow;
+    ComponentRef<Transform2D> lyrielDeath;
+    ComponentRef<Transform2D> particles1;
+    ComponentRef<Transform2D> particles2;
     std::string nextSceneName;
 
 private:
diff --git a/export_scripts.ps1 b/export_scripts.ps1
index 80525e2e..b0dbb6de 100644
--- a/export_scripts.ps1
+++ b/export_scripts.ps1
@@ -17,10 +17,8 @@ cp .\Engine_Master_UPC\Keyboard.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\Layer.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\Script.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\ScriptAPI.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptAutoRegister.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptComponentRef.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptCreator.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptFieldInfo.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\ComponentRef.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\FieldInfo.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\Tag.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\Transform.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\UID.h .\export\EngineDependencies\
@@ -31,15 +29,15 @@ cp .\Engine_Master_UPC\ScriptMethodList.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\StateMachineScript.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\UISlider.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\UIFill.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptFieldMacros.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptFieldHandler.h .\export\EngineDependencies\
-cp .\Engine_Master_UPC\ScriptFieldHandlerRegistry.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\FieldMacros.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\FieldHandler.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\FieldHandlerRegistry.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\NavMeshTypes.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\ISerializable.h .\export\EngineDependencies\
 
 cp .\Engine_Master_UPC\PrefabInstance.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\MD5Fwd.h .\export\EngineDependencies\
 
-cp .\Engine_Master_UPC\ScriptFieldTypeTraits.h .\export\EngineDependencies\
+cp .\Engine_Master_UPC\FieldTypeTraits.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\Transform2D.h .\export\EngineDependencies\
 cp .\Engine_Master_UPC\UIRect.h .\export\EngineDependencies\
\ No newline at end of file