FRLG walker: encounters and obstacles (wild steps across maps, late battles, warp fades vs battles, signs and ledges)

SerialPrograms/Source/VideoGames/PokemonFRLG/Inference/PokemonFRLG_BattleFlashWatcher.cpp

@@ -0,0 +1,76 @@
+/*  Battle Flash Watcher
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include "CommonFramework/ImageTools/ImageBoxes.h"
+#include "CommonFramework/ImageTools/ImageStats.h"
+#include "CommonFramework/ImageTypes/ImageViewRGB32.h"
+#include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
+#include "VideoGames/PokemonFRLG/PokemonFRLG_Settings.h"
+#include "PokemonFRLG_BattleFlashWatcher.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonFRLG{
+
+using namespace std::chrono_literals;
+
+
+namespace{
+
+//  On the console a flash took the screen from 145 to 98 (two thirds) and
+//  back within 80ms, twice in about 300ms.
+constexpr std::chrono::milliseconds FLASH_WINDOW = 400ms;
+constexpr double FLASH_DARKER = 0.8;    //  the dip is below this much of the brightness before it
+constexpr double FLASH_FLOOR = 0.4;     //  and above this much: lower is a fade to black
+constexpr double FLASH_RECOVERY = 1.1;  //  then the screen comes back to this much of the dip
+
+}
+
+
+BattleFlashWatcher::BattleFlashWatcher(Color color)
+    : VisualInferenceCallback("BattleFlashWatcher")
+    , m_color(color)
+{}
+
+void BattleFlashWatcher::make_overlays(VideoOverlaySet& items) const{
+    items.add(m_color, GameSettings::instance().GAME_BOX);
+}
+
+bool BattleFlashWatcher::process_frame(const ImageViewRGB32& frame, WallClock timestamp){
+    const ImageViewRGB32 game_screen = extract_box_reference(frame, GameSettings::instance().GAME_BOX);
+    const double brightness = image_stats(game_screen).average.sum();
+    while (!m_history.empty() && timestamp - m_history.front().first > FLASH_WINDOW){
+        m_history.pop_front();
+    }
+
+    //  The brightest frame before the screen first dips, and the darkest
+    //  frame since.
+    double before = 0;
+    double dip = -1;
+    for (const auto& item : m_history){
+        if (dip < 0){
+            if (item.second < before * FLASH_DARKER){
+                dip = item.second;
+            }else{
+                before = std::max(before, item.second);
+            }
+        }else{
+            dip = std::min(dip, item.second);
+        }
+    }
+    m_history.emplace_back(timestamp, brightness);
+
+    return dip >= 0
+        && dip > before * FLASH_FLOOR
+        && brightness > dip * FLASH_RECOVERY;
+}
+
+
+
+}
+}
+}

SerialPrograms/Source/VideoGames/PokemonFRLG/Inference/PokemonFRLG_BattleFlashWatcher.h

@@ -0,0 +1,46 @@
+/*  Battle Flash Watcher
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Every wild battle starts with the overworld flashing dark twice, within
+ *  half a second of the step that set it off, before the battle's own wipe.
+ *  The wipe and the battle screen differ by map and come seconds later, so
+ *  the flash is the earliest and the same sign of a battle everywhere.
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonFRLG_BattleFlashWatcher_H
+#define PokemonAutomation_PokemonFRLG_BattleFlashWatcher_H
+
+#include <deque>
+#include <utility>
+#include "Common/Cpp/Color.h"
+#include "CommonTools/InferenceCallbacks/VisualInferenceCallback.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonFRLG{
+
+
+//  Fires when the game screen darkens by a fifth or more and starts to come
+//  back within a moment. A warp's fade, or the Switch dimming its screen,
+//  only darkens and so doesn't count.
+class BattleFlashWatcher : public VisualInferenceCallback{
+public:
+    BattleFlashWatcher(Color color);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+
+private:
+    Color m_color;
+    //  Recent brightness of the game screen.
+    std::deque<std::pair<WallClock, double>> m_history;
+};
+
+
+
+}
+}
+}
+#endif

SerialPrograms/Source/VideoGames/PokemonFRLG/Inference/PokemonFRLG_BattleScreenDetector.cpp

@@ -0,0 +1,36 @@
+/*  Battle Screen Detector
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "PokemonFRLG_BattleScreenDetector.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonFRLG{
+
+
+BattleScreenDetector::BattleScreenDetector(Color color)
+    : m_dialog(color)
+    , m_menu(color)
+    , m_opponent(color)
+    , m_player(color)
+{}
+void BattleScreenDetector::make_overlays(VideoOverlaySet& items) const{
+    m_dialog.make_overlays(items);
+    m_opponent.make_overlays(items);
+    m_player.make_overlays(items);
+}
+bool BattleScreenDetector::detect(const ImageViewRGB32& screen){
+    if (m_menu.detect(screen)){
+        return true;
+    }
+    return m_dialog.detect(screen) && (m_opponent.detect(screen) || m_player.detect(screen));
+}
+
+
+
+}
+}
+}

SerialPrograms/Source/VideoGames/PokemonFRLG/Inference/PokemonFRLG_BattleScreenDetector.h

@@ -0,0 +1,54 @@
+/*  Battle Screen Detector
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  A battle on screen: the battle text box, and with it the opponent's HP
+ *  box, the player's or the battle menu. The text box alone also reads on
+ *  the black below a small indoor map (console B, 2026-11-01: Oak's Lab's
+ *  mat, Viridian Forest's north gate).
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonFRLG_BattleScreenDetector_H
+#define PokemonAutomation_PokemonFRLG_BattleScreenDetector_H
+
+#include <chrono>
+#include "Common/Cpp/Color.h"
+#include "CommonFramework/ImageTypes/ImageViewRGB32.h"
+#include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
+#include "CommonTools/VisualDetector.h"
+#include "VideoGames/PokemonFRLG/Inference/Dialogs/PokemonFRLG_BattleDialogs.h"
+#include "VideoGames/PokemonFRLG/Inference/PokemonFRLG_BattlePokemonDetector.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonFRLG{
+
+
+class BattleScreenDetector : public StaticScreenDetector{
+public:
+    BattleScreenDetector(Color color = COLOR_RED);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
+    virtual bool detect(const ImageViewRGB32& screen) override;
+
+private:
+    BattleDialogDetector m_dialog;
+    BattleMenuDetector m_menu;
+    BattleOpponentDetector m_opponent;
+    BattlePokemonDetector m_player;
+};
+
+class BattleScreenWatcher : public DetectorToFinder<BattleScreenDetector>{
+public:
+    BattleScreenWatcher(Color color = COLOR_RED)
+        : DetectorToFinder("BattleScreenWatcher", std::chrono::milliseconds(250), color)
+    {}
+};
+
+
+
+}
+}
+}
+#endif