From ea359ba3d021daf9d2e472c06f6db929c03ca35a Mon Sep 17 00:00:00 2001 From: dayfine Date: Tue, 20 Oct 2026 21:08:30 -0700 Subject: [PATCH 01/18] Run the BBQ farmer's rounds against an injectable BBQGameActions BBQSoloFarmer::program() runs its quest rounds inline against the console, so the round logic (which quests count, when to stop, when to save) can only be exercised by running the farmer on a Switch. Move the round loop into run_bbq_rounds(), which takes the game actions it depends on as a BBQGameActions interface: read the quests, process them, do a quest, report a completed quest, and end the round (saving if due). BBQSoloFarmer implements these with the calls they replace, in the same order; the date fix, save/reset, stats and notification move together into end_round(). Startup, flying to the plaza and end-of-program handling stay in program(). The commented-out single-quest debug block declares its own egg counter now that the loop locals have moved. process_quest_list() only reads its quest list and egg count, so take them as const& and by value. Add PokemonSV::BBQFarmerRounds, a table of scenarios run against a simulated singleplayer quest panel: 3 blue quests, completed quests are replaced, impossible quests are skipped, and a panel with nothing doable is rerolled. Each scenario checks the number of completed quests and the exact action sequence: finishing the round that reaches the goal, a quest already gone, a failed quest, a panel with nothing doable, saving at exact multiples, and stopping when out of eggs. No behavior change. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 222 ++++++++++++++++++ .../Farming/PokemonSV_BBQSoloFarmer.cpp | 166 ++++++++----- .../Farming/PokemonSV_BBQSoloFarmer.h | 42 ++++ .../Farming/PokemonSV_BlueberryQuests.cpp | 4 +- .../Farming/PokemonSV_BlueberryQuests.h | 4 +- 5 files changed, 375 insertions(+), 63 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index d966bfe133..f894861d68 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -4,6 +4,7 @@ * */ +#include #include "Common/Cpp/TestRunners/UnitTestDatabase.h" #include "Inference/PokemonSV_WhiteButtonDetector.h" #include "Inference/Boxes/PokemonSV_BoxDetection.h" @@ -25,15 +26,236 @@ #include "Inference/Overworld/PokemonSV_LetsGoKillDetector.h" #include "Inference/Picnics/PokemonSV_SandwichRecipeDetector.h" #include "Inference/Picnics/PokemonSV_SandwichHandDetector.h" +#include "Programs/Farming/PokemonSV_BlueberryQuests.h" +#include "Programs/Farming/PokemonSV_BBQSoloFarmer.h" #include "PokemonSV_Tests.h" namespace PokemonAutomation{ namespace NintendoSwitch{ namespace PokemonSV{ +namespace{ +class NullLogger : public Logger{ +public: + virtual void log(const std::string&, Color) override{} +}; + +// A singleplayer quest panel that behaves like the game's: 3 blue quests, +// and a completed quest is replaced by a new one. process_quest_list() +// follows the two rules of the real one that the round loop depends on: +// quests in not_possible_quests are skipped, and if nothing is doable all +// quests are rerolled and nothing is returned. Red quests and the +// exclusions table are not modeled. Records the game actions taken. +class SimulatedBBQGameActions : public BBQGameActions{ +public: + std::vector panel; + // Each attempt returns the next outcome; once exhausted, attempts succeed. + std::vector outcomes; + // Completing the first quest also completes the second, e.g. walking + // 500 meters while navigating to a photo target. + std::vector> also_completes; + + std::vector events; + + virtual std::vector read_quests() override{ + events.push_back("read"); + if (++m_reads > 1000){ + throw std::runtime_error("Too many quest panel reads."); + } + return panel; + } + virtual std::vector process_quest_list( + const std::vector& quests, uint8_t + ) override{ + events.push_back("process"); + std::vector doable; + for (BBQuests quest : quests){ + if (!not_possible_quests.contains(quest)){ + doable.push_back(quest); + } + } + if (doable.empty()){ + for (BBQuests& slot : panel){ + slot = next_new_quest(); + } + } + return doable; + } + virtual bool do_quest(BBQuests quest, uint8_t&) override{ + events.push_back("do"); + const bool success = m_next_outcome < outcomes.size() ? outcomes[m_next_outcome++] : true; + if (success){ + complete(quest); + for (const auto& [done, extra] : also_completes){ + if (done == quest){ + complete(extra); + } + } + } + return success; + } + virtual void quest_completed() override{ + events.push_back("completed"); + } + virtual void end_round(bool save) override{ + events.push_back(save ? "end(save)" : "end"); + } + +private: + void complete(BBQuests quest){ + auto iter = std::find(panel.begin(), panel.end(), quest); + if (iter != panel.end()){ + *iter = next_new_quest(); + } + } + + // New quests come from a fixed rotation of doable blue quests, skipping + // any that are already on the panel. + BBQuests next_new_quest(){ + static const BBQuests ROTATION[] = { + BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar, + BBQuests::photo_savanna, BBQuests::catch_any, BBQuests::catch_normal, + BBQuests::catch_fire, BBQuests::catch_water, BBQuests::catch_grass, + }; + while (true){ + BBQuests quest = ROTATION[m_next_new_quest++ % std::size(ROTATION)]; + if (std::find(panel.begin(), panel.end(), quest) == panel.end()){ + return quest; + } + } + } + + size_t m_reads = 0; + size_t m_next_outcome = 0; + size_t m_next_new_quest = 0; +}; + +std::string join_events(const std::vector& events){ + std::string ret; + for (const std::string& event : events){ + if (!ret.empty()) ret += ' '; + ret += event; + } + return ret; +} + +// One simulated farmer run: option values, the panel it starts with and how +// quests turn out, and the game actions it must take. +struct BBQRoundsScenario{ + std::string name; + uint64_t num_quests; + uint64_t save_num_quests = 0; + bool stop_when_out_of_eggs = false; + std::vector panel = {BBQuests::make_tm, BBQuests::auto_10, BBQuests::sneak_up}; + std::vector outcomes; + std::vector> also_completes; + uint64_t expected_completed = 0; + std::string expected; +}; + +class Test_BBQFarmerRounds : public UnitTest{ +public: + Test_BBQFarmerRounds(BBQRoundsScenario scenario) + : UnitTest("PokemonSV::BBQFarmerRounds - " + scenario.name) + , m_scenario(std::move(scenario)) + {} + + virtual UnitTestResult run(Logger&, CancellableScope&) const override{ + BBQOption options; + options.NUM_QUESTS.set(m_scenario.num_quests); + options.SAVE_NUM_QUESTS.set(m_scenario.save_num_quests); + if (m_scenario.stop_when_out_of_eggs){ + options.NUM_EGGS.set(0); + options.OUT_OF_EGGS.set(BBQOption::OOEggs::Stop); + } + + SimulatedBBQGameActions game; + game.panel = m_scenario.panel; + game.outcomes = m_scenario.outcomes; + game.also_completes = m_scenario.also_completes; + + NullLogger logger; + run_bbq_rounds(logger, options, game); + const uint64_t completed = (uint64_t)std::count(game.events.begin(), game.events.end(), "completed"); + if (completed != m_scenario.expected_completed){ + return "Expected " + std::to_string(m_scenario.expected_completed) + + " completed quests, counted " + std::to_string(completed); + } + const std::string actual = join_events(game.events); + if (actual != m_scenario.expected){ + return "Expected: " + m_scenario.expected + "\nActual: " + actual; + } + return true; + } + +private: + const BBQRoundsScenario m_scenario; +}; + +void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ + const std::string round_of_3 = "read process read do completed read do completed read do completed"; + const BBQRoundsScenario scenarios[] = { + { + // The goal (4) is reached in the middle of round 2. The loop only + // checks the goal between rounds, so round 2 finishes and 6 quests + // complete. + .name = "finishes the round that reaches the quest goal", + .num_quests = 4, + .expected_completed = 6, + .expected = round_of_3 + " end " + round_of_3 + " end", + }, + { + // Doing photo_swim also completes travel_500, so travel_500 is + // gone when the loop reads the panel before attempting it. + .name = "quest already gone counts as completed", + .num_quests = 3, + .panel = {BBQuests::photo_swim, BBQuests::travel_500, BBQuests::make_tm}, + .also_completes = {{BBQuests::photo_swim, BBQuests::travel_500}}, + .expected_completed = 3, + .expected = "read process read do completed read completed read do completed end", + }, + { + // The first attempt fails: 3 attempts, 2 completions. + .name = "failed quest does not count", + .num_quests = 2, + .outcomes = {false}, + .expected_completed = 2, + .expected = "read process read do read do completed read do completed end", + }, + { + // Nothing on the panel is doable, so process_quest_list() rerolls + // all of it and returns nothing; the loop reads the panel again. + .name = "panel with nothing doable is rerolled", + .num_quests = 3, + .panel = {BBQuests::pickup_10, BBQuests::catch_flying, BBQuests::UnableToDetect}, + .expected_completed = 3, + .expected = "read process " + round_of_3 + " end", + }, + { + .name = "saves at exact multiples", + .num_quests = 6, + .save_num_quests = 3, + .expected_completed = 6, + .expected = round_of_3 + " end(save) " + round_of_3 + " end(save)", + }, + { + .name = "stops when out of eggs", + .num_quests = 5, + .stop_when_out_of_eggs = true, + .expected_completed = 0, + .expected = "", + }, + }; + for (const BBQRoundsScenario& scenario : scenarios){ + database.add(scenario); + } +} + +} void add_tests(UnitTestDatabase& database){ + add_tests_BBQFarmerRounds(database); add_tests_WhiteButtonDetector(database); add_tests_BoxInfoDetector(database); add_tests_BoxEggDetector(database); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index 1c874e32a1..c6deaccca9 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -74,48 +74,22 @@ BBQSoloFarmer::BBQSoloFarmer() PA_ADD_OPTION(NOTIFICATIONS); } -void BBQSoloFarmer::program(SingleSwitchProgramEnvironment& env, ProControllerContext& context){ - StartProgramChecks::check_performance_class_wired_or_wireless(context); - assert_16_9_720p_min(env.logger(), env.console); - - BBQSoloFarmer_Descriptor::Stats& stats = env.current_stats(); - - //Make sure console type is set - if (env.console.state().console_type() == ConsoleType::Unknown){ - throw UserSetupError(env.console, "Console Type (Switch 1 or 2) must be specified."); - } - - // Connect the controller. - require_player(env.console, context, BUTTON_LCLICK); - - //Fly to plaza - open_map_from_overworld(env.program_info(), env.console, context); - fly_to_overworld_from_map(env.program_info(), env.console, context); - +void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game){ std::vector quest_list; //all quests std::vector quests_to_do; //do-able quests uint8_t eggs_hatched = 0; //Track eggs uint64_t num_completed_quests = 0; - //Test a specific quest - /* - BBQuests test_quest = BBQuests::catch_water; - bool questTest = process_and_do_quest(env, env.console, context, BBQ_OPTIONS, test_quest, eggs_hatched); - if (questTest){ - env.log("Finished quest."); - } - */ - - while (num_completed_quests < BBQ_OPTIONS.NUM_QUESTS){ - if (BBQ_OPTIONS.OUT_OF_EGGS == BBQOption::OOEggs::Stop && eggs_hatched >= BBQ_OPTIONS.NUM_EGGS){ - env.log("Stop when out of eggs selected. Stopping program."); + while (num_completed_quests < options.NUM_QUESTS){ + if (options.OUT_OF_EGGS == BBQOption::OOEggs::Stop && eggs_hatched >= options.NUM_EGGS){ + logger.log("Stop when out of eggs selected. Stopping program."); break; } //Get and reroll quests until we can at least one while (quests_to_do.size() < 1){ - quest_list = read_quests(env.program_info(), env.console, context, BBQ_OPTIONS); - quests_to_do = process_quest_list(env.program_info(), env.console, context, BBQ_OPTIONS, quest_list, eggs_hatched); + quest_list = game.read_quests(); + quests_to_do = game.process_quest_list(quest_list, eggs_hatched); //Clear out the regular quest list. quest_list.clear(); @@ -123,23 +97,21 @@ void BBQSoloFarmer::program(SingleSwitchProgramEnvironment& env, ProControllerCo for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) - quest_list = read_quests(env.program_info(), env.console, context, BBQ_OPTIONS); + quest_list = game.read_quests(); if (std::find(quest_list.begin(), quest_list.end(), current_quest) != quest_list.end()){ - env.log("Current quest exists on list. Doing quest."); - bool questSuccess = process_and_do_quest(env, env.console, context, BBQ_OPTIONS, current_quest, eggs_hatched); + logger.log("Current quest exists on list. Doing quest."); + bool questSuccess = game.do_quest(current_quest, eggs_hatched); if (questSuccess){ - env.log("Quest completed successfully."); - stats.questsCompleted++; - env.update_stats(); + logger.log("Quest completed successfully."); + game.quest_completed(); num_completed_quests++; }else{ - env.log("Quest did not complete successfully."); + logger.log("Quest did not complete successfully."); } }else{ //Note: This doesn't account for case such as "sneak up" being added and then completed alongside the next quest - env.log("Current quest does not exist on list. Quest completed at some point."); - stats.questsCompleted++; - env.update_stats(); + logger.log("Current quest does not exist on list. Quest completed at some point."); + game.quest_completed(); num_completed_quests++; } quest_list.clear(); @@ -147,27 +119,103 @@ void BBQSoloFarmer::program(SingleSwitchProgramEnvironment& env, ProControllerCo //Clear out the todo list quests_to_do.clear(); - //Fix the time to prevent running out of years - pbf_wait(context, 2000ms); - context.wait_for_all_requests(); - go_home(env.console, context); - home_to_date_time(env.console, context, false); - pbf_press_button(context, BUTTON_A, 160ms, 840ms); - pbf_press_button(context, BUTTON_A, 160ms, 840ms); - pbf_press_button(context, BUTTON_HOME, 160ms, ConsoleSettings::instance().SETTINGS_TO_HOME_DELAY0); - resume_game_from_home(env.console, context); + uint64_t temp_save_num_option = options.SAVE_NUM_QUESTS; + game.end_round(temp_save_num_option != 0 && num_completed_quests % temp_save_num_option == 0); + } +} + - uint64_t temp_save_num_option = BBQ_OPTIONS.SAVE_NUM_QUESTS; - if (temp_save_num_option != 0 && num_completed_quests % temp_save_num_option == 0){ - env.log("Saving and resetting."); - save_game_from_overworld(env.program_info(), env.console, context); - reset_game(env.program_info(), env.console, context); - stats.saves++; +namespace{ + +class BBQSoloFarmerGameActions : public BBQGameActions{ +public: + BBQSoloFarmerGameActions( + SingleSwitchProgramEnvironment& env, ProControllerContext& context, + BBQOption& options, BBQSoloFarmer_Descriptor::Stats& stats, + EventNotificationOption& status_update + ) + : m_env(env), m_context(context) + , m_options(options), m_stats(stats) + , m_status_update(status_update) + {} + + virtual std::vector read_quests() override{ + return PokemonSV::read_quests(m_env.program_info(), m_env.console, m_context, m_options); + } + virtual std::vector process_quest_list( + const std::vector& quests, uint8_t eggs_hatched + ) override{ + return PokemonSV::process_quest_list(m_env.program_info(), m_env.console, m_context, m_options, quests, eggs_hatched); + } + virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) override{ + return process_and_do_quest(m_env, m_env.console, m_context, m_options, quest, eggs_hatched); + } + virtual void quest_completed() override{ + m_stats.questsCompleted++; + m_env.update_stats(); + } + virtual void end_round(bool save) override{ + //Fix the time to prevent running out of years + pbf_wait(m_context, 2000ms); + m_context.wait_for_all_requests(); + go_home(m_env.console, m_context); + home_to_date_time(m_env.console, m_context, false); + pbf_press_button(m_context, BUTTON_A, 160ms, 840ms); + pbf_press_button(m_context, BUTTON_A, 160ms, 840ms); + pbf_press_button(m_context, BUTTON_HOME, 160ms, ConsoleSettings::instance().SETTINGS_TO_HOME_DELAY0); + resume_game_from_home(m_env.console, m_context); + + if (save){ + m_env.log("Saving and resetting."); + save_game_from_overworld(m_env.program_info(), m_env.console, m_context); + reset_game(m_env.program_info(), m_env.console, m_context); + m_stats.saves++; } - env.update_stats(); - send_program_status_notification(env, NOTIFICATION_STATUS_UPDATE); + m_env.update_stats(); + send_program_status_notification(m_env, m_status_update); + } + +private: + SingleSwitchProgramEnvironment& m_env; + ProControllerContext& m_context; + BBQOption& m_options; + BBQSoloFarmer_Descriptor::Stats& m_stats; + EventNotificationOption& m_status_update; +}; + +} + +void BBQSoloFarmer::program(SingleSwitchProgramEnvironment& env, ProControllerContext& context){ + StartProgramChecks::check_performance_class_wired_or_wireless(context); + assert_16_9_720p_min(env.logger(), env.console); + + BBQSoloFarmer_Descriptor::Stats& stats = env.current_stats(); + + //Make sure console type is set + if (env.console.state().console_type() == ConsoleType::Unknown){ + throw UserSetupError(env.console, "Console Type (Switch 1 or 2) must be specified."); + } + + // Connect the controller. + require_player(env.console, context, BUTTON_LCLICK); + + //Fly to plaza + open_map_from_overworld(env.program_info(), env.console, context); + fly_to_overworld_from_map(env.program_info(), env.console, context); + + //Test a specific quest + /* + uint8_t eggs_hatched = 0; + BBQuests test_quest = BBQuests::catch_water; + bool questTest = process_and_do_quest(env, env.console, context, BBQ_OPTIONS, test_quest, eggs_hatched); + if (questTest){ + env.log("Finished quest."); } + */ + + BBQSoloFarmerGameActions game(env, context, BBQ_OPTIONS, stats, NOTIFICATION_STATUS_UPDATE); + run_bbq_rounds(env.logger(), BBQ_OPTIONS, game); env.update_stats(); if (BBQ_OPTIONS.FIX_TIME_WHEN_DONE){ diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h index 9917606334..1ac8535caf 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h @@ -7,6 +7,9 @@ #ifndef PokemonAutomation_PokemonSV_BBQSoloFarmer_H #define PokemonAutomation_PokemonSV_BBQSoloFarmer_H +#include +#include +#include "Common/Cpp/Logging/AbstractLogger.h" #include "CommonFramework/Notifications/EventNotificationsTable.h" #include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h" #include "NintendoSwitch/Options/NintendoSwitch_GoHomeWhenDoneOption.h" @@ -16,6 +19,45 @@ namespace PokemonAutomation{ namespace NintendoSwitch{ namespace PokemonSV{ + +// The game actions that run_bbq_rounds() depends on. They are injected so +// that the round loop (which quests to attempt, which ones count, when to +// stop, when to save) runs in tests without a Switch: BBQSoloFarmer performs +// them on the console, and tests replace them with scripted results. +class BBQGameActions{ +public: + virtual ~BBQGameActions() = default; + + // Open the quest panel and read the quests on it. + virtual std::vector read_quests() = 0; + + // Decide which of the quests just read are worth attempting this round. + // May reroll quests in game, so the returned list can be empty even when + // `quests` is not; the loop then reads the panel again. + virtual std::vector process_quest_list( + const std::vector& quests, uint8_t eggs_hatched + ) = 0; + + // Attempt one quest that is on the panel, after process_quest_list() + // chose it. Returns true if it is no longer on the panel afterwards. + // Increments `eggs_hatched` when the quest hatches eggs. + virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) = 0; + + // Progress reporting only: a quest was counted as completed. Lets stats + // update after every quest instead of once per round. + virtual void quest_completed() = 0; + + // A round has ended. The loop decides whether a save is due, because + // that depends on how many quests it has counted; how to fix the date, + // save and reset, and report the round is up to the game side. + virtual void end_round(bool save) = 0; +}; + +// Run rounds of quests until NUM_QUESTS have been completed, or until +// eggs run out when OUT_OF_EGGS is Stop. +void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game); + + class BBQSoloFarmer_Descriptor : public SingleSwitchProgramDescriptor{ public: BBQSoloFarmer_Descriptor(); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 43740d2c1c..fda3441a39 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -225,8 +225,8 @@ std::vector process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, - std::vector& quest_list, - uint8_t& eggs_hatched + const std::vector& quest_list, + uint8_t eggs_hatched ){ std::vector quests_to_do; bool rerolled = false; diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 957a3c50e9..8ab92394f1 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -71,8 +71,8 @@ std::vector process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, - std::vector& quest_list, - uint8_t& eggs_hatched + const std::vector& quest_list, + uint8_t eggs_hatched ); //Take the current quest and calls the function to do it, then checks the quest was successful. Returns true if so. From 548ac951c4aaf65d30f189bd1cfbcae233f6f09b Mon Sep 17 00:00:00 2001 From: dayfine Date: Tue, 20 Oct 2026 21:42:30 -0700 Subject: [PATCH 02/18] Fix BBQ save/reset milestones across stalled and batched rounds The farmer saved and reset when the completion count was an exact multiple of SAVE_NUM_QUESTS. A round that completed nothing while the count sat at 0 or 50 saved again, and a round going from 49 to 52 skipped the 50 milestone entirely. Compare the count before and after each round and ask end_round() to save once when it crosses a multiple of the interval. Stalled rounds and an interval of 0 never save. Fix the option label to say "completing", not "attempting". Add two PokemonSV::BBQFarmerRounds scenarios that fail with the old rule: a round that skips past a milestone, and rounds with no completions. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../PokemonSV/Options/PokemonSV_BBQOption.cpp | 2 +- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 20 ++++++++++++++++++- .../Farming/PokemonSV_BBQSoloFarmer.cpp | 15 +++++++++++++- 3 files changed, 34 insertions(+), 3 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp index 4067d75fa3..4758cdd47b 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp @@ -151,7 +151,7 @@ BBQOption::BBQOption(OCR::LanguageOCROption* language_option) 1000 ) , SAVE_NUM_QUESTS( - "Save and reset the game after attempting this many quests:
This preserves progress and prevents potential game lags from long runs.
0 disables this option.", + "Save and reset the game after completing this many quests:
This preserves progress and prevents potential game lags from long runs.
0 disables this option.", LockMode::UNLOCK_WHILE_RUNNING, 50 ) , INVERTED_FLIGHT( diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index f894861d68..16b905a61f 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -233,12 +233,30 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .expected = "read process " + round_of_3 + " end", }, { - .name = "saves at exact multiples", + .name = "saves at each milestone", .num_quests = 6, .save_num_quests = 3, .expected_completed = 6, .expected = round_of_3 + " end(save) " + round_of_3 + " end(save)", }, + { + // 0 -> 3 crosses the milestone at 2 without landing on it. + .name = "saves when a round skips past a milestone", + .num_quests = 6, + .save_num_quests = 2, + .expected_completed = 6, + .expected = round_of_3 + " end(save) " + round_of_3 + " end(save)", + }, + { + // Round 1 completes nothing. It must not save, even though the + // count (0) is a multiple of the interval. + .name = "round without completions does not save", + .num_quests = 3, + .save_num_quests = 2, + .outcomes = {false, false, false}, + .expected_completed = 3, + .expected = "read process read do read do read do end " + round_of_3 + " end(save)", + }, { .name = "stops when out of eggs", .num_quests = 5, diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index c6deaccca9..6686ada964 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -74,6 +74,17 @@ BBQSoloFarmer::BBQSoloFarmer() PA_ADD_OPTION(NOTIFICATIONS); } +namespace{ + +// Whether a round that took the completed count from previous_completed +// to completed crossed a nonzero multiple of the save interval. +bool bbq_save_due(uint64_t previous_completed, uint64_t completed, uint64_t interval){ + return interval != 0 && completed > previous_completed + && completed / interval > previous_completed / interval; +} + +} + void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game){ std::vector quest_list; //all quests std::vector quests_to_do; //do-able quests @@ -95,6 +106,7 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga quest_list.clear(); } + const uint64_t completed_before_round = num_completed_quests; for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) quest_list = game.read_quests(); @@ -120,7 +132,8 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga quests_to_do.clear(); uint64_t temp_save_num_option = options.SAVE_NUM_QUESTS; - game.end_round(temp_save_num_option != 0 && num_completed_quests % temp_save_num_option == 0); + // A round can cross a milestone without ending at an exact multiple. + game.end_round(bbq_save_due(completed_before_round, num_completed_quests, temp_save_num_option)); } } From 102957f131d20d503526da3ceaa108b8670549f8 Mon Sep 17 00:00:00 2001 From: dayfine Date: Tue, 20 Oct 2026 22:39:54 -0700 Subject: [PATCH 03/18] Separate the BBQ quest plan from the controller actions that carry it out process_quest_list() decided what to do with each quest and pressed the buttons for it in the same loop, so the decisions could only be checked on a Switch. plan_quests() now makes the decisions from the options alone: which quests to do, which panel slots to reroll, and whether to reroll all. process_quest_list() carries out the plan, and opening the panel is a shared helper instead of three copies. All rerolls now move the cursor to the quest's slot. The out-of-eggs reroll used to reroll the top slot; the egg quest is a red quest and red quests are listed at the top, so this is the same in practice. OOEggs::Stop reaching the planner is now an InternalProgramError, since the farmer stops before that can happen. Unit tests cover the plan for exclusions, duplicate rows, quests that are not possible, and eggs. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 150 +++++++++++ .../Farming/PokemonSV_BlueberryQuests.cpp | 255 ++++++++---------- .../Farming/PokemonSV_BlueberryQuests.h | 17 ++ 3 files changed, 279 insertions(+), 143 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index d966bfe133..8c9563ff9a 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -25,15 +25,165 @@ #include "Inference/Overworld/PokemonSV_LetsGoKillDetector.h" #include "Inference/Picnics/PokemonSV_SandwichRecipeDetector.h" #include "Inference/Picnics/PokemonSV_SandwichHandDetector.h" +#include "Programs/Farming/PokemonSV_BlueberryQuests.h" #include "PokemonSV_Tests.h" namespace PokemonAutomation{ namespace NintendoSwitch{ namespace PokemonSV{ +namespace{ + +class NullLogger : public Logger{ +public: + virtual void log(const std::string&, Color) override{} +}; + +// The quests read from the panel, the options that matter, and the plan +// plan_quests() must make. The default exclusions table has one row: +// auto-10, skip. +struct BBQuestPlanScenario{ + std::string name; + std::vector quests; + std::vector> extra_exclusions; + uint8_t num_eggs = 1; + uint8_t eggs_hatched = 0; + BBQOption::OOEggs out_of_eggs = BBQOption::OOEggs::Reroll; + std::vector expected_to_do; + std::vector expected_reroll_slots; + bool expected_reroll_all = false; +}; + +std::string quests_to_string(const std::vector& quests){ + std::string ret; + for (BBQuests quest : quests){ + ret += std::to_string((int)quest) + " "; + } + return ret; +} +std::string slots_to_string(const std::vector& slots){ + std::string ret; + for (size_t slot : slots){ + ret += std::to_string(slot) + " "; + } + return ret; +} + +class Test_BBQuestPlan : public UnitTest{ +public: + Test_BBQuestPlan(BBQuestPlanScenario scenario) + : UnitTest("PokemonSV::BBQuestPlan - " + scenario.name) + , m_scenario(std::move(scenario)) + {} + + virtual UnitTestResult run(Logger&, CancellableScope&) const override{ + BBQOption options; + options.NUM_EGGS.set(m_scenario.num_eggs); + options.OUT_OF_EGGS.set(m_scenario.out_of_eggs); + for (const auto& [quest, action] : m_scenario.extra_exclusions){ + auto row = std::make_unique(options.QUEST_EXCLUSIONS); + row->quest.set(quest); + row->action.set(action); + options.QUEST_EXCLUSIONS.append_row(std::move(row)); + } + + NullLogger logger; + const BBQuestPlan plan = plan_quests(logger, options, m_scenario.quests, m_scenario.eggs_hatched); + if (plan.to_do != m_scenario.expected_to_do){ + return "Expected quests to do: " + quests_to_string(m_scenario.expected_to_do) + + "got: " + quests_to_string(plan.to_do); + } + if (plan.reroll_slots != m_scenario.expected_reroll_slots){ + return "Expected reroll slots: " + slots_to_string(m_scenario.expected_reroll_slots) + + "got: " + slots_to_string(plan.reroll_slots); + } + if (plan.reroll_all != m_scenario.expected_reroll_all){ + return std::string("Expected reroll_all = ") + (m_scenario.expected_reroll_all ? "true" : "false"); + } + return true; + } + +private: + const BBQuestPlanScenario m_scenario; +}; + +} + +void add_tests_BBQuestPlan(UnitTestDatabase& database){ + using enum BBQuests; + const BBQuestPlanScenario scenarios[] = { + { + .name = "default table skips auto-10", + .quests = {make_tm, auto_10, sneak_up}, + .expected_to_do = {make_tm, sneak_up}, + }, + { + .name = "quests not possible are left out", + .quests = {pickup_10, make_tm, UnableToDetect}, + .expected_to_do = {make_tm}, + }, + { + .name = "nothing doable rerolls all", + .quests = {pickup_10, auto_10, catch_flying}, + .expected_reroll_all = true, + }, + { + // The reroll replaces a quest, so the next read has something new. + .name = "a reroll row rerolls that slot", + .quests = {make_tm, sneak_up, travel_500}, + .extra_exclusions = {{travel_500, BBQAction::reroll}}, + .expected_to_do = {make_tm, sneak_up}, + .expected_reroll_slots = {2}, + }, + { + // A reroll is already a change, so nothing more is rerolled. + .name = "a rerolled slot with nothing doable does not reroll all", + .quests = {pickup_10, sneak_up, auto_10}, + .extra_exclusions = {{sneak_up, BBQAction::reroll}}, + .expected_reroll_slots = {1}, + }, + { + // Each row for a quest applies, in table order. + .name = "every table row for a quest applies", + .quests = {travel_500, auto_10}, + .extra_exclusions = { + {travel_500, BBQAction::run}, + {auto_10, BBQAction::run}, + {travel_500, BBQAction::run}, + }, + .expected_to_do = {travel_500, travel_500, auto_10}, + }, + { + .name = "egg quest is done while eggs remain", + .quests = {make_tm, hatch_egg, sneak_up}, + .expected_to_do = {make_tm, hatch_egg, sneak_up}, + }, + { + // The egg quest is rerolled where it is on the panel, not always + // in the top slot. + .name = "out of eggs rerolls the egg quest slot", + .quests = {make_tm, hatch_egg, sneak_up}, + .eggs_hatched = 1, + .expected_to_do = {make_tm, sneak_up}, + .expected_reroll_slots = {1}, + }, + { + .name = "out of eggs with keep going leaves the egg quest", + .quests = {make_tm, hatch_egg, sneak_up}, + .eggs_hatched = 1, + .out_of_eggs = BBQOption::OOEggs::KeepGoing, + .expected_to_do = {make_tm, sneak_up}, + }, + }; + for (const BBQuestPlanScenario& scenario : scenarios){ + database.add(scenario); + } +} + void add_tests(UnitTestDatabase& database){ + add_tests_BBQuestPlan(database); add_tests_WhiteButtonDetector(database); add_tests_BoxInfoDetector(database); add_tests_BoxEggDetector(database); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 43740d2c1c..dab292b71a 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -221,6 +221,97 @@ std::vector read_quests( return quest_list; } +BBQuestPlan plan_quests( + Logger& logger, + const BBQOption& BBQ_OPTIONS, + const std::vector& quest_list, + uint8_t eggs_hatched +){ + BBQuestPlan plan; + std::vector> exclusions_table = BBQ_OPTIONS.QUEST_EXCLUSIONS.copy_snapshot(); + + logger.log("Processing quests."); + for (size_t slot = 0; slot < quest_list.size(); slot++){ + const BBQuests n = quest_list[slot]; + if (not_possible_quests.contains(n)){ + logger.log("Quest not possible"); + continue; + } + //Check eggs remaining. + if (n == BBQuests::hatch_egg && eggs_hatched >= BBQ_OPTIONS.NUM_EGGS){ + logger.log("Out of eggs! Quest not possible."); + switch (BBQ_OPTIONS.OUT_OF_EGGS){ + case BBQOption::OOEggs::Reroll: + logger.log("Reroll selected. Rerolling Egg quest. New quest will be run in the next batch of quests."); + //logger.log("Warning: This does not handle/check being out of BP!", COLOR_RED); + plan.reroll_slots.push_back(slot); + break; + case BBQOption::OOEggs::KeepGoing: + logger.log("Keep Going selected. Ignoring quest."); + break; + default: + //This case is handled in BBQSoloFarmer. + throw InternalProgramError(&logger, PA_CURRENT_FUNCTION, "OOEggs is Stop in process_quest_list()."); + } + continue; + } + bool quest_in_table = false; + for (const std::unique_ptr& row : exclusions_table){ + if (n != row->quest){ + continue; + } + logger.log("Quest found in inclusions/exclusions table."); + quest_in_table = true; + switch (row->action){ + case BBQAction::run: + logger.log("Run selected. Adding quest to list."); + plan.to_do.push_back(n); + break; + case BBQAction::reroll: + logger.log("Reroll selected. Rerolling quest. New quest will be run in the next batch of quests."); + plan.reroll_slots.push_back(slot); + break; + case BBQAction::skip: + logger.log("Skip selected. Skipping quest."); + break; + } + } + if (!quest_in_table){ + logger.log("Quest not in inclusion/exclusions table. Adding to list."); + plan.to_do.push_back(n); + } + } + + //Check that quests_to_do is not empty (after completing all quests on the list, be sure to erase it. + //Lag might be a problem in multi - look into making slots like menu-left navigation + plan.reroll_all = plan.reroll_slots.empty() && plan.to_do.empty(); + return plan; +} + +namespace{ + +//Open the quest panel from the overworld, with the cursor on the top quest. +void open_quest_panel(VideoStream& stream, ProControllerContext& context){ + WhiteButtonWatcher panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); + int result = run_until( + stream, context, + [&](ProControllerContext& context){ + for (int i = 0; i < 6; i++){ + pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); + pbf_wait(context, 1600ms); + context.wait_for_all_requests(); + } + }, + {{ panel }} + ); + if (result == 0){ + stream.log("Found quest panel."); + } + context.wait_for_all_requests(); +} + +} + std::vector process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, @@ -228,155 +319,33 @@ std::vector process_quest_list( std::vector& quest_list, uint8_t& eggs_hatched ){ - std::vector quests_to_do; - bool rerolled = false; - std::vector> exclusions_table = BBQ_OPTIONS.QUEST_EXCLUSIONS.copy_snapshot(); - int questpos = 0; - - stream.log("Processing quests."); - //Put all do-able quests into a different list - for (auto n : quest_list){ - if (not_possible_quests.contains(n)){ - stream.log("Quest not possible"); - }else{ - //Check eggs remaining. - if (n == BBQuests::hatch_egg && eggs_hatched >= BBQ_OPTIONS.NUM_EGGS){ - stream.log("Out of eggs! Quest not possible."); - - switch (BBQ_OPTIONS.OUT_OF_EGGS){ - case BBQOption::OOEggs::Reroll: - { - stream.log("Reroll selected. Rerolling Egg quest. New quest will be run in the next batch of quests."); - //stream.log("Warning: This does not handle/check being out of BP!", COLOR_RED); - - WhiteButtonWatcher right_panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); - int result = run_until( - stream, context, - [&](ProControllerContext& context){ - for (int i = 0; i < 6; i++){ - pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); - pbf_wait(context, 1600ms); - context.wait_for_all_requests(); - } - }, - {{ right_panel }} - ); - if (result == 0){ - stream.log("Found quest panel."); - } - context.wait_for_all_requests(); - - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); + BBQuestPlan plan = plan_quests(stream.logger(), BBQ_OPTIONS, quest_list, eggs_hatched); - rerolled = true; - press_Bs_to_back_to_overworld(info, stream, context); + for (size_t slot : plan.reroll_slots){ + open_quest_panel(stream, context); - break; - } - case BBQOption::OOEggs::KeepGoing: - stream.log("Keep Going selected. Ignoring quest."); - break; - default: - //This case is handled in BBQSoloFarmer. - stream.log("OOEggs is Stop in process_quest_list()."); - OperationFailedExceptionWithScreenshot::fire( - ErrorReportMode::SEND_ERROR_REPORT, - "OOEggs is Stop in process_quest_list().", - stream - ); - break; - } - }else{ - bool quest_in_table = false; - for (const std::unique_ptr& row : exclusions_table){ - if(n == row->quest){ - stream.log("Quest found in inclusions/exclusions table."); - quest_in_table = true; - - WhiteButtonWatcher rp2(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); - int result2; - switch (row->action){ - case BBQAction::run: - stream.log("Run selected. Adding quest to list."); - quests_to_do.push_back(n); - break; - case BBQAction::reroll: - stream.log("Reroll selected. Rerolling quest. New quest will be run in the next batch of quests."); - result2 = run_until( - stream, context, - [&](ProControllerContext& context){ - for (int i = 0; i < 6; i++){ - pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); - pbf_wait(context, 1600ms); - context.wait_for_all_requests(); - } - }, - {{ rp2 }} - ); - if (result2 == 0){ - stream.log("Found quest panel."); - } - context.wait_for_all_requests(); - - //Move cursor down to quest - for (int i = 0; i < questpos; i++){ - pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - } - - //Reroll - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - - //Prevent error/rerolling again at the end (allows program to read the rerolled quests) - rerolled = true; - - press_Bs_to_back_to_overworld(info, stream, context); - break; - case BBQAction::skip: - stream.log("Skip selected. Skipping quest."); - break; - } - } - } - if(!quest_in_table){ - stream.log("Quest not in inclusion/exclusions table. Adding to list."); - quests_to_do.push_back(n); - } - } + //Move cursor down to quest + for (size_t i = 0; i < slot; i++){ + pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); + pbf_wait(context, 800ms); + context.wait_for_all_requests(); } - questpos++; + + //Reroll + pbf_press_button(context, BUTTON_A, 160ms, 400ms); + pbf_press_button(context, BUTTON_A, 160ms, 400ms); + pbf_wait(context, 800ms); + context.wait_for_all_requests(); + + press_Bs_to_back_to_overworld(info, stream, context); } - - //Check that quests_to_do is not empty (after completing all quests on the list, be sure to erase it. - //Lag might be a problem in multi - look into making slots like menu-left navigation - if (!rerolled && quests_to_do.size() == 0){ + + if (plan.reroll_all){ stream.log("No possible quests! Rerolling all quests."); //Open quest panel and reroll all quests. //This does not handle out of BP. - WhiteButtonWatcher panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); - int result = run_until( - stream, context, - [&](ProControllerContext& context){ - for (int i = 0; i < 6; i++){ - pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); - pbf_wait(context, 1600ms); - context.wait_for_all_requests(); - } - }, - {{ panel }} - ); - if (result == 0){ - stream.log("Found quest panel."); - } - context.wait_for_all_requests(); + open_quest_panel(stream, context); for (string::size_type i = 0; i < quest_list.size(); i++){ pbf_press_button(context, BUTTON_A, 160ms, 400ms); @@ -391,7 +360,7 @@ std::vector process_quest_list( press_Bs_to_back_to_overworld(info, stream, context); } /* - if (!rerolled && quests_to_do.size() == 0){ + if (plan.reroll_all){ OperationFailedExceptionWithScreenshot::fire( ErrorReportMode::SEND_ERROR_REPORT, "No possible quests! Check language selection.", @@ -399,7 +368,7 @@ std::vector process_quest_list( ); } */ - return quests_to_do; + return plan.to_do; } bool process_and_do_quest( diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 957a3c50e9..92270cf374 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -65,6 +65,23 @@ std::vector read_quests( const BBQOption& BBQ_OPTIONS ); +//What to do with the quests read from the panel. Slot 0 is the top quest on the panel. +struct BBQuestPlan{ + std::vector to_do; //Quests to attempt, in panel order. + std::vector reroll_slots; //Slots to reroll, in panel order. + bool reroll_all = false; //Nothing to do and nothing rerolled: reroll every slot. +}; +//Decide what to do with each quest from the options alone, without touching the game, so +//the decision can be tested. Quests not possible are left out. Out-of-egg hatch quests and +//quests set to reroll in the exclusions table are rerolled. A quest with several table rows +//gets the action of each row, in table order. +BBQuestPlan plan_quests( + Logger& logger, + const BBQOption& BBQ_OPTIONS, + const std::vector& quest_list, + uint8_t eggs_hatched +); + //Determine which quests are possible and which quests are not. (ex. no eggs, reroll egg hatcher.) //Quests not possible are removed from the list. If the list is empty, then reroll all items. std::vector process_quest_list( From 053e59b375ab3bdcf06c5ed167820e5d844ab070 Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 10:51:21 -0700 Subject: [PATCH 04/18] Do not retry a failed BBQ quest every round while it stays on the panel process_and_do_quest() gives up on a quest after NUM_RETRIES retries, but the quest stays on the panel, so the next round attempts it again with a fresh set of retries. A quest that cannot be done, such as a sneak-up whose target does not spawn, is retried forever. run_bbq_rounds() now remembers quests that failed all their attempts and leaves them out of later rounds. A quest is forgotten once a read of 4 known quests shows it gone, so it gets its attempts again if it comes back. If only failed quests are doable, the farmer stops instead of spending BP to reroll them. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 78 ++++++++++++++++--- .../Farming/PokemonSV_BBQSoloFarmer.cpp | 45 ++++++++++- .../Farming/PokemonSV_BBQSoloFarmer.h | 3 +- 3 files changed, 114 insertions(+), 12 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index f894861d68..f98872d0ba 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -5,6 +5,7 @@ */ #include +#include #include "Common/Cpp/TestRunners/UnitTestDatabase.h" #include "Inference/PokemonSV_WhiteButtonDetector.h" #include "Inference/Boxes/PokemonSV_BoxDetection.h" @@ -55,6 +56,15 @@ class SimulatedBBQGameActions : public BBQGameActions{ // Completing the first quest also completes the second, e.g. walking // 500 meters while navigating to a photo target. std::vector> also_completes; + // Attempts at these always fail, e.g. a target that never spawns. + std::set never_completes; + // New quests are drawn from this list in turn, skipping any that are + // already on the panel. + std::vector new_quests = { + BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar, + BBQuests::photo_savanna, BBQuests::catch_any, BBQuests::catch_normal, + BBQuests::catch_fire, BBQuests::catch_water, BBQuests::catch_grass, + }; std::vector events; @@ -84,7 +94,8 @@ class SimulatedBBQGameActions : public BBQGameActions{ } virtual bool do_quest(BBQuests quest, uint8_t&) override{ events.push_back("do"); - const bool success = m_next_outcome < outcomes.size() ? outcomes[m_next_outcome++] : true; + const bool success = !never_completes.contains(quest) + && (m_next_outcome < outcomes.size() ? outcomes[m_next_outcome++] : true); if (success){ complete(quest); for (const auto& [done, extra] : also_completes){ @@ -110,16 +121,9 @@ class SimulatedBBQGameActions : public BBQGameActions{ } } - // New quests come from a fixed rotation of doable blue quests, skipping - // any that are already on the panel. BBQuests next_new_quest(){ - static const BBQuests ROTATION[] = { - BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar, - BBQuests::photo_savanna, BBQuests::catch_any, BBQuests::catch_normal, - BBQuests::catch_fire, BBQuests::catch_water, BBQuests::catch_grass, - }; while (true){ - BBQuests quest = ROTATION[m_next_new_quest++ % std::size(ROTATION)]; + BBQuests quest = new_quests[m_next_new_quest++ % new_quests.size()]; if (std::find(panel.begin(), panel.end(), quest) == panel.end()){ return quest; } @@ -150,6 +154,8 @@ struct BBQRoundsScenario{ std::vector panel = {BBQuests::make_tm, BBQuests::auto_10, BBQuests::sneak_up}; std::vector outcomes; std::vector> also_completes; + std::set never_completes; + std::vector new_quests; uint64_t expected_completed = 0; std::string expected; }; @@ -174,6 +180,10 @@ class Test_BBQFarmerRounds : public UnitTest{ game.panel = m_scenario.panel; game.outcomes = m_scenario.outcomes; game.also_completes = m_scenario.also_completes; + game.never_completes = m_scenario.never_completes; + if (!m_scenario.new_quests.empty()){ + game.new_quests = m_scenario.new_quests; + } NullLogger logger; run_bbq_rounds(logger, options, game); @@ -246,6 +256,56 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .expected_completed = 0, .expected = "", }, + { + // sneak-up fails in round 1 and is still on the panel in round 2, + // where only the two new quests are attempted. + .name = "failed quest is not attempted again", + .num_quests = 4, + .never_completes = {BBQuests::sneak_up}, + .expected_completed = 4, + .expected = + "read process read do completed read do completed read do end " + "read process read do completed read do completed end", + }, + { + .name = "stops when only failed quests are doable", + .num_quests = 3, + .panel = {BBQuests::sneak_up, BBQuests::pickup_10, BBQuests::catch_flying}, + .never_completes = {BBQuests::sneak_up}, + .expected_completed = 0, + .expected = "read process read do end read process", + }, + { + // sneak-up fails, then leaves the panel along with make-tm. Round 2 + // reads a full panel without it, and its replacement for + // photo-canyon brings it back. Round 3 attempts it again. + .name = "failed quest that leaves a full panel is attempted again", + .num_quests = 5, + .panel = {BBQuests::sneak_up, BBQuests::make_tm, BBQuests::pickup_10, BBQuests::catch_flying}, + .outcomes = {false}, + .also_completes = {{BBQuests::make_tm, BBQuests::sneak_up}}, + .new_quests = {BBQuests::auto_10, BBQuests::photo_canyon, BBQuests::sneak_up}, + .expected_completed = 5, + .expected = + "read process read do read do completed end " + "read process read do completed read do completed end " + "read process read do completed read do completed end", + }, + { + // As above with 3 slots. A 4th quest could have been missed by + // OCR, so the read does not prove sneak-up left: it stays failed. + .name = "failed quest missing from a 3-slot panel stays failed", + .num_quests = 4, + .panel = {BBQuests::sneak_up, BBQuests::make_tm, BBQuests::pickup_10}, + .outcomes = {false}, + .also_completes = {{BBQuests::make_tm, BBQuests::sneak_up}}, + .new_quests = {BBQuests::auto_10, BBQuests::photo_canyon, BBQuests::sneak_up}, + .expected_completed = 4, + .expected = + "read process read do read do completed end " + "read process read do completed read do completed end " + "read process read do completed end", + }, }; for (const BBQRoundsScenario& scenario : scenarios){ database.add(scenario); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index c6deaccca9..ee63a9b792 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -4,6 +4,7 @@ * */ +#include #include "Common/Cpp/Exceptions.h" #include "CommonFramework/Notifications/ProgramNotifications.h" #include "CommonFramework/ProgramStats/StatsTracking.h" @@ -74,12 +75,40 @@ BBQSoloFarmer::BBQSoloFarmer() PA_ADD_OPTION(NOTIFICATIONS); } +namespace{ + +// Forget the failed quests that are gone from the panel, so a quest that +// comes back later gets its attempts again. The first 3 slots are always +// read, as UnableToDetect when OCR fails, but a 4th slot is only there when +// OCR reads it. So only a read of 4 known quests proves a quest is gone; a +// missed read must not give a failing quest new attempts. +void forget_quests_gone_from_panel(std::set& failed_quests, const std::vector& panel){ + if (panel.size() < 4 || std::find(panel.begin(), panel.end(), BBQuests::UnableToDetect) != panel.end()){ + return; + } + std::erase_if(failed_quests, [&](BBQuests quest){ + return std::find(panel.begin(), panel.end(), quest) == panel.end(); + }); +} + +} + void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game){ std::vector quest_list; //all quests std::vector quests_to_do; //do-able quests uint8_t eggs_hatched = 0; //Track eggs uint64_t num_completed_quests = 0; + // Quests that failed every attempt do_quest() made. A failed quest stays + // on the panel, so without this it gets NUM_RETRIES more attempts every + // round, forever, e.g. a sneak-up whose target does not spawn. + std::set failed_quests; + auto read_panel = [&](){ + std::vector panel = game.read_quests(); + forget_quests_gone_from_panel(failed_quests, panel); + return panel; + }; + while (num_completed_quests < options.NUM_QUESTS){ if (options.OUT_OF_EGGS == BBQOption::OOEggs::Stop && eggs_hatched >= options.NUM_EGGS){ logger.log("Stop when out of eggs selected. Stopping program."); @@ -88,16 +117,27 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga //Get and reroll quests until we can at least one while (quests_to_do.size() < 1){ - quest_list = game.read_quests(); + quest_list = read_panel(); quests_to_do = game.process_quest_list(quest_list, eggs_hatched); + // Rerolling costs BP and the failed quests may be doable another + // time, so stop instead of spending BP to replace them. + const bool found_doable = !quests_to_do.empty(); + std::erase_if(quests_to_do, [&](BBQuests quest){ + return failed_quests.contains(quest); + }); + if (found_doable && quests_to_do.empty()){ + logger.log("Every doable quest on the panel failed all its attempts. Stopping program.", COLOR_RED); + return; + } + //Clear out the regular quest list. quest_list.clear(); } for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) - quest_list = game.read_quests(); + quest_list = read_panel(); if (std::find(quest_list.begin(), quest_list.end(), current_quest) != quest_list.end()){ logger.log("Current quest exists on list. Doing quest."); bool questSuccess = game.do_quest(current_quest, eggs_hatched); @@ -107,6 +147,7 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga num_completed_quests++; }else{ logger.log("Quest did not complete successfully."); + failed_quests.insert(current_quest); } }else{ //Note: This doesn't account for case such as "sneak up" being added and then completed alongside the next quest diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h index 1ac8535caf..1afa74e6dc 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h @@ -54,7 +54,8 @@ class BBQGameActions{ }; // Run rounds of quests until NUM_QUESTS have been completed, or until -// eggs run out when OUT_OF_EGGS is Stop. +// eggs run out when OUT_OF_EGGS is Stop, or until every doable quest on the +// panel is one that already failed all its attempts. void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game); From fe5055a40c7de35885fb4d248123ee7347111ea1 Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 10:59:00 -0700 Subject: [PATCH 05/18] Break the BBQ quest planner and its controller steps into helpers Move the out-of-eggs choice, the exclusions table rows, a single-slot reroll and the reroll of every slot into file-local helpers, so plan_quests() and process_quest_list() read as one level of steps. Explain why the language-selection error is commented out. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../Farming/PokemonSV_BlueberryQuests.cpp | 217 ++++++++++-------- 1 file changed, 125 insertions(+), 92 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index dab292b71a..f960282969 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -221,6 +221,122 @@ std::vector read_quests( return quest_list; } +namespace{ + +//Out of eggs, the egg quest cannot be done. OUT_OF_EGGS decides what happens to it. +void plan_out_of_eggs(Logger& logger, const BBQOption& BBQ_OPTIONS, size_t slot, BBQuestPlan& plan){ + switch (BBQ_OPTIONS.OUT_OF_EGGS){ + case BBQOption::OOEggs::Reroll: + logger.log("Reroll selected. Rerolling Egg quest. New quest will be run in the next batch of quests."); + //logger.log("Warning: This does not handle/check being out of BP!", COLOR_RED); + plan.reroll_slots.push_back(slot); + break; + case BBQOption::OOEggs::KeepGoing: + logger.log("Keep Going selected. Ignoring quest."); + break; + default: + //This case is handled in BBQSoloFarmer. + throw InternalProgramError(&logger, PA_CURRENT_FUNCTION, "OOEggs is Stop in process_quest_list()."); + } +} + +//Apply each exclusions table row for the quest, in table order. Returns false if no row is for it. +bool plan_from_exclusions( + Logger& logger, + const std::vector>& exclusions_table, + BBQuests quest, size_t slot, + BBQuestPlan& plan +){ + bool quest_in_table = false; + for (const std::unique_ptr& row : exclusions_table){ + if (quest != row->quest){ + continue; + } + logger.log("Quest found in inclusions/exclusions table."); + quest_in_table = true; + switch (row->action){ + case BBQAction::run: + logger.log("Run selected. Adding quest to list."); + plan.to_do.push_back(quest); + break; + case BBQAction::reroll: + logger.log("Reroll selected. Rerolling quest. New quest will be run in the next batch of quests."); + plan.reroll_slots.push_back(slot); + break; + case BBQAction::skip: + logger.log("Skip selected. Skipping quest."); + break; + } + } + return quest_in_table; +} + +//Open the quest panel from the overworld, with the cursor on the top quest. +void open_quest_panel(VideoStream& stream, ProControllerContext& context){ + WhiteButtonWatcher panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); + int result = run_until( + stream, context, + [&](ProControllerContext& context){ + for (int i = 0; i < 6; i++){ + pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); + pbf_wait(context, 1600ms); + context.wait_for_all_requests(); + } + }, + {{ panel }} + ); + if (result == 0){ + stream.log("Found quest panel."); + } + context.wait_for_all_requests(); +} + +void reroll_slot( + const ProgramInfo& info, + VideoStream& stream, ProControllerContext& context, + size_t slot +){ + open_quest_panel(stream, context); + + //Move cursor down to quest + for (size_t i = 0; i < slot; i++){ + pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); + pbf_wait(context, 800ms); + context.wait_for_all_requests(); + } + + //Reroll + pbf_press_button(context, BUTTON_A, 160ms, 400ms); + pbf_press_button(context, BUTTON_A, 160ms, 400ms); + pbf_wait(context, 800ms); + context.wait_for_all_requests(); + + press_Bs_to_back_to_overworld(info, stream, context); +} + +//This does not handle out of BP. +void reroll_all_slots( + const ProgramInfo& info, + VideoStream& stream, ProControllerContext& context, + size_t slots +){ + open_quest_panel(stream, context); + + for (size_t i = 0; i < slots; i++){ + pbf_press_button(context, BUTTON_A, 160ms, 400ms); + pbf_press_button(context, BUTTON_A, 160ms, 400ms); //Yes. + pbf_wait(context, 800ms); + context.wait_for_all_requests(); + pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); + pbf_wait(context, 800ms); + context.wait_for_all_requests(); + } + //Close quest panel - mash b + press_Bs_to_back_to_overworld(info, stream, context); +} + +} + BBQuestPlan plan_quests( Logger& logger, const BBQOption& BBQ_OPTIONS, @@ -240,43 +356,10 @@ BBQuestPlan plan_quests( //Check eggs remaining. if (n == BBQuests::hatch_egg && eggs_hatched >= BBQ_OPTIONS.NUM_EGGS){ logger.log("Out of eggs! Quest not possible."); - switch (BBQ_OPTIONS.OUT_OF_EGGS){ - case BBQOption::OOEggs::Reroll: - logger.log("Reroll selected. Rerolling Egg quest. New quest will be run in the next batch of quests."); - //logger.log("Warning: This does not handle/check being out of BP!", COLOR_RED); - plan.reroll_slots.push_back(slot); - break; - case BBQOption::OOEggs::KeepGoing: - logger.log("Keep Going selected. Ignoring quest."); - break; - default: - //This case is handled in BBQSoloFarmer. - throw InternalProgramError(&logger, PA_CURRENT_FUNCTION, "OOEggs is Stop in process_quest_list()."); - } + plan_out_of_eggs(logger, BBQ_OPTIONS, slot, plan); continue; } - bool quest_in_table = false; - for (const std::unique_ptr& row : exclusions_table){ - if (n != row->quest){ - continue; - } - logger.log("Quest found in inclusions/exclusions table."); - quest_in_table = true; - switch (row->action){ - case BBQAction::run: - logger.log("Run selected. Adding quest to list."); - plan.to_do.push_back(n); - break; - case BBQAction::reroll: - logger.log("Reroll selected. Rerolling quest. New quest will be run in the next batch of quests."); - plan.reroll_slots.push_back(slot); - break; - case BBQAction::skip: - logger.log("Skip selected. Skipping quest."); - break; - } - } - if (!quest_in_table){ + if (!plan_from_exclusions(logger, exclusions_table, n, slot, plan)){ logger.log("Quest not in inclusion/exclusions table. Adding to list."); plan.to_do.push_back(n); } @@ -288,30 +371,6 @@ BBQuestPlan plan_quests( return plan; } -namespace{ - -//Open the quest panel from the overworld, with the cursor on the top quest. -void open_quest_panel(VideoStream& stream, ProControllerContext& context){ - WhiteButtonWatcher panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); - int result = run_until( - stream, context, - [&](ProControllerContext& context){ - for (int i = 0; i < 6; i++){ - pbf_press_dpad(context, DPAD_RIGHT, 400ms, 160ms); - pbf_wait(context, 1600ms); - context.wait_for_all_requests(); - } - }, - {{ panel }} - ); - if (result == 0){ - stream.log("Found quest panel."); - } - context.wait_for_all_requests(); -} - -} - std::vector process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, @@ -322,43 +381,17 @@ std::vector process_quest_list( BBQuestPlan plan = plan_quests(stream.logger(), BBQ_OPTIONS, quest_list, eggs_hatched); for (size_t slot : plan.reroll_slots){ - open_quest_panel(stream, context); - - //Move cursor down to quest - for (size_t i = 0; i < slot; i++){ - pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - } - - //Reroll - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - - press_Bs_to_back_to_overworld(info, stream, context); + reroll_slot(info, stream, context, slot); } - if (plan.reroll_all){ stream.log("No possible quests! Rerolling all quests."); - - //Open quest panel and reroll all quests. - //This does not handle out of BP. - open_quest_panel(stream, context); - - for (string::size_type i = 0; i < quest_list.size(); i++){ - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_press_button(context, BUTTON_A, 160ms, 400ms); //Yes. - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - } - //Close quest panel - mash b - press_Bs_to_back_to_overworld(info, stream, context); + reroll_all_slots(info, stream, context, quest_list.size()); } + + //Disabled since 2025-05, when the exclusions table gained its reroll action. Before that, + //nothing doable stopped the program here, because it usually meant the game language + //option did not match the game and no quest could be read. Now all quests are rerolled + //above instead, which also covers a panel of only excluded quests. /* if (plan.reroll_all){ OperationFailedExceptionWithScreenshot::fire( From 5b86beecb19588dadffddbdaffc40035b9937dde Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 13:05:54 -0700 Subject: [PATCH 06/18] Check which quest a BBQ reroll pays for, and that it was replaced reroll_slot() opened the quest panel, pressed DOWN once per slot from where it assumed the cursor was, and pressed A twice. The panel does not always open with the cursor on the top quest: on a Switch it opened where the cursor was left, so the reroll paid for a different quest than planned. Nothing checked the menu opened or the quest changed, so running out of BP went unnoticed and the same quest was rerolled every round. reroll_quest() now does a reroll through injectable BBQRerollActions: open the reroll menu wherever the cursor is, see which quest the menu opened next to from its arrow, move to the planned quest, and only then confirm. Afterwards it reads the panel (up to 3 times, as OCR can miss a read) to check the quest was replaced. Panel or menu not found stops before spending BP; a quest not replaced stops without an error report, as it usually means out of BP. The arrow boxes for the top three slots were checked on a Switch; the fourth uses the same spacing. Reroll-all is unchanged. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 216 ++++++++++++++++++ .../Farming/PokemonSV_BlueberryQuests.cpp | 158 +++++++++++-- .../Farming/PokemonSV_BlueberryQuests.h | 47 ++++ 3 files changed, 403 insertions(+), 18 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 8c9563ff9a..610a5bb935 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -107,6 +107,128 @@ class Test_BBQuestPlan : public UnitTest{ const BBQuestPlanScenario m_scenario; }; + +// A quest panel with a cursor. A reroll replaces the quest under the cursor +// with the next of `replacements`, unless out of BP. +class SimulatedQuestPanel : public BBQRerollActions{ +public: + std::vector quests; + std::vector replacements; + size_t cursor = 0; + bool panel_opens = true; + bool menu_seen = true; + bool out_of_bp = false; + int missed_reads = 0; // Reads that fail OCR on every slot. + + bool panel_open = false; + bool menu_open = false; + std::vector rerolled_slots; + + virtual bool open_panel() override{ + panel_open = panel_opens; + return panel_open; + } + virtual std::optional open_reroll_menu() override{ + menu_open = true; + if (!menu_seen){ + return std::nullopt; + } + return cursor; + } + virtual void close_reroll_menu() override{ + menu_open = false; + } + virtual void move_cursor(int slots) override{ + cursor = (size_t)((int)cursor + slots); + } + virtual void confirm_reroll() override{ + menu_open = false; + if (out_of_bp){ + return; + } + rerolled_slots.push_back(cursor); + quests[cursor] = replacements[rerolled_slots.size() - 1]; + } + virtual void close_panel() override{ + panel_open = false; + menu_open = false; + } + virtual std::vector read_quests() override{ + if (missed_reads > 0){ + missed_reads--; + return std::vector(quests.size(), BBQuests::UnableToDetect); + } + return quests; + } +}; + +struct BBQRerollScenario{ + std::string name; + std::vector quests; + std::vector replacements; + size_t slot; + size_t cursor = 0; + bool panel_opens = true; + bool menu_seen = true; + bool out_of_bp = false; + int missed_reads = 0; + BBQRerollResult expected; + std::vector expected_rerolled_slots; + std::vector expected_quests; +}; + +std::string reroll_result_to_string(BBQRerollResult result){ + switch (result){ + case BBQRerollResult::Rerolled: return "Rerolled"; + case BBQRerollResult::PanelNotOpened: return "PanelNotOpened"; + case BBQRerollResult::MenuNotFound: return "MenuNotFound"; + case BBQRerollResult::NotReplaced: return "NotReplaced"; + } + return "?"; +} + +class Test_BBQReroll : public UnitTest{ +public: + Test_BBQReroll(BBQRerollScenario scenario) + : UnitTest("PokemonSV::BBQReroll - " + scenario.name) + , m_scenario(std::move(scenario)) + {} + + virtual UnitTestResult run(Logger&, CancellableScope&) const override{ + SimulatedQuestPanel panel; + panel.quests = m_scenario.quests; + panel.replacements = m_scenario.replacements; + panel.cursor = m_scenario.cursor; + panel.panel_opens = m_scenario.panel_opens; + panel.menu_seen = m_scenario.menu_seen; + panel.out_of_bp = m_scenario.out_of_bp; + panel.missed_reads = m_scenario.missed_reads; + + NullLogger logger; + std::vector quests = m_scenario.quests; + const BBQRerollResult result = reroll_quest(logger, panel, quests, m_scenario.slot); + if (result != m_scenario.expected){ + return "Expected " + reroll_result_to_string(m_scenario.expected) + + ", got " + reroll_result_to_string(result); + } + if (panel.rerolled_slots != m_scenario.expected_rerolled_slots){ + return "Expected rerolled slots: " + slots_to_string(m_scenario.expected_rerolled_slots) + + "got: " + slots_to_string(panel.rerolled_slots); + } + if (quests != m_scenario.expected_quests){ + return "Expected quests: " + quests_to_string(m_scenario.expected_quests) + + "got: " + quests_to_string(quests); + } + if (panel.panel_open || panel.menu_open){ + return "Panel left open."; + } + return true; + } + +private: + const BBQRerollScenario m_scenario; +}; + } void add_tests_BBQuestPlan(UnitTestDatabase& database){ @@ -180,10 +302,104 @@ void add_tests_BBQuestPlan(UnitTestDatabase& database){ } } +void add_tests_BBQReroll(UnitTestDatabase& database){ + using enum BBQuests; + const BBQRerollScenario scenarios[] = { + { + .name = "cursor on the top quest", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + }, + { + // Seen on a Switch: the panel can open with the cursor where it + // was left, so moving down from the top rerolls the wrong quest. + .name = "cursor left below the quest moves up", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 1, + .cursor = 3, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {1}, + .expected_quests = {make_tm, catch_any, sneak_up, hatch_egg}, + }, + { + .name = "fourth quest", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 3, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {3}, + .expected_quests = {make_tm, travel_500, sneak_up, catch_any}, + }, + { + .name = "panel not opened spends nothing", + .quests = {make_tm, sneak_up, travel_500}, + .slot = 2, + .panel_opens = false, + .expected = BBQRerollResult::PanelNotOpened, + .expected_quests = {make_tm, sneak_up, travel_500}, + }, + { + .name = "menu not seen spends nothing", + .quests = {make_tm, sneak_up, travel_500}, + .slot = 2, + .menu_seen = false, + .expected = BBQRerollResult::MenuNotFound, + .expected_quests = {make_tm, sneak_up, travel_500}, + }, + { + .name = "out of BP is not replaced", + .quests = {make_tm, sneak_up, travel_500}, + .slot = 2, + .out_of_bp = true, + .expected = BBQRerollResult::NotReplaced, + .expected_quests = {make_tm, sneak_up, travel_500}, + }, + { + .name = "a missed read is read again", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .missed_reads = 2, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + }, + { + .name = "three missed reads give up", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .missed_reads = 3, + .expected = BBQRerollResult::NotReplaced, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, travel_500}, + }, + { + // Cannot be told apart from out of BP. + .name = "replaced by the same quest is not replaced", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {travel_500}, + .slot = 2, + .expected = BBQRerollResult::NotReplaced, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, travel_500}, + }, + }; + for (const BBQRerollScenario& scenario : scenarios){ + database.add(scenario); + } +} + void add_tests(UnitTestDatabase& database){ add_tests_BBQuestPlan(database); + add_tests_BBQReroll(database); add_tests_WhiteButtonDetector(database); add_tests_BoxInfoDetector(database); add_tests_BoxEggDetector(database); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index f960282969..28e5481912 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -22,6 +22,7 @@ #include "VideoGames/PokemonSV/PokemonSV_Settings.h" #include "VideoGames/PokemonSV/Programs/PokemonSV_GameEntry.h" #include "VideoGames/PokemonSV/Inference/Dialogs/PokemonSV_DialogDetector.h" +#include "VideoGames/PokemonSV/Inference/Dialogs/PokemonSV_GradientArrowDetector.h" #include "VideoGames/PokemonSV/Inference/Battles/PokemonSV_NormalBattleMenus.h" #include "VideoGames/PokemonSV/Inference/Battles/PokemonSV_EncounterWatcher.h" #include "VideoGames/PokemonSV/Inference/PokemonSV_MainMenuDetector.h" @@ -271,8 +272,8 @@ bool plan_from_exclusions( return quest_in_table; } -//Open the quest panel from the overworld, with the cursor on the top quest. -void open_quest_panel(VideoStream& stream, ProControllerContext& context){ +//Open the quest panel from the overworld. Returns false if it did not open. +bool open_quest_panel(VideoStream& stream, ProControllerContext& context){ WhiteButtonWatcher panel(COLOR_BLUE, WhiteButton::ButtonB, {0.484, 0.117, 0.022, 0.037}); int result = run_until( stream, context, @@ -289,29 +290,102 @@ void open_quest_panel(VideoStream& stream, ProControllerContext& context){ stream.log("Found quest panel."); } context.wait_for_all_requests(); + return result == 0; } +class ConsoleBBQRerollActions : public BBQRerollActions{ +public: + ConsoleBBQRerollActions( + const ProgramInfo& info, + VideoStream& stream, ProControllerContext& context, + const BBQOption& BBQ_OPTIONS + ) + : m_info(info), m_stream(stream), m_context(context), m_options(BBQ_OPTIONS) + {} + + virtual bool open_panel() override{ + return open_quest_panel(m_stream, m_context); + } + virtual std::optional open_reroll_menu() override{ + //The menu opens next to the quest, with an arrow on its top choice. Slots are 0.177 + //apart; the boxes for the top 3 slots were checked on a Switch, the 4th is spaced + //the same way. + GradientArrowWatcher slot0(COLOR_RED, GradientArrowType::RIGHT, {0.475, 0.218, 0.070, 0.095}); + GradientArrowWatcher slot1(COLOR_RED, GradientArrowType::RIGHT, {0.475, 0.395, 0.070, 0.095}); + GradientArrowWatcher slot2(COLOR_RED, GradientArrowType::RIGHT, {0.475, 0.572, 0.070, 0.095}); + GradientArrowWatcher slot3(COLOR_RED, GradientArrowType::RIGHT, {0.475, 0.749, 0.070, 0.095}); + pbf_press_button(m_context, BUTTON_A, 160ms, 400ms); + m_context.wait_for_all_requests(); + int ret = wait_until( + m_stream, m_context, std::chrono::seconds(3), + {slot0, slot1, slot2, slot3} + ); + if (ret < 0){ + return std::nullopt; + } + return (size_t)ret; + } + virtual void close_reroll_menu() override{ + pbf_press_button(m_context, BUTTON_B, 160ms, 400ms); + m_context.wait_for_all_requests(); + } + virtual void move_cursor(int slots) override{ + for (int i = 0; i < std::abs(slots); i++){ + pbf_press_dpad(m_context, slots > 0 ? DPAD_DOWN : DPAD_UP, 160ms, 160ms); + pbf_wait(m_context, 800ms); + } + m_context.wait_for_all_requests(); + } + virtual void confirm_reroll() override{ + pbf_press_button(m_context, BUTTON_A, 160ms, 400ms); + pbf_wait(m_context, 800ms); + m_context.wait_for_all_requests(); + } + virtual void close_panel() override{ + press_Bs_to_back_to_overworld(m_info, m_stream, m_context); + } + virtual std::vector read_quests() override{ + return PokemonSV::read_quests(m_info, m_stream, m_context, m_options); + } + +private: + const ProgramInfo& m_info; + VideoStream& m_stream; + ProControllerContext& m_context; + const BBQOption& m_options; +}; + void reroll_slot( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, + const BBQOption& BBQ_OPTIONS, + std::vector& quest_list, size_t slot ){ - open_quest_panel(stream, context); - - //Move cursor down to quest - for (size_t i = 0; i < slot; i++){ - pbf_press_dpad(context, DPAD_DOWN, 160ms, 160ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); + ConsoleBBQRerollActions actions(info, stream, context, BBQ_OPTIONS); + switch (reroll_quest(stream.logger(), actions, quest_list, slot)){ + case BBQRerollResult::Rerolled: + return; + case BBQRerollResult::PanelNotOpened: + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::SEND_ERROR_REPORT, + "Unable to open the quest panel to reroll a quest.", + stream + ); + case BBQRerollResult::MenuNotFound: + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::SEND_ERROR_REPORT, + "Unable to open the reroll menu for quest " + std::to_string(slot + 1) + ". No BP was spent.", + stream + ); + case BBQRerollResult::NotReplaced: + //Most likely out of BP, which is not a program error. + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::NO_ERROR_REPORT, + "Quest " + std::to_string(slot + 1) + " was not replaced after rerolling it. Check that there is enough BP.", + stream + ); } - - //Reroll - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_press_button(context, BUTTON_A, 160ms, 400ms); - pbf_wait(context, 800ms); - context.wait_for_all_requests(); - - press_Bs_to_back_to_overworld(info, stream, context); } //This does not handle out of BP. @@ -337,6 +411,54 @@ void reroll_all_slots( } +BBQRerollResult reroll_quest( + Logger& logger, + BBQRerollActions& actions, + std::vector& quests, + size_t slot +){ + if (!actions.open_panel()){ + return BBQRerollResult::PanelNotOpened; + } + + //The cursor is not always on the top quest when the panel opens; it can be left where it + //was. So open the menu wherever the cursor is, see which quest it opened next to, and move + //from there. Moving can drop a press, so this is tried a few times. + bool menu_on_slot = false; + for (int attempt = 0; attempt < 3 && !menu_on_slot; attempt++){ + std::optional menu_slot = actions.open_reroll_menu(); + if (!menu_slot){ + //Without a menu, B would close the panel instead, so stop here. + break; + } + if (*menu_slot == slot){ + menu_on_slot = true; + break; + } + logger.log("Reroll menu opened on quest " + std::to_string(*menu_slot + 1) + ". Moving to quest " + std::to_string(slot + 1) + "."); + actions.close_reroll_menu(); + actions.move_cursor((int)slot - (int)*menu_slot); + } + if (!menu_on_slot){ + actions.close_panel(); + return BBQRerollResult::MenuNotFound; + } + actions.confirm_reroll(); + actions.close_panel(); + + //A read can miss the quest in the slot, so read up to 3 times before deciding it is + //still the old quest. + for (int read = 0; read < 3; read++){ + std::vector after = actions.read_quests(); + if (slot < after.size() && after[slot] != quests[slot] && after[slot] != BBQuests::UnableToDetect){ + logger.log("Quest " + std::to_string(slot + 1) + " rerolled."); + quests[slot] = after[slot]; + return BBQRerollResult::Rerolled; + } + } + return BBQRerollResult::NotReplaced; +} + BBQuestPlan plan_quests( Logger& logger, const BBQOption& BBQ_OPTIONS, @@ -381,7 +503,7 @@ std::vector process_quest_list( BBQuestPlan plan = plan_quests(stream.logger(), BBQ_OPTIONS, quest_list, eggs_hatched); for (size_t slot : plan.reroll_slots){ - reroll_slot(info, stream, context, slot); + reroll_slot(info, stream, context, BBQ_OPTIONS, quest_list, slot); } if (plan.reroll_all){ stream.log("No possible quests! Rerolling all quests."); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 92270cf374..25a847c154 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -7,6 +7,7 @@ #ifndef PokemonAutomation_PokemonSV_BlueberryQuests_H #define PokemonAutomation_PokemonSV_BlueberryQuests_H +#include #include #include "NintendoSwitch/Controllers/Procon/NintendoSwitch_ProController.h" #include "NintendoSwitch/NintendoSwitch_ConsoleHandle.h" @@ -82,6 +83,52 @@ BBQuestPlan plan_quests( uint8_t eggs_hatched ); +//The steps of rerolling one quest on the quest panel. They are injected so that the reroll +//(which quest it pays for, when it gives up) runs in tests without a Switch. +class BBQRerollActions{ +public: + virtual ~BBQRerollActions() = default; + + //Open the quest panel from the overworld. Returns false if it did not open. + virtual bool open_panel() = 0; + + //Press A on the quest under the cursor, which opens its reroll menu. Returns the slot of + //the quest the menu opened next to, or nothing if no menu was seen. + virtual std::optional open_reroll_menu() = 0; + + //Close the reroll menu without rerolling. + virtual void close_reroll_menu() = 0; + + //Move the cursor down this many slots, or up if negative. + virtual void move_cursor(int slots) = 0; + + //Choose to reroll in the open menu. This spends BP. + virtual void confirm_reroll() = 0; + + //Close the quest panel and return to the overworld. + virtual void close_panel() = 0; + + //Open the quest panel and read the quests on it, as read_quests() does. + virtual std::vector read_quests() = 0; +}; + +enum class BBQRerollResult{ + Rerolled, //The quest in the slot was replaced. + PanelNotOpened, //Nothing was spent. + MenuNotFound, //Nothing was spent. + NotReplaced, //The reroll was confirmed, but the slot still shows the same quest. +}; + +//Reroll the quest in `slot` of `quests`, the quests last read from the panel. Only pays once +//the reroll menu is open next to that slot, then reads the panel again to check the quest was +//replaced. On Rerolled, `quests[slot]` is updated to the new quest. +BBQRerollResult reroll_quest( + Logger& logger, + BBQRerollActions& actions, + std::vector& quests, + size_t slot +); + //Determine which quests are possible and which quests are not. (ex. no eggs, reroll egg hatcher.) //Quests not possible are removed from the list. If the list is empty, then reroll all items. std::vector process_quest_list( From f7e3ba6f0743b1e72286c3a8ee214d0f6494fd17 Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 13:07:34 -0700 Subject: [PATCH 07/18] Let the BBQ exclusions table reroll quests the farmer cannot do plan_quests() dropped quests the farmer cannot do (pickup, flying photo and catch) before looking at the exclusions table, so a reroll row for one of them did nothing: the quest stayed on the panel and blocked the slot. Pickup could not be picked in the table at all. The table is now applied first. Reroll and skip rows work for quests the farmer cannot do; a run row for one is ignored, since there is no route for it. Pickup is listed in the table. With nothing to do and nothing rerolled, the first quest the farmer cannot do that has no table row is rerolled instead of every quest, which costs one reroll instead of three or four. Every quest is still rerolled when there is no such quest. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../PokemonSV/Options/PokemonSV_BBQOption.cpp | 7 ++-- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 36 ++++++++++++++++- .../Farming/PokemonSV_BlueberryQuests.cpp | 39 +++++++++++++++---- .../Farming/PokemonSV_BlueberryQuests.h | 8 ++-- 4 files changed, 75 insertions(+), 15 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp index 4067d75fa3..4b50f2fcdf 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp @@ -17,7 +17,7 @@ const EnumDropdownDatabase& BBQuests_database(){ static EnumDropdownDatabase database{ {BBQuests::auto_10, "auto-10", "Defeat 10 wild Pokemon using Auto Battle!"}, {BBQuests::make_tm, "make-tm", "Make yourself a TM!"}, - //{BBQuests::pickup_10, "pickup-10", "Pick up items on the ground 10 times!"}, + {BBQuests::pickup_10, "pickup-10", "Pick up items on the ground 10 times!"}, {BBQuests::sneak_up, "sneak-up", "Successfully sneak up on 1 Pokemon and surprise them with a battle!"}, {BBQuests::photo_fly, "photo-fly", "Take a photo of a wild Pokemon in flight!"}, {BBQuests::photo_swim, "photo-swim", "Take a photo of a wild Pokemon that is swimming!"}, @@ -110,8 +110,9 @@ BBQuestTable::BBQuestTable() "Exclude the quests in the table. If you want to skip a quest, select it below. " "(Quests can be explicitly included, but this is not necessary.) " "Do not exclude too many quests, as rerolling costs BP. " - "The program will automatically reroll all quests if none are possible, but will not handle being out of BP. " - "Does not include egg hatching or pickup quests, as eggs are handled in other options and pickup is not possible. ", + "If no quest is possible, the program rerolls one quest it cannot do, or all quests if there is none. " + "Quests the program cannot do, such as pickup, are never run, but can be rerolled or skipped here. " + "Does not include egg hatching, as eggs are handled in other options. ", //"Duplicates of the same quest", //duplicates will work in table order. might lead to weird behavior like rerolling and then marking a quest as complete. //won't break the program though. diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 610a5bb935..1a4eeda810 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -245,10 +245,42 @@ void add_tests_BBQuestPlan(UnitTestDatabase& database){ .expected_to_do = {make_tm}, }, { - .name = "nothing doable rerolls all", - .quests = {pickup_10, auto_10, catch_flying}, + // One quest costs less BP to reroll than all of them. + .name = "nothing doable rerolls the first quest not possible", + .quests = {auto_10, pickup_10, catch_flying}, + .expected_reroll_slots = {1}, + }, + { + .name = "nothing doable and nothing not possible rerolls all", + .quests = {auto_10, sneak_up}, + .extra_exclusions = {{sneak_up, BBQAction::skip}}, .expected_reroll_all = true, }, + { + // An undetected quest is not known to be impossible. + .name = "an undetected quest is not rerolled alone", + .quests = {UnableToDetect, auto_10}, + .expected_reroll_all = true, + }, + { + .name = "a skipped quest not possible is not rerolled", + .quests = {pickup_10, auto_10, catch_flying}, + .extra_exclusions = {{pickup_10, BBQAction::skip}}, + .expected_reroll_slots = {2}, + }, + { + .name = "a reroll row rerolls a quest not possible", + .quests = {make_tm, sneak_up, pickup_10}, + .extra_exclusions = {{pickup_10, BBQAction::reroll}}, + .expected_to_do = {make_tm, sneak_up}, + .expected_reroll_slots = {2}, + }, + { + .name = "a run row does not run a quest not possible", + .quests = {make_tm, pickup_10}, + .extra_exclusions = {{pickup_10, BBQAction::run}}, + .expected_to_do = {make_tm}, + }, { // The reroll replaces a quest, so the next read has something new. .name = "a reroll row rerolls that slot", diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 28e5481912..3fa394a421 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -242,10 +242,11 @@ void plan_out_of_eggs(Logger& logger, const BBQOption& BBQ_OPTIONS, size_t slot, } //Apply each exclusions table row for the quest, in table order. Returns false if no row is for it. +//A quest the program cannot do is never run, but can still be rerolled or skipped. bool plan_from_exclusions( Logger& logger, const std::vector>& exclusions_table, - BBQuests quest, size_t slot, + BBQuests quest, size_t slot, bool possible, BBQuestPlan& plan ){ bool quest_in_table = false; @@ -257,6 +258,10 @@ bool plan_from_exclusions( quest_in_table = true; switch (row->action){ case BBQAction::run: + if (!possible){ + logger.log("Run selected, but this quest is not possible. Skipping quest."); + break; + } logger.log("Run selected. Adding quest to list."); plan.to_do.push_back(quest); break; @@ -468,11 +473,14 @@ BBQuestPlan plan_quests( BBQuestPlan plan; std::vector> exclusions_table = BBQ_OPTIONS.QUEST_EXCLUSIONS.copy_snapshot(); + //The first quest not possible that has no table row, to reroll if nothing else can be done. + std::optional not_possible_slot; + logger.log("Processing quests."); for (size_t slot = 0; slot < quest_list.size(); slot++){ const BBQuests n = quest_list[slot]; - if (not_possible_quests.contains(n)){ - logger.log("Quest not possible"); + if (n == BBQuests::UnableToDetect){ + logger.log("Quest not detected."); continue; } //Check eggs remaining. @@ -481,15 +489,32 @@ BBQuestPlan plan_quests( plan_out_of_eggs(logger, BBQ_OPTIONS, slot, plan); continue; } - if (!plan_from_exclusions(logger, exclusions_table, n, slot, plan)){ - logger.log("Quest not in inclusion/exclusions table. Adding to list."); - plan.to_do.push_back(n); + const bool possible = !not_possible_quests.contains(n); + if (plan_from_exclusions(logger, exclusions_table, n, slot, possible, plan)){ + continue; + } + if (!possible){ + logger.log("Quest not possible."); + if (!not_possible_slot){ + not_possible_slot = slot; + } + continue; } + logger.log("Quest not in inclusion/exclusions table. Adding to list."); + plan.to_do.push_back(n); } //Check that quests_to_do is not empty (after completing all quests on the list, be sure to erase it. //Lag might be a problem in multi - look into making slots like menu-left navigation - plan.reroll_all = plan.reroll_slots.empty() && plan.to_do.empty(); + if (plan.reroll_slots.empty() && plan.to_do.empty()){ + if (not_possible_slot){ + //Rerolling one quest costs less BP than rerolling all of them. + logger.log("No possible quests! Rerolling a quest that is not possible."); + plan.reroll_slots.push_back(*not_possible_slot); + }else{ + plan.reroll_all = true; + } + } return plan; } diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 25a847c154..d32d9fb5cc 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -73,9 +73,11 @@ struct BBQuestPlan{ bool reroll_all = false; //Nothing to do and nothing rerolled: reroll every slot. }; //Decide what to do with each quest from the options alone, without touching the game, so -//the decision can be tested. Quests not possible are left out. Out-of-egg hatch quests and -//quests set to reroll in the exclusions table are rerolled. A quest with several table rows -//gets the action of each row, in table order. +//the decision can be tested. Quests not possible are left out, unless the exclusions table +//rerolls them. Out-of-egg hatch quests and quests set to reroll in the exclusions table are +//rerolled. A quest with several table rows gets the action of each row, in table order. With +//nothing to do and nothing rerolled, the first quest not possible and not in the table is +//rerolled, or else every quest. BBQuestPlan plan_quests( Logger& logger, const BBQOption& BBQ_OPTIONS, From a1b685f9e255bd8de34eed566a998322900da271 Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 13:10:16 -0700 Subject: [PATCH 08/18] Let the BBQ farmer reroll or stop on a quest that fails all its retries A quest that fails all its retries is skipped while it stays on the panel. That keeps the farmer going, but the quest blocks its slot, and if every doable quest is one that failed the farmer stops. OUT_OF_RETRIES now chooses what happens: - Skip (default): as before. - Reroll: reroll the failed quest, so its slot gets a new quest. Uses reroll_quest_slot(), which checks which quest it pays for and that it was replaced. - Stop: end the program there, through the normal end of program. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../PokemonSV/Options/PokemonSV_BBQOption.cpp | 11 +++ .../PokemonSV/Options/PokemonSV_BBQOption.h | 7 ++ .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 27 ++++++++ .../Farming/PokemonSV_BBQSoloFarmer.cpp | 22 +++++- .../Farming/PokemonSV_BBQSoloFarmer.h | 7 +- .../Farming/PokemonSV_BlueberryQuests.cpp | 67 ++++++++++--------- .../Farming/PokemonSV_BlueberryQuests.h | 10 +++ 7 files changed, 116 insertions(+), 35 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp index 4067d75fa3..a15034162b 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.cpp @@ -192,6 +192,16 @@ BBQOption::BBQOption(OCR::LanguageOCROption* language_option) "Number of Retries:
Reattempt a quest this many times if it fails.", LockMode::UNLOCK_WHILE_RUNNING, 1, 0, 5 ) + , OUT_OF_RETRIES( + "Out of Retries:
When a quest fails all its retries, do the selected option.", + { + {OutOfRetries::Skip, "skip", "Skip Quest - Not attempted again while it stays on the panel"}, + {OutOfRetries::Reroll, "reroll", "Reroll Quest - Costs BP"}, + {OutOfRetries::Stop, "stop", "Stop Program"}, + }, + LockMode::UNLOCK_WHILE_RUNNING, + OutOfRetries::Skip + ) , FIX_TIME_WHEN_DONE( "Fix Time when Done:
Fix the time after the program finishes.", LockMode::UNLOCK_WHILE_RUNNING, false @@ -212,6 +222,7 @@ BBQOption::BBQOption(OCR::LanguageOCROption* language_option) PA_ADD_OPTION(BATTLE_AI); PA_ADD_OPTION(CATCH_ON_WIN); PA_ADD_OPTION(NUM_RETRIES); + PA_ADD_OPTION(OUT_OF_RETRIES); PA_ADD_OPTION(FIX_TIME_WHEN_DONE); } diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.h b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.h index 48db02d5f9..c93cb83a21 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Options/PokemonSV_BBQOption.h @@ -85,6 +85,12 @@ class BBQOption : public GroupOption{ KeepGoing, }; + enum class OutOfRetries{ + Skip, + Reroll, + Stop, + }; + OCR::LanguageOCROption& LANGUAGE; SimpleIntegerOption NUM_QUESTS; @@ -109,6 +115,7 @@ class BBQOption : public GroupOption{ TeraFarmerCatchOnWin CATCH_ON_WIN; SimpleIntegerOption NUM_RETRIES; + EnumDropdownOption OUT_OF_RETRIES; BooleanCheckBoxOption FIX_TIME_WHEN_DONE; diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 0e25fd09c3..2325d9b069 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -465,6 +465,13 @@ class SimulatedBBQGameActions : public BBQGameActions{ } return success; } + virtual void reroll_quest(BBQuests quest) override{ + events.push_back("reroll"); + auto iter = std::find(panel.begin(), panel.end(), quest); + if (iter != panel.end()){ + *iter = next_new_quest(); + } + } virtual void quest_completed() override{ events.push_back("completed"); } @@ -515,6 +522,7 @@ struct BBQRoundsScenario{ std::vector> also_completes; std::set never_completes; std::vector new_quests; + BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; uint64_t expected_completed = 0; std::string expected; }; @@ -534,6 +542,7 @@ class Test_BBQFarmerRounds : public UnitTest{ options.NUM_EGGS.set(0); options.OUT_OF_EGGS.set(BBQOption::OOEggs::Stop); } + options.OUT_OF_RETRIES.set(m_scenario.out_of_retries); SimulatedBBQGameActions game; game.panel = m_scenario.panel; @@ -665,6 +674,24 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ "read process read do completed read do completed end " "read process read do completed end", }, + { + // sneak-up is rerolled to photo-polar, which round 2 attempts. + .name = "out of retries with reroll replaces the failed quest", + .num_quests = 3, + .never_completes = {BBQuests::sneak_up}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .expected_completed = 5, + .expected = "read process read do completed read do completed read do reroll end " + round_of_3 + " end", + }, + { + .name = "out of retries with stop stops at once", + .num_quests = 3, + .panel = {BBQuests::sneak_up, BBQuests::make_tm, BBQuests::auto_10}, + .never_completes = {BBQuests::sneak_up}, + .out_of_retries = BBQOption::OutOfRetries::Stop, + .expected_completed = 0, + .expected = "read process read do", + }, }; for (const BBQRoundsScenario& scenario : scenarios){ database.add(scenario); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index ee63a9b792..d67906f0ff 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -147,7 +147,18 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga num_completed_quests++; }else{ logger.log("Quest did not complete successfully."); - failed_quests.insert(current_quest); + switch (options.OUT_OF_RETRIES){ + case BBQOption::OutOfRetries::Skip: + failed_quests.insert(current_quest); + break; + case BBQOption::OutOfRetries::Reroll: + logger.log("Reroll selected. Rerolling the failed quest."); + game.reroll_quest(current_quest); + break; + case BBQOption::OutOfRetries::Stop: + logger.log("Stop selected. Stopping program.", COLOR_RED); + return; + } } }else{ //Note: This doesn't account for case such as "sneak up" being added and then completed alongside the next quest @@ -191,6 +202,15 @@ class BBQSoloFarmerGameActions : public BBQGameActions{ virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) override{ return process_and_do_quest(m_env, m_env.console, m_context, m_options, quest, eggs_hatched); } + virtual void reroll_quest(BBQuests quest) override{ + std::vector quests = PokemonSV::read_quests(m_env.program_info(), m_env.console, m_context, m_options); + auto iter = std::find(quests.begin(), quests.end(), quest); + if (iter == quests.end()){ + m_env.log("Failed quest is no longer on the panel. Not rerolling."); + return; + } + reroll_quest_slot(m_env.program_info(), m_env.console, m_context, m_options, quests, iter - quests.begin()); + } virtual void quest_completed() override{ m_stats.questsCompleted++; m_env.update_stats(); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h index 1afa74e6dc..c9c32d591c 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h @@ -43,6 +43,10 @@ class BBQGameActions{ // Increments `eggs_hatched` when the quest hatches eggs. virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) = 0; + // Reroll a quest that failed all its attempts, if it is still on the + // panel. Spends BP. + virtual void reroll_quest(BBQuests quest) = 0; + // Progress reporting only: a quest was counted as completed. Lets stats // update after every quest instead of once per round. virtual void quest_completed() = 0; @@ -55,7 +59,8 @@ class BBQGameActions{ // Run rounds of quests until NUM_QUESTS have been completed, or until // eggs run out when OUT_OF_EGGS is Stop, or until every doable quest on the -// panel is one that already failed all its attempts. +// panel is one that already failed all its attempts, or until a quest fails +// all its attempts when OUT_OF_RETRIES is Stop. void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& game); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 59d5656a8a..2f5514dbc6 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -355,38 +355,6 @@ class ConsoleBBQRerollActions : public BBQRerollActions{ const BBQOption& m_options; }; -void reroll_slot( - const ProgramInfo& info, - VideoStream& stream, ProControllerContext& context, - const BBQOption& BBQ_OPTIONS, - std::vector& quest_list, - size_t slot -){ - ConsoleBBQRerollActions actions(info, stream, context, BBQ_OPTIONS); - switch (reroll_quest(stream.logger(), actions, quest_list, slot)){ - case BBQRerollResult::Rerolled: - return; - case BBQRerollResult::PanelNotOpened: - OperationFailedExceptionWithScreenshot::fire( - ErrorReportMode::SEND_ERROR_REPORT, - "Unable to open the quest panel to reroll a quest.", - stream - ); - case BBQRerollResult::MenuNotFound: - OperationFailedExceptionWithScreenshot::fire( - ErrorReportMode::SEND_ERROR_REPORT, - "Unable to open the reroll menu for quest " + std::to_string(slot + 1) + ". No BP was spent.", - stream - ); - case BBQRerollResult::NotReplaced: - //Most likely out of BP, which is not a program error. - OperationFailedExceptionWithScreenshot::fire( - ErrorReportMode::NO_ERROR_REPORT, - "Quest " + std::to_string(slot + 1) + " was not replaced after rerolling it. Check that there is enough BP.", - stream - ); - } -} //This does not handle out of BP. void reroll_all_slots( @@ -459,6 +427,39 @@ BBQRerollResult reroll_quest( return BBQRerollResult::NotReplaced; } +void reroll_quest_slot( + const ProgramInfo& info, + VideoStream& stream, ProControllerContext& context, + const BBQOption& BBQ_OPTIONS, + std::vector& quest_list, + size_t slot +){ + ConsoleBBQRerollActions actions(info, stream, context, BBQ_OPTIONS); + switch (reroll_quest(stream.logger(), actions, quest_list, slot)){ + case BBQRerollResult::Rerolled: + return; + case BBQRerollResult::PanelNotOpened: + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::SEND_ERROR_REPORT, + "Unable to open the quest panel to reroll a quest.", + stream + ); + case BBQRerollResult::MenuNotFound: + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::SEND_ERROR_REPORT, + "Unable to open the reroll menu for quest " + std::to_string(slot + 1) + ". No BP was spent.", + stream + ); + case BBQRerollResult::NotReplaced: + //Most likely out of BP, which is not a program error. + OperationFailedExceptionWithScreenshot::fire( + ErrorReportMode::NO_ERROR_REPORT, + "Quest " + std::to_string(slot + 1) + " was not replaced after rerolling it. Check that there is enough BP.", + stream + ); + } +} + BBQuestPlan plan_quests( Logger& logger, const BBQOption& BBQ_OPTIONS, @@ -505,7 +506,7 @@ std::vector process_quest_list( //Each reroll updates the panel the next one checks against. std::vector panel = quest_list; for (size_t slot : plan.reroll_slots){ - reroll_slot(info, stream, context, BBQ_OPTIONS, panel, slot); + reroll_quest_slot(info, stream, context, BBQ_OPTIONS, panel, slot); } if (plan.reroll_all){ stream.log("No possible quests! Rerolling all quests."); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 5939c326e6..a7044e73fe 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -129,6 +129,16 @@ BBQRerollResult reroll_quest( size_t slot ); +//Reroll the quest in `slot` of `quests` on the console, with reroll_quest(). Stops the program +//if the reroll fails. +void reroll_quest_slot( + const ProgramInfo& info, + VideoStream& stream, ProControllerContext& context, + const BBQOption& BBQ_OPTIONS, + std::vector& quests, + size_t slot +); + //Determine which quests are possible and which quests are not. (ex. no eggs, reroll egg hatcher.) //Quests not possible are removed from the list. If the list is empty, then reroll all items. std::vector process_quest_list( From 3f1f79f0a32cfb625860668eb683c99a7f4104bf Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 18:30:38 -0700 Subject: [PATCH 09/18] BBQ Farmer: reuse complete reroll observations before new game actions --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 84 +++++++++++++++++-- .../Farming/PokemonSV_BBQSoloFarmer.cpp | 33 +++++++- .../Farming/PokemonSV_BBQSoloFarmer.h | 6 +- .../Farming/PokemonSV_BlueberryQuests.cpp | 31 +++++-- .../Farming/PokemonSV_BlueberryQuests.h | 19 +++-- 5 files changed, 147 insertions(+), 26 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 089a1c50cf..0570376d93 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -120,8 +120,8 @@ class SimulatedQuestPanel : public BBQRerollActions{ size_t cursor = 0; bool panel_opens = true; bool menu_seen = true; - bool out_of_bp = false; int missed_reads = 0; // Reads that fail OCR on every slot. + std::optional> read_override; bool panel_open = false; bool menu_open = false; @@ -161,7 +161,7 @@ class SimulatedQuestPanel : public BBQRerollActions{ missed_reads--; return std::vector(quests.size(), BBQuests::UnableToDetect); } - return quests; + return read_override.value_or(quests); } }; @@ -173,11 +173,12 @@ struct BBQRerollScenario{ size_t cursor = 0; bool panel_opens = true; bool menu_seen = true; - bool out_of_bp = false; int missed_reads = 0; + std::optional> read_override; BBQRerollResult expected; std::vector expected_rerolled_slots; std::vector expected_quests; + std::optional> expected_observed_panel; }; std::string reroll_result_to_string(BBQRerollResult result){ @@ -206,10 +207,12 @@ class Test_BBQReroll : public UnitTest{ panel.menu_seen = m_scenario.menu_seen; panel.out_of_bp = m_scenario.out_of_bp; panel.missed_reads = m_scenario.missed_reads; + panel.read_override = m_scenario.read_override; NullLogger logger; std::vector quests = m_scenario.quests; - const BBQRerollResult result = reroll_quest(logger, panel, quests, m_scenario.slot); + std::optional> observed_panel; + const BBQRerollResult result = reroll_quest(logger, panel, quests, m_scenario.slot, observed_panel); if (result != m_scenario.expected){ return "Expected " + reroll_result_to_string(m_scenario.expected) + ", got " + reroll_result_to_string(result); @@ -222,6 +225,10 @@ class Test_BBQReroll : public UnitTest{ return "Expected quests: " + quests_to_string(m_scenario.expected_quests) + "got: " + quests_to_string(quests); } + if (observed_panel != m_scenario.expected_observed_panel){ + return "Expected observed panel: " + quests_to_string(m_scenario.expected_observed_panel.value_or(std::vector{})) + + ", got: " + quests_to_string(observed_panel.value_or(std::vector{})); + } if (panel.panel_open || panel.menu_open){ return "Panel left open."; } @@ -340,6 +347,47 @@ void add_tests_BBQuestPlan(UnitTestDatabase& database){ void add_tests_BBQReroll(UnitTestDatabase& database){ using enum BBQuests; const BBQRerollScenario scenarios[] = { + { + .name = "unknown fourth slot is not reusable", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{make_tm, travel_500, catch_any, UnableToDetect}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, travel_500, catch_any, hatch_egg}, + }, + { + .name = "missing fourth slot is not reusable", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{make_tm, travel_500, catch_any}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, travel_500, catch_any, hatch_egg}, + }, + { + .name = "another changed quest is not reusable", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{photo_canyon, travel_500, catch_any, hatch_egg}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, travel_500, catch_any, hatch_egg}, + }, + { + .name = "complete observation after missed reads is reusable", + .quests = {make_tm, travel_500, sneak_up, hatch_egg}, + .replacements = {catch_any}, + .slot = 2, + .missed_reads = 2, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, travel_500, catch_any, hatch_egg}, + .expected_observed_panel = std::vector{make_tm, travel_500, catch_any, hatch_egg}, + }, { .name = "cursor on the top quest", .quests = {make_tm, sneak_up, travel_500}, @@ -360,6 +408,7 @@ void add_tests_BBQReroll(UnitTestDatabase& database){ .expected = BBQRerollResult::Rerolled, .expected_rerolled_slots = {1}, .expected_quests = {make_tm, catch_any, sneak_up, hatch_egg}, + .expected_observed_panel = std::vector{make_tm, catch_any, sneak_up, hatch_egg}, }, { .name = "fourth quest", @@ -369,6 +418,7 @@ void add_tests_BBQReroll(UnitTestDatabase& database){ .expected = BBQRerollResult::Rerolled, .expected_rerolled_slots = {3}, .expected_quests = {make_tm, travel_500, sneak_up, catch_any}, + .expected_observed_panel = std::vector{make_tm, travel_500, sneak_up, catch_any}, }, { .name = "panel not opened spends nothing", @@ -456,6 +506,7 @@ class SimulatedBBQGameActions : public BBQGameActions{ BBQuests::photo_savanna, BBQuests::catch_any, BBQuests::catch_normal, BBQuests::catch_fire, BBQuests::catch_water, BBQuests::catch_grass, }; + bool reuse_rerolled_panel = false; std::vector events; @@ -466,7 +517,7 @@ class SimulatedBBQGameActions : public BBQGameActions{ } return panel; } - virtual std::vector process_quest_list( + virtual BBQuestBatch process_quest_list( const std::vector& quests, uint8_t ) override{ events.push_back("process"); @@ -476,12 +527,13 @@ class SimulatedBBQGameActions : public BBQGameActions{ doable.push_back(quest); } } - if (doable.empty()){ + const bool rerolled = doable.empty(); + if (rerolled){ for (BBQuests& slot : panel){ slot = next_new_quest(); } } - return doable; + return {std::move(doable), rerolled && reuse_rerolled_panel && quests.size() == 4 ? std::optional(panel) : std::nullopt}; } virtual bool do_quest(BBQuests quest, uint8_t&) override{ events.push_back("do"); @@ -555,6 +607,7 @@ struct BBQRoundsScenario{ std::set never_completes; std::vector new_quests; BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; + bool reuse_rerolled_panel = false; uint64_t expected_completed = 0; std::string expected; }; @@ -584,6 +637,7 @@ class Test_BBQFarmerRounds : public UnitTest{ if (!m_scenario.new_quests.empty()){ game.new_quests = m_scenario.new_quests; } + game.reuse_rerolled_panel = m_scenario.reuse_rerolled_panel; NullLogger logger; run_bbq_rounds(logger, options, game); @@ -606,6 +660,22 @@ class Test_BBQFarmerRounds : public UnitTest{ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ const std::string round_of_3 = "read process read do completed read do completed read do completed"; const BBQRoundsScenario scenarios[] = { + { + .name = "reuses reroll observation for selection and first dispatch only", + .num_quests = 1, + .panel = {BBQuests::pickup_10, BBQuests::catch_flying, BBQuests::UnableToDetect, BBQuests::photo_flying}, + .reuse_rerolled_panel = true, + .expected_completed = 4, + .expected = "read process process do completed read do completed read do completed read do completed end", + }, + { + .name = "three-slot reroll still reads the panel again", + .num_quests = 1, + .panel = {BBQuests::pickup_10, BBQuests::catch_flying, BBQuests::UnableToDetect}, + .reuse_rerolled_panel = true, + .expected_completed = 3, + .expected = "read process read process read do completed read do completed read do completed end", + }, { // The goal (4) is reached in the middle of round 2. The loop only // checks the goal between rounds, so round 2 finishes and 6 quests diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index d67906f0ff..6c3c2fcf83 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -103,6 +103,8 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga // on the panel, so without this it gets NUM_RETRIES more attempts every // round, forever, e.g. a sneak-up whose target does not spawn. std::set failed_quests; + std::optional> observed_panel; + std::optional> dispatch_panel; auto read_panel = [&](){ std::vector panel = game.read_quests(); forget_quests_gone_from_panel(failed_quests, panel); @@ -117,8 +119,22 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga //Get and reroll quests until we can at least one while (quests_to_do.size() < 1){ - quest_list = read_panel(); - quests_to_do = game.process_quest_list(quest_list, eggs_hatched); + const bool reused_panel = observed_panel.has_value(); + if (observed_panel){ + logger.log("Reusing verified quest panel for scheduling."); + quest_list = std::move(*observed_panel); + observed_panel.reset(); + forget_quests_gone_from_panel(failed_quests, quest_list); + }else{ + logger.log("Reading quest panel for scheduling."); + quest_list = read_panel(); + } + BBQuestBatch batch = game.process_quest_list(quest_list, eggs_hatched); + quests_to_do = std::move(batch.to_do); + observed_panel = std::move(batch.observed_panel); + if (reused_panel && !quests_to_do.empty() && !observed_panel){ + dispatch_panel = quest_list; + } // Rerolling costs BP and the failed quests may be doable another // time, so stop instead of spending BP to replace them. @@ -135,9 +151,18 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga quest_list.clear(); } + //Never carry an observation across quest actions or the round's date/reset work. + observed_panel.reset(); for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) - quest_list = read_panel(); + if (dispatch_panel){ + logger.log("Reusing verified quest panel for first dispatch."); + quest_list = std::move(*dispatch_panel); + dispatch_panel.reset(); + }else{ + logger.log("Reading quest panel before dispatch."); + quest_list = read_panel(); + } if (std::find(quest_list.begin(), quest_list.end(), current_quest) != quest_list.end()){ logger.log("Current quest exists on list. Doing quest."); bool questSuccess = game.do_quest(current_quest, eggs_hatched); @@ -194,7 +219,7 @@ class BBQSoloFarmerGameActions : public BBQGameActions{ virtual std::vector read_quests() override{ return PokemonSV::read_quests(m_env.program_info(), m_env.console, m_context, m_options); } - virtual std::vector process_quest_list( + virtual BBQuestBatch process_quest_list( const std::vector& quests, uint8_t eggs_hatched ) override{ return PokemonSV::process_quest_list(m_env.program_info(), m_env.console, m_context, m_options, quests, eggs_hatched); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h index c9c32d591c..17701b0fe5 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h @@ -13,7 +13,7 @@ #include "CommonFramework/Notifications/EventNotificationsTable.h" #include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h" #include "NintendoSwitch/Options/NintendoSwitch_GoHomeWhenDoneOption.h" -#include "VideoGames/PokemonSV/Options/PokemonSV_BBQOption.h" +#include "VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h" namespace PokemonAutomation{ namespace NintendoSwitch{ @@ -33,8 +33,8 @@ class BBQGameActions{ // Decide which of the quests just read are worth attempting this round. // May reroll quests in game, so the returned list can be empty even when - // `quests` is not; the loop then reads the panel again. - virtual std::vector process_quest_list( + // `quests` is not; a complete post-reroll observation can seed selection. + virtual BBQuestBatch process_quest_list( const std::vector& quests, uint8_t eggs_hatched ) = 0; diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 0c9b2c2ce7..4e5425c6dc 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -350,6 +350,7 @@ class ConsoleBBQRerollActions : public BBQRerollActions{ press_Bs_to_back_to_overworld(m_info, m_stream, m_context); } virtual std::vector read_quests() override{ + m_stream.log("Reading quest panel to verify reroll."); return PokemonSV::read_quests(m_info, m_stream, m_context, m_options); } @@ -388,8 +389,10 @@ BBQRerollResult reroll_quest( Logger& logger, BBQRerollActions& actions, std::vector& quests, - size_t slot + size_t slot, + std::optional>& observed_panel ){ + observed_panel.reset(); if (!actions.open_panel()){ return BBQRerollResult::PanelNotOpened; } @@ -426,13 +429,19 @@ BBQRerollResult reroll_quest( if (slot < after.size() && after[slot] != quests[slot] && after[slot] != BBQuests::UnableToDetect){ logger.log("Quest " + std::to_string(slot + 1) + " rerolled."); quests[slot] = after[slot]; + //Three slots can mean a missed fourth quest. Reuse only a complete + //read whose other slots agree with the panel used for this reroll. + if (after.size() == 4 && after == quests + && std::find(after.begin(), after.end(), BBQuests::UnableToDetect) == after.end()){ + observed_panel = std::move(after); + } return BBQRerollResult::Rerolled; } } return BBQRerollResult::NotReplaced; } -void reroll_quest_slot( +std::optional> reroll_quest_slot( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, @@ -440,9 +449,10 @@ void reroll_quest_slot( size_t slot ){ ConsoleBBQRerollActions actions(info, stream, context, BBQ_OPTIONS); - switch (reroll_quest(stream.logger(), actions, quest_list, slot)){ + std::optional> observed_panel; + switch (reroll_quest(stream.logger(), actions, quest_list, slot, observed_panel)){ case BBQRerollResult::Rerolled: - return; + return observed_panel; case BBQRerollResult::PanelNotOpened: OperationFailedExceptionWithScreenshot::fire( ErrorReportMode::SEND_ERROR_REPORT, @@ -519,7 +529,7 @@ BBQuestPlan plan_quests( return plan; } -std::vector process_quest_list( +BBQuestBatch process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, @@ -530,8 +540,9 @@ std::vector process_quest_list( //Each reroll updates the panel the next one checks against. std::vector panel = quest_list; + std::optional> observed_panel; for (size_t slot : plan.reroll_slots){ - reroll_quest_slot(info, stream, context, BBQ_OPTIONS, panel, slot); + observed_panel = reroll_quest_slot(info, stream, context, BBQ_OPTIONS, panel, slot); } if (plan.reroll_all){ stream.log("No possible quests! Rerolling all quests."); @@ -551,7 +562,12 @@ std::vector process_quest_list( ); } */ - return plan.to_do; + //A mutation invalidates queued work, even when other quests remain runnable. + //A complete replacement observation can seed the next selection instead. + if (!plan.reroll_slots.empty() || plan.reroll_all){ + return {{}, std::move(observed_panel)}; + } + return {std::move(plan.to_do), std::nullopt}; } bool process_and_do_quest( @@ -664,6 +680,7 @@ bool process_and_do_quest( } //Validate quest was completed by checking list + console.log("Reading quest panel after attempt."); std::vector quest_list = read_quests(env.program_info(), console, context, BBQ_OPTIONS); if (std::find(quest_list.begin(), quest_list.end(), current_quest) != quest_list.end()){ console.log("Current quest exists on list. Quest did not complete."); diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index 4f036ed73a..e4e614e2a2 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -85,6 +85,13 @@ BBQuestPlan plan_quests( uint8_t eggs_hatched ); +//Work selected from a panel, or a complete observed panel to replan after a reroll. +//The observation is consumed once, before any further game actions. +struct BBQuestBatch{ + std::vector to_do; + std::optional> observed_panel; +}; + //The steps of rerolling one quest on the quest panel. They are injected so that the reroll //(which quest it pays for, when it gives up) runs in tests without a Switch. class BBQRerollActions{ @@ -123,17 +130,19 @@ enum class BBQRerollResult{ //Reroll the quest in `slot` of `quests`, the quests last read from the panel. Only pays once //the reroll menu is open next to that slot, then reads the panel again to check the quest was -//replaced. On Rerolled, `quests[slot]` is updated to the new quest. +//replaced. On Rerolled, `quests[slot]` is updated. observed_panel is populated +//only for four known slots with no other changes, so scheduling can reuse it. BBQRerollResult reroll_quest( Logger& logger, BBQRerollActions& actions, std::vector& quests, - size_t slot + size_t slot, + std::optional>& observed_panel ); //Reroll the quest in `slot` of `quests` on the console, with reroll_quest(). Stops the program -//if the reroll fails. -void reroll_quest_slot( +//if the reroll fails. Returns a complete observed panel when reusable. +std::optional> reroll_quest_slot( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, @@ -143,7 +152,7 @@ void reroll_quest_slot( //Determine which quests are possible and which quests are not. (ex. no eggs, reroll egg hatcher.) //Quests not possible are removed from the list. If the list is empty, then reroll all items. -std::vector process_quest_list( +BBQuestBatch process_quest_list( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, const BBQOption& BBQ_OPTIONS, From 0ec332559dd7d24afb21e895d8505dcb18c0ddd8 Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 18:29:36 -0700 Subject: [PATCH 10/18] lab: adapt save regression to persistent failed-quest handling --- SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index b1980077a0..7f6843989f 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -734,8 +734,9 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .num_quests = 3, .save_num_quests = 2, .outcomes = {false, false, false}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 3, - .expected = "read process read do read do read do end " + round_of_3 + " end(save)", + .expected = "read process read do reroll read do reroll read do reroll end " + round_of_3 + " end(save)", }, { .name = "stops when out of eggs", From 2ff0fdd65cb835fbabc3b5cad7b47940234c964d Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 21:01:07 -0700 Subject: [PATCH 11/18] BBQ Farmer: replan after rerolling an exhausted quest --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 58 ++++++++++++++++++- .../Farming/PokemonSV_BBQSoloFarmer.cpp | 8 +++ 2 files changed, 63 insertions(+), 3 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 7f6843989f..023ef0e9a7 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -509,6 +509,7 @@ class SimulatedBBQGameActions : public BBQGameActions{ bool reuse_rerolled_panel = false; std::vector events; + std::vector attempted_quests; virtual std::vector read_quests() override{ events.push_back("read"); @@ -537,6 +538,7 @@ class SimulatedBBQGameActions : public BBQGameActions{ } virtual bool do_quest(BBQuests quest, uint8_t&) override{ events.push_back("do"); + attempted_quests.push_back(quest); const bool success = !never_completes.contains(quest) && (m_next_outcome < outcomes.size() ? outcomes[m_next_outcome++] : true); if (success){ @@ -609,6 +611,7 @@ struct BBQRoundsScenario{ BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; bool reuse_rerolled_panel = false; uint64_t expected_completed = 0; + std::vector expected_attempted; std::string expected; }; @@ -646,6 +649,18 @@ class Test_BBQFarmerRounds : public UnitTest{ return "Expected " + std::to_string(m_scenario.expected_completed) + " completed quests, counted " + std::to_string(completed); } + if (!m_scenario.expected_attempted.empty() && game.attempted_quests != m_scenario.expected_attempted){ + std::vector expected_quests; + std::vector actual_quests; + for (BBQuests quest : m_scenario.expected_attempted){ + expected_quests.push_back(std::to_string((int)quest)); + } + for (BBQuests quest : game.attempted_quests){ + actual_quests.push_back(std::to_string((int)quest)); + } + return "Expected quest order: " + join_events(expected_quests) + + "\nActual quest order: " + join_events(actual_quests); + } const std::string actual = join_events(game.events); if (actual != m_scenario.expected){ return "Expected: " + m_scenario.expected + "\nActual: " + actual; @@ -660,6 +675,41 @@ class Test_BBQFarmerRounds : public UnitTest{ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ const std::string round_of_3 = "read process read do completed read do completed read do completed"; const BBQRoundsScenario scenarios[] = { + { + .name = "failed reroll replans before queued photo and TM", + .num_quests = 1, + .panel = {BBQuests::catch_grass, BBQuests::photo_savanna, BBQuests::make_tm}, + .outcomes = {false}, + .new_quests = {BBQuests::travel_500, BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .expected_completed = 3, + .expected_attempted = {BBQuests::catch_grass, BBQuests::travel_500, BBQuests::photo_savanna, BBQuests::make_tm}, + .expected = "read process read do reroll end " + round_of_3 + " end", + }, + { + .name = "failed reroll on full board reads fresh after round actions", + .num_quests = 1, + .panel = {BBQuests::catch_grass, BBQuests::photo_savanna, BBQuests::make_tm, BBQuests::wash_pokemon}, + .outcomes = {false}, + .new_quests = {BBQuests::travel_500, BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .reuse_rerolled_panel = true, + .expected_completed = 4, + .expected_attempted = {BBQuests::catch_grass, BBQuests::travel_500, BBQuests::photo_savanna, BBQuests::make_tm, BBQuests::wash_pokemon}, + .expected = "read process read do reroll end " + round_of_3 + " read do completed end", + }, + { + .name = "replanning after failure preserves a crossed save milestone", + .num_quests = 2, + .save_num_quests = 1, + .panel = {BBQuests::make_tm, BBQuests::catch_grass, BBQuests::photo_savanna}, + .outcomes = {true, false}, + .new_quests = {BBQuests::photo_canyon, BBQuests::travel_500, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .expected_completed = 4, + .expected_attempted = {BBQuests::make_tm, BBQuests::catch_grass, BBQuests::photo_canyon, BBQuests::travel_500, BBQuests::photo_savanna}, + .expected = "read process read do completed read do reroll end(save) " + round_of_3 + " end(save)", + }, { .name = "reuses reroll observation for selection and first dispatch only", .num_quests = 1, @@ -728,15 +778,17 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .expected = round_of_3 + " end(save) " + round_of_3 + " end(save)", }, { - // Round 1 completes nothing. It must not save, even though the - // count (0) is a multiple of the interval. + // Three partial rounds each fail and reroll their first quest. + // None may save while the completed count is still zero. .name = "round without completions does not save", .num_quests = 3, .save_num_quests = 2, .outcomes = {false, false, false}, .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 3, - .expected = "read process read do reroll read do reroll read do reroll end " + round_of_3 + " end(save)", + .expected = + "read process read do reroll end read process read do reroll end " + "read process read do reroll end " + round_of_3 + " end(save)", }, { .name = "stops when out of eggs", diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index ffe2b25e20..277caaa7bf 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -161,6 +161,7 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga //Never carry an observation across quest actions or the round's date/reset work. observed_panel.reset(); const uint64_t completed_before_round = num_completed_quests; + bool replan_after_reroll = false; for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) if (dispatch_panel){ @@ -187,6 +188,8 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga case BBQOption::OutOfRetries::Reroll: logger.log("Reroll selected. Rerolling the failed quest."); game.reroll_quest(current_quest); + logger.log("Reroll finished. Discarding the remaining batch before scheduling."); + replan_after_reroll = true; break; case BBQOption::OutOfRetries::Stop: logger.log("Stop selected. Stopping program.", COLOR_RED); @@ -200,6 +203,11 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga num_completed_quests++; } quest_list.clear(); + if (replan_after_reroll){ + //A replacement belongs in the next plan, before more old queued + //work. Finish normal round actions so save milestones are kept. + break; + } } //Clear out the todo list quests_to_do.clear(); From 8dbace6c74a0a833737996229d8fa9d467dcc8bb Mon Sep 17 00:00:00 2001 From: dayfine Date: Wed, 21 Oct 2026 21:45:20 -0700 Subject: [PATCH 12/18] Preserve existing out-of-BP reroll fixtures during extraction --- SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 0570376d93..ec3632f72e 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -120,6 +120,7 @@ class SimulatedQuestPanel : public BBQRerollActions{ size_t cursor = 0; bool panel_opens = true; bool menu_seen = true; + bool out_of_bp = false; int missed_reads = 0; // Reads that fail OCR on every slot. std::optional> read_override; @@ -173,6 +174,7 @@ struct BBQRerollScenario{ size_t cursor = 0; bool panel_opens = true; bool menu_seen = true; + bool out_of_bp = false; int missed_reads = 0; std::optional> read_override; BBQRerollResult expected; From 50a3704bedd5ad9b825ebb638039fbf42a701980 Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 21:21:52 -0700 Subject: [PATCH 13/18] BBQ tests: default-initialize scenario fields Give BBQRoundsScenario's `never_completes`, `new_quests` a default member initializer (= {}), so test cases that leave them out of a designated initializer compile on the Windows Clang CI job. That job builds with clang-cl /W4 /WX, which turns on -Wmissing-designated-field-initializers: a designated initializer that omits a field without a default member initializer is an error. Apple clang's -Wextra does not enable that warning, so macOS builds miss it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index f98872d0ba..85b1b13f57 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -154,8 +154,8 @@ struct BBQRoundsScenario{ std::vector panel = {BBQuests::make_tm, BBQuests::auto_10, BBQuests::sneak_up}; std::vector outcomes; std::vector> also_completes; - std::set never_completes; - std::vector new_quests; + std::set never_completes = {}; + std::vector new_quests = {}; uint64_t expected_completed = 0; std::string expected; }; From 84800b286577344eb5f308bec8b15f5fc2a943b0 Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 21:22:12 -0700 Subject: [PATCH 14/18] BBQ tests: default-initialize scenario fields Give BBQRerollScenario's `replacements`, `expected_rerolled_slots` a default member initializer (= {}), so test cases that leave them out of a designated initializer compile on the Windows Clang CI job. That job builds with clang-cl /W4 /WX, which turns on -Wmissing-designated-field-initializers: a designated initializer that omits a field without a default member initializer is an error. Apple clang's -Wextra does not enable that warning, so macOS builds miss it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 610a5bb935..af191304cb 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -165,7 +165,7 @@ class SimulatedQuestPanel : public BBQRerollActions{ struct BBQRerollScenario{ std::string name; std::vector quests; - std::vector replacements; + std::vector replacements = {}; size_t slot; size_t cursor = 0; bool panel_opens = true; @@ -173,7 +173,7 @@ struct BBQRerollScenario{ bool out_of_bp = false; int missed_reads = 0; BBQRerollResult expected; - std::vector expected_rerolled_slots; + std::vector expected_rerolled_slots = {}; std::vector expected_quests; }; From bbc231861bc66e080e6fb3a680e4cf8d7fc33bc5 Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 21:23:22 -0700 Subject: [PATCH 15/18] BBQ tests: default-initialize scenario fields Give BBQRerollScenario's `read_override`, `expected_observed_panel` a default member initializer (= {}), so test cases that leave them out of a designated initializer compile on the Windows Clang CI job. That job builds with clang-cl /W4 /WX, which turns on -Wmissing-designated-field-initializers: a designated initializer that omits a field without a default member initializer is an error. Apple clang's -Wextra does not enable that warning, so macOS builds miss it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index aa954ded76..c65bac1cf3 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -176,11 +176,11 @@ struct BBQRerollScenario{ bool menu_seen = true; bool out_of_bp = false; int missed_reads = 0; - std::optional> read_override; + std::optional> read_override = {}; BBQRerollResult expected; std::vector expected_rerolled_slots = {}; std::vector expected_quests; - std::optional> expected_observed_panel; + std::optional> expected_observed_panel = {}; }; std::string reroll_result_to_string(BBQRerollResult result){ From e4c5cc4aeac36c1638533529d0e5c4418b13bd47 Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 21:23:58 -0700 Subject: [PATCH 16/18] BBQ tests: default-initialize scenario fields Give BBQRoundsScenario's `expected_attempted` a default member initializer (= {}), so test cases that leave them out of a designated initializer compile on the Windows Clang CI job. That job builds with clang-cl /W4 /WX, which turns on -Wmissing-designated-field-initializers: a designated initializer that omits a field without a default member initializer is an error. Apple clang's -Wextra does not enable that warning, so macOS builds miss it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index c6ab24bb79..b18e526680 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -613,7 +613,7 @@ struct BBQRoundsScenario{ BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; bool reuse_rerolled_panel = false; uint64_t expected_completed = 0; - std::vector expected_attempted; + std::vector expected_attempted = {}; std::string expected; }; From 7dfc056e4e8b5c68a08883f533fa414e06bd341f Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 08:02:57 -0700 Subject: [PATCH 17/18] BBQ Farmer: reuse verified quest panel reads after a failed-quest reroll After a failed quest was rerolled (OUT_OF_RETRIES = Reroll), the round loop read the panel 3 times before the next attempt, each right after a read of the same unchanged panel: - The out-of-retries reroll now returns its verified read, and the next plan starts from it unless the round ended with a save and reset. - reroll_quest() also reuses a 3-slot read when the panel used for the reroll had 3 slots, every slot is known and the other slots agree. A 3-slot read after a 4-slot panel (a missed 4th quest) is still not reused. - The first dispatch of a round reuses the panel its work was chosen from: process_quest_list() only returns work when it changed nothing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../VideoGames/PokemonSV/PokemonSV_Tests.cpp | 183 +++++++++++++++--- .../Farming/PokemonSV_BBQSoloFarmer.cpp | 26 ++- .../Farming/PokemonSV_BBQSoloFarmer.h | 8 +- .../Farming/PokemonSV_BlueberryQuests.cpp | 11 +- .../Farming/PokemonSV_BlueberryQuests.h | 5 +- 5 files changed, 186 insertions(+), 47 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index b18e526680..66b178b083 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -379,6 +379,49 @@ void add_tests_BBQReroll(UnitTestDatabase& database){ .expected_rerolled_slots = {2}, .expected_quests = {make_tm, travel_500, catch_any, hatch_egg}, }, + { + // The panel used for the reroll had 3 slots, so a 3-slot read is + // not a missed fourth quest. + .name = "three-slot read of a three-slot panel is reusable", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + .expected_observed_panel = std::vector{make_tm, sneak_up, catch_any}, + }, + { + .name = "three-slot read with an unknown slot is not reusable", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{make_tm, UnableToDetect, catch_any}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + }, + { + .name = "three-slot read with another changed quest is not reusable", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{photo_canyon, sneak_up, catch_any}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + }, + { + // The panel used for the reroll missed this fourth quest. + .name = "fourth quest not on the three-slot panel is not reusable", + .quests = {make_tm, sneak_up, travel_500}, + .replacements = {catch_any}, + .slot = 2, + .read_override = std::vector{make_tm, sneak_up, catch_any, hatch_egg}, + .expected = BBQRerollResult::Rerolled, + .expected_rerolled_slots = {2}, + .expected_quests = {make_tm, sneak_up, catch_any}, + }, { .name = "complete observation after missed reads is reusable", .quests = {make_tm, travel_500, sneak_up, hatch_egg}, @@ -398,6 +441,7 @@ void add_tests_BBQReroll(UnitTestDatabase& database){ .expected = BBQRerollResult::Rerolled, .expected_rerolled_slots = {2}, .expected_quests = {make_tm, sneak_up, catch_any}, + .expected_observed_panel = std::vector{make_tm, sneak_up, catch_any}, }, { // Seen on a Switch: the panel can open with the cursor where it @@ -455,6 +499,7 @@ void add_tests_BBQReroll(UnitTestDatabase& database){ .expected = BBQRerollResult::Rerolled, .expected_rerolled_slots = {2}, .expected_quests = {make_tm, sneak_up, catch_any}, + .expected_observed_panel = std::vector{make_tm, sneak_up, catch_any}, }, { .name = "three missed reads give up", @@ -487,10 +532,11 @@ namespace{ // A singleplayer quest panel that behaves like the game's: 3 blue quests, // and a completed quest is replaced by a new one. process_quest_list() -// follows the two rules of the real one that the round loop depends on: -// quests in not_possible_quests are skipped, and if nothing is doable all -// quests are rerolled and nothing is returned. Red quests and the -// exclusions table are not modeled. Records the game actions taken. +// follows the rules of the real one that the round loop depends on: quests +// in not_possible_quests are skipped, quests in table_rerolls are rerolled +// in their slot as an exclusions table reroll row does, and if nothing is +// doable all quests are rerolled. After any reroll it returns nothing to do. +// Red quests are not modeled. Records the game actions taken. class SimulatedBBQGameActions : public BBQGameActions{ public: std::vector panel; @@ -508,6 +554,10 @@ class SimulatedBBQGameActions : public BBQGameActions{ BBQuests::photo_savanna, BBQuests::catch_any, BBQuests::catch_normal, BBQuests::catch_fire, BBQuests::catch_water, BBQuests::catch_grass, }; + // Quests that process_quest_list() rerolls in their slot. + std::set table_rerolls; + // Rerolls return the panel they read to verify the reroll, as + // reroll_quest() does when that read is reusable. bool reuse_rerolled_panel = false; std::vector events; @@ -524,19 +574,29 @@ class SimulatedBBQGameActions : public BBQGameActions{ const std::vector& quests, uint8_t ) override{ events.push_back("process"); + bool rerolled = false; + for (BBQuests& slot : panel){ + if (table_rerolls.contains(slot)){ + slot = next_new_quest(); + rerolled = true; + } + } std::vector doable; for (BBQuests quest : quests){ if (!not_possible_quests.contains(quest)){ doable.push_back(quest); } } - const bool rerolled = doable.empty(); - if (rerolled){ + if (!rerolled && doable.empty()){ for (BBQuests& slot : panel){ slot = next_new_quest(); } + rerolled = true; + } + if (rerolled){ + return {{}, reuse_rerolled_panel ? std::optional(panel) : std::nullopt}; } - return {std::move(doable), rerolled && reuse_rerolled_panel && quests.size() == 4 ? std::optional(panel) : std::nullopt}; + return {std::move(doable), std::nullopt}; } virtual bool do_quest(BBQuests quest, uint8_t&) override{ events.push_back("do"); @@ -553,12 +613,14 @@ class SimulatedBBQGameActions : public BBQGameActions{ } return success; } - virtual void reroll_quest(BBQuests quest) override{ + virtual std::optional> reroll_quest(BBQuests quest) override{ events.push_back("reroll"); auto iter = std::find(panel.begin(), panel.end(), quest); - if (iter != panel.end()){ - *iter = next_new_quest(); + if (iter == panel.end()){ + return std::nullopt; } + *iter = next_new_quest(); + return reuse_rerolled_panel ? std::optional(panel) : std::nullopt; } virtual void quest_completed() override{ events.push_back("completed"); @@ -611,9 +673,11 @@ struct BBQRoundsScenario{ std::set never_completes = {}; std::vector new_quests = {}; BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; + std::set table_rerolls; bool reuse_rerolled_panel = false; uint64_t expected_completed = 0; std::vector expected_attempted = {}; + std::optional expected_reads; std::string expected; }; @@ -642,6 +706,7 @@ class Test_BBQFarmerRounds : public UnitTest{ if (!m_scenario.new_quests.empty()){ game.new_quests = m_scenario.new_quests; } + game.table_rerolls = m_scenario.table_rerolls; game.reuse_rerolled_panel = m_scenario.reuse_rerolled_panel; NullLogger logger; @@ -663,6 +728,11 @@ class Test_BBQFarmerRounds : public UnitTest{ return "Expected quest order: " + join_events(expected_quests) + "\nActual quest order: " + join_events(actual_quests); } + const size_t reads = (size_t)std::count(game.events.begin(), game.events.end(), "read"); + if (m_scenario.expected_reads && reads != *m_scenario.expected_reads){ + return "Expected " + std::to_string(*m_scenario.expected_reads) + + " quest panel reads, counted " + std::to_string(reads); + } const std::string actual = join_events(game.events); if (actual != m_scenario.expected){ return "Expected: " + m_scenario.expected + "\nActual: " + actual; @@ -675,7 +745,7 @@ class Test_BBQFarmerRounds : public UnitTest{ }; void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ - const std::string round_of_3 = "read process read do completed read do completed read do completed"; + const std::string round_of_3 = "read process do completed read do completed read do completed"; const BBQRoundsScenario scenarios[] = { { .name = "failed reroll replans before queued photo and TM", @@ -686,10 +756,10 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 3, .expected_attempted = {BBQuests::catch_grass, BBQuests::travel_500, BBQuests::photo_savanna, BBQuests::make_tm}, - .expected = "read process read do reroll end " + round_of_3 + " end", + .expected = "read process do reroll end " + round_of_3 + " end", }, { - .name = "failed reroll on full board reads fresh after round actions", + .name = "failed reroll on full board reuses its verified read after round actions", .num_quests = 1, .panel = {BBQuests::catch_grass, BBQuests::photo_savanna, BBQuests::make_tm, BBQuests::wash_pokemon}, .outcomes = {false}, @@ -698,7 +768,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .reuse_rerolled_panel = true, .expected_completed = 4, .expected_attempted = {BBQuests::catch_grass, BBQuests::travel_500, BBQuests::photo_savanna, BBQuests::make_tm, BBQuests::wash_pokemon}, - .expected = "read process read do reroll end " + round_of_3 + " read do completed end", + .expected = "read process do reroll end process do completed read do completed read do completed read do completed end", }, { .name = "replanning after failure preserves a crossed save milestone", @@ -710,7 +780,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 4, .expected_attempted = {BBQuests::make_tm, BBQuests::catch_grass, BBQuests::photo_canyon, BBQuests::travel_500, BBQuests::photo_savanna}, - .expected = "read process read do completed read do reroll end(save) " + round_of_3 + " end(save)", + .expected = "read process do completed read do reroll end(save) " + round_of_3 + " end(save)", }, { .name = "reuses reroll observation for selection and first dispatch only", @@ -721,12 +791,61 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .expected = "read process process do completed read do completed read do completed read do completed end", }, { - .name = "three-slot reroll still reads the panel again", + // reroll_quest() decides whether a 3-slot read is reusable. + .name = "reusable three-slot reroll observation is not read again", .num_quests = 1, .panel = {BBQuests::pickup_10, BBQuests::catch_flying, BBQuests::UnableToDetect}, .reuse_rerolled_panel = true, .expected_completed = 3, - .expected = "read process read process read do completed read do completed read do completed end", + .expected = "read process process do completed read do completed read do completed end", + }, + { + // Seen in a live run: catch-fighting fails and is rerolled into + // pickup-10, which the exclusions table rerolls into travel-500. + // Each reroll's verified read is reused, and so is the last one + // for the first dispatch. The round loop used to read the panel + // 3 times between the failed reroll and the next attempt. + .name = "failed reroll then table reroll reuse verified reads", + .num_quests = 1, + .panel = {BBQuests::catch_fighting, BBQuests::make_tm, BBQuests::photo_savanna}, + .outcomes = {false}, + .new_quests = {BBQuests::pickup_10, BBQuests::travel_500, BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .table_rerolls = {BBQuests::pickup_10}, + .reuse_rerolled_panel = true, + .expected_completed = 3, + .expected_attempted = {BBQuests::catch_fighting, BBQuests::travel_500, BBQuests::make_tm, BBQuests::photo_savanna}, + .expected_reads = 3, + .expected = "read process do reroll end process process do completed read do completed read do completed end", + }, + { + // As above, but neither reroll's read is reusable. Only the + // first dispatch skips a read: 2 reads before the next attempt + // instead of 3. + .name = "failed reroll then table reroll without reusable reads", + .num_quests = 1, + .panel = {BBQuests::catch_fighting, BBQuests::make_tm, BBQuests::photo_savanna}, + .outcomes = {false}, + .new_quests = {BBQuests::pickup_10, BBQuests::travel_500, BBQuests::photo_canyon, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .table_rerolls = {BBQuests::pickup_10}, + .expected_completed = 3, + .expected_attempted = {BBQuests::catch_fighting, BBQuests::travel_500, BBQuests::make_tm, BBQuests::photo_savanna}, + .expected_reads = 5, + .expected = "read process do reroll end read process read process do completed read do completed read do completed end", + }, + { + // The save resets the game, so the reroll's read is not reused. + .name = "failed reroll before a save reads the panel after it", + .num_quests = 2, + .save_num_quests = 1, + .panel = {BBQuests::make_tm, BBQuests::catch_grass, BBQuests::photo_savanna}, + .outcomes = {true, false}, + .new_quests = {BBQuests::photo_canyon, BBQuests::travel_500, BBQuests::photo_coastal, BBQuests::photo_polar}, + .out_of_retries = BBQOption::OutOfRetries::Reroll, + .reuse_rerolled_panel = true, + .expected_completed = 4, + .expected = "read process do completed read do reroll end(save) " + round_of_3 + " end(save)", }, { // The goal (4) is reached in the middle of round 2. The loop only @@ -745,7 +864,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .panel = {BBQuests::photo_swim, BBQuests::travel_500, BBQuests::make_tm}, .also_completes = {{BBQuests::photo_swim, BBQuests::travel_500}}, .expected_completed = 3, - .expected = "read process read do completed read completed read do completed end", + .expected = "read process do completed read completed read do completed end", }, { // The first attempt fails: 3 attempts, 2 completions. @@ -753,7 +872,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .num_quests = 2, .outcomes = {false}, .expected_completed = 2, - .expected = "read process read do read do completed read do completed end", + .expected = "read process do read do completed read do completed end", }, { // Nothing on the panel is doable, so process_quest_list() rerolls @@ -789,8 +908,8 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 3, .expected = - "read process read do reroll end read process read do reroll end " - "read process read do reroll end " + round_of_3 + " end(save)", + "read process do reroll end read process do reroll end " + "read process do reroll end " + round_of_3 + " end(save)", }, { .name = "stops when out of eggs", @@ -807,8 +926,8 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .never_completes = {BBQuests::sneak_up}, .expected_completed = 4, .expected = - "read process read do completed read do completed read do end " - "read process read do completed read do completed end", + "read process do completed read do completed read do end " + "read process do completed read do completed end", }, { .name = "stops when only failed quests are doable", @@ -816,7 +935,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .panel = {BBQuests::sneak_up, BBQuests::pickup_10, BBQuests::catch_flying}, .never_completes = {BBQuests::sneak_up}, .expected_completed = 0, - .expected = "read process read do end read process", + .expected = "read process do end read process", }, { // sneak-up fails, then leaves the panel along with make-tm. Round 2 @@ -830,9 +949,9 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .new_quests = {BBQuests::auto_10, BBQuests::photo_canyon, BBQuests::sneak_up}, .expected_completed = 5, .expected = - "read process read do read do completed end " - "read process read do completed read do completed end " - "read process read do completed read do completed end", + "read process do read do completed end " + "read process do completed read do completed end " + "read process do completed read do completed end", }, { // As above with 3 slots. A 4th quest could have been missed by @@ -845,9 +964,9 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .new_quests = {BBQuests::auto_10, BBQuests::photo_canyon, BBQuests::sneak_up}, .expected_completed = 4, .expected = - "read process read do read do completed end " - "read process read do completed read do completed end " - "read process read do completed end", + "read process do read do completed end " + "read process do completed read do completed end " + "read process do completed end", }, { // sneak-up is rerolled to photo-polar, which round 2 attempts. @@ -856,7 +975,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .never_completes = {BBQuests::sneak_up}, .out_of_retries = BBQOption::OutOfRetries::Reroll, .expected_completed = 5, - .expected = "read process read do completed read do completed read do reroll end " + round_of_3 + " end", + .expected = "read process do completed read do completed read do reroll end " + round_of_3 + " end", }, { .name = "out of retries with stop stops at once", @@ -865,7 +984,7 @@ void add_tests_BBQFarmerRounds(UnitTestDatabase& database){ .never_completes = {BBQuests::sneak_up}, .out_of_retries = BBQOption::OutOfRetries::Stop, .expected_completed = 0, - .expected = "read process read do", + .expected = "read process do", }, }; for (const BBQRoundsScenario& scenario : scenarios){ diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp index 277caaa7bf..45faa1c628 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp @@ -126,7 +126,6 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga //Get and reroll quests until we can at least one while (quests_to_do.size() < 1){ - const bool reused_panel = observed_panel.has_value(); if (observed_panel){ logger.log("Reusing verified quest panel for scheduling."); quest_list = std::move(*observed_panel); @@ -139,7 +138,9 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga BBQuestBatch batch = game.process_quest_list(quest_list, eggs_hatched); quests_to_do = std::move(batch.to_do); observed_panel = std::move(batch.observed_panel); - if (reused_panel && !quests_to_do.empty() && !observed_panel){ + //Work is only returned when nothing changed in game, so the panel + //it was chosen from is still current for the first dispatch. + if (!quests_to_do.empty() && !observed_panel){ dispatch_panel = quest_list; } @@ -158,10 +159,11 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga quest_list.clear(); } - //Never carry an observation across quest actions or the round's date/reset work. + //Never carry an observation across quest actions or a save and reset. observed_panel.reset(); const uint64_t completed_before_round = num_completed_quests; bool replan_after_reroll = false; + std::optional> rerolled_panel; for (auto current_quest : quests_to_do){ //Check if quest was already completed (ex. 500 meters completed while navigating to take a photo) if (dispatch_panel){ @@ -187,7 +189,7 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga break; case BBQOption::OutOfRetries::Reroll: logger.log("Reroll selected. Rerolling the failed quest."); - game.reroll_quest(current_quest); + rerolled_panel = game.reroll_quest(current_quest); logger.log("Reroll finished. Discarding the remaining batch before scheduling."); replan_after_reroll = true; break; @@ -214,7 +216,15 @@ void run_bbq_rounds(Logger& logger, const BBQOption& options, BBQGameActions& ga uint64_t temp_save_num_option = options.SAVE_NUM_QUESTS; // A round can cross a milestone without ending at an exact multiple. - game.end_round(bbq_save_due(completed_before_round, num_completed_quests, temp_save_num_option)); + const bool save = bbq_save_due(completed_before_round, num_completed_quests, temp_save_num_option); + game.end_round(save); + + //The reroll was the last game action of the round. Fixing the date + //does not change the quests, so its verified read can seed the next + //plan. A save resets the game, so the panel is read again after one. + if (rerolled_panel && !save){ + observed_panel = std::move(rerolled_panel); + } } } @@ -244,14 +254,14 @@ class BBQSoloFarmerGameActions : public BBQGameActions{ virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) override{ return process_and_do_quest(m_env, m_env.console, m_context, m_options, quest, eggs_hatched); } - virtual void reroll_quest(BBQuests quest) override{ + virtual std::optional> reroll_quest(BBQuests quest) override{ std::vector quests = PokemonSV::read_quests(m_env.program_info(), m_env.console, m_context, m_options); auto iter = std::find(quests.begin(), quests.end(), quest); if (iter == quests.end()){ m_env.log("Failed quest is no longer on the panel. Not rerolling."); - return; + return std::nullopt; } - reroll_quest_slot(m_env.program_info(), m_env.console, m_context, m_options, quests, iter - quests.begin()); + return reroll_quest_slot(m_env.program_info(), m_env.console, m_context, m_options, quests, iter - quests.begin()); } virtual void quest_completed() override{ m_stats.questsCompleted++; diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h index 17701b0fe5..c7e9c1fbeb 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h @@ -8,6 +8,7 @@ #define PokemonAutomation_PokemonSV_BBQSoloFarmer_H #include +#include #include #include "Common/Cpp/Logging/AbstractLogger.h" #include "CommonFramework/Notifications/EventNotificationsTable.h" @@ -34,6 +35,8 @@ class BBQGameActions{ // Decide which of the quests just read are worth attempting this round. // May reroll quests in game, so the returned list can be empty even when // `quests` is not; a complete post-reroll observation can seed selection. + // Only returns quests to attempt when it changed nothing in game, so + // `quests` still shows the panel. virtual BBQuestBatch process_quest_list( const std::vector& quests, uint8_t eggs_hatched ) = 0; @@ -44,8 +47,9 @@ class BBQGameActions{ virtual bool do_quest(BBQuests quest, uint8_t& eggs_hatched) = 0; // Reroll a quest that failed all its attempts, if it is still on the - // panel. Spends BP. - virtual void reroll_quest(BBQuests quest) = 0; + // panel. Spends BP. Returns the panel read to verify the reroll when + // reroll_quest() found it reusable, so scheduling can skip a read. + virtual std::optional> reroll_quest(BBQuests quest) = 0; // Progress reporting only: a quest was counted as completed. Lets stats // update after every quest instead of once per round. diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 4e5425c6dc..92bc9a990f 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -429,9 +429,14 @@ BBQRerollResult reroll_quest( if (slot < after.size() && after[slot] != quests[slot] && after[slot] != BBQuests::UnableToDetect){ logger.log("Quest " + std::to_string(slot + 1) + " rerolled."); quests[slot] = after[slot]; - //Three slots can mean a missed fourth quest. Reuse only a complete - //read whose other slots agree with the panel used for this reroll. - if (after.size() == 4 && after == quests + //Reuse only a read whose slots are all known and, apart from the + //rerolled one, agree with the panel used for this reroll. Three + //slots can mean a missed fourth quest, so a 3-slot read is only + //reused when that panel had 3 slots too. Both reads could have + //missed the same fourth quest, as a fresh read also could. That + //quest is then left out of one plan, which costs no BP, and a + //3-slot read never proves a failed quest left the panel. + if (after.size() >= 3 && after == quests && std::find(after.begin(), after.end(), BBQuests::UnableToDetect) == after.end()){ observed_panel = std::move(after); } diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h index e4e614e2a2..eec8eb1034 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.h @@ -131,7 +131,8 @@ enum class BBQRerollResult{ //Reroll the quest in `slot` of `quests`, the quests last read from the panel. Only pays once //the reroll menu is open next to that slot, then reads the panel again to check the quest was //replaced. On Rerolled, `quests[slot]` is updated. observed_panel is populated -//only for four known slots with no other changes, so scheduling can reuse it. +//only when every slot is known and no other slot changed, so scheduling can +//reuse it. A 3-slot read is only reused when `quests` had 3 slots. BBQRerollResult reroll_quest( Logger& logger, BBQRerollActions& actions, @@ -141,7 +142,7 @@ BBQRerollResult reroll_quest( ); //Reroll the quest in `slot` of `quests` on the console, with reroll_quest(). Stops the program -//if the reroll fails. Returns a complete observed panel when reusable. +//if the reroll fails. Returns the observed panel when reusable. std::optional> reroll_quest_slot( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, From f4d4c473a61fa40cbe88be6c880676587e38b87f Mon Sep 17 00:00:00 2001 From: dayfine Date: Thu, 22 Oct 2026 21:24:17 -0700 Subject: [PATCH 18/18] BBQ tests: default-initialize scenario fields Give BBQRoundsScenario's `table_rerolls`, `expected_reads` a default member initializer (= {}), so test cases that leave them out of a designated initializer compile on the Windows Clang CI job. That job builds with clang-cl /W4 /WX, which turns on -Wmissing-designated-field-initializers: a designated initializer that omits a field without a default member initializer is an error. Apple clang's -Wextra does not enable that warning, so macOS builds miss it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E --- .../Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp index 66b178b083..11c07336c3 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/PokemonSV_Tests.cpp @@ -673,11 +673,11 @@ struct BBQRoundsScenario{ std::set never_completes = {}; std::vector new_quests = {}; BBQOption::OutOfRetries out_of_retries = BBQOption::OutOfRetries::Skip; - std::set table_rerolls; + std::set table_rerolls = {}; bool reuse_rerolled_panel = false; uint64_t expected_completed = 0; std::vector expected_attempted = {}; - std::optional expected_reads; + std::optional expected_reads = {}; std::string expected; };