Fix incorrect end battle detection in Doubles Leveling when wild Graveler uses magnitude.

Author: Mysticial

SerialPrograms/Source/CommonFramework/Globals.cpp

@@ -25,7 +25,7 @@ namespace PokemonAutomation{
 const bool IS_BETA_VERSION = true;
 const int PROGRAM_VERSION_MAJOR = 0;
 const int PROGRAM_VERSION_MINOR = 50;
-const int PROGRAM_VERSION_PATCH = 16;
+const int PROGRAM_VERSION_PATCH = 17;
 
 const std::string PROGRAM_VERSION_BASE =
     "v" + std::to_string(PROGRAM_VERSION_MAJOR) +

SerialPrograms/Source/CommonFramework/Inference/BlackScreenDetector.cpp

@@ -57,44 +57,41 @@ bool WhiteScreenDetector::detect(const ImageViewRGB32& screen) const{
 
 
 
-BlackScreenWatcher::BlackScreenWatcher(
-    Color color, const ImageFloatBox& box,
-    double max_rgb_sum,
-    double max_stddev_sum
-)
-    : BlackScreenDetector(color, box, max_rgb_sum, max_stddev_sum)
-    , VisualInferenceCallback("BlackScreenWatcher")
-{}
-void BlackScreenWatcher::make_overlays(VideoOverlaySet& items) const{
-    BlackScreenDetector::make_overlays(items);
-}
-bool BlackScreenWatcher::process_frame(const ImageViewRGB32& frame, WallClock timestamp){
-    return detect(frame);
-}
-
 
 
 
 BlackScreenOverWatcher::BlackScreenOverWatcher(
     Color color, const ImageFloatBox& box,
     double max_rgb_sum,
-    double max_stddev_sum
+    double max_stddev_sum,
+    std::chrono::milliseconds hold_duration,
+    std::chrono::milliseconds release_duration
 )
     : VisualInferenceCallback("BlackScreenOverWatcher")
-    , m_detector(color, box, max_rgb_sum, max_stddev_sum)
+    , m_on(color, box, max_rgb_sum, max_stddev_sum, BlackScreenWatcher::FinderType::PRESENT, hold_duration)
+    , m_off(color, box, max_rgb_sum, max_stddev_sum, BlackScreenWatcher::FinderType::GONE, release_duration)
 {}
 void BlackScreenOverWatcher::make_overlays(VideoOverlaySet& items) const{
-    m_detector.make_overlays(items);
+    m_on.make_overlays(items);
 }
 bool BlackScreenOverWatcher::process_frame(const ImageViewRGB32& frame, WallClock timestamp){
-    return black_is_over(frame);
-}
-bool BlackScreenOverWatcher::black_is_over(const ImageViewRGB32& frame){
-    if (m_detector.detect(frame)){
-        m_has_been_black = true;
+    if (m_black_is_over.load(std::memory_order_acquire)){
+        return true;
+    }
+    if (!m_has_been_black){
+        m_has_been_black = m_on.process_frame(frame, timestamp);
         return false;
     }
-    return m_has_been_black;
+
+    bool is_over = m_off.process_frame(frame, timestamp);
+    if (!is_over){
+        return false;
+    }
+    m_black_is_over.store(true, std::memory_order_release);
+    return true;
+}
+bool BlackScreenOverWatcher::black_is_over(const ImageViewRGB32& frame){
+    return m_black_is_over.load(std::memory_order_acquire);
 }
 
 

SerialPrograms/Source/CommonFramework/Inference/BlackScreenDetector.h

@@ -57,17 +57,18 @@ class WhiteScreenDetector : public StaticScreenDetector{
 };
 
 
-class BlackScreenWatcher : public BlackScreenDetector, public VisualInferenceCallback{
+class BlackScreenWatcher : public DetectorToFinder<BlackScreenDetector>{
 public:
     BlackScreenWatcher(
         Color color = COLOR_RED,
         const ImageFloatBox& box = {0.1, 0.1, 0.8, 0.8},
         double max_rgb_sum = 100,
-        double max_stddev_sum = 10
-    );
-
-    virtual void make_overlays(VideoOverlaySet& items) const override;
-    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+        double max_stddev_sum = 10,
+        FinderType finder_type = FinderType::PRESENT,
+        std::chrono::milliseconds duration = std::chrono::milliseconds(250)
+    )
+        : DetectorToFinder("BlackScreenWatcher", finder_type, duration, color, box, max_rgb_sum, max_stddev_sum)
+    {}
 };
 
 // Detect when a period of black screen is over
@@ -77,7 +78,9 @@ class BlackScreenOverWatcher : public VisualInferenceCallback{
         Color color = COLOR_RED,
         const ImageFloatBox& box = {0.1, 0.1, 0.8, 0.8},
         double max_rgb_sum = 100,
-        double max_stddev_sum = 10
+        double max_stddev_sum = 10,
+        std::chrono::milliseconds hold_duration = std::chrono::milliseconds(250),
+        std::chrono::milliseconds release_duration = std::chrono::milliseconds(250)
     );
 
     bool black_is_over(const ImageViewRGB32& frame);
@@ -87,8 +90,10 @@ class BlackScreenOverWatcher : public VisualInferenceCallback{
     virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
 
 private:
-    BlackScreenDetector m_detector;
+    BlackScreenWatcher m_on;
+    BlackScreenWatcher m_off;
     bool m_has_been_black = false;
+    std::atomic<bool> m_black_is_over = false;
 };
 
 

SerialPrograms/Source/CommonFramework/Tools/ErrorDumper.cpp

@@ -43,14 +43,16 @@ std::string dump_image_alone(
 void dump_image(
     Logger& logger,
     const ProgramInfo& program_info, const std::string& label,
-    const ImageViewRGB32& image
+    const ImageViewRGB32& image,
+    ConsoleHandle* console
 ){
     report_error(
         &logger,
         program_info,
         label,
         {},
-        image
+        image,
+        console
     );
 }
 void dump_image(

SerialPrograms/Source/CommonFramework/Tools/ErrorDumper.h

@@ -32,7 +32,8 @@ std::string dump_image_alone(
 void dump_image(
     Logger& logger,
     const ProgramInfo& program_info, const std::string& label,
-    const ImageViewRGB32& image
+    const ImageViewRGB32& image,
+    ConsoleHandle* console = nullptr
 );
 void dump_image(
     const ProgramInfo& program_info,

SerialPrograms/Source/PokemonBDSP/Inference/Battles/PokemonBDSP_EndBattleDetector.cpp

@@ -21,7 +21,7 @@ namespace PokemonBDSP{
 
 
 
-
+#if 0
 EndBattleWatcher::EndBattleWatcher(const ImageFloatBox& box, Color color)
     : VisualInferenceCallback("EndBattleWatcher")
     , m_color(color)
@@ -50,6 +50,7 @@ bool EndBattleWatcher::battle_is_over(const ImageViewRGB32& frame){
     }
     return true;
 }
+#endif
 
 
 

SerialPrograms/Source/PokemonBDSP/Inference/Battles/PokemonBDSP_EndBattleDetector.h

@@ -9,15 +9,14 @@
 
 #include "Common/Cpp/Color.h"
 #include "CommonFramework/ImageTools/ImageBoxes.h"
-#include "CommonFramework/Inference/VisualDetector.h"
-#include "CommonFramework/InferenceInfra/VisualInferenceCallback.h"
+#include "CommonFramework/Inference/BlackScreenDetector.h"
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
 namespace PokemonBDSP{
 
 
-
+#if 0
 class EndBattleWatcher : public VisualInferenceCallback{
 public:
     EndBattleWatcher(
@@ -36,6 +35,21 @@ class EndBattleWatcher : public VisualInferenceCallback{
     ImageFloatBox m_box;
     bool m_has_been_black = false;
 };
+#endif
+
+
+class EndBattleWatcher : public BlackScreenOverWatcher{
+public:
+    EndBattleWatcher(
+        const ImageFloatBox& box = {0.1, 0.1, 0.8, 0.8},
+        Color color = COLOR_RED
+    )
+        : BlackScreenOverWatcher(
+            color, box, 100, 10, std::chrono::milliseconds(1000)
+        )
+    {}
+
+};
 
 
 

SerialPrograms/Source/PokemonBDSP/Programs/Farming/PokemonBDSP_DoublesLeveling.cpp

@@ -7,6 +7,7 @@
 #include "CommonFramework/Exceptions/OperationFailedException.h"
 #include "CommonFramework/Notifications/ProgramNotifications.h"
 #include "CommonFramework/InferenceInfra/InferenceRoutines.h"
+#include "CommonFramework/Inference/FrozenImageDetector.h"
 #include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
 #include "PokemonSwSh/ShinyHuntTracker.h"
 #include "PokemonBDSP/Inference/PokemonBDSP_SelectionArrow.h"
@@ -102,15 +103,17 @@ bool DoublesLeveling::battle(SingleSwitchProgramEnvironment& env, BotBaseContext
         BattleMenuWatcher battle_menu(BattleType::STANDARD);
         EndBattleWatcher end_battle;
         SelectionArrowFinder learn_move(env.console, {0.50, 0.62, 0.40, 0.18}, COLOR_YELLOW);
+        FrozenImageDetector overworld(std::chrono::seconds(5), 10);
         int ret = run_until(
             env.console, context,
             [](BotBaseContext& context){
                 pbf_mash_button(context, BUTTON_B, 120 * TICKS_PER_SECOND);
             },
             {
-                {battle_menu},
-                {end_battle},
-                {learn_move},
+                battle_menu,
+                end_battle,
+                learn_move,
+                overworld,
             }
         );
         switch (ret){
@@ -131,6 +134,10 @@ bool DoublesLeveling::battle(SingleSwitchProgramEnvironment& env, BotBaseContext
                 break;
             }
             return true;
+        case 3:
+            env.log("Detected possible overworld!", COLOR_BLUE);
+            pbf_mash_button(context, BUTTON_B, 250);
+            return false;
         default:
             env.log("Timed out.", COLOR_RED);
             stats.add_error();

SerialPrograms/Source/PokemonBDSP/Programs/PokemonBDSP_EncounterDetection.cpp

@@ -130,7 +130,8 @@ std::set<std::string> StandardEncounterDetection::read_name(const ImageViewRGB32
         dump_image(
             m_console, ProgramInfo(),
             "StandardEncounterDetection-NameOCR-" + language_data(m_language).code,
-            screen
+            screen,
+            &m_console
         );
     }else{
         for (const auto& item : result.results){