diff --git a/include/lighting/ChromaEventData.hpp b/include/lighting/ChromaEventData.hpp
index 8ca176e..57960c0 100644
--- a/include/lighting/ChromaEventData.hpp
+++ b/include/lighting/ChromaEventData.hpp
@@ -18,8 +18,8 @@ namespace Chroma {
     class ChromaEventData {
     private:
         ChromaEventData(const ChromaEventData&) = default;
-        friend class std::unordered_map<GlobalNamespace::BasicBeatmapEventData *, ChromaEventData>;
-        friend class std::pair<GlobalNamespace::BasicBeatmapEventData *const, Chroma::ChromaEventData>;
+        friend class std::unordered_map<GlobalNamespace::BeatmapEventData *, ChromaEventData>;
+        friend class std::pair<GlobalNamespace::BeatmapEventData *const, Chroma::ChromaEventData>;
 
     public:
         ChromaEventData() = default;
@@ -74,12 +74,12 @@ namespace Chroma {
 
         bool LockPosition;
 
-        std::unordered_map<int, std::pair<GlobalNamespace::BasicBeatmapEventData*, ChromaEventData*>> NextSameTypeEvent;
+        std::unordered_map<int, std::pair<GlobalNamespace::BeatmapEventData*, ChromaEventData*>> NextSameTypeEvent;
     };
 
     class ChromaEventDataManager {
     public:
-        using EventMapType = std::unordered_map<GlobalNamespace::BasicBeatmapEventData *, ChromaEventData>;
+        using EventMapType = std::unordered_map<GlobalNamespace::BeatmapEventData *, ChromaEventData>;
         inline static EventMapType ChromaEventDatas;
 
         static void deserialize(CustomJSONData::CustomBeatmapData *beatmapData);
diff --git a/src/lighting/ChromaEventData.cpp b/src/lighting/ChromaEventData.cpp
index b9a4807..88034be 100644
--- a/src/lighting/ChromaEventData.cpp
+++ b/src/lighting/ChromaEventData.cpp
@@ -15,217 +15,219 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
     ChromaEventDatas.clear();
 
     auto beatmapDataCast = beatmapData;
-    auto beatmapEvents = beatmapDataCast->GetBeatmapItemsCpp<GlobalNamespace::BasicBeatmapEventData *>(
-            GlobalNamespace::BeatmapDataItem::BeatmapDataItemType::BeatmapEvent);
-
+    static auto CustomBasicBeatmapEventDataKlass = classof(CustomJSONData::CustomBeatmapEventData*);
 
     bool v2 = beatmapDataCast->v2orEarlier;
 
-    for (auto beatmapEventData: beatmapEvents) {
-        if (!beatmapEventData)
-            continue;
+    for (auto beatmapEvent: beatmapDataCast->beatmapEventDatas) {
 
-        auto customBeatmapEvent = il2cpp_utils::try_cast<CustomJSONData::CustomBeatmapEventData>(beatmapEventData);
-        if (customBeatmapEvent) {
-            auto const &optionalDynData = (*customBeatmapEvent)->customData->value;
+        if (beatmapEvent->klass != CustomBasicBeatmapEventDataKlass) continue;
+        auto customBeatmapEvent = reinterpret_cast<CustomJSONData::CustomBeatmapEventData *>(beatmapEvent);
 
+        auto const &optionalDynData = customBeatmapEvent->customData->value;
 
-            std::optional<ChromaEventData::GradientObjectData> gradientObject = std::nullopt;
 
-            debugSpamLog(contextLogger, "Light gradient");
+        std::optional<ChromaEventData::GradientObjectData> gradientObject = std::nullopt;
 
-            // ASSIGN
-            ChromaEventData chromaEventData;
+        debugSpamLog(contextLogger, "Light gradient");
 
-            if (optionalDynData) {
-                rapidjson::Value const &unwrappedData = *optionalDynData;
+        // ASSIGN
+        ChromaEventData chromaEventData;
 
-#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()) {
-                        auto const &gValue = gradientJSON->value;
+        if (optionalDynData) {
+            rapidjson::Value const &unwrappedData = *optionalDynData;
 
-                        float duration = ChromaUtils::getIfExists<float>(gValue,
-                                                                         Chroma::NewConstants::V2_DURATION).value_or(0);
+#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()) {
+                    auto const &gValue = gradientJSON->value;
 
-                        Sombrero::FastColor initcolor = ChromaUtils::ChromaUtilities::GetColorFromData(gValue,
-                                                                                                       Chroma::NewConstants::V2_START_COLOR).value();
+                    float duration = ChromaUtils::getIfExists<float>(gValue,
+                                                                     Chroma::NewConstants::V2_DURATION).value_or(0);
 
-                        Sombrero::FastColor endcolor = ChromaUtils::ChromaUtilities::GetColorFromData(gValue,
-                                                                                                      Chroma::NewConstants::V2_END_COLOR).value();
+                    Sombrero::FastColor initcolor = ChromaUtils::ChromaUtilities::GetColorFromData(gValue,
+                                                                                                   Chroma::NewConstants::V2_START_COLOR).value();
 
-                        std::string_view easingString = gValue.FindMember(
-                                Chroma::NewConstants::V2_EASING.data())->value.GetString();
+                    Sombrero::FastColor endcolor = ChromaUtils::ChromaUtilities::GetColorFromData(gValue,
+                                                                                                  Chroma::NewConstants::V2_END_COLOR).value();
 
-                        Functions easing;
+                    std::string_view easingString = gValue.FindMember(
+                            Chroma::NewConstants::V2_EASING.data())->value.GetString();
 
-                        if (easingString.empty()) {
-                            easing = Functions::easeLinear;
-                        } else {
-                            easing = FunctionFromStr(easingString);
-                        }
+                    Functions easing;
 
-                        gradientObject = std::make_optional(ChromaEventData::GradientObjectData{
-                                duration,
-                                initcolor,
-                                endcolor,
-                                easing
-                        });
+                    if (easingString.empty()) {
+                        easing = Functions::easeLinear;
+                    } else {
+                        easing = FunctionFromStr(easingString);
                     }
 
+                    gradientObject = std::make_optional(ChromaEventData::GradientObjectData{
+                            duration,
+                            initcolor,
+                            endcolor,
+                            easing
+                    });
+                }
 
-                    auto propId = unwrappedData.FindMember(Chroma::NewConstants::V2_PROPAGATION_ID.data());
-                    // Prop ID is deprecated apparently.  https://github.com/Aeroluna/Chroma/commit/711cb19f7d03a1776a24cef52fd8ef6fd7685a2b#diff-b8fcfff3ebc4ceb7b43d8401d9f50750dc88326d0a87897c5593923e55b23879R41
-                    if (propId != unwrappedData.MemberEnd()) {
-                        rapidjson::Value const &propIDData = propId->value;
 
-                        std::vector<int> propIds;
+                auto propId = unwrappedData.FindMember(Chroma::NewConstants::V2_PROPAGATION_ID.data());
+                // Prop ID is deprecated apparently.  https://github.com/Aeroluna/Chroma/commit/711cb19f7d03a1776a24cef52fd8ef6fd7685a2b#diff-b8fcfff3ebc4ceb7b43d8401d9f50750dc88326d0a87897c5593923e55b23879R41
+                if (propId != unwrappedData.MemberEnd()) {
+                    rapidjson::Value const &propIDData = propId->value;
 
+                    std::vector<int> propIds;
 
-                        if (propIDData.IsNumber()) {
-                            auto propIdLong = propIDData.GetInt();
-                            propIds.push_back(propIdLong);
-                        } else {
-                            // It's a list
-                            if (propIDData.IsObject()) {
-                                auto const &propIDobjects = propIDData.GetObject();
-                                propIds.reserve(propIDobjects.MemberCount());
-
-                                for (auto const &lightId: propIDobjects) {
-                                    auto propId = lightId.value.GetInt64();
-                                    propIds.push_back((int) propId);
-                                }
-                            } else if (propIDData.IsArray()) {
-                                auto const &propIDArray = propIDData.GetArray();
-                                propIds.reserve(propIDArray.Size());
-
-                                for (auto const &lightId: propIDArray) {
-                                    auto propId = lightId.GetInt64();
-                                    propIds.push_back((int) propId);
-                                }
-                            } else {
-                                getLogger().error("Prop id type is not array or number!");
+
+                    if (propIDData.IsNumber()) {
+                        auto propIdLong = propIDData.GetInt();
+                        propIds.push_back(propIdLong);
+                    } else {
+                        // It's a list
+                        if (propIDData.IsObject()) {
+                            auto const &propIDobjects = propIDData.GetObject();
+                            propIds.reserve(propIDobjects.MemberCount());
+
+                            for (auto const &lightId: propIDobjects) {
+                                auto propId = lightId.value.GetInt64();
+                                propIds.push_back((int) propId);
                             }
-                        }
+                        } else if (propIDData.IsArray()) {
+                            auto const &propIDArray = propIDData.GetArray();
+                            propIds.reserve(propIDArray.Size());
 
-                        chromaEventData.PropID = propIds;
+                            for (auto const &lightId: propIDArray) {
+                                auto propId = lightId.GetInt64();
+                                propIds.push_back((int) propId);
+                            }
+                        } else {
+                            getLogger().error("Prop id type is not array or number!");
+                        }
                     }
+
+                    chromaEventData.PropID = propIds;
                 }
+            }
 #pragma endregion
-                auto easingString = getIfExists<std::string>(optionalDynData,
-                                                             v2 ? NewConstants::V2_EASING : NewConstants::EASING);
+            auto easingString = getIfExists<std::string>(optionalDynData,
+                                                         v2 ? NewConstants::V2_EASING : NewConstants::EASING);
 
-                if (easingString) {
-                    Functions easing;
+            if (easingString) {
+                Functions easing;
 
-                    if (easingString->empty()) {
-                        easing = Functions::easeLinear;
-                    } else {
-                        easing = FunctionFromStr(*easingString);
-                    }
-
-                    chromaEventData.Easing = easing;
+                if (easingString->empty()) {
+                    easing = Functions::easeLinear;
+                } else {
+                    easing = FunctionFromStr(*easingString);
                 }
 
-                auto lerpTypeStr = getIfExists<std::string>(optionalDynData,
-                                                            v2 ? NewConstants::V2_LERP_TYPE : NewConstants::LERP_TYPE);
+                chromaEventData.Easing = easing;
+            }
 
-                if (lerpTypeStr) {
-                    LerpType lerpType;
+            auto lerpTypeStr = getIfExists<std::string>(optionalDynData,
+                                                        v2 ? NewConstants::V2_LERP_TYPE : NewConstants::LERP_TYPE);
 
-                    if (easingString->empty()) {
-                        lerpType = LerpType::RGB;
-                    } else {
-                        lerpType = LerpTypeFromString(*easingString);
-                    }
+            if (lerpTypeStr) {
+                LerpType lerpType;
 
-                    chromaEventData.LerpType = lerpType;
+                if (easingString->empty()) {
+                    lerpType = LerpType::RGB;
+                } else {
+                    lerpType = LerpTypeFromString(*easingString);
                 }
 
-                debugSpamLog(contextLogger, "Light ID");
-                auto lightId = unwrappedData.FindMember(
-                        v2 ? NewConstants::V2_LIGHT_ID.data() : NewConstants::LIGHT_ID.data());
+                chromaEventData.LerpType = lerpType;
+            }
 
+            debugSpamLog(contextLogger, "Light ID");
+            auto lightId = unwrappedData.FindMember(
+                    v2 ? NewConstants::V2_LIGHT_ID.data() : NewConstants::LIGHT_ID.data());
 
-                if (lightId != unwrappedData.MemberEnd()) {
-                    rapidjson::Value const &lightIdData = lightId->value;
-                    std::vector<int> lightIds;
 
-                    if (lightIdData.IsNumber()) {
-                        auto lightIdLong = lightIdData.GetInt64();
-                        lightIds.push_back((int) lightIdLong);
+            if (lightId != unwrappedData.MemberEnd()) {
+                rapidjson::Value const &lightIdData = lightId->value;
+                std::vector<int> lightIds;
 
-                    } else if (lightIdData.IsArray()) {
-                        lightIds.reserve(lightIdData.Size());
-                        // It's an array
-                        auto const &lightIDobjects = lightIdData.GetArray();
-                        for (auto const &lightId: lightIDobjects) {
-                            lightIds.push_back(lightId.GetInt());
-                        }
-                    } else {
-                        getLogger().error("Light id type is not array or number!");
-                    }
+                if (lightIdData.IsNumber()) {
+                    auto lightIdLong = lightIdData.GetInt64();
+                    lightIds.push_back((int) lightIdLong);
 
-                    chromaEventData.LightID = lightIds;
+                } else if (lightIdData.IsArray()) {
+                    lightIds.reserve(lightIdData.Size());
+                    // It's an array
+                    auto const &lightIDobjects = lightIdData.GetArray();
+                    for (auto const &lightId: lightIDobjects) {
+                        lightIds.push_back(lightId.GetInt());
+                    }
+                } else {
+                    getLogger().error("Light id type is not array or number!");
                 }
 
+                chromaEventData.LightID = lightIds;
+            }
 
 
-                // Light stuff
-                chromaEventData.ColorData = ChromaUtilities::GetColorFromData(optionalDynData, v2);
-                chromaEventData.GradientObject = gradientObject;
 
-                // RING STUFF
-                chromaEventData.NameFilter = getIfExists<std::string>(optionalDynData, v2 ? NewConstants::V2_NAME_FILTER
-                                                                                          : NewConstants::NAME_FILTER);
-                chromaEventData.Direction = getIfExists<int>(optionalDynData,
-                                                             v2 ? NewConstants::V2_DIRECTION : NewConstants::DIRECTION);
-                chromaEventData.CounterSpin = v2 ? getIfExists<bool>(optionalDynData, NewConstants::V2_COUNTER_SPIN)
-                                                 : std::nullopt;
-                chromaEventData.Reset = v2 ? getIfExists<bool>(optionalDynData, NewConstants::V2_RESET) : std::nullopt;
+            // Light stuff
+            chromaEventData.ColorData = ChromaUtilities::GetColorFromData(optionalDynData, v2);
+            chromaEventData.GradientObject = gradientObject;
 
-                std::optional<float> speed = getIfExists<float>(optionalDynData,
-                                                                v2 ? NewConstants::V2_SPEED : NewConstants::SPEED);
+            // RING STUFF
+            chromaEventData.NameFilter = getIfExists<std::string>(optionalDynData, v2 ? NewConstants::V2_NAME_FILTER
+                                                                                      : NewConstants::NAME_FILTER);
+            chromaEventData.Direction = getIfExists<int>(optionalDynData,
+                                                         v2 ? NewConstants::V2_DIRECTION : NewConstants::DIRECTION);
+            chromaEventData.CounterSpin = v2 ? getIfExists<bool>(optionalDynData, NewConstants::V2_COUNTER_SPIN)
+                                             : std::nullopt;
+            chromaEventData.Reset = v2 ? getIfExists<bool>(optionalDynData, NewConstants::V2_RESET) : std::nullopt;
 
-                if (!speed && v2)
-                    speed = getIfExists<float>(optionalDynData, NewConstants::V2_PRECISE_SPEED);
+            std::optional<float> speed = getIfExists<float>(optionalDynData,
+                                                            v2 ? NewConstants::V2_SPEED : NewConstants::SPEED);
 
-                chromaEventData.Prop = getIfExists<float>(optionalDynData,
-                                                          v2 ? NewConstants::V2_PROP : NewConstants::PROP);
-                chromaEventData.Step = getIfExists<float>(optionalDynData,
-                                                          v2 ? NewConstants::V2_STEP : NewConstants::STEP);
-                chromaEventData.Speed = speed;
-                chromaEventData.Rotation = getIfExists<float>(optionalDynData,
-                                                              v2 ? NewConstants::V2_ROTATION : NewConstants::ROTATION);
-            }
+            if (!speed && v2)
+                speed = getIfExists<float>(optionalDynData, NewConstants::V2_PRECISE_SPEED);
+
+            chromaEventData.Prop = getIfExists<float>(optionalDynData,
+                                                      v2 ? NewConstants::V2_PROP : NewConstants::PROP);
+            chromaEventData.Step = getIfExists<float>(optionalDynData,
+                                                      v2 ? NewConstants::V2_STEP : NewConstants::STEP);
+            chromaEventData.Speed = speed;
+            chromaEventData.Rotation = getIfExists<float>(optionalDynData,
+                                                          v2 ? NewConstants::V2_ROTATION : NewConstants::ROTATION);
+        }
 
-            chromaEventData.StepMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_STEP_MULT, 1.0f) : 1;
-            chromaEventData.PropMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_PROP_MULT, 1.0f) : 1;
-            chromaEventData.SpeedMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_SPEED_MULT, 1.0f) : 1;
+        chromaEventData.StepMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_STEP_MULT, 1.0f) : 1;
+        chromaEventData.PropMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_PROP_MULT, 1.0f) : 1;
+        chromaEventData.SpeedMult = v2 ? getIfExists<float>(optionalDynData, NewConstants::V2_SPEED_MULT, 1.0f) : 1;
 
 
-            // Light stuff again
-            chromaEventData.LockPosition = getIfExists<bool>(optionalDynData, v2 ? NewConstants::V2_LOCK_POSITION
-                                                                                 : NewConstants::LOCK_POSITION, false);
+        // Light stuff again
+        chromaEventData.LockPosition = getIfExists<bool>(optionalDynData, v2 ? NewConstants::V2_LOCK_POSITION
+                                                                             : NewConstants::LOCK_POSITION, false);
 
 
-            ChromaEventDatas.try_emplace(beatmapEventData, std::move(chromaEventData));
-        }
+        ChromaEventDatas.try_emplace(customBeatmapEvent, std::move(chromaEventData));
     }
 
+
     int i = -1;
-    auto beatmapEventsLength = beatmapEvents.size();
+    auto beatmapEventsLength = beatmapDataCast->beatmapEventDatas.size();
 
-    for (auto beatmapEventData: beatmapEvents) {
+    for (auto beatmapEventData: beatmapDataCast->beatmapEventDatas) {
         i++;
-        auto chromaEventDataIt = ChromaEventDatas.find(beatmapEventData);
+
+        auto tryCast = il2cpp_utils::try_cast<GlobalNamespace::BasicBeatmapEventData>(beatmapEventData);
+        if (!tryCast) continue;
+
+        auto basicBeatmapEventData = *tryCast;
+        auto chromaEventDataIt = ChromaEventDatas.find(basicBeatmapEventData);
 
         if (chromaEventDataIt == ChromaEventDatas.end())
             continue;
 
-        auto *customBeatmapEvent = static_cast<CustomJSONData::CustomBeatmapEventData *>(beatmapEventData);
+        auto *customBeatmapEvent = static_cast<CustomJSONData::CustomBeatmapEventData *>(basicBeatmapEventData);
         auto &currentEventData = chromaEventDataIt->second;
 // Horrible stupid logic to get next same type event per light id
         if (currentEventData.LightID) {
@@ -238,11 +240,12 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
                     continue;
                 }
 
-                int nextIndex = FindIndex(beatmapEvents, [type, id](GlobalNamespace::BasicBeatmapEventData *n) {
-                    if (!n)
+                int nextIndex = FindIndex(beatmapDataCast->beatmapEventDatas, [type, id](GlobalNamespace::BeatmapEventData *n) {
+                    auto tryCast = il2cpp_utils::try_cast<GlobalNamespace::BasicBeatmapEventData>(n);
+                    if (!tryCast)
                         return false;
 
-                    if (n->basicBeatmapEventType != type) {
+                    if (tryCast.value()->basicBeatmapEventType != type) {
                         return false;
                     }
 
@@ -258,14 +261,15 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
                 }, i + 1);
 
                 if (nextIndex != -1) {
-                    auto beatmapEvent = beatmapEvents[nextIndex];
+                    auto beatmapEvent = beatmapDataCast->beatmapEventDatas[nextIndex];
                     currentEventData.NextSameTypeEvent[id] = {beatmapEvent, &ChromaEventDatas.at(beatmapEvent)};
                 } else {
-                    int nextIndex = FindIndex(beatmapEvents, [type](GlobalNamespace::BasicBeatmapEventData *n) {
-                        if (!n)
+                    int nextIndex = FindIndex(beatmapDataCast->beatmapEventDatas, [type](GlobalNamespace::BeatmapEventData *n) {
+                        auto tryCast = il2cpp_utils::try_cast<GlobalNamespace::BasicBeatmapEventData>(n);
+                        if (!tryCast)
                             return false;
 
-                        if (n->basicBeatmapEventType != type) {
+                        if (tryCast.value()->basicBeatmapEventType != type) {
                             return false;
                         }
 
@@ -276,7 +280,7 @@ void Chroma::ChromaEventDataManager::deserialize(CustomJSONData::CustomBeatmapDa
                     }, i + 1);
 
                     if (nextIndex != -1) {
-                        auto beatmapEvent = beatmapEvents[nextIndex];
+                        auto beatmapEvent = beatmapDataCast->beatmapEventDatas[nextIndex];
                         currentEventData.NextSameTypeEvent[id] = {beatmapEvent, &ChromaEventDatas.at(beatmapEvent)};
                     }
                 }
diff --git a/src/lighting/ChromaLightSwitchEventEffect.cpp b/src/lighting/ChromaLightSwitchEventEffect.cpp
index d99f9dc..cc2a202 100644
--- a/src/lighting/ChromaLightSwitchEventEffect.cpp
+++ b/src/lighting/ChromaLightSwitchEventEffect.cpp
@@ -257,7 +257,7 @@ void ChromaLightSwitchEventEffect::Refresh(bool hard, const std::optional<std::v
             if (eventData && eventData->NextSameTypeEvent.contains(tween->Id))
             {
                 auto [anextSameTypeEvent, anextEventData] = eventData->NextSameTypeEvent.at(tween->Id);
-                nextSameTypeEvent = anextSameTypeEvent;
+                nextSameTypeEvent = il2cpp_utils::try_cast<BasicBeatmapEventData>(anextSameTypeEvent).value_or(nullptr);
                 nextEventData = anextEventData;
             }
             else