mock thumbnail idek if this works

Author: BlueWitherer

src/main.cpp

@@ -1,23 +1,103 @@
 #include "popup/HorribleMenuPopup.hpp"
 
+#include <fmt/core.h>
+
 #include <Geode/Geode.hpp>
 
-#include <Geode/modify/CCMenuItem.hpp>
 #include <Geode/modify/MenuLayer.hpp>
+#include <Geode/modify/CCLayer.hpp>
+#include <Geode/modify/CCMenuItem.hpp>
 
 #include <Geode/binding/FMODAudioEngine.hpp>
 
 using namespace geode::prelude;
+using namespace geode::utils;
+using namespace matjson;
 
 auto horribleMod = getMod();
 
+class $modify(HorribleCCLayer, CCLayer) {
+    bool init() {
+        if (!CCLayer::init()) return false;
+
+        log::debug("Hooked Cocos layer {}", getID());
+
+        if (horribleMod && horribleMod->getSavedValue<bool>("mock", false)) {
+            if (auto b = true) { // change to random chance
+                auto mockConfigPath = fmt::format("{}\\mock.json", horribleMod->getSaveDir());
+                auto mockConfig = file::readJson(std::filesystem::path(mockConfigPath));
+
+                if (mockConfig.isOk()) {
+                    auto mockConfigUnwr = mockConfig.unwrapOr(Value());
+
+                    std::srand(static_cast<unsigned int>(std::time(nullptr)));
+                    int randInd = std::rand() % mockConfigUnwr.size(); // random index of the matjson
+
+                    auto lvl = mockConfigUnwr.get(as<size_t>(randInd));
+
+                    if (lvl.isOk()) {
+                        auto lvlUnwr = lvl.unwrap();
+
+                        auto id = lvlUnwr.getKey().value_or("");
+                        auto percent = lvlUnwr.asInt().unwrapOr(99);
+
+                        if (!id.empty()) {
+                            std::string path = fmt::format("{}\\{}.png", horribleMod->getSaveDir(), id);
+
+                            // screenshot sprite
+                            auto ss = LazySprite::create({ 192.f, 108.f });
+                            ss->setID("mock"_spr);
+                            ss->setAnchorPoint({ 0.5, 0.5 });
+                            ss->setPosition({ -192.f, -108.f });
+
+                            ss->setLoadCallback([this, ss, percent](Result<> res) {
+                                if (res.isOk()) {
+                                    // Success: scale and position the sprite
+                                    log::info("Sprite loaded successfully");
+
+                                    float yA = as<float>(std::rand()) / RAND_MAX; // first y pos %
+                                    float yB = as<float>(std::rand()) / RAND_MAX; // last y pos %
+
+                                    auto percLabelText = fmt::format("{}%", std::to_string(percent));
+
+                                    auto percLabel = CCLabelBMFont::create(percLabelText.c_str(), "bigFont.fnt");
+                                    percLabel->setPosition({ ss->getScaledContentWidth() / 2.f, ss->getScaledContentHeight() / 2.f });
+
+                                    ss->setPositionY(getScaledContentHeight() * yA);
+                                    ss->setRotation(360.f * (yA * yB));
+
+                                    auto move = CCEaseIn::create(CCMoveTo::create(7.5f, { getScaledContentWidth() + 192.f, getScaledContentHeight() * yB }), 1.f);
+                                    auto rotate = CCEaseOut::create(CCRotateBy::create(12.5f, 45.f), 1.f);
+
+                                    auto action = CCSpawn::createWithTwoActions(move, rotate);
+                                    ss->runAction(action);
+
+                                    log::info("Animated sprite successfully");
+                                } else {
+                                    log::error("Sprite failed to load: {}", res.unwrapErr());
+                                    ss->removeMeAndCleanup();
+                                };
+                                                });
+
+                            ss->loadFromFile(std::filesystem::path(path));
+                            addChild(ss);
+                        };
+                    };
+                };
+            };
+        };
+
+        return true;
+    };
+};
+
 // modify CCMenuItem so it plays the sound whenever a button is clicked regardless of the layer
-class $modify(HorribleMenuItem, CCMenuItem) {
+class $modify(HorribleCCMenuItem, CCMenuItem) {
     void activate() override {
         if (horribleMod && horribleMod->getSavedValue<bool>("achieve", true)) {
             if (auto fmod = FMODAudioEngine::sharedEngine()) {
                 // @geode-ignore(unknown-resource)
-                if ((rand() % 50) == 0) fmod->playEffect("achievement_01.ogg"); // 50/50 chance of playing
+                if ((rand() % 75) == 0) fmod->playEffect("achievement_01.ogg"); // 75% chance of playing
             };
         };
 
@@ -35,12 +115,14 @@ class $modify(MyMenuLayer, MenuLayer) {
                 "GJ_moonsIcon_001.png",
                 0.875f,
                 CircleBaseColor::Green,
-                CircleBaseSize::MediumAlt);
+                CircleBaseSize::MediumAlt
+            );
 
             auto btn = CCMenuItemSpriteExtra::create(
                 btnSprite,
                 this,
-                menu_selector(MyMenuLayer::onHorribleButton));
+                menu_selector(MyMenuLayer::onHorribleButton)
+            );
             btn->setID("horribleBtn");
 
             if (auto menu = typeinfo_cast<CCMenu*>(bottomMenu)) {
@@ -49,6 +131,34 @@ class $modify(MyMenuLayer, MenuLayer) {
             };
         };
 
+        // TESTING
+
+        // DELETE LATER
+
+        auto ss = CCSprite::createWithSpriteFrameName("GJLargeLock_001.png");
+        ss->setPosition({ -192.f, 108.f });
+        ss->setZOrder(501);
+
+        addChild(ss);
+
+        float yA = as<float>(std::rand()) / RAND_MAX; // first y pos %
+        float yB = as<float>(std::rand()) / RAND_MAX; // last y pos %
+
+        ss->setPositionY(getScaledContentHeight() * yA);
+        ss->setRotation(360.f * (yA * yB));
+
+        auto move = CCEaseIn::create(CCMoveTo::create(7.5f, { getScaledContentWidth() + 192.f, getScaledContentHeight() * yB }), 1.f);
+        auto rotate = CCEaseOut::create(CCRotateBy::create(12.5f, 45.f), 1.f);
+
+        auto action = CCSpawn::createWithTwoActions(move, rotate);
+        ss->runAction(action);
+
+        log::info("Animated sprite successfully");
+
+        // DELETE LATER
+
+        // TESTING
+
         return true;
     };
 

src/modified/LevelManager.cpp

@@ -6,6 +6,7 @@ using namespace geode::prelude;
 namespace LevelManager {
     void DownloadGriefLevel() {
         auto horribleMod = getMod();
+
         if (horribleMod->getSavedValue<bool>("grief", false)) {
             auto glm = GameLevelManager::get();
             auto mdm = MusicDownloadManager::sharedState();
@@ -25,9 +26,11 @@ namespace LevelManager {
 
     void DownloadCongregLevel() {
         auto horribleMod = getMod();
+
         if (horribleMod->getSavedValue<bool>("congregation", false)) {
             auto glm = GameLevelManager::get();
             auto mdm = MusicDownloadManager::sharedState();
+
             auto level = glm->getSavedLevel(93437568);
 
             if (glm->hasDownloadedLevel(93437568)) {

src/modified/PlayLayer.cpp

@@ -1,3 +1,5 @@
+#include <fmt/core.h>
+
 #include <Geode/Geode.hpp>
 
 #include <Geode/utils/terminate.hpp>
@@ -8,6 +10,8 @@
 #include "LevelManager.hpp"
 
 using namespace geode::prelude;
+using namespace geode::utils;
+using namespace matjson;
 
 class $modify(HorriblePlayLayer, PlayLayer) {
     struct Fields {
@@ -175,9 +179,12 @@ class $modify(HorriblePlayLayer, PlayLayer) {
 
                 if (congregLevel && !congregLevel->m_levelNotDownloaded && (!m_level || m_level->m_levelID.value() != 93437568)) {
                     PlayLayer::destroyPlayer(player, game);
+
                     onExit();
+
                     auto scene = PlayLayer::scene(congregLevel, false, false);
                     CCDirector::get()->replaceScene(scene);
+
                     log::info("Switching to Congregation level (93437568) by 10% chance");
                     return;
                 } else if (congregLevel && !congregLevel->m_levelNotDownloaded) {
@@ -216,11 +223,40 @@ class $modify(HorriblePlayLayer, PlayLayer) {
             renderTexture->begin();
             scene->visit();
             renderTexture->end();
-            auto image = renderTexture->newCCImage();
 
-            if (image) {
-                std::string path = fmt::format("{}\\{}.png", Mod::get()->getSaveDir(), id);
+            if (auto image = renderTexture->newCCImage()) {
+                std::string path = fmt::format("{}\\{}.png", horribleMod->getSaveDir(), id);
+
                 if (image->saveToFile(path.c_str(), false)) {
+                    auto mockConfigPath = fmt::format("{}\\mock.json", horribleMod->getSaveDir());
+                    auto mockConfig = file::readJson(std::filesystem::path(mockConfigPath)); // get the saved fails to mock the player with :)
+
+                    auto toWrite = Value(); // what we're gonna write in the mock.json file
+
+                    if (mockConfig.isOk()) {
+                        // unwrap the whole thing
+                        auto mockConfigUnwr = mockConfig.unwrapOr(Value());
+
+                        // overwrite this field (or add it) with the percent
+                        mockConfigUnwr[std::to_string(id)] = percentage;
+
+                        toWrite = mockConfigUnwr;
+                    } else {
+                        toWrite = makeObject({
+                            { std::to_string(id), percentage }
+                                             });
+                    };
+
+                    if (!toWrite.isNull()) {
+                        auto mockJson = file::writeToJson(mockConfigPath, toWrite);
+
+                        if (mockJson.isOk()) {
+                            log::info("Saved highly mockable percentage of {} to data", percentage);
+                        } else {
+                            log::error("Aw man, failed to save mockable percentage of {} to data", percentage);
+                        };
+                    };
+
                     log::info("Saved screenshot to {}", path);
                 } else {
                     log::error("Failed to save screenshot to {}", path);
@@ -232,4 +268,33 @@ class $modify(HorriblePlayLayer, PlayLayer) {
             };
         };
     };
+
+    void levelComplete() {
+        auto horribleMod = getMod();
+
+        if (horribleMod->getSavedValue<bool>("mock", false)) {
+            int id = m_level->m_levelID;
+            int percentage = m_level->m_normalPercent;
+
+            auto mockConfigPath = fmt::format("{}\\mock.json", horribleMod->getSaveDir());
+            auto mockConfig = file::readJson(std::filesystem::path(mockConfigPath)); // get the saved levels to mock the player :)
+
+            if (mockConfig.isOk()) {
+                log::debug("Clearing mock record for {}", id);
+                auto mockConfigUnwr = mockConfig.unwrapOr(Value());
+
+                mockConfigUnwr[std::to_string(id)].clear();
+
+                auto mockJson = file::writeToJson(mockConfigPath, mockConfigUnwr);
+
+                if (mockJson.isOk()) {
+                    log::info("Saved highly mockable percentage of {} to data", percentage);
+                } else {
+                    log::error("Aw man, failed to save mockable percentage of {} to data", percentage);
+                };
+            };
+        };
+
+        PlayLayer::levelComplete();
+    };
 };

src/popup/HorribleMenuPopup.cpp

@@ -8,8 +8,7 @@
 using namespace geode::prelude;
 
 // add yo mods here :D
-std::vector<std::tuple<std::string, std::string, std::string, SillyTier, bool>> HorribleMenuPopup::getAllOptions()
-{
+std::vector<std::tuple<std::string, std::string, std::string, SillyTier, bool>> HorribleMenuPopup::getAllOptions() {
     // for simple minded: [modID, modName, modDescription, sillyTier, restartRequired]
     return {
         {
@@ -53,21 +52,21 @@ std::vector<std::tuple<std::string, std::string, std::string, SillyTier, bool>>
          "Play the achievement sound when doing random things.\n<cy>Credit: Cheeseworks</c>",
          SillyTier::Low,
          false
-        } };
+        }
+    };
 };
 
-bool HorribleMenuPopup::setup()
-{
+bool HorribleMenuPopup::setup() {
     setID("options"_spr);
     setTitle("Horrible Options");
 
     auto mainLayerSize = m_mainLayer->getContentSize();
 
     // Add a background sprite to the popup
     auto optionScrollBg = CCScale9Sprite::create("square02_001.png");
-    optionScrollBg->setAnchorPoint({0.5, 0.5});
-    optionScrollBg->setPosition({mainLayerSize.width / 2.f, mainLayerSize.height / 2.f - 10.f});
-    optionScrollBg->setContentSize({mainLayerSize.width - 25.f, mainLayerSize.height - 45.f});
+    optionScrollBg->setAnchorPoint({ 0.5, 0.5 });
+    optionScrollBg->setPosition({ mainLayerSize.width / 2.f, mainLayerSize.height / 2.f - 10.f });
+    optionScrollBg->setContentSize({ mainLayerSize.width - 25.f, mainLayerSize.height - 45.f });
     optionScrollBg->setOpacity(50);
 
     m_mainLayer->addChild(optionScrollBg);
@@ -78,9 +77,9 @@ bool HorribleMenuPopup::setup()
     columnLayout->setAxisAlignment(AxisAlignment::End);
 
     // scroll layer
-    auto optionsScrollLayer = ScrollLayer::create({optionScrollBg->getContentSize().width - 10.f, optionScrollBg->getContentSize().height - 10.f});
+    auto optionsScrollLayer = ScrollLayer::create({ optionScrollBg->getContentSize().width - 10.f, optionScrollBg->getContentSize().height - 10.f });
     optionsScrollLayer->setID("scrollLayer");
-    optionsScrollLayer->setAnchorPoint({0.5, 0.5});
+    optionsScrollLayer->setAnchorPoint({ 0.5, 0.5 });
     optionsScrollLayer->ignoreAnchorPointForPosition(false);
     optionsScrollLayer->setPosition(optionScrollBg->getPosition());
 
@@ -90,14 +89,12 @@ bool HorribleMenuPopup::setup()
     auto modOptions = getAllOptions();
 
     // Sort mod options alphabetically by name
-    std::sort(modOptions.begin(), modOptions.end(), [](const auto &a, const auto &b)
-              { return std::get<4>(a) < std::get<4>(b); });
+    std::sort(modOptions.begin(), modOptions.end(), [](const auto& a, const auto& b) { return std::get<4>(a) < std::get<4>(b); });
 
-    for (const auto &option : modOptions)
-    {
-        const auto &[id, name, desc, silly, restart] = option;
+    for (const auto& option : modOptions) {
+        const auto& [id, name, desc, silly, restart] = option;
 
-        if (auto modOption = ModOption::create({optionsScrollLayer->m_contentLayer->getScaledContentWidth(), 32.f}, id, name, desc, silly, restart))
+        if (auto modOption = ModOption::create({ optionsScrollLayer->m_contentLayer->getScaledContentWidth(), 32.f }, id, name, desc, silly, restart))
             optionsScrollLayer->m_contentLayer->addChild(modOption);
     };
 
@@ -108,12 +105,10 @@ bool HorribleMenuPopup::setup()
     return true;
 };
 
-HorribleMenuPopup *HorribleMenuPopup::create()
-{
+HorribleMenuPopup* HorribleMenuPopup::create() {
     auto ret = new HorribleMenuPopup();
 
-    if (ret && ret->initAnchored(300.f, 280.f))
-    {
+    if (ret && ret->initAnchored(300.f, 280.f)) {
         ret->autorelease();
         return ret;
     };