diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.cpp new file mode 100644 index 0000000000..38295e00c7 --- /dev/null +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.cpp @@ -0,0 +1,102 @@ +/* BBQ Diagnostic Logger + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include +#include +#include "Common/Cpp/PrettyPrint.h" +#include "PokemonSV_BBQLogger.h" + +namespace PokemonAutomation{ +namespace NintendoSwitch{ +namespace PokemonSV{ + + +namespace{ + +constexpr std::string_view UNKNOWN = "unknown"; + +std::string_view quest_label(BBQuests quest){ + const std::string& slug = BBQuests_enum_to_string(quest); + return slug.empty() ? UNKNOWN : std::string_view(slug); +} + +void append_elapsed(std::ostream& out, std::string_view field, BBQAttemptLog::Clock::duration elapsed){ + const auto milliseconds = std::chrono::duration_cast(elapsed); + out << ' ' << field << "_ms=" << milliseconds.count() + << ' ' << field << "=\"" << duration_to_string(milliseconds) << '\"'; +} + +} // namespace + + +void BBQLogger::board(bool panel_detected, const std::vector& quests){ + std::ostringstream out; + out << "BBQ event=board panel_detected=" << panel_detected << " quests="; + bool first = true; + for (BBQuests quest : quests){ + if (!first){ + out << ','; + } + first = false; + out << quest_label(quest); + } + m_logger.log(out.str()); +} + +void BBQLogger::reroll_attempt(size_t slot, BBQuests quest){ + m_logger.log( + "Rerolling quest " + std::to_string(slot + 1) + " (" + std::string(quest_label(quest)) + ")." + ); +} + +void BBQLogger::battle_entry_timeout(BBQuests quest){ + std::ostringstream out; + out << "BBQ quest=" << quest_label(quest) << " event=battle_entry outcome=timeout"; + m_logger.log(out.str()); +} + +void BBQLogger::retry_exhausted(BBQuests quest){ + std::ostringstream out; + out << "BBQ quest=" << quest_label(quest) << " event=retry_exhausted recovery=skip_current_batch"; + m_logger.log(out.str(), COLOR_RED); +} + + +BBQAttemptLog::BBQAttemptLog( + Logger& logger, BBQuests quest, + unsigned attempt, unsigned limit, + Clock::time_point start +) + : m_logger(logger), m_start(start), m_route_end(start) +{ + std::ostringstream out; + out << "BBQ quest=" << quest_label(quest) << " attempt=" << attempt << " limit=" << limit; + m_attempt_description = out.str(); + out << " event=start"; + m_logger.log(out.str()); +} + +void BBQAttemptLog::route_return(Clock::time_point end){ + m_route_end = end; + std::ostringstream out; + out << m_attempt_description << " event=route_return"; + append_elapsed(out, "elapsed", end - m_start); + m_logger.log(out.str()); +} + +void BBQAttemptLog::result(bool completed, Clock::time_point end){ + std::ostringstream out; + out << m_attempt_description << " event=result outcome=" + << (completed ? "absent_from_board" : "still_on_board"); + append_elapsed(out, "verification", end - m_route_end); + append_elapsed(out, "total", end - m_start); + m_logger.log(out.str()); +} + + +} // namespace PokemonSV +} // namespace NintendoSwitch +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.h new file mode 100644 index 0000000000..f6ab0adb7a --- /dev/null +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.h @@ -0,0 +1,76 @@ +/* BBQ Diagnostic Logger + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#ifndef PokemonAutomation_PokemonSV_BBQLogger_H +#define PokemonAutomation_PokemonSV_BBQLogger_H + +#include +#include +#include +#include "Common/Cpp/Logging/AbstractLogger.h" +#include "VideoGames/PokemonSV/Options/PokemonSV_BBQuests.h" + +namespace PokemonAutomation{ +namespace NintendoSwitch{ +namespace PokemonSV{ + + +// Formats one-line "BBQ ..." diagnostic events through an existing Logger. +// Does no image I/O and no controller input. +class BBQLogger{ +public: + explicit BBQLogger(Logger& logger) : m_logger(logger) {} + + // The quest board as read from one panel snapshot: whether the panel was + // detected, and the quests in board order. + void board(bool panel_detected, const std::vector& quests); + + // Logs a zero-based board slot before attempting its reroll, including failures. + void reroll_attempt(size_t slot, BBQuests quest); + + // A catch quest gave up waiting for the battle menu after navigating to its target. + void battle_entry_timeout(BBQuests quest); + + // A quest used all of its attempts and the rest of the batch will be skipped. + void retry_exhausted(BBQuests quest); + +private: + Logger& m_logger; +}; + + +// The event sequence and monotonic timing of one quest attempt. +// Timestamps default to now; tests pass fixed values. +class BBQAttemptLog{ +public: + using Clock = std::chrono::steady_clock; + + // Logs the start of attempt number `attempt` out of `limit`. + BBQAttemptLog( + Logger& logger, BBQuests quest, + unsigned attempt, unsigned limit, + Clock::time_point start = Clock::now() + ); + + // The quest routine returned; logs the time since start. + void route_return(Clock::time_point end = Clock::now()); + + // The board was re-read. `completed` means the quest is no longer on it. + // Logs the verification time since route_return() and the total time. + void result(bool completed, Clock::time_point end = Clock::now()); + +private: + Logger& m_logger; + const Clock::time_point m_start; + Clock::time_point m_route_end; + std::string m_attempt_description; +}; + + +} // namespace PokemonSV +} // namespace NintendoSwitch +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.cpp new file mode 100644 index 0000000000..a250b58cff --- /dev/null +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.cpp @@ -0,0 +1,193 @@ +/* BBQ Diagnostic Logger Tests + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include +#include +#include +#include +#include +#include "Common/Cpp/TestRunners/UnitTestDatabase.h" +#include "PokemonSV_BBQLogger.h" +#include "PokemonSV_BBQLogger_Tests.h" + +namespace PokemonAutomation{ +namespace NintendoSwitch{ +namespace PokemonSV{ +namespace{ + +// Captures the production Logger interface without image or controller I/O. +class BBQTestLogger : public Logger{ +public: + virtual void log(const std::string& message, Color color) override{ + messages.push_back(message); + colors.push_back(color); + } + std::vector messages; + std::vector colors; +}; + +// One board snapshot and its detection outcome. +struct BoardLogInput{ + bool panel_detected; + std::vector quests; +}; + +// One timed attempt, including optional timeout and retry-exhaustion events. +struct AttemptLogInput{ + BBQuests quest; + unsigned attempt; + unsigned limit; + std::chrono::milliseconds route_duration; + std::chrono::milliseconds verification_duration; + bool completed; + bool battle_timeout = false; + bool retry_exhausted = false; +}; + +// A row exercises one board read or one complete attempt event sequence. +struct DiagnosticLogInput{ + std::string name; + std::variant event; +}; + +// Exact message order is part of the diagnostics contract. +struct DiagnosticLogExpectation{ + std::vector messages; + Color final_color{}; +}; + +// Each case keeps all inputs and expected output visible together. +struct DiagnosticLogCase{ + DiagnosticLogInput input; + DiagnosticLogExpectation expectation; +}; + +// Exercise the real formatter with a scripted board observation. +void emit_logs(Logger& logger, const BoardLogInput& input){ + BBQLogger(logger).board(input.panel_detected, input.quests); +} + +// Fixed monotonic timestamps make durations and event order deterministic. +void emit_logs(Logger& logger, const AttemptLogInput& input){ + const BBQAttemptLog::Clock::time_point start{}; + if (input.battle_timeout){ + BBQLogger(logger).battle_entry_timeout(input.quest); + } + BBQAttemptLog attempt(logger, input.quest, input.attempt, input.limit, start); + attempt.route_return(start + input.route_duration); + attempt.result(input.completed, start + input.route_duration + input.verification_duration); + if (input.retry_exhausted){ + BBQLogger(logger).retry_exhausted(input.quest); + } +} + +// Report the first missing, unexpected or mismatched message with its index. +class Test_BBQDiagnosticLogs : public UnitTest{ +public: + explicit Test_BBQDiagnosticLogs(DiagnosticLogCase test_case) + : UnitTest("PokemonSV::BBQDiagnosticLogs - " + test_case.input.name) + , m_case(std::move(test_case)) + {} + + virtual UnitTestResult run(Logger&, CancellableScope&) const override{ + BBQTestLogger logger; + std::visit([&](const auto& input){ emit_logs(logger, input); }, m_case.input.event); + const auto& expected = m_case.expectation.messages; + if (logger.messages.size() != expected.size()){ + return "Expected " + std::to_string(expected.size()) + " log messages; read " + + std::to_string(logger.messages.size()) + "."; + } + for (size_t index = 0; index < expected.size(); index++){ + if (logger.messages[index] != expected[index]){ + return "Message " + std::to_string(index) + ": expected [" + expected[index] + + "]; read [" + logger.messages[index] + "]."; + } + } + if (logger.colors.back() != m_case.expectation.final_color){ + return "Final message color differs from the expected severity."; + } + return true; + } + +private: + const DiagnosticLogCase m_case; +}; + +// Covers board order/unknown/empty output and success, exhaustion and long durations. +const DiagnosticLogCase DIAGNOSTIC_LOG_CASES[] = { + { + .input = {.name = "board-order", .event = BoardLogInput{ + .panel_detected = true, + .quests = {BBQuests::photo_swim, BBQuests::sneak_up, BBQuests::auto_10}, + }}, + .expectation = {.messages = { + "BBQ event=board panel_detected=1 quests=photo-swim,sneak-up,auto-10", + }}, + }, + { + .input = {.name = "undetected-board", .event = BoardLogInput{ + .panel_detected = false, .quests = {BBQuests::UnableToDetect}, + }}, + .expectation = {.messages = {"BBQ event=board panel_detected=0 quests=unknown"}}, + }, + { + .input = {.name = "empty-board", .event = BoardLogInput{ + .panel_detected = true, .quests = {}, + }}, + .expectation = {.messages = {"BBQ event=board panel_detected=1 quests="}}, + }, + { + .input = {.name = "success", .event = AttemptLogInput{ + .quest = BBQuests::make_tm, .attempt = 1, .limit = 2, + .route_duration = std::chrono::milliseconds(2000), + .verification_duration = std::chrono::milliseconds(500), .completed = true, + }}, + .expectation = {.messages = { + "BBQ quest=make-tm attempt=1 limit=2 event=start", + "BBQ quest=make-tm attempt=1 limit=2 event=route_return elapsed_ms=2000 elapsed=\"2.000 seconds\"", + "BBQ quest=make-tm attempt=1 limit=2 event=result outcome=absent_from_board verification_ms=500 verification=\"0.500 seconds\" total_ms=2500 total=\"2.500 seconds\"", + }}, + }, + { + .input = {.name = "retry-exhausted", .event = AttemptLogInput{ + .quest = BBQuests::catch_any, .attempt = 2, .limit = 2, + .route_duration = std::chrono::milliseconds(3345), + .verification_duration = std::chrono::milliseconds(765), .completed = false, + .battle_timeout = true, .retry_exhausted = true, + }}, + .expectation = {.messages = { + "BBQ quest=catch-any event=battle_entry outcome=timeout", + "BBQ quest=catch-any attempt=2 limit=2 event=start", + "BBQ quest=catch-any attempt=2 limit=2 event=route_return elapsed_ms=3345 elapsed=\"3.345 seconds\"", + "BBQ quest=catch-any attempt=2 limit=2 event=result outcome=still_on_board verification_ms=765 verification=\"0.765 seconds\" total_ms=4110 total=\"4.110 seconds\"", + "BBQ quest=catch-any event=retry_exhausted recovery=skip_current_batch", + }, .final_color = COLOR_RED}, + }, + { + .input = {.name = "long-duration", .event = AttemptLogInput{ + .quest = BBQuests::UnableToDetect, .attempt = 256, .limit = 256, + .route_duration = std::chrono::milliseconds(120000), + .verification_duration = std::chrono::milliseconds(0), .completed = false, + }}, + .expectation = {.messages = { + "BBQ quest=unknown attempt=256 limit=256 event=start", + "BBQ quest=unknown attempt=256 limit=256 event=route_return elapsed_ms=120000 elapsed=\"2.000 minutes\"", + "BBQ quest=unknown attempt=256 limit=256 event=result outcome=still_on_board verification_ms=0 verification=\"0.000 seconds\" total_ms=120000 total=\"2.000 minutes\"", + }}, + }, +}; + +} // namespace + +void add_tests_BBQDiagnosticLogs(UnitTestDatabase& database){ + for (const DiagnosticLogCase& test_case : DIAGNOSTIC_LOG_CASES){ + database.add(test_case); + } +} + +} // namespace PokemonSV +} // namespace NintendoSwitch +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.h b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.h new file mode 100644 index 0000000000..24ba73f8ea --- /dev/null +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.h @@ -0,0 +1,22 @@ +/* BBQ Diagnostic Logger Tests + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#ifndef PokemonAutomation_PokemonSV_BBQLogger_Tests_H +#define PokemonAutomation_PokemonSV_BBQLogger_Tests_H + +#include "Common/Cpp/TestRunners/UnitTest.h" + +namespace PokemonAutomation{ +namespace NintendoSwitch{ +namespace PokemonSV{ + +// Registers deterministic event formatting and ordering tests; no console input. +void add_tests_BBQDiagnosticLogs(UnitTestDatabase& database); + +} // namespace PokemonSV +} // namespace NintendoSwitch +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQTests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQTests.cpp index 6dd1d9ef43..2230619401 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQTests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQTests.cpp @@ -11,6 +11,7 @@ #include "Tests/ImageUnitTest.h" #include "VideoGames/PokemonSV/Inference/PokemonSV_BlueberryPointsReader.h" #include "VideoGames/PokemonSV/Options/PokemonSV_BBQuests.h" +#include "PokemonSV_BBQLogger_Tests.h" #include "PokemonSV_BlueberryQuests.h" #include "PokemonSV_BBQSoloFarmer.h" #include "PokemonSV_BBQTests.h" @@ -131,6 +132,13 @@ class NullLogger : public Logger{ public: virtual void log(const std::string&, Color) override{} }; +class RecordingLogger : public Logger{ +public: + std::vector lines; + virtual void log(const std::string& line, Color) override{ + lines.push_back(line); + } +}; // 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() @@ -592,9 +600,18 @@ class Test_BBQReroll : public UnitTest{ panel.out_of_bp = m_scenario.out_of_bp; panel.missed_reads = m_scenario.missed_reads; - NullLogger logger; + RecordingLogger logger; std::vector quests = m_scenario.quests; const BBQRerollResult result = reroll_quest(logger, panel, quests, m_scenario.slot); + //Each reroll logs one line naming its slot and quest, whatever the result. + const std::string reroll_line = "Rerolling quest " + std::to_string(m_scenario.slot + 1) + + " (" + BBQuests_enum_to_string(m_scenario.quests[m_scenario.slot]) + ")."; + const size_t reroll_lines = std::count_if(logger.lines.begin(), logger.lines.end(), [](const std::string& line){ + return line.starts_with("Rerolling quest "); + }); + if (reroll_lines != 1 || std::find(logger.lines.begin(), logger.lines.end(), reroll_line) == logger.lines.end()){ + return "Expected one log line \"" + reroll_line + "\", got " + std::to_string(reroll_lines) + " reroll lines."; + } if (result != m_scenario.expected){ return "Expected " + reroll_result_to_string(m_scenario.expected) + ", got " + reroll_result_to_string(result); @@ -800,6 +817,7 @@ void add_tests_BBQ(UnitTestDatabase& database){ add_tests_BBQuestPlan(database); add_tests_BBQFarmerRounds(database); add_tests_TeraEncounterAction(database); + add_tests_BBQDiagnosticLogs(database); } diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryCatchPhoto.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryCatchPhoto.cpp index 3a24e1d187..a77219fc37 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryCatchPhoto.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryCatchPhoto.cpp @@ -5,7 +5,6 @@ */ #include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h" -#include "CommonFramework/Tools/ErrorDumper.h" #include "CommonFramework/Exceptions/ProgramFinishedException.h" #include "CommonTools/Async/InferenceRoutines.h" #include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h" @@ -26,6 +25,7 @@ #include "VideoGames/PokemonSV/Programs/PokemonSV_WorldNavigation.h" #include "VideoGames/PokemonSV/Programs/Battles/PokemonSV_BasicCatcher.h" #include "VideoGames/PokemonSV/Programs/PokemonSV_Terarium.h" +#include "PokemonSV_BBQLogger.h" #include "PokemonSV_BlueberryCatchPhoto.h" namespace PokemonAutomation{ @@ -916,7 +916,7 @@ void quest_catch( { battle_menu } ); if (ret2 != 0){ - console.log("Did not enter battle. Did target spawn?"); + BBQLogger(console.logger()).battle_entry_timeout(current_quest); } }, { diff --git a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp index 2861283c87..afe39c8692 100644 --- a/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp +++ b/SerialPrograms/Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryQuests.cpp @@ -43,6 +43,7 @@ #include "VideoGames/PokemonSV/Programs/TeraRaids/PokemonSV_TeraBattler.h" #include "VideoGames/PokemonSV/Programs/Farming/PokemonSV_BlueberryCatchPhoto.h" #include "VideoGames/PokemonSV/Programs/PokemonSV_Terarium.h" +#include "PokemonSV_BBQLogger.h" #include "PokemonSV_BlueberryQuests.h" @@ -102,6 +103,7 @@ bool open_quest_panel(VideoStream& stream, ProControllerContext& context){ } +// Detector index 0 confirms the quest panel; a negative run_until result means no detection. std::vector read_quests( const ProgramInfo& info, VideoStream& stream, ProControllerContext& context, @@ -144,6 +146,8 @@ std::vector read_quests( quest_list.push_back(BBQuests_string_to_enum(fourth_quest)); } + BBQLogger(stream.logger()).board(/*panel_detected=*/result == 0, quest_list); + //Close quest list pbf_mash_button(context, BUTTON_B, 800ms); context.wait_for_all_requests(); @@ -292,6 +296,9 @@ BBQRerollResult reroll_quest( std::vector& quests, size_t slot ){ + // An unavailable slot is logged as unknown without indexing outside the board. + const BBQuests quest = slot < quests.size() ? quests[slot] : BBQuests::UnableToDetect; + BBQLogger(logger).reroll_attempt(/*slot=*/slot, /*quest=*/quest); if (!actions.open_panel()){ return BBQRerollResult::PanelNotOpened; } @@ -447,6 +454,10 @@ bool process_and_do_quest( int quest_attempts = 0; while (!quest_completed){ + BBQAttemptLog attempt_log( + console.logger(), /*quest=*/current_quest, + /*attempt=*/quest_attempts + 1, /*limit=*/static_cast(BBQ_OPTIONS.NUM_RETRIES) + 1 + ); switch (current_quest){ case BBQuests::make_tm: quest_make_tm(env.program_info(), console, context); @@ -545,13 +556,12 @@ bool process_and_do_quest( break; } + attempt_log.route_return(); //Validate quest was completed by checking list 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."); quest_attempts++; }else{ - console.log("Current quest was not found. Quest completed!"); if (current_quest == BBQuests::hatch_egg){ eggs_hatched++; console.log("Eggs hatched: " + std::to_string(eggs_hatched)); @@ -560,8 +570,9 @@ bool process_and_do_quest( quest_completed = true; } + attempt_log.result(/*completed=*/quest_completed); if (quest_attempts > BBQ_OPTIONS.NUM_RETRIES){ - console.log("Failed to complete a quest multiple times. Skipping it for now.", COLOR_RED); + BBQLogger(console.logger()).retry_exhausted(current_quest); break; } } diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake index 32c8dbf362..011038f97e 100644 --- a/SerialPrograms/cmake/SourceFiles.cmake +++ b/SerialPrograms/cmake/SourceFiles.cmake @@ -2641,6 +2641,10 @@ file(GLOB LIBRARY_SOURCES Source/VideoGames/PokemonSV/Programs/Eggs/PokemonSV_EggRoutines.h Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_AuctionFarmer.cpp Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_AuctionFarmer.h + Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.cpp + Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger.h + Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.cpp + Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQLogger_Tests.h Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.cpp Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQSoloFarmer.h Source/VideoGames/PokemonSV/Programs/Farming/PokemonSV_BBQTests.cpp