remove invalid runs

Author: abb2k

src/main.cpp

@@ -12,39 +12,51 @@ using namespace geode::prelude;
 
         auto graphs = std::vector<DTGraphInfo>{
             DTGraphInfo{
-                .isEnabled = true,
+                .isEnabled = false,
                 .coverage = static_cast<DTGraphCoverage>(3),
                 .type = static_cast<DTGraphType>(0),
                 .orderPos = 0,
                 .thickness = 1.0f,
                 .outlineThickness = 0.75f,
-                .pointScale = 0.10000000149011612f,
+#if defined(GEODE_IS_MOBILE)
+                .pointScale = 0.175,
+#else
+                .pointScale = 0.1,
+#endif
                 .color = {122, 74, 0, 255},
                 .outlineColor = {101, 50, 0, 255},
                 .pointColor = {164, 76, 0, 255},
                 .name = "session runs"
             },
             DTGraphInfo{
-                .isEnabled = true,
+                .isEnabled = false,
                 .coverage = static_cast<DTGraphCoverage>(2),
                 .type = static_cast<DTGraphType>(0),
                 .orderPos = 1,
                 .thickness = 1.0f,
                 .outlineThickness = 0.75f,
-                .pointScale = 0.10000000149011612f,
+#if defined(GEODE_IS_MOBILE)
+                .pointScale = 0.175,
+#else
+                .pointScale = 0.1,
+#endif
                 .color = {255, 145, 0, 255},
                 .outlineColor = {170, 104, 16, 255},
                 .pointColor = {114, 66, 3, 255},
                 .name = "sess from0"
             },
             DTGraphInfo{
-                .isEnabled = true,
+                .isEnabled = false,
                 .coverage = static_cast<DTGraphCoverage>(1),
                 .type = static_cast<DTGraphType>(0),
                 .orderPos = 2,
                 .thickness = 0.75f,
                 .outlineThickness = 0.5f,
-                .pointScale = 0.07999999821186066f,
+#if defined(GEODE_IS_MOBILE)
+                .pointScale = 0.175,
+#else
+                .pointScale = 0.1,
+#endif
                 .color = {14, 138, 37, 253},
                 .outlineColor = {11, 96, 32, 255},
                 .pointColor = {5, 181, 48, 255},
@@ -57,7 +69,11 @@ using namespace geode::prelude;
                 .orderPos = 3,
                 .thickness = 1.0f,
                 .outlineThickness = 0.75f,
-                .pointScale = 0.10000000149011612f,
+#if defined(GEODE_IS_MOBILE)
+                .pointScale = 0.175,
+#else
+                .pointScale = 0.1,
+#endif
                 .color = {0, 255, 55, 255},
                 .outlineColor = {18, 162, 53, 255},
                 .pointColor = {15, 105, 41, 255},

src/managers/StatsManager.cpp

@@ -314,7 +314,7 @@ Result<> StatsManager::setGeneral(const GeneralData& stats, const std::string& l
 }
 
 Result<> StatsManager::addBackup(const std::string& levelKey, bool saveLevelStats, std::optional<int> sessionsToSave){
-    log::info("adding backup for level {} | {} | {}", levelKey, saveLevelStats, sessionsToSave);
+    //log::info("adding backup for level {} | {} | {}", levelKey, saveLevelStats, sessionsToSave);
     auto metaRes = getMetadata(levelKey);
     if (metaRes.isErr()) return Err("No level to back up! {}", metaRes.unwrapErr());
     auto metadata = metaRes.unwrap();
@@ -536,7 +536,7 @@ void StatsManager::logDeaths(const std::vector<int>& percents) {
 }
 
 void StatsManager::logRun(const Run& run, bool instantSave) {
-    if (currentLevel == nullptr) {
+    if (currentLevel == nullptr || !run.start.has_value()) {
         log::error("Failed to log deaths");
         return;
     }
@@ -549,15 +549,15 @@ void StatsManager::logRun(const Run& run, bool instantSave) {
     }
 
     auto runKey = fmt::format("{}-{}",
-        run.start,
+        run.start.value(),
         run.end
     );
 
     auto session = StatsManager::getCurrentSession();
     if (session != nullptr){
         session->data.runs[runKey]++;
 
-        log::info("logging run {}-{} to session {}", run.start, run.end, session->sessionStartDate);
+        log::info("logging run {}-{} to session {}", run.start.value(), run.end, session->sessionStartDate);
     }
 
     if (currentFrom0.has_value()){
@@ -637,19 +637,26 @@ Result<std::string> StatsManager::getLevelKey(GJGameLevel* const& level) {
 }
 
 Result<Run> StatsManager::splitRunKey(const std::string& runKey) {
+    bool firstNegative = false;
+    if (runKey.size() && runKey[0] == '-')
+        firstNegative = true;
+
     auto runKeySplit = StatsManager::splitStr(runKey, "-");
 
     if (runKeySplit.size() == 0 || runKeySplit.size() > 2)
         return Err("Invalid run key!");
 
-    int start = -1;
+    std::optional<int> start = std::nullopt;
     int end = -1;
 
     if (runKeySplit.size() == 1){
         GEODE_UNWRAP_INTO(end, geode::utils::numFromString<int>(runKeySplit[0]));
+        if (firstNegative)
+            end *= -1;
     }
     else{
-        GEODE_UNWRAP_INTO(start, geode::utils::numFromString<int>(runKeySplit[0]));
+        GEODE_UNWRAP_INTO(int startRes, geode::utils::numFromString<int>(runKeySplit[0]));
+        start = startRes * (firstNegative ? -1 : 1);
         GEODE_UNWRAP_INTO(end, geode::utils::numFromString<int>(runKeySplit[1]));
     }
 
@@ -661,7 +668,7 @@ Result<Run> StatsManager::splitRunKey(const std::string& runKey) {
 }
 
 Result<std::string> StatsManager::createRunKey(const Run& runKey){
-    if (runKey.start == -1){
+    if (runKey.start == std::nullopt){
         return Ok(std::to_string(runKey.end));
     }
     else if (runKey.start >= 0){

src/nodes/DTGraphNode.cpp

@@ -100,9 +100,9 @@ void DTGraphNode::updateGraphContent(){
         auto runStartRes = StatsManager::splitRunKey(death.first);
         if (runStartRes.isErr()) continue;
         auto start = runStartRes.unwrap().start;
-        if (start != -1) {
+        if (start != std::nullopt) {
             if (!hasRunStart || start < RunStartPercent) {
-                RunStartPercent = start;
+                RunStartPercent = start.value();
                 hasRunStart = true;
             }
         }
@@ -124,8 +124,8 @@ void DTGraphNode::updateGraphContent(){
         auto runRes = StatsManager::splitRunKey(death.first);
         if (runRes.isErr()) continue;
 
-        if (runRes.unwrap().start != -1){
-            if (runRes.unwrap().start == runPercent)
+        if (runRes.unwrap().start != std::nullopt){
+            if (runRes.unwrap().start.value() == runPercent)
                 sortedDeaths[runRes.unwrap()] += death.second;
         }
         else

src/nodes/GraphPointDisplay.cpp

@@ -38,12 +38,12 @@ bool GraphPointDisplay::init(){
 }
 
 void GraphPointDisplay::setContent(std::string run, float ratePercent, DTGraphType type, ccColor3B graphInner, ccColor3B graphOuter){
-    auto runInfo = StatsManager::splitRunKey(run).unwrapOr(Run{-1, -1});
+    auto runInfo = StatsManager::splitRunKey(run).unwrapOr(Run{std::nullopt, -1});
 
     std::string runSprFormatted;
-    if (runInfo.start == -1 && runInfo.end == -1)
+    if (runInfo.start == std::nullopt && runInfo.end == -1)
         runSprFormatted = "Error";
-    else if (runInfo.start == -1)
+    else if (runInfo.start == std::nullopt)
         runSprFormatted = fmt::format("{}%", runInfo.end);
     else
         runSprFormatted = fmt::format("{}%-{}%", runInfo.start, runInfo.end);

src/nodes/layers/DTLayer.cpp

@@ -1225,28 +1225,29 @@ bool DTLayer::createDeathsString(const Deaths& deaths, const LevelMetadeta& meta
 
         auto& runSplit = runSplitRes.unwrap();
 
-        bool includeRunStart = runSplit.start != -1;
+        bool includeRunStart = runSplit.start != std::nullopt;
 
         std::string nbDeColor = "";
         std::string nbColor = "";
 
         if (includeRunStart && !ignoreExtraSettings){
             if (!meta.showAnyRun && meta.runsToShow.size()){
-                if (meta.runsToShow.contains(runSplit.start)){
-                    if (meta.runsToShow.at(runSplit.start) > runSplit.end)
+                if (meta.runsToShow.contains(runSplit.start.value())){
+                    if (meta.runsToShow.at(runSplit.start.value()) > runSplit.end)
                         continue;
                 }
                 else{
                     continue;
                 }
             }
             else{
-                if (meta.sharedRunToShow > runSplit.end - runSplit.start)
+                if (meta.sharedRunToShow > runSplit.end - runSplit.start.value())
                     continue;
             }
         }
         else if (!includeRunStart && !ignoreExtraSettings){
-            if (meta.hideUpto > runSplit.end)
+            log::info("a {}", runSplit.end);
+            if (meta.hideUpto > runSplit.end && runSplit.end >= 0)
                 continue;
 
             if (newBests.has_value() && newBests.value().contains(runSplit.end)){
@@ -1255,16 +1256,16 @@ bool DTLayer::createDeathsString(const Deaths& deaths, const LevelMetadeta& meta
             }
         }
 
-        if (prevStart != runSplit.start){
+        if (prevStart != runSplit.start.value_or(-1)){
             if (prevStart != -2){
                 out += "----------{nl}";
             }
-            prevStart = runSplit.start;
+            prevStart = runSplit.start.value_or(-1);
         }
 
         auto format = custom.format;
 
-        std::string toReplaceWith = includeRunStart ? fmt::format("{}-{}", runSplit.start, runSplit.end) : fmt::format("{}", runSplit.end);
+        std::string toReplaceWith = includeRunStart ? fmt::format("{}-{}", runSplit.start.value(), runSplit.end) : fmt::format("{}", runSplit.end);
         format = std::regex_replace(
             format,
             std::regex("\\{per\\}"),
@@ -2265,7 +2266,7 @@ void DTLayer::modifyRun(int startPer, int amount, std::optional<int> sessionNumb
         }
 
         auto newNum = data[runStr] + amount;
-        log::info("{} | {} | {}", amount, data[runStr], newNum);
+        //log::info("{} | {} | {}", amount, data[runStr], newNum);
 
         if (newNum <= 0){
             data.erase(runStr);
@@ -2678,10 +2679,10 @@ long long DTLayer::calcPlaytime(const Deaths& deaths){
         if (runSplitRes.isErr()) continue;
 
         float runLength;
-        if (runSplitRes.unwrap().start == -1)
+        if (runSplitRes.unwrap().start == std::nullopt)
             runLength = runSplitRes.unwrap().end;
         else
-            runLength = (runSplitRes.unwrap().end - runSplitRes.unwrap().start);
+            runLength = (runSplitRes.unwrap().end - runSplitRes.unwrap().start.value());
         // log::info("{} | {} | {}", runLength, runSplitRes.unwrap().end, runSplitRes.unwrap().start);
         // log::info("{}", death.second);
 
@@ -2866,10 +2867,12 @@ UpdateFuture DTLayer::onBestRunsKey(){
         if (splitRunRes.isErr()) continue;
         auto splitRun = splitRunRes.unwrap();
 
-        if (!bestRuns.contains(splitRun.start))
-            bestRuns.insert({splitRun.start, splitRun.end});
-        else if (bestRuns[splitRun.start] < splitRun.end){
-            bestRuns[splitRun.start] = splitRun.end;
+        auto realStart = splitRun.start.value_or(-1);
+
+        if (!bestRuns.contains(realStart))
+            bestRuns.insert({realStart, splitRun.end});
+        else if (bestRuns[realStart] < splitRun.end){
+            bestRuns[realStart] = splitRun.end;
         }
     }
 
@@ -2941,10 +2944,12 @@ UpdateFuture DTLayer::onSessionBestRunsKey(){
         if (splitRunRes.isErr()) continue;
         auto splitRun = splitRunRes.unwrap();
 
-        if (!bestRuns.contains(splitRun.start))
-            bestRuns.insert({splitRun.start, splitRun.end});
-        else if (bestRuns[splitRun.start] < splitRun.end){
-            bestRuns[splitRun.start] = splitRun.end;
+        auto realStart = splitRun.start.value_or(-1);
+
+        if (!bestRuns.contains(realStart))
+            bestRuns.insert({realStart, splitRun.end});
+        else if (bestRuns[realStart] < splitRun.end){
+            bestRuns[realStart] = splitRun.end;
         }
     }
 
@@ -3145,7 +3150,7 @@ UpdateFuture DTLayer::onSectionKey(){
         if (splitDeathRes.isErr()) continue;
         auto splitDeath = splitDeathRes.unwrap();
 
-        if (splitDeath.start == -1){
+        if (splitDeath.start == std::nullopt){
             CreateSectioIDForSectionPair(splitDeath, std::nullopt, death.second);
             continue;
         }
@@ -3154,7 +3159,7 @@ UpdateFuture DTLayer::onSectionKey(){
 
         for (const auto& section : validSections)
         {
-            if (!section.isPercentInSection(splitDeath.start)) continue;
+            if (!section.isPercentInSection(splitDeath.start.value_or(-1))) continue;
 
             startingSectionsForDeath.push_back(section);
         }
@@ -3224,8 +3229,9 @@ UpdateFuture DTLayer::onLevelRunsKey() {
         auto res = StatsManager::splitRunKey(key);
         if (res.isOk()) {
             Run run = res.unwrap();
-            if (run.start <= -1) run.start = 0;
-            if (count > 0 && run.end > run.start) {
+            auto runStartReal = run.start.value_or(-1);
+            if (runStartReal <= -1) runStartReal = 0;
+            if (count > 0 && run.end > runStartReal) {
                 validRuns.push_back(run);
             }
         }

src/nodes/layers/DTLayer.hpp

@@ -120,7 +120,7 @@ class DTLayer : public Popup, public FLAlertLayerProtocol {
         void CleanGetStats();
 
         template<class T>
-        GetTFuture<T> getTFor(geode::Function<T(GeneralData const&)> dataGetter, geode::Function<T(T const&, T const&)> combineFunc, bool session){
+        GetTFuture<T> getTFor(geode::Function<T(GeneralData const&)> dataGetter, geode::Function<T(T const&, T const&)> combineFunc, bool session, bool localOnly = false){
             if (!session){
                 if (m_MyLevelStats.isErr()) co_return Err("Failed to calculate playtime");
                 auto myStats = m_MyLevelStats.unwrap();
@@ -136,12 +136,14 @@ class DTLayer : public Popup, public FLAlertLayerProtocol {
 
                 T all = dataGetter(myFrom0Stats);
 
-                for (const auto& levelData : linkedLevelsCopy)
-                {
-                    co_await arc::yield();
-                    if (levelData.from0.isErr() || levelData.levelKey == myStats.levelKey) continue;
-                    auto levelFrom0Stats = levelData.from0.unwrap();
-                    all = combineFunc(all, dataGetter(levelFrom0Stats));
+                if (!localOnly){
+                    for (const auto& levelData : linkedLevelsCopy)
+                    {
+                        co_await arc::yield();
+                        if (levelData.from0.isErr() || levelData.levelKey == myStats.levelKey) continue;
+                        auto levelFrom0Stats = levelData.from0.unwrap();
+                        all = combineFunc(all, dataGetter(levelFrom0Stats));
+                    }
                 }
 
                 co_return Ok(all);