diff --git a/include/Chroma.hpp b/include/Chroma.hpp
index 63cbaa2..1aa77eb 100644
--- a/include/Chroma.hpp
+++ b/include/Chroma.hpp
@@ -76,6 +76,7 @@ inline static constexpr const std::string_view STEP = "step";
 inline static constexpr const std::string_view RING_ROTATION = "rotation";
 
 inline static constexpr const std::string_view ENVIRONMENT = "environment";
+
 inline static constexpr const std::string_view GAMEOBJECT_ID = "id";
 inline static constexpr const std::string_view GEOMETRY = "geometry";
 inline static constexpr const std::string_view MATERIAL = "material";
diff --git a/include/ChromaEvents.hpp b/include/ChromaEvents.hpp
index 695721d..2a3075f 100644
--- a/include/ChromaEvents.hpp
+++ b/include/ChromaEvents.hpp
@@ -28,7 +28,9 @@ struct AnimateComponentEventData {
   };
 
   AnimateComponentEventData(AnimateComponentEventData&&) = default;
-  AnimateComponentEventData(AnimateComponentEventData const&) = delete;
+
+  [[deprecated("Copy invoked")]]
+  AnimateComponentEventData(AnimateComponentEventData const&) = default;
   ~AnimateComponentEventData() = default;
   AnimateComponentEventData() = default;
   AnimateComponentEventData(float duration, Functions easing, TracksAD::TracksVector track,
@@ -48,18 +50,27 @@ struct CustomEventAssociatedData {
   bool parsed = false;
 
   CustomEventAssociatedData() : data(nullptr) {};
-};
 
-static std::unordered_map<CustomJSONData::CustomEventData const*, CustomEventAssociatedData> eventDataMap;
+  AssignBloomFogTrack* getAssignBloomFogTrack() {
+    return std::get_if<AssignBloomFogTrack>(&data);
+  }
+
+  AnimateComponentEventData* getAnimateComponentEventData() {
+    return std::get_if<AnimateComponentEventData>(&data);
+  }
+};
 
-static CustomEventAssociatedData& getEventAD(CustomJSONData::CustomEventData const* customData) {
-  return eventDataMap[customData];
+static CustomEventAssociatedData& getEventAD(CustomJSONData::CustomEventData const* customEvent) {
+  auto& ad = customEvent->customData->associatedData['C'];
+  if (!ad.has_value()) {
+    ad = std::make_any<ChromaEvents::CustomEventAssociatedData>();
+  }
+  return std::any_cast<ChromaEvents::CustomEventAssociatedData&>(ad);
 }
 
 void deserialize(CustomJSONData::CustomBeatmapData* readOnlyBeatmap);
 
-void parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD, CustomJSONData::CustomEventData const* customEventData,
-                    bool v2);
+void parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD, CustomJSONData::CustomEventData const* customEventData, bool v2);
 
 void AddEventCallbacks();
 } // namespace ChromaEvents
diff --git a/include/ChromaObjectData.hpp b/include/ChromaObjectData.hpp
index 686fb87..c46f3af 100644
--- a/include/ChromaObjectData.hpp
+++ b/include/ChromaObjectData.hpp
@@ -11,6 +11,9 @@ class BeatmapObjectData;
 
 namespace CustomJSONData {
 class CustomBeatmapData;
+class CustomNoteData;
+class CustomObstacleData;
+class CustomSliderData;
 }
 
 // Third-party includes
@@ -18,14 +21,11 @@ class CustomBeatmapData;
 #include "tracks/shared/Animation/PointDefinition.h"
 #include "sombrero/shared/ColorUtils.hpp"
 
+#include "custom-json-data/shared/JSONWrapper.h"
+
 namespace Chroma {
 
 class ChromaObjectData {
-private:
-  ChromaObjectData(ChromaObjectData const&) = default;
-  friend class std::unordered_map<GlobalNamespace::BeatmapObjectData*, ChromaObjectData>;
-  friend class std::pair<GlobalNamespace::BeatmapObjectData* const, Chroma::ChromaObjectData>;
-
 public:
   std::optional<Sombrero::FastColor> Color;
   std::span<TrackW const> Tracks; // probably a bad idea, this could be freed.
@@ -37,14 +37,26 @@ class ChromaObjectData {
 
   ChromaObjectData() = default;
   ChromaObjectData(ChromaObjectData&&) = default;
+
+  [[deprecated("Copy invoked")]]
+  ChromaObjectData(ChromaObjectData const&) = default;
+
+  ChromaObjectData& operator=(ChromaObjectData&&) noexcept = default;
+  ChromaObjectData& operator=(ChromaObjectData const&) = default;
 };
 
 class ChromaObjectDataManager {
 public:
-  using ChromaObjectDataType = std::unordered_map<GlobalNamespace::BeatmapObjectData*, ChromaObjectData>;
-  inline static ChromaObjectDataType ChromaObjectDatas;
-
   static void deserialize(CustomJSONData::CustomBeatmapData* beatmapData);
 };
 
+static ChromaObjectData& getObjectAD(CustomJSONData::JSONWrapper* customData) {
+  auto& ad = customData->associatedData['C'];
+  if (!ad.has_value()) ad = std::make_any<Chroma::ChromaObjectData>();
+  return std::any_cast<Chroma::ChromaObjectData&>(ad);
+}
+
+// defined in ChromaObjectData.cpp to avoid include bloat
+ChromaObjectData* getObjectAD(GlobalNamespace::BeatmapObjectData* obj);
+
 } // namespace Chroma
\ No newline at end of file
diff --git a/include/lighting/ChromaEventData.hpp b/include/lighting/ChromaEventData.hpp
index 0ff3718..d902028 100644
--- a/include/lighting/ChromaEventData.hpp
+++ b/include/lighting/ChromaEventData.hpp
@@ -4,6 +4,7 @@
 
 #include "tracks/shared/Animation/Easings.h"
 
+#include <functional>
 #include <unordered_map>
 
 #include "sombrero/shared/ColorUtils.hpp"
@@ -14,17 +15,18 @@
 namespace GlobalNamespace {
 class BasicBeatmapEventData;
 class BeatmapObjectSpawnController;
-};
+}; // namespace GlobalNamespace
 
 namespace Chroma {
 class ChromaEventData {
-private:
-  ChromaEventData(ChromaEventData const&) = default;
-  friend class std::unordered_map<GlobalNamespace::BeatmapEventData*, ChromaEventData>;
-  friend class std::pair<GlobalNamespace::BeatmapEventData* const, Chroma::ChromaEventData>;
-
 public:
   ChromaEventData() = default;
+  [[deprecated("Copy invoked")]]
+  ChromaEventData(ChromaEventData const&) = default;
+  ChromaEventData(ChromaEventData&&) = default;
+
+  ChromaEventData& operator=(ChromaEventData&&) noexcept = default;
+  ChromaEventData& operator=(ChromaEventData const&) = default;
 
   std::optional<Functions> Easing;
 
@@ -81,10 +83,23 @@ class ChromaEventData {
 
 class ChromaEventDataManager {
 public:
-  using EventMapType = std::unordered_map<GlobalNamespace::BeatmapEventData*, ChromaEventData>;
-  inline static EventMapType ChromaEventDatas;
-
   static void deserialize(CustomJSONData::CustomBeatmapData* beatmapData);
 };
 
+constexpr ChromaEventData& getLightAD(CustomJSONData::JSONWrapper* customData) {
+  auto& ad = customData->associatedData['C'];
+  if (!ad.has_value()) {
+    ad = std::make_any<Chroma::ChromaEventData>();
+  }
+  return std::any_cast<Chroma::ChromaEventData&>(ad);
+}
+
+constexpr ChromaEventData* getLightAD(GlobalNamespace::BeatmapEventData* beatmap) {
+  auto customBeatmapEvent = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmap);
+  if (!customBeatmapEvent) {
+    return nullptr;
+  }
+  return &getLightAD(customBeatmapEvent.value()->customData);
+}
+
 } // namespace Chroma
\ No newline at end of file
diff --git a/src/ChromaEvents.cpp b/src/ChromaEvents.cpp
index d419f71..3fb657e 100644
--- a/src/ChromaEvents.cpp
+++ b/src/ChromaEvents.cpp
@@ -1,37 +1,32 @@
 #include <algorithm>
 #include <utility>
 
-
 #include "ChromaEvents.hpp"
 #include "Chroma.hpp"
 #include "ChromaLogger.hpp"
 #include "lighting/ChromaFogController.hpp"
 #include "ChromaComponentManager.hpp"
 
-
 #include "GlobalNamespace/BeatmapData.hpp"
 #include "GlobalNamespace/BeatmapCallbacksController.hpp"
 
-
 #include "custom-json-data/shared/CustomBeatmapData.h"
 #include "custom-json-data/shared/CustomEventData.h"
 #include "tracks/shared/TimeSourceHelper.h"
 #include "tracks/shared/Vector.h"
 #include "tracks/shared/Json.h"
 
-
-
 using namespace GlobalNamespace;
 using namespace NEVector;
 
-void ChromaEvents::parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD,
-                                  CustomJSONData::CustomEventData const* customEventData, bool v2) {
+void ChromaEvents::parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD, CustomJSONData::CustomEventData const* customEventData,
+                                  bool v2) {
   bool isType = false;
 
   auto typeHash = customEventData->typeHash;
 
-#define TYPE_GET(jsonName, varName)                                                                                    \
-  static auto jsonNameHash_##varName = std::hash<std::string_view>()(jsonName);                                        \
+#define TYPE_GET(jsonName, varName)                                                                                                        \
+  static auto jsonNameHash_##varName = std::hash<std::string_view>()(jsonName);                                                            \
   if (!isType && typeHash == (jsonNameHash_##varName)) isType = true;
 
   TYPE_GET(Chroma::OldConstants::ASSIGNFOGTRACK, ASSIGNFOGTRACK)
@@ -41,25 +36,22 @@ void ChromaEvents::parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD,
     return;
   }
 
-  if (!customEventData->customData || !customEventData->customData->value) {
-    return;
-  }
-
-  rapidjson::Value const& eventData = *customEventData->customData->value;
   auto& eventAD = getEventAD(customEventData);
-
   if (eventAD.parsed) {
     return;
   }
-
+  if (!customEventData->customData  || !customEventData->customData->value) {
+    return;
+  }
   eventAD.parsed = true;
 
+  rapidjson::Value const& eventData = *customEventData->customData->value;
+
   if (typeHash == jsonNameHash_ASSIGNFOGTRACK) {
     auto trackIt = eventData.FindMember((v2 ? Chroma::NewConstants::V2_TRACK : Chroma::NewConstants::TRACK).data());
 
     if (trackIt == eventData.MemberEnd() || trackIt->value.IsNull() || !trackIt->value.IsString()) {
-      ChromaLogger::Logger.debug("Track data is missing for Chroma custom event {}",
-                                 customEventData->____time_k__BackingField);
+      ChromaLogger::Logger.debug("Track data is missing for Chroma custom event {}", customEventData->____time_k__BackingField);
       return;
     }
 
@@ -73,20 +65,18 @@ void ChromaEvents::parseEventData(TracksAD::BeatmapAssociatedData& beatmapAD,
     auto trackIt = eventData.FindMember((v2 ? Chroma::NewConstants::V2_TRACK : Chroma::NewConstants::TRACK).data());
 
     if (trackIt == eventData.MemberEnd() || trackIt->value.IsNull() || !trackIt->value.IsString()) {
-      ChromaLogger::Logger.debug("Track data is missing for Chroma custom event {}",
-                                 customEventData->____time_k__BackingField);
+      ChromaLogger::Logger.debug("Track data is missing for Chroma custom event {}", customEventData->____time_k__BackingField);
       return;
     }
 
     float const duration = NEJSON::ReadOptionalFloat(eventData, Chroma::NewConstants::DURATION.data()).value_or(0);
 
-    auto easing = static_cast<Functions>(NEJSON::ReadOptionalInt(eventData, Chroma::NewConstants::EASING.data())
-                                             .value_or(static_cast<int>(Functions::EaseLinear)));
+    auto easing = static_cast<Functions>(
+        NEJSON::ReadOptionalInt(eventData, Chroma::NewConstants::EASING.data()).value_or(static_cast<int>(Functions::EaseLinear)));
 
     auto tracks = NEJSON::ReadOptionalTracks(eventData, Chroma::NewConstants::TRACK, beatmapAD).value();
 
-    auto const availableNames = { Chroma::NewConstants::BLOOM_FOG_ENVIRONMENT,
-                                  Chroma::NewConstants::TUBE_BLOOM_PRE_PASS_LIGHT };
+    auto const availableNames = { Chroma::NewConstants::BLOOM_FOG_ENVIRONMENT, Chroma::NewConstants::TUBE_BLOOM_PRE_PASS_LIGHT };
     std::unordered_map<std::string_view, std::vector<AnimateComponentEventData::ComponentData>> coroutineInfos;
 
     // eventData -> {
@@ -150,43 +140,41 @@ void ChromaEvents::deserialize(CustomJSONData::CustomBeatmapData* readOnlyBeatma
   }
 }
 
-void CustomEventCallback(BeatmapCallbacksController* callbackController,
-                         CustomJSONData::CustomEventData* customEventData) {
-  PAPER_IL2CPP_CATCH_HANDLER(
-      bool isType = false;
+void CustomEventCallback(BeatmapCallbacksController* callbackController, CustomJSONData::CustomEventData* customEventData) {
 
-      auto typeHash = customEventData->typeHash;
+  bool isType = false;
 
-#define TYPE_GET(jsonName, varName)                                                                                    \
-  static auto jsonNameHash_##varName = std::hash<std::string_view>()(jsonName);                                        \
-  if (!isType && typeHash == (jsonNameHash_##varName)) isType = true;
+  auto typeHash = customEventData->typeHash;
 
-      TYPE_GET(Chroma::OldConstants::ASSIGNFOGTRACK, ASSIGNFOGTRACK)
-          TYPE_GET(Chroma::NewConstants::ANIMATE_COMPONENT, ANIMATE_COMPONENT)
+#define TYPE_GET(jsonName, varName)                                                                                                        \
+  static auto jsonNameHash_##varName = std::hash<std::string_view>()(jsonName);                                                            \
+  if (!isType && typeHash == (jsonNameHash_##varName)) isType = true;
 
-              if (!isType) { return; }
+  TYPE_GET(Chroma::OldConstants::ASSIGNFOGTRACK, ASSIGNFOGTRACK)
+  TYPE_GET(Chroma::NewConstants::ANIMATE_COMPONENT, ANIMATE_COMPONENT)
 
-      auto const& ad = ChromaEvents::getEventAD(customEventData);
+  if (!isType) {
+    return;
+  }
 
-      // fail safe, idek why this needs to be done smh
-      // CJD you bugger
-      auto* customBeatmapData = il2cpp_utils::cast<CustomJSONData::CustomBeatmapData>(callbackController->_beatmapData);
-      if (!ad.parsed) {
-        TracksAD::BeatmapAssociatedData& beatmapAD = TracksAD::getBeatmapAD(customBeatmapData->customData);
-        ChromaEvents::parseEventData(beatmapAD, customEventData, customBeatmapData->v2orEarlier);
-      }
+  auto const& ad = ChromaEvents::getEventAD(customEventData);
 
-      if (typeHash == jsonNameHash_ASSIGNFOGTRACK) {
-        Chroma::ChromaFogController::getInstance()->AssignTrack(
-            std::get<ChromaEvents::AssignBloomFogTrack>(ad.data).track);
-        CJDLogger::Logger.fmtLog<Paper::LogLevel::INF>("Assigned fog controller to track");
-      } if (typeHash == jsonNameHash_ANIMATE_COMPONENT && !customBeatmapData->v2orEarlier) {
-        CJDLogger::Logger.fmtLog<Paper::LogLevel::INF>("Animated component");
-        Chroma::Component::StartEvent(callbackController, customEventData,
-                                      std::get<ChromaEvents::AnimateComponentEventData>(ad.data));
-      }
+  // fail safe, idek why this needs to be done smh
+  // CJD you bugger
+  auto* customBeatmapData = il2cpp_utils::cast<CustomJSONData::CustomBeatmapData>(callbackController->_beatmapData);
+  if (!ad.parsed) {
+    TracksAD::BeatmapAssociatedData& beatmapAD = TracksAD::getBeatmapAD(customBeatmapData->customData);
+    ChromaEvents::parseEventData(beatmapAD, customEventData, customBeatmapData->v2orEarlier);
+  }
 
-  )
+  if (typeHash == jsonNameHash_ASSIGNFOGTRACK) {
+    Chroma::ChromaFogController::getInstance()->AssignTrack(std::get<ChromaEvents::AssignBloomFogTrack>(ad.data).track);
+    CJDLogger::Logger.fmtLog<Paper::LogLevel::INF>("Assigned fog controller to track");
+  }
+  if (typeHash == jsonNameHash_ANIMATE_COMPONENT && !customBeatmapData->v2orEarlier) {
+    CJDLogger::Logger.fmtLog<Paper::LogLevel::INF>("Animated component");
+    Chroma::Component::StartEvent(callbackController, customEventData, std::get<ChromaEvents::AnimateComponentEventData>(ad.data));
+  }
 }
 
 void ChromaEvents::AddEventCallbacks() {
diff --git a/src/ChromaObjectData.cpp b/src/ChromaObjectData.cpp
index cb6dc69..37a51c8 100644
--- a/src/ChromaObjectData.cpp
+++ b/src/ChromaObjectData.cpp
@@ -24,8 +24,6 @@ using namespace ChromaUtils;
 using namespace GlobalNamespace;
 
 void Chroma::ChromaObjectDataManager::deserialize(CustomJSONData::CustomBeatmapData* beatmapData) {
-  ChromaObjectDatas.clear();
-
   auto* beatmapDataCast = beatmapData;
   bool v2 = beatmapDataCast->v2orEarlier;
 
@@ -79,24 +77,6 @@ void Chroma::ChromaObjectDataManager::deserialize(CustomJSONData::CustomBeatmapD
       objectDynData = customObstacleData->customData;
       chromaObjectData.Color = ChromaUtilities::GetColorFromData(objectDynData->value, v2);
     }
-    //                else if (false && ASSIGNMENT_CHECK(CustomWaypointDataKlass,beatmapObjectData->klass)) {
-    //                    debugSpamLog("Custom waypoint");
-    //                    auto *customBeatmapEvent =
-    //                    il2cpp_utils::cast<CustomJSONData::CustomWaypointData>(beatmapObjectData);
-    //
-    //                    // TODO: uncomment when CJD adds customData
-    //                    // bool isCustomData = customBeatmapEvent->customData && customBeatmapEvent->customData->value
-    //                    &&
-    //                    //                customBeatmapEvent->customData->value->IsObject();
-    //                    // dynData = isCustomData ? customBeatmapEvent->customData->value : nullptr;
-    //
-    //                    auto data = std::make_shared<ChromaObjectData>();
-    //
-    //                    data->Color = std::nullopt;
-    //
-    //
-    //                    chromaObjectData = data;
-    //                }
     else {
       continue;
     }
@@ -116,6 +96,20 @@ void Chroma::ChromaObjectDataManager::deserialize(CustomJSONData::CustomBeatmapD
     auto const& tracks = TracksAD::getAD(objectDynData).tracks;
     chromaObjectData.Tracks = tracks;
 
-    ChromaObjectDatas.try_emplace(beatmapObjectData, chromaObjectData);
+    getObjectAD(objectDynData) = std::move(chromaObjectData);
   }
 }
+
+Chroma::ChromaObjectData* Chroma::getObjectAD(GlobalNamespace::BeatmapObjectData* obj) {
+  if (auto note = il2cpp_utils::try_cast<CustomJSONData::CustomNoteData>(obj)) {
+    return &getObjectAD(note.value()->customData);
+  }
+  if (auto obstacle = il2cpp_utils::try_cast<CustomJSONData::CustomObstacleData>(obj)) {
+    return &getObjectAD(obstacle.value()->customData);
+  }
+  if (auto slider = il2cpp_utils::try_cast<CustomJSONData::CustomSliderData>(obj)) {
+    return &getObjectAD(slider.value()->customData);
+  }
+
+  return nullptr;
+}
\ No newline at end of file
diff --git a/src/api/BombAPI.cpp b/src/api/BombAPI.cpp
index 63431c6..3c2e334 100644
--- a/src/api/BombAPI.cpp
+++ b/src/api/BombAPI.cpp
@@ -42,13 +42,13 @@ EXPOSE_API(getBombNoteControllerOverrideColorSafe, OptColor, BombNoteController*
 }
 
 EXPOSE_API(getBombNoteControllerColorSafe, OptColor, BombNoteController* BombNoteController) {
-  auto it = ChromaObjectDataManager::ChromaObjectDatas.find(BombNoteController->_noteData);
+  auto ad = getObjectAD(BombNoteController->_noteData);
 
-  if (it == ChromaObjectDataManager::ChromaObjectDatas.end()) {
+  if (!ad) {
     return OptColorNull;
   }
 
-  auto color = it->second.Color;
+  auto color = ad->Color;
 
   if (!color) {
     return OptColorNull;
diff --git a/src/api/NoteAPI.cpp b/src/api/NoteAPI.cpp
index fcf5b09..def2bb1 100644
--- a/src/api/NoteAPI.cpp
+++ b/src/api/NoteAPI.cpp
@@ -1,3 +1,4 @@
+#include "ChromaObjectData.hpp"
 #include "main.hpp"
 #include "NoteAPI.hpp"
 #include "colorizer/NoteColorizer.hpp"
@@ -34,13 +35,14 @@ EXPOSE_API(getNoteControllerOverrideColorSafe, OptColor, NoteController* noteCon
 }
 
 EXPOSE_API(getNoteControllerColorSafe, OptColor, NoteController* noteController) {
-  auto it = ChromaObjectDataManager::ChromaObjectDatas.find(noteController->_noteData);
 
-  if (it == ChromaObjectDataManager::ChromaObjectDatas.end()) {
+  auto *ad = getObjectAD(noteController->_noteData);
+
+  if (!ad) {
     return OptColorNull;
   }
 
-  auto const& color = it->second.Color;
+  auto const& color = ad->Color;
 
   if (!color) {
     return OptColorNull;
diff --git a/src/hooks/BeatEffectSpawner.cpp b/src/hooks/BeatEffectSpawner.cpp
index 0832601..fbf7d0a 100644
--- a/src/hooks/BeatEffectSpawner.cpp
+++ b/src/hooks/BeatEffectSpawner.cpp
@@ -26,10 +26,10 @@ using namespace Chroma;
 using namespace GlobalNamespace;
 
 static bool BeatEffectHide(bool original, NoteController* noteController) {
-  auto it = ChromaObjectDataManager::ChromaObjectDatas.find(noteController->_noteData);
+  auto it = getObjectAD(noteController->_noteData);
 
-  if (it != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& chromaData = it->second;
+  if (it) {
+    auto const& chromaData = *it;
     std::optional<bool> force = chromaData.SpawnEffect;
 
     if (force.has_value()) {
diff --git a/src/hooks/Events/LightPairRotationEventEffect.cpp b/src/hooks/Events/LightPairRotationEventEffect.cpp
index 032661d..efd2481 100644
--- a/src/hooks/Events/LightPairRotationEventEffect.cpp
+++ b/src/hooks/Events/LightPairRotationEventEffect.cpp
@@ -50,17 +50,15 @@ MAKE_HOOK_MATCH(LightPairRotationEventEffect_UpdateRotationData, &LightPairRotat
     return;
   }
 
-  auto* beatmapEventData = LastLightPairRotationEventEffectData;
-
-  auto chromaIt = ChromaEventDataManager::ChromaEventDatas.find(beatmapEventData);
-
-  // Not found
-  if (chromaIt == ChromaEventDataManager::ChromaEventDatas.end()) {
-    LightPairRotationEventEffect_UpdateRotationData(self, beatmapEventDataValue, rotationData, startRotationOffset, direction);
+  auto beatmapEventDataOpt = getLightAD(LastLightPairRotationEventEffectData);
+  if (!beatmapEventDataOpt) {
+    LightPairRotationEventEffect_UpdateRotationData(self, beatmapEventDataValue, rotationData, startRotationOffset,
+                                                direction);
     return;
   }
 
-  auto const& chromaData = chromaIt->second;
+  auto beatmapEventData = LastLightPairRotationEventEffectData;
+  auto const& chromaData = *beatmapEventDataOpt;
 
   bool isLeftEvent = beatmapEventData->basicBeatmapEventType == self->_eventL;
   // rotationData
diff --git a/src/hooks/Events/LightRotationEventEffect.cpp b/src/hooks/Events/LightRotationEventEffect.cpp
index 13245a5..80b3495 100644
--- a/src/hooks/Events/LightRotationEventEffect.cpp
+++ b/src/hooks/Events/LightRotationEventEffect.cpp
@@ -33,15 +33,15 @@ MAKE_HOOK_MATCH(LightRotationEventEffect_HandleBeatmapObjectCallbackControllerBe
     return;
   }
 
-  auto chromaIt = ChromaEventDataManager::ChromaEventDatas.find(beatmapEventData);
-
-  // Not found
-  if (chromaIt == ChromaEventDataManager::ChromaEventDatas.end()) {
+  auto *chromaDataOpt = getLightAD(beatmapEventData);
+  if (!chromaDataOpt) {
     LightRotationEventEffect_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(self, beatmapEventData);
     return;
   }
 
-  auto const& chromaData = chromaIt->second;
+  // Not found
+
+  auto const& chromaData = *chromaDataOpt;
 
   bool isLeftEvent = self->_event == BasicBeatmapEventType::Event12;
 
diff --git a/src/hooks/Events/TrackLaneRingsPositionStepEffectSpawner.cpp b/src/hooks/Events/TrackLaneRingsPositionStepEffectSpawner.cpp
index 4fd06cd..4a2140a 100644
--- a/src/hooks/Events/TrackLaneRingsPositionStepEffectSpawner.cpp
+++ b/src/hooks/Events/TrackLaneRingsPositionStepEffectSpawner.cpp
@@ -13,30 +13,20 @@ using namespace Chroma;
 using namespace GlobalNamespace;
 
 static float GetPrecisionStep(float const defaultF, GlobalNamespace::BasicBeatmapEventData* beatmapEventData) {
-  auto const& map = ChromaEventDataManager::ChromaEventDatas;
-  auto it = map.find(beatmapEventData);
+  auto const& chromaData = getLightAD(beatmapEventData);
+  if (chromaData && chromaData->Step) {
 
-  if (it != map.end()) {
-    auto const& chromaData = it->second;
-
-    if (chromaData.Step) {
-      return chromaData.Step.value();
-    }
+    return chromaData->Step.value();
   }
 
   return defaultF;
 }
 
 static float GetPrecisionSpeed(float const defaultF, GlobalNamespace::BasicBeatmapEventData* beatmapEventData) {
-  auto const& map = ChromaEventDataManager::ChromaEventDatas;
-  auto it = map.find(beatmapEventData);
-
-  if (it != map.end()) {
-    auto const& chromaData = it->second;
+  auto chromaData = getLightAD(beatmapEventData);
 
-    if (chromaData.Speed) {
-      return chromaData.Speed.value();
-    }
+  if (chromaData && chromaData->Speed) {
+    return chromaData->Speed.value();
   }
 
   return defaultF;
@@ -45,12 +35,10 @@ static float GetPrecisionSpeed(float const defaultF, GlobalNamespace::BasicBeatm
 // Aero why do you have to use transpilers for everything damn it? Just rewrite the method
 MAKE_HOOK_MATCH(TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger,
                 &TrackLaneRingsPositionStepEffectSpawner::HandleBeatmapEvent, void,
-                GlobalNamespace::TrackLaneRingsPositionStepEffectSpawner* self,
-                GlobalNamespace::BasicBeatmapEventData* beatmapEventData) {
+                GlobalNamespace::TrackLaneRingsPositionStepEffectSpawner* self, GlobalNamespace::BasicBeatmapEventData* beatmapEventData) {
   // Essentially, here we cancel the original method. DO NOT call it IF it's a Chroma map
   if (!ChromaController::DoChromaHooks()) {
-    TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(
-        self, beatmapEventData);
+    TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(self, beatmapEventData);
     return;
   }
 
@@ -69,8 +57,7 @@ MAKE_HOOK_MATCH(TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallb
 }
 
 void TrackLaneRingsPositionStepEffectSpawnerHook() {
-  INSTALL_HOOK(ChromaLogger::Logger,
-               TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger);
+  INSTALL_HOOK(ChromaLogger::Logger, TrackLaneRingsPositionStepEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger);
   //    INSTALL_HOOK_OFFSETLESS(ChromaLogger::Logger, SaberManager_Finalize, il2cpp_utils::FindMethodUnsafe("System", "Object",
   //    "Finalize", 0));
 }
diff --git a/src/hooks/Events/TrackLaneRingsRotationEffectSpawner.cpp b/src/hooks/Events/TrackLaneRingsRotationEffectSpawner.cpp
index d44b492..a384a03 100644
--- a/src/hooks/Events/TrackLaneRingsRotationEffectSpawner.cpp
+++ b/src/hooks/Events/TrackLaneRingsRotationEffectSpawner.cpp
@@ -46,8 +46,8 @@ template <typename T> T getValueOrDefault(rapidjson::Value* val, std::string con
   return v != val->MemberEnd() ? v->value.Get<T>() : def;
 }
 
-void TriggerRotation(TrackLaneRingsRotationEffect* trackLaneRingsRotationEffect, bool rotRight, float rotation,
-                     float rotationStep, float rotationPropagationSpeed, float rotationFlexySpeed) {
+void TriggerRotation(TrackLaneRingsRotationEffect* trackLaneRingsRotationEffect, bool rotRight, float rotation, float rotationStep,
+                     float rotationPropagationSpeed, float rotationFlexySpeed) {
   debugSpamLog("DOING TRIGGER ROTATION {}", trackLaneRingsRotationEffect->klass->name);
 
   auto* chromaRingRotation = static_cast<ChromaRingsRotationEffect*>(trackLaneRingsRotationEffect);
@@ -61,8 +61,8 @@ void TriggerRotation(TrackLaneRingsRotationEffect* trackLaneRingsRotationEffect,
 // This method is directly ported from TrackLaneRingsRotationEffectSpawner. It is required to be ported since for some
 // inexplicable reason using the original method causes CJD or something else to stop loading the map and it just stays
 // as limbo. Hopefully with time we can fix that and use that instead
-void origHandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(
-    GlobalNamespace::TrackLaneRingsRotationEffectSpawner* self, BasicBeatmapEventData* beatmapEventData) {
+void origHandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(GlobalNamespace::TrackLaneRingsRotationEffectSpawner* self,
+                                                                     BasicBeatmapEventData* beatmapEventData) {
   if (beatmapEventData->basicBeatmapEventType != self->_beatmapEventType) {
     return;
   }
@@ -87,24 +87,21 @@ void origHandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(
 
     auto* chromaRotation = reinterpret_cast<ChromaRingsRotationEffect*>(rotationEffect.ptr());
 
-    chromaRotation->AddRingRotationEffectF(
-        chromaRotation->GetFirstRingDestinationRotationAngleCpp() +
-            (self->_rotation * static_cast<float>((ChromaController::randomXoshiro() < 0.5F) ? 1 : -1)),
-        step, static_cast<float>(self->_rotationPropagationSpeed), self->_rotationFlexySpeed);
+    chromaRotation->AddRingRotationEffectF(chromaRotation->GetFirstRingDestinationRotationAngleCpp() +
+                                               (self->_rotation * static_cast<float>((ChromaController::randomXoshiro() < 0.5F) ? 1 : -1)),
+                                           step, static_cast<float>(self->_rotationPropagationSpeed), self->_rotationFlexySpeed);
   } else {
-    rotationEffect->AddRingRotationEffect(
-        rotationEffect->GetFirstRingDestinationRotationAngle() +
-            (self->_rotation * static_cast<float>((ChromaController::randomXoshiro() < 0.5F) ? 1 : -1)),
-        step, self->_rotationPropagationSpeed, self->_rotationFlexySpeed);
+    rotationEffect->AddRingRotationEffect(rotationEffect->GetFirstRingDestinationRotationAngle() +
+                                              (self->_rotation * static_cast<float>((ChromaController::randomXoshiro() < 0.5F) ? 1 : -1)),
+                                          step, self->_rotationPropagationSpeed, self->_rotationFlexySpeed);
   }
 }
 
 MAKE_HOOK_MATCH(TrackLaneRingsRotationEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger,
-                &TrackLaneRingsRotationEffectSpawner::HandleBeatmapEvent, void,
-                GlobalNamespace::TrackLaneRingsRotationEffectSpawner* self, BasicBeatmapEventData* beatmapEventData) {
+                &TrackLaneRingsRotationEffectSpawner::HandleBeatmapEvent, void, GlobalNamespace::TrackLaneRingsRotationEffectSpawner* self,
+                BasicBeatmapEventData* beatmapEventData) {
   if (!ChromaController::DoChromaHooks()) {
-    TrackLaneRingsRotationEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(self,
-                                                                                                    beatmapEventData);
+    TrackLaneRingsRotationEffectSpawner_HandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(self, beatmapEventData);
     return;
   }
 
@@ -115,15 +112,15 @@ MAKE_HOOK_MATCH(TrackLaneRingsRotationEffectSpawner_HandleBeatmapObjectCallbackC
   //                      : 1);
 
   if (beatmapEventData->basicBeatmapEventType == self->_beatmapEventType) {
-    auto chromaIt = ChromaEventDataManager::ChromaEventDatas.find(beatmapEventData);
+    auto beatmapEventDataOpt = il2cpp_utils::try_cast<CustomBeatmapEventData>(beatmapEventData);
 
     // Not found
-    if (chromaIt == ChromaEventDataManager::ChromaEventDatas.end()) {
+    if (!beatmapEventDataOpt) {
       origHandleBeatmapObjectCallbackControllerBeatmapEventDidTrigger(self, beatmapEventData);
       return;
     }
 
-    auto const& chromaData = chromaIt->second;
+    auto const& chromaData = getLightAD(beatmapEventDataOpt.value()->customData);
 
     debugSpamLog("Doing stuff with custom Data ring");
 
@@ -188,8 +185,7 @@ MAKE_HOOK_MATCH(TrackLaneRingsRotationEffectSpawner_HandleBeatmapObjectCallbackC
     float propMult = chromaData.PropMult;
     float speedMult = chromaData.SpeedMult;
 
-    TriggerRotation(self->_trackLaneRingsRotationEffect, rotRight, rotation, step * stepMult, prop * propMult,
-                    speed * speedMult);
+    TriggerRotation(self->_trackLaneRingsRotationEffect, rotRight, rotation, step * stepMult, prop * propMult, speed * speedMult);
     debugSpamLog("Finished spawn, returning");
     return;
   }
diff --git a/src/hooks/MovementBeatmapEventEffect.cpp b/src/hooks/MovementBeatmapEventEffect.cpp
index e6a8c95..9e32c58 100644
--- a/src/hooks/MovementBeatmapEventEffect.cpp
+++ b/src/hooks/MovementBeatmapEventEffect.cpp
@@ -59,7 +59,7 @@ using namespace GlobalNamespace;
 //    {
 //        return;
 //    }
-//    if (noteController->_noteData->_time + 0.1f < self->audioTimeSyncController->_songTime)
+//    if (noteController->_noteData->time + 0.1f < self->audioTimeSyncController->songTime)
 //    {
 //        return;
 //    }
diff --git a/src/hooks/colorizer/BombNoteController.cpp b/src/hooks/colorizer/BombNoteController.cpp
index 7ff415a..1b5a0ca 100644
--- a/src/hooks/colorizer/BombNoteController.cpp
+++ b/src/hooks/colorizer/BombNoteController.cpp
@@ -22,9 +22,9 @@ MAKE_HOOK_MATCH(BombNoteController_Init, &BombNoteController::Init, void, BombNo
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(noteData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& color = chromaData->second.Color;
+  auto const& chromaData = getObjectAD(noteData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
     BombColorizer::ColorizeBomb(self, color);
   }
diff --git a/src/hooks/colorizer/BurstSliderController.cpp b/src/hooks/colorizer/BurstSliderController.cpp
index 93954ba..697bfb5 100644
--- a/src/hooks/colorizer/BurstSliderController.cpp
+++ b/src/hooks/colorizer/BurstSliderController.cpp
@@ -55,9 +55,9 @@ MAKE_HOOK_MATCH(BurstSliderGameNoteController_Init, &BurstSliderGameNoteControll
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_noteData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& color = chromaData->second.Color;
+  auto const& chromaData =  getObjectAD(self->_noteData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
     NoteColorizer::ColorizeNote(self, color);
   }
diff --git a/src/hooks/colorizer/ColorNoteVisuals.cpp b/src/hooks/colorizer/ColorNoteVisuals.cpp
index cc64f23..9a8a0e5 100644
--- a/src/hooks/colorizer/ColorNoteVisuals.cpp
+++ b/src/hooks/colorizer/ColorNoteVisuals.cpp
@@ -25,10 +25,10 @@ MAKE_HOOK_MATCH(ColorNoteVisuals_HandleNoteControllerDidInit, &ColorNoteVisuals:
   auto NoteControllerCast = il2cpp_utils::try_cast<NoteController>(noteController);
 
   if (NoteControllerCast) {
-    auto it = ChromaObjectDataManager::ChromaObjectDatas.find(NoteControllerCast.value()->_noteData);
+    auto it = getObjectAD(NoteControllerCast.value()->_noteData);
 
-    if (it != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-      auto const& chromaData = it->second;
+    if (it) {
+      auto const& chromaData = *it;
 
       std::optional<Sombrero::FastColor> const& color = chromaData.Color;
 
diff --git a/src/hooks/colorizer/Note/NoteCutEffectSpawner.cpp b/src/hooks/colorizer/Note/NoteCutEffectSpawner.cpp
index 41affc1..8f9c1a5 100644
--- a/src/hooks/colorizer/Note/NoteCutEffectSpawner.cpp
+++ b/src/hooks/colorizer/Note/NoteCutEffectSpawner.cpp
@@ -24,9 +24,9 @@ using namespace Chroma;
 // If this is true, we disable debris spawning in hooks
 static bool global_DisableDebris_Disable = false;
 static bool DisableDebrisOpt(NoteController* noteController) {
-  auto it = ChromaObjectDataManager::ChromaObjectDatas.find(noteController->_noteData);
-  if (it != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& chromaData = it->second;
+  auto it = getObjectAD(noteController->_noteData);
+  if (it) {
+    auto const& chromaData = *it;
     std::optional<bool> disableDebris = chromaData.DisableDebris;
     return disableDebris.has_value() && disableDebris.value();
   }
diff --git a/src/hooks/colorizer/NoteController.cpp b/src/hooks/colorizer/NoteController.cpp
index 0d443df..55e9321 100644
--- a/src/hooks/colorizer/NoteController.cpp
+++ b/src/hooks/colorizer/NoteController.cpp
@@ -36,9 +36,9 @@ MAKE_HOOK_MATCH(NoteController_Init, &NoteController::Init, void, NoteController
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_noteData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& color = chromaData->second.Color;
+  auto const& chromaData =  getObjectAD(self->_noteData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
     NoteColorizer::ColorizeNote(self, color);
   }
@@ -52,17 +52,20 @@ MAKE_HOOK_MATCH(NoteController_Update, &NoteController::ManualUpdate, void, Note
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_noteData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& tracks = chromaData->second.Tracks;
 
-    auto pathPointDefinition = chromaData->second.LocalPathColor;
+
+  auto const& chromaData =  getObjectAD(self->_noteData);
+  if (chromaData) {
+    auto const& tracks = chromaData->Tracks;
+
+
+    auto pathPointDefinition = chromaData->LocalPathColor;
     if (!tracks.empty() || pathPointDefinition) {
       NoteJump* noteJump = self->_noteMovement->_jump;
       VariableMovementW movement(noteJump->_variableMovementDataProvider);
       float jumpDuration = movement.jumpDuration;
       float elapsedTime = ChromaTimeSourceHelper::getSongTimeChroma(noteJump->_audioTimeSyncController) -
-                          (self->_noteData->_time_k__BackingField - (jumpDuration * 0.5F));
+                          (self->_noteData->time - (jumpDuration * 0.5F));
       float normalTime = elapsedTime / jumpDuration;
 
       [[maybe_unused]] bool updated = false;
diff --git a/src/hooks/colorizer/ObstacleController.cpp b/src/hooks/colorizer/ObstacleController.cpp
index 6bd739e..dcbd780 100644
--- a/src/hooks/colorizer/ObstacleController.cpp
+++ b/src/hooks/colorizer/ObstacleController.cpp
@@ -32,9 +32,9 @@ MAKE_HOOK_MATCH(ObstacleController_Init, &ObstacleController::Init, void, Obstac
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(obstacleData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& color = chromaData->second.Color;
+  auto const& chromaData =  getObjectAD(obstacleData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
     ObstacleColorizer::ColorizeObstacle(self, color);
   }
@@ -50,18 +50,21 @@ MAKE_HOOK_MATCH(ObstacleController_ManualUpdate, &ObstacleController::ManualUpda
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_obstacleData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
+  auto const& chromaData =  getObjectAD(self->_obstacleData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
-    auto const& tracks = chromaData->second.Tracks;
+    auto const& tracks = chromaData->Tracks;
 
-    auto const& pathPointDefinition = chromaData->second.LocalPathColor;
+    auto const& pathPointDefinition = chromaData->LocalPathColor;
     if (!tracks.empty() || pathPointDefinition) {
       VariableMovementW movement(self->_variableMovementDataProvider);
 
       float jumpDuration = movement.jumpDuration;
-      float elapsedTime = ChromaTimeSourceHelper::getSongTimeChroma(self->_audioTimeSyncController) - self->_startTimeOffset;
-      float normalTime = (elapsedTime - movement.moveDuration) / (jumpDuration + self->_obstacleData->_duration_k__BackingField);
+      float elapsedTime =
+          ChromaTimeSourceHelper::getSongTimeChroma(self->_audioTimeSyncController) - self->_startTimeOffset;
+      float normalTime =
+          (elapsedTime - movement.moveDuration) / (jumpDuration + self->_obstacleData->duration);
 
       [[maybe_unused]] bool updated = false;
       std::optional<Sombrero::FastColor> colorOffset =
diff --git a/src/hooks/colorizer/SliderController.cpp b/src/hooks/colorizer/SliderController.cpp
index 6c7a8e2..6e4bac9 100644
--- a/src/hooks/colorizer/SliderController.cpp
+++ b/src/hooks/colorizer/SliderController.cpp
@@ -30,9 +30,9 @@ MAKE_HOOK_MATCH(SliderController_Init, &SliderController::Init, void, SliderCont
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_sliderData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& color = chromaData->second.Color;
+  auto const& chromaData =  getObjectAD(self->_sliderData);
+  if (chromaData) {
+    auto const& color = chromaData->Color;
 
     if (color) {
       SliderColorizer::ColorizeSlider(self, color);
@@ -48,17 +48,17 @@ MAKE_HOOK_MATCH(SliderController_Update, &SliderController::ManualUpdate, void,
     return;
   }
 
-  auto chromaData = ChromaObjectDataManager::ChromaObjectDatas.find(self->_sliderData);
-  if (chromaData != ChromaObjectDataManager::ChromaObjectDatas.end()) {
-    auto const& tracks = chromaData->second.Tracks;
+  auto const& chromaData =  getObjectAD(self->_sliderData);
+  if (chromaData) {
+    auto const& tracks = chromaData->Tracks;
 
-    auto pathPointDefinition = chromaData->second.LocalPathColor;
+    auto pathPointDefinition = chromaData->LocalPathColor;
     if (!tracks.empty() || pathPointDefinition) {
       VariableMovementW movement(self->_sliderMovement->_variableMovementDataProvider);
       float jumpDuration = movement.jumpDuration;
 
-      float duration = (jumpDuration * 0.75F) + (self->_sliderData->_tailTime_k__BackingField - self->_sliderData->_time_k__BackingField);
-      float normalTime = self->_sliderMovement->_timeSinceHeadNoteJump / (jumpDuration + duration);
+      float duration = (jumpDuration * 0.75F) + (self->_sliderData->tailTime - self->_sliderData->time);
+      float normalTime = self->sliderMovement->timeSinceHeadNoteJump / (jumpDuration + duration);
 
       [[maybe_unused]] bool updated = false;
       std::optional<Sombrero::FastColor> colorOffset =
diff --git a/src/lighting/ChromaEventData.cpp b/src/lighting/ChromaEventData.cpp
index 39ce487..212493e 100644
--- a/src/lighting/ChromaEventData.cpp
+++ b/src/lighting/ChromaEventData.cpp
@@ -13,43 +13,35 @@
 using namespace ChromaUtils;
 
 void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapData* beatmapData) {
-  ChromaEventDatas.clear();
-
   auto* beatmapDataCast = beatmapData;
-  static auto* CustomBasicBeatmapEventDataKlass = classof(CustomJSONData::CustomBeatmapEventData*);
 
   bool v2 = beatmapDataCast->v2orEarlier;
 
   auto const& beatmapEventDatas = beatmapDataCast->beatmapEventDatas;
 
+  ChromaLogger::Logger.debug("Deserializing Chroma events, count: {}", beatmapEventDatas.size());
   for (auto* beatmapEvent : beatmapEventDatas) {
 
-    if (beatmapEvent->klass != CustomBasicBeatmapEventDataKlass) {
+    auto customBeatmapEvent = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmapEvent);
+
+    if (!customBeatmapEvent) {
       continue;
     }
-    auto* customBeatmapEvent = reinterpret_cast<CustomJSONData::CustomBeatmapEventData*>(beatmapEvent);
-    if (!customBeatmapEvent->customData) {
+
+    if (!customBeatmapEvent.value()->customData) {
       continue;
     }
-    auto const& optionalDynData = customBeatmapEvent->customData->value;
+    auto const& optionalDynData = customBeatmapEvent.value()->customData->value;
 
-    std::optional<ChromaEventData::GradientObjectData> gradientObject = std::nullopt;
-
-    debugSpamLog("Light gradient");
 
     // ASSIGN
-    ChromaEventData chromaEventData;
-    if (!optionalDynData.has_value()) {
-      continue;
-    }
+    ChromaEventData& chromaEventData = getLightAD(customBeatmapEvent.value()->customData);
     if (optionalDynData) {
       rapidjson::Value const& unwrappedData = *optionalDynData;
 
-#pragma region V2 Gradients and prop
       if (v2) {
         auto gradientJSON = unwrappedData.FindMember(NewConstants::V2_LIGHT_GRADIENT.data());
-        if (gradientJSON != unwrappedData.MemberEnd() && !gradientJSON->value.IsNull() &&
-            gradientJSON->value.IsObject()) {
+        if (gradientJSON != unwrappedData.MemberEnd() && !gradientJSON->value.IsNull() && gradientJSON->value.IsObject()) {
           auto const& gValue = gradientJSON->value;
 
           float duration = ChromaUtils::getIfExists<float>(gValue, Chroma::NewConstants::V2_DURATION).value_or(0);
@@ -57,8 +49,7 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
           Sombrero::FastColor initcolor =
               ChromaUtils::ChromaUtilities::GetColorFromData(gValue, Chroma::NewConstants::V2_START_COLOR).value();
 
-          Sombrero::FastColor endcolor =
-              ChromaUtils::ChromaUtilities::GetColorFromData(gValue, Chroma::NewConstants::V2_END_COLOR).value();
+          Sombrero::FastColor endcolor = ChromaUtils::ChromaUtilities::GetColorFromData(gValue, Chroma::NewConstants::V2_END_COLOR).value();
 
           std::string_view easingString = gValue.FindMember(Chroma::NewConstants::V2_EASING.data())->value.GetString();
 
@@ -70,8 +61,8 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
             easing = FunctionFromStr(easingString);
           }
 
-          gradientObject = std::make_optional(ChromaEventData::GradientObjectData{
-              .Duration = duration, .StartColor = initcolor, .EndColor = endcolor, .Easing = easing });
+          chromaEventData.GradientObject = std::make_optional(
+              ChromaEventData::GradientObjectData{ .Duration = duration, .StartColor = initcolor, .EndColor = endcolor, .Easing = easing });
         }
 
         auto propId = unwrappedData.FindMember(Chroma::NewConstants::V2_PROPAGATION_ID.data());
@@ -111,9 +102,8 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
           chromaEventData.PropID = propIds;
         }
       }
-#pragma endregion
-      auto easingString =
-          getIfExistsOpt<std::string>(optionalDynData, v2 ? NewConstants::V2_EASING : NewConstants::EASING);
+
+      auto easingString = getIfExistsOpt<std::string>(optionalDynData, v2 ? NewConstants::V2_EASING : NewConstants::EASING);
 
       if (easingString) {
         Functions easing;
@@ -127,8 +117,7 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
         chromaEventData.Easing = easing;
       }
 
-      auto lerpTypeStr =
-          getIfExistsOpt<std::string>(optionalDynData, v2 ? NewConstants::V2_LERP_TYPE : NewConstants::LERP_TYPE);
+      auto lerpTypeStr = getIfExistsOpt<std::string>(optionalDynData, v2 ? NewConstants::V2_LERP_TYPE : NewConstants::LERP_TYPE);
 
       if (lerpTypeStr) {
         LerpType lerpType;
@@ -142,7 +131,6 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
         chromaEventData.LerpType = lerpType;
       }
 
-      debugSpamLog("Light ID");
       auto lightId = unwrappedData.FindMember(v2 ? NewConstants::V2_LIGHT_ID.data() : NewConstants::LIGHT_ID.data());
 
       if (lightId != unwrappedData.MemberEnd()) {
@@ -169,19 +157,16 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
 
       // Light stuff
       chromaEventData.ColorData = ChromaUtilities::GetColorFromData(optionalDynData, v2);
-      chromaEventData.GradientObject = gradientObject;
+
 
       // RING STUFF
       chromaEventData.NameFilter =
           getIfExistsOpt<std::string>(optionalDynData, v2 ? NewConstants::V2_NAME_FILTER : NewConstants::NAME_FILTER);
-      chromaEventData.Direction =
-          getIfExistsOpt<int>(optionalDynData, v2 ? NewConstants::V2_DIRECTION : NewConstants::DIRECTION);
-      chromaEventData.CounterSpin =
-          v2 ? getIfExistsOpt<bool>(optionalDynData, NewConstants::V2_COUNTER_SPIN) : std::nullopt;
+      chromaEventData.Direction = getIfExistsOpt<int>(optionalDynData, v2 ? NewConstants::V2_DIRECTION : NewConstants::DIRECTION);
+      chromaEventData.CounterSpin = v2 ? getIfExistsOpt<bool>(optionalDynData, NewConstants::V2_COUNTER_SPIN) : std::nullopt;
       chromaEventData.Reset = v2 ? getIfExistsOpt<bool>(optionalDynData, NewConstants::V2_RESET) : std::nullopt;
 
-      std::optional<float> speed =
-          getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_SPEED : NewConstants::SPEED);
+      std::optional<float> speed = getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_SPEED : NewConstants::SPEED);
 
       if (!speed && v2) {
         speed = getIfExistsOpt<float>(optionalDynData, NewConstants::V2_PRECISE_SPEED);
@@ -190,8 +175,7 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
       chromaEventData.Prop = getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_PROP : NewConstants::PROP);
       chromaEventData.Step = getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_STEP : NewConstants::STEP);
       chromaEventData.Speed = speed;
-      chromaEventData.Rotation =
-          getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_ROTATION : NewConstants::ROTATION);
+      chromaEventData.Rotation = getIfExistsOpt<float>(optionalDynData, v2 ? NewConstants::V2_ROTATION : NewConstants::ROTATION);
     }
 
     chromaEventData.StepMult = v2 ? getIfExistsOpt<float>(optionalDynData, NewConstants::V2_STEP_MULT, 1.0F) : 1;
@@ -201,8 +185,6 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
     // Light stuff again
     chromaEventData.LockPosition =
         getIfExistsOpt<bool>(optionalDynData, v2 ? NewConstants::V2_LOCK_POSITION : NewConstants::LOCK_POSITION, false);
-
-    ChromaEventDatas.try_emplace(customBeatmapEvent, std::move(chromaEventData));
   }
 
   // Horrible stupid logic to get next same type event per light id
@@ -211,26 +193,21 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
   if (beatmapEventDatas.size() == 0) {
     return;
   }
-  for (auto *beatmapEventData : std::ranges::reverse_view(beatmapEventDatas)) {
-     auto const& basicBeatmapEventDataOpt =
-        il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmapEventData);
+  for (auto* beatmapEventData : std::ranges::reverse_view(beatmapEventDatas)) {
+    auto basicBeatmapEventDataOpt = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmapEventData);
     if (!basicBeatmapEventDataOpt) {
       continue;
     }
     auto const& basicBeatmapEventData = *basicBeatmapEventDataOpt;
 
-    auto eventDataIt = ChromaEventDatas.find(beatmapEventData);
-    if (eventDataIt == ChromaEventDatas.end()) {
-      continue;
-    }
-    auto& currentEventData = eventDataIt->second;
+    auto& currentEventData = getLightAD(basicBeatmapEventData->customData);
 
     int type = (int)basicBeatmapEventData->basicBeatmapEventType.value__;
     auto& nextSameTypes = allNextSameTypes[type];
 
     if (currentEventData.NextSameTypeEvent.empty()) {
       for (auto const& [k, v] : nextSameTypes) {
-        currentEventData.NextSameTypeEvent[k] = std::pair(v, &ChromaEventDatas.at(v));
+        currentEventData.NextSameTypeEvent[k] = std::pair(v, &getLightAD(v->customData));
       }
     }
 
diff --git a/src/lighting/ChromaLightSwitchEventEffect.cpp b/src/lighting/ChromaLightSwitchEventEffect.cpp
index ffa81c4..7591b91 100644
--- a/src/lighting/ChromaLightSwitchEventEffect.cpp
+++ b/src/lighting/ChromaLightSwitchEventEffect.cpp
@@ -112,17 +112,18 @@ void Chroma::ChromaLightSwitchEventEffect::HandleEvent(GlobalNamespace::BasicBea
 
   // fun fun chroma stuff
 
-  auto chromaIt = ChromaEventDataManager::ChromaEventDatas.find(beatmapEventData);
+  auto beatmapEventDataOpt = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmapEventData);
 
   // Aero thinks legacy was a mistake. I think a Quest port was a bigger mistake.
   std::optional<Sombrero::FastColor> color;
 
-  if (chromaIt == ChromaEventDataManager::ChromaEventDatas.end()) {
+  if (!beatmapEventDataOpt) {
     color = LegacyLightHelper::GetLegacyColor(beatmapEventData);
   } else {
     debugSpamLog("Color is legacy? {}", color ? "true" : "false");
 
-    auto const& chromaData = chromaIt->second;
+    auto const& chromaData = getLightAD(beatmapEventDataOpt.value()->customData);
+
 
     auto const& lightMember = chromaData.LightID;
     auto const& propMember = chromaData.PropID;
@@ -226,8 +227,9 @@ void ChromaLightSwitchEventEffect::Refresh(bool hard, std::optional<std::vector<
     float previousFloatValue = previousEvent->floatValue;
 
     auto CheckNextEventForFadeBetter = [&, this, hard, easing, lerpType]() {
-      auto eventDataIt = ChromaEventDataManager::ChromaEventDatas.find(previousEvent);
-      auto const* eventData = eventDataIt != ChromaEventDataManager::ChromaEventDatas.end() ? &eventDataIt->second : nullptr;
+      auto previousEventOpt = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(previousEvent);
+
+      auto const* eventData = getLightAD(previousEvent);
 
       auto const& nextSameTypesDict = eventData != nullptr ? &eventData->NextSameTypeEvent : nullptr;
 
@@ -259,9 +261,11 @@ void ChromaLightSwitchEventEffect::Refresh(bool hard, std::optional<std::vector<
       EnvironmentColorType nextColorType = GetLightColorTypeFromEventDataValue(nextSameTypeEvent->value);
       Sombrero::FastColor nextColor;
 
-      eventDataIt = ChromaEventDataManager::ChromaEventDatas.find(nextSameTypeEvent);
+      previousEventOpt = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(nextSameTypeEvent);
+
+
       if (nextEventData == nullptr) {
-        nextEventData = eventDataIt != ChromaEventDataManager::ChromaEventDatas.end() ? &eventDataIt->second : nullptr;
+        nextEventData = getLightAD(nextSameTypeEvent);
       }
 
       std::optional<Sombrero::FastColor> nextColorData = nextEventData != nullptr ? nextEventData->ColorData : std::nullopt;