BDSP navigation v4: the walker, with battles passed in

SerialPrograms/Source/PokemonBDSP/Inference/PokemonBDSP_TransitionWatchers.cpp

@@ -0,0 +1,45 @@
+/*  BDSP Transition Watchers
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Adapted from PokemonAutomation/Arduino-Source#1717 by Developer-Butters.
+ */
+
+#include "PokemonBDSP_TransitionWatchers.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+WhiteScreenOverWatcher::WhiteScreenOverWatcher(Color color, const ImageFloatBox& box)
+    : VisualInferenceCallback("WhiteScreenOverWatcher")
+    , m_on(color, box, WhiteScreenWatcher::FinderType::PRESENT, std::chrono::milliseconds(100))
+    , m_off(color, box, WhiteScreenWatcher::FinderType::GONE, std::chrono::milliseconds(100))
+{}
+void WhiteScreenOverWatcher::make_overlays(VideoOverlaySet& items) const{
+    m_on.make_overlays(items);
+}
+bool WhiteScreenOverWatcher::process_frame(const ImageViewRGB32& frame, WallClock timestamp){
+    if (m_white_is_over.load(std::memory_order_acquire)){
+        return true;
+    }
+    if (!m_has_been_white){
+        m_has_been_white = m_on.process_frame(frame, timestamp);
+        return false;
+    }
+    bool is_over = m_off.process_frame(frame, timestamp);
+    if (!is_over){
+        return false;
+    }
+    m_white_is_over.store(true, std::memory_order_release);
+    return true;
+}
+bool WhiteScreenOverWatcher::white_is_over(const ImageViewRGB32& frame){
+    return m_white_is_over.load(std::memory_order_acquire);
+}
+
+
+} // namespace PokemonBDSP
+} // namespace NintendoSwitch
+} // namespace PokemonAutomation

SerialPrograms/Source/PokemonBDSP/Inference/PokemonBDSP_TransitionWatchers.h

@@ -0,0 +1,51 @@
+/*  BDSP Transition Watchers
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Adapted from PokemonAutomation/Arduino-Source#1717 by Developer-Butters.
+ */
+
+#ifndef PokemonAutomation_PokemonBDSP_TransitionWatchers_H
+#define PokemonAutomation_PokemonBDSP_TransitionWatchers_H
+
+#include "CommonTools/VisualDetectors/BlackScreenDetector.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+// AutoStory-specific transition handling; shared watchers retain upstream behavior.
+//  A white screen (RGB sum over 500, stddev sum under 10) in `box`,
+//  present or gone for `duration`.
+class WhiteScreenWatcher : public DetectorToFinder<WhiteScreenDetector>{
+public:
+    WhiteScreenWatcher(Color color, const ImageFloatBox& box, FinderType finder_type, std::chrono::milliseconds duration)
+        : DetectorToFinder("WhiteScreenWatcher", finder_type, duration, color, box, 500, 10)
+    {}
+};
+
+//  The screen in `box` went white for 100 ms, then stopped being white for
+//  100 ms: an encounter's flash.
+class WhiteScreenOverWatcher : public VisualInferenceCallback{
+public:
+    WhiteScreenOverWatcher(Color color, const ImageFloatBox& box);
+
+    bool white_is_over(const ImageViewRGB32& frame);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+
+    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+
+private:
+    WhiteScreenWatcher m_on;
+    WhiteScreenWatcher m_off;
+    bool m_has_been_white = false;
+    std::atomic<bool> m_white_is_over = false;
+};
+
+
+} // namespace PokemonBDSP
+} // namespace NintendoSwitch
+} // namespace PokemonAutomation
+#endif

SerialPrograms/Source/PokemonBDSP/PokemonBDSP_Tests.cpp

@@ -6,10 +6,12 @@
 
 #include "Common/Cpp/TestRunners/UnitTestDatabase.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_Maps_Tests.h"
+#include "Programs/AutoStory/PokemonBDSP_AutoStory_PlannedRoute_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_RoutePlanner_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_Segment00_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_StoryMaps_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_StoryWorld_Tests.h"
+#include "Programs/AutoStory/PokemonBDSP_AutoStory_Walk_Tests.h"
 #include "PokemonBDSP_Tests.h"
 
 namespace PokemonAutomation{
@@ -24,6 +26,8 @@ void add_tests(UnitTestDatabase& database){
     add_tests_AutoStory_RoutePlanner(database);
     add_tests_AutoStory_StoryMaps(database);
     add_tests_AutoStory_Segment00(database);
+    add_tests_AutoStory_Walk(database);
+    add_tests_AutoStory_PlannedRoute(database);
 }
 
 

SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Detect/PokemonBDSP_AutoStory_OverworldDetector.cpp

@@ -0,0 +1,136 @@
+/*  BDSP AutoStory - Overworld Detector
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Adapted from PokemonAutomation/Arduino-Source#1717 by Developer-Butters.
+ */
+
+#include "CommonFramework/ImageTools/ImageStats.h"
+#include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
+
+#include "CommonTools/Async/InferenceRoutines.h"
+#include "CommonTools/Images/SolidColorTest.h"
+
+#include "PokemonBDSP_AutoStory_OverworldDetector.h"
+
+using namespace std::chrono_literals;
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+// ---------------------------------------------------------------------------
+//  OverworldDetector
+// ---------------------------------------------------------------------------
+
+OverworldDetector::OverworldDetector(Color color)
+    : m_color(color)
+    , m_battle_menu(BattleType::STANDARD, color){
+}
+
+void OverworldDetector::make_overlays(VideoOverlaySet& items) const {
+    m_dialog.make_overlays(items);
+    m_battle_menu.make_overlays(items);
+    m_menu.make_overlays(items);
+}
+
+bool OverworldDetector::detect(const ImageViewRGB32& screen){
+    // We are in the overworld when none of the overlay screens are present.
+    if (m_dialog.detect(screen)){
+        return false;
+    }
+    if (m_battle_menu.detect(screen)){
+        return false;
+    }
+    if (m_menu.detect(screen)){
+        return false;
+    }
+    return true;
+}
+
+
+// ---------------------------------------------------------------------------
+//  OverworldWatcher
+// ---------------------------------------------------------------------------
+
+OverworldWatcher::OverworldWatcher(Color color)
+    : OverworldDetector(color)
+    , VisualInferenceCallback("OverworldWatcher"){
+}
+
+void OverworldWatcher::make_overlays(VideoOverlaySet& items) const {
+    OverworldDetector::make_overlays(items);
+}
+
+bool OverworldWatcher::process_frame(const ImageViewRGB32& frame, WallClock /*timestamp*/){
+    return detect(frame);
+}
+
+
+// ---------------------------------------------------------------------------
+//  PoketchButtonDetector
+// ---------------------------------------------------------------------------
+
+PoketchButtonDetector::PoketchButtonDetector(Color color)
+    : m_color(color)
+    , m_button(0.968, 0.170, 0.022, 0.120){
+}
+
+void PoketchButtonDetector::make_overlays(VideoOverlaySet& items) const {
+    items.add(m_color, m_button);
+}
+
+bool PoketchButtonDetector::detect(const ImageViewRGB32& screen){
+    ImageStats stats = image_stats(extract_box_reference(screen, m_button));
+    //  The button is a glossy red with a highlight, so allow a wide stddev.
+    return is_solid(stats, {0.74, 0.10, 0.16}, 0.12, 80);
+}
+
+PoketchButtonWatcher::PoketchButtonWatcher(Color color)
+    : PoketchButtonDetector(color)
+    , VisualInferenceCallback("PoketchButtonWatcher"){
+}
+
+void PoketchButtonWatcher::make_overlays(VideoOverlaySet& items) const {
+    PoketchButtonDetector::make_overlays(items);
+}
+
+bool PoketchButtonWatcher::process_frame(const ImageViewRGB32& frame, WallClock){
+    return detect(frame);
+}
+
+
+static bool look_for_poketch_button(VideoStream& stream, ProControllerContext& context){
+    context.wait_for_all_requests();
+    PoketchButtonWatcher watcher;
+    return wait_until(stream, context, 2s, {{watcher}}) == 0;
+}
+
+bool ensure_poketch_visible(VideoStream& stream, ProControllerContext& context){
+    for (size_t attempt = 0; attempt < 3; attempt++){
+        if (look_for_poketch_button(stream, context)){
+            return true;
+        }
+        stream.log("[AutoStory] Poketch button not found. Attempt " + std::to_string(attempt + 1) + " of 3.",
+            COLOR_ORANGE);
+
+        if (attempt == 0){
+            //  Most likely hidden: one tap shows it.
+            pbf_press_button(context, BUTTON_R, 205ms, 0ms);
+        }else{
+            //  Long press hides it, then a tap shows it at the normal size.
+            pbf_press_button(context, BUTTON_R, 1548ms, 0ms);
+            pbf_wait(context, 1418ms);
+            pbf_press_button(context, BUTTON_R, 143ms, 0ms);
+        }
+    }
+
+    //  Check the result of the last press sequence.
+    return look_for_poketch_button(stream, context);
+}
+
+
+} // namespace PokemonBDSP
+} // namespace NintendoSwitch
+} // namespace PokemonAutomation

SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Detect/PokemonBDSP_AutoStory_OverworldDetector.h

@@ -0,0 +1,101 @@
+/*  BDSP AutoStory - Overworld Detector
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Adapted from PokemonAutomation/Arduino-Source#1717 by Developer-Butters.
+ *
+ *  Detects that the player is in the free-roaming overworld state:
+ *  no dialog box, no battle menu, and no in-game menu open.
+ *
+ *  BDSP does not ship a standalone OverworldDetector in PokemonBDSP/Inference/,
+ *  so this composite detector is defined here for AutoStory use.
+ *
+ *  Reuses:
+ *    - ShortDialogDetector   (PokemonBDSP_DialogDetector.h) — absence required
+ *    - BattleMenuDetector    (PokemonBDSP_BattleMenuDetector.h) — absence required
+ *    - MenuDetector          (PokemonBDSP_MenuDetector.h) — absence required
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonBDSP_AutoStory_OverworldDetector_H
+#define PokemonAutomation_PokemonBDSP_AutoStory_OverworldDetector_H
+
+#include "Common/Cpp/Color.h"
+
+#include "CommonFramework/Tools/VideoStream.h"
+
+#include "CommonTools/InferenceCallbacks/VisualInferenceCallback.h"
+#include "CommonTools/VisualDetector.h"
+
+#include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
+
+#include "PokemonBDSP/Inference/Battles/PokemonBDSP_BattleMenuDetector.h"
+#include "PokemonBDSP/Inference/PokemonBDSP_DialogDetector.h"
+#include "PokemonBDSP/Inference/PokemonBDSP_MenuDetector.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+//  Static (single-frame) version — use when you already have a frame.
+class OverworldDetector : public StaticScreenDetector {
+public:
+    OverworldDetector(Color color = COLOR_CYAN);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+
+    //  Returns true when none of: short dialog, battle menu, or in-game menu
+    //  are present on the given frame.
+    virtual bool detect(const ImageViewRGB32& screen) override;
+
+private:
+    Color m_color;
+    ShortDialogDetector m_dialog;
+    BattleMenuDetector m_battle_menu;
+    MenuDetector m_menu;
+};
+
+
+//  Watcher (callback) version — use with run_until<> or wait_until().
+class OverworldWatcher : public OverworldDetector, public VisualInferenceCallback {
+public:
+    OverworldWatcher(Color color = COLOR_CYAN);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+};
+
+
+//  Detects the big red button on the right edge of the Poketch overlay.
+//  Present only while the Poketch is shown at its normal size.
+class PoketchButtonDetector : public StaticScreenDetector {
+public:
+    PoketchButtonDetector(Color color = COLOR_RED);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+    virtual bool detect(const ImageViewRGB32& screen) override;
+
+private:
+    Color m_color;
+    ImageFloatBox m_button;
+};
+
+//  Inference watcher tracking the visibility of the Poketch button on screen.
+class PoketchButtonWatcher : public PoketchButtonDetector, public VisualInferenceCallback {
+public:
+    PoketchButtonWatcher(Color color = COLOR_RED);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+};
+
+//  Tries up to 3 times to get the Poketch button on screen using R presses.
+//  Returns true if the button was seen.
+bool ensure_poketch_visible(VideoStream& stream, ProControllerContext& context);
+
+
+} // namespace PokemonBDSP
+} // namespace NintendoSwitch
+} // namespace PokemonAutomation
+#endif