Merge branch 'main' of https://github.com/PokemonAutomation/Arduino-Source

Author: Mysticial

SerialPrograms/Source/NintendoSwitch/Programs/NintendoSwitch_GameEntry.h

@@ -16,7 +16,9 @@ namespace PokemonAutomation{
 namespace NintendoSwitch{
 
 
+// Press Home button to go from game to Switch Home screen
 void go_home(ConsoleHandle& console, ProControllerContext& context);
+// Press Home button to go from game to Switch Home screen
 void go_home(ConsoleHandle& console, JoyconContext& context);
 void ensure_at_home(ConsoleHandle& console, ProControllerContext& context);
 void ensure_at_home(ConsoleHandle& console, JoyconContext& context);

SerialPrograms/Source/PokemonLZA/Inference/Boxes/PokemonLZA_BoxDetection.cpp

@@ -5,7 +5,6 @@
  */
 
 #include "Common/Cpp/Exceptions.h"
-// #include "CommonFramework/Exceptions/FatalProgramException.h"
 #include "CommonFramework/ImageTools/ImageStats.h"
 #include "CommonFramework/VideoPipeline/VideoOverlay.h"
 #include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
@@ -211,6 +210,11 @@ void BoxDetector::move_cursor(
     const ProgramInfo& info, VideoStream& stream, ProControllerContext& context,
     uint8_t row, uint8_t col
 ){
+    if (row >= 6 || col >= 6){
+        throw InternalProgramError(&stream.logger(), "BoxDetector::move_cursor",
+            "row or col out of range: " + std::to_string(row) + ", " + std::to_string(col));
+    }
+
     WallClock start = current_time();
     while (true){
         if (current_time() - start > std::chrono::seconds(60)){

SerialPrograms/Source/PokemonLZA/Inference/Boxes/PokemonLZA_BoxInfoDetector.cpp

@@ -157,6 +157,36 @@ bool BoxAlphaDetector::detect(const ImageViewRGB32& screen){
     return found;
 }
 
+BoxPageInfoWatcher::BoxPageInfoWatcher(VideoOverlay* overlay)
+: VisualInferenceCallback("BoxPageInfoWatcher")
+, m_shiny_watcher(COLOR_BLACK, overlay)
+, m_alpha_watcher(COLOR_RED, overlay)
+{}
+
+void BoxPageInfoWatcher::make_overlays(VideoOverlaySet& items) const{
+    m_shiny_watcher.make_overlays(items);
+    m_alpha_watcher.make_overlays(items);
+}
+
+bool BoxPageInfoWatcher::process_frame(const ImageViewRGB32& frame, WallClock timestamp){
+    bool shiny_determined = m_shiny_watcher.process_frame(frame, timestamp);
+    bool alpha_determined = m_alpha_watcher.process_frame(frame, timestamp);
+    return shiny_determined && alpha_determined;
+}
+
+std::string BoxPageInfoWatcher::info_str() const{
+    const bool is_shiny = m_shiny_watcher.consistent_result();
+    const bool is_alpha = m_alpha_watcher.consistent_result();
+
+    if (is_shiny && is_alpha){
+        return "Shiny Alpha";
+    } else if (is_shiny){
+        return "Shiny";
+    } else if (is_alpha){
+        return "Alpha";
+    }
+    return "Normal";
+}
 
 
 

SerialPrograms/Source/PokemonLZA/Inference/Boxes/PokemonLZA_BoxInfoDetector.h

@@ -39,6 +39,8 @@ class BoxShinyDetector : public StaticScreenDetector{
     std::optional<OverlayBoxScope> m_last_detected_box;
 };
 
+// Detect whether there is a shiny symbol on the current pokemon in the box system.
+// Call BoxShinyWatcher::consistent_result() to know if the pokemon is shiny or not.
 class BoxShinyWatcher : public DetectorToFinder<BoxShinyDetector>{
 public:
     BoxShinyWatcher(
@@ -71,6 +73,8 @@ class BoxAlphaDetector : public StaticScreenDetector{
     std::optional<OverlayBoxScope> m_last_detected_box;
 };
 
+// Detect whether there is an alpha symbol on the current pokemon in the box system.
+// Call BoxAlphaWatcher::consistent_result() to know if the pokemon is alpha or not.
 class BoxAlphaWatcher : public DetectorToFinder<BoxAlphaDetector>{
 public:
     BoxAlphaWatcher(
@@ -82,7 +86,37 @@ class BoxAlphaWatcher : public DetectorToFinder<BoxAlphaDetector>{
     {}
 };
 
+// Check both shiny and alpha-ness of the current pokemon in the box view
+class BoxPageInfoWatcher : public VisualInferenceCallback{
+public:
+    BoxPageInfoWatcher(VideoOverlay* overlay);
+
+    virtual void make_overlays(VideoOverlaySet& items) const override;
 
+    // return true when the watcher determines the shiny and alpha-ness of the pokemon
+    virtual bool process_frame(const ImageViewRGB32& frame, WallClock timestamp) override;
+
+    // reset internal state so the watcher is ready for detect another pokemon's info
+    void reset_state(){
+        m_shiny_watcher.reset_state();
+        m_alpha_watcher.reset_state();
+    }
+
+    // After detection is done, call this to check shiny-ness
+    bool is_shiny() const { return m_shiny_watcher.consistent_result(); }
+    // After detection is done, call this to check alpha-ness
+    bool is_alpha() const { return m_alpha_watcher.consistent_result(); }
+    // Return string of detected shiny and alpha-ness for logging. It can be:
+    // - "Normal"
+    // - "Shiny"
+    // - "Alpha"
+    // - "Shiny Alpha"
+    std::string info_str() const;
+
+private:
+    BoxShinyWatcher m_shiny_watcher;
+    BoxAlphaWatcher m_alpha_watcher;
+};
 
 
 }

SerialPrograms/Source/PokemonLZA/Programs/PokemonLZA_AutoFossil.cpp

@@ -7,13 +7,19 @@
 #include "CommonFramework/ProgramStats/StatsTracking.h"
 #include "CommonTools/Async/InferenceRoutines.h"
 #include "CommonFramework/Exceptions/OperationFailedException.h"
+#include "CommonFramework/Notifications/ProgramNotifications.h"
+#include "CommonFramework/VideoPipeline/VideoFeed.h"
 #include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
 #include "Pokemon/Pokemon_Strings.h"
+#include "Pokemon/Pokemon_Notification.h"
+#include "PokemonLZA/Inference/Boxes/PokemonLZA_BoxDetection.h"
+#include "PokemonLZA/Inference/Boxes/PokemonLZA_BoxInfoDetector.h"
 #include "PokemonLZA/Inference/PokemonLZA_ButtonDetector.h"
 #include "PokemonLZA/Inference/PokemonLZA_SelectionArrowDetector.h"
 #include "PokemonLZA/Inference/PokemonLZA_DialogDetector.h"
+#include "PokemonLZA/Programs/PokemonLZA_GameEntry.h"
 #include "PokemonLZA/Programs/PokemonLZA_MenuNavigation.h"
-#include "PokemonLZA/Inference/Boxes/PokemonLZA_BoxDetection.h"
+#include "NintendoSwitch/Programs/NintendoSwitch_GameEntry.h"
 #include "PokemonLZA_AutoFossil.h"
 
 #include <sstream>
@@ -53,13 +59,19 @@ class AutoFossil_Descriptor::Stats : public StatsTracker{
 public:
     Stats()
         : fossils(m_stats["Fossils"])
+        , alphas(m_stats["Alphas"])
+        , shinies(m_stats["Shinies"])
         , errors(m_stats["Errors"])
     {
         m_display_order.emplace_back("Fossils");
+        m_display_order.emplace_back("Alphas");
+        m_display_order.emplace_back("Shinies");
         m_display_order.emplace_back("Errors", HIDDEN_IF_ZERO);
     }
 
     std::atomic<uint64_t>& fossils;
+    std::atomic<uint64_t>& alphas;
+    std::atomic<uint64_t>& shinies;
     std::atomic<uint64_t>& errors;
 };
 
@@ -68,23 +80,60 @@ std::unique_ptr<StatsTracker> AutoFossil_Descriptor::make_stats() const{
 }
 
 
-AutoFossil::AutoFossil(){}
+AutoFossil::AutoFossil()
+    : NUM_BOXES("<b>Boxes of Fossils to Revive:</b>",
+        LockMode::LOCK_WHILE_RUNNING,
+        1, 1, 32
+    )
+    , FOUND_SHINY_OR_ALPHA(
+        "Found Shiny or Alpha",
+        true, true,
+        ImageAttachmentMode::JPG,
+        {"Notifs", "Showcase"}
+    )
+    , NOTIFICATION_STATUS("Status Update", true, false, std::chrono::seconds(3600))
+    , NOTIFICATIONS({
+        &NOTIFICATION_STATUS,
+        &FOUND_SHINY_OR_ALPHA,
+        &NOTIFICATION_PROGRAM_FINISH,
+        &NOTIFICATION_ERROR_RECOVERABLE,
+        &NOTIFICATION_ERROR_FATAL,
+    })
+{
+    PA_ADD_OPTION(STOP_ON);
+    PA_ADD_OPTION(NUM_BOXES);
+    PA_ADD_OPTION(NOTIFICATIONS);
+}
 
 
 void AutoFossil::program(SingleSwitchProgramEnvironment& env, ProControllerContext& context){
-    // AutoFossil_Descriptor::Stats& stats = env.current_stats<AutoFossil_Descriptor::Stats>();
-    overworld_to_box_system(env.console, context);
-    return;
-
-    // Example loop structure
-    size_t num_fossils_to_revive = 3;
-    for(size_t i = 0; i < num_fossils_to_revive; i++){
-        revive_one_fossil(env, context);
-        std::ostringstream os;
-        os << "Got Fossil " << i + 1 << "/" << num_fossils_to_revive;
-        std::string log_str = os.str();
-        env.log(log_str);
-        env.console.overlay().add_log(log_str);
+    while(true){
+        size_t num_fossils_to_revive = size_t(NUM_BOXES) * 30;
+        for(size_t i = 0; i < num_fossils_to_revive; i++){
+            revive_one_fossil(env, context);
+            std::ostringstream os;
+            os << "Got Fossil " << i + 1 << "/" << num_fossils_to_revive;
+            std::string log_str = os.str();
+            env.log(log_str);
+            env.console.overlay().add_log(log_str);
+        }
+
+        overworld_to_box_system(env.console, context);
+        for(uint8_t i = 0; i < NUM_BOXES; i++){
+            bool found_match = check_fossils_in_one_box(env, context);
+            if (found_match){
+                return;
+            }
+            if (i != NUM_BOXES - 1){
+                // go to next page
+                pbf_press_button(context, BUTTON_R, 200ms, 200ms);
+            }
+        }
+        // checked all boxes, no match
+        go_home(env.console, context);
+        reset_game_from_home(env, env.console, context);
+        
+        send_program_status_notification(env, NOTIFICATION_STATUS);
     }
 }
 
@@ -149,27 +198,96 @@ void AutoFossil::revive_one_fossil(SingleSwitchProgramEnvironment& env, ProContr
         case 3:
             env.log("Detected blue dialog.");
             pbf_press_button(context, BUTTON_B, 80ms, 40ms);
+            // in normal cases when blue dialog box is detected, we already seen the selection
+            // arrow. But just in case somehow the program misses the selection arrow detection,
+            // we can still set it to true here to ensure subsequent program execution is smooth.
+            seen_selection_arrow = true;
             continue;
 
         default:
             stats.errors++;
             env.update_stats();
             OperationFailedException::fire(
                 ErrorReport::SEND_ERROR_REPORT,
-                "run_lobby(): No recognized state after 60 seconds.",
+                "revive_one_fossil(): No recognized state after 60 seconds.",
                 env.console
             );
         }
     }
 }
 
 // start at box system, check fossils one by one
-void AutoFossil::check_fossils_in_box(SingleSwitchProgramEnvironment& env, ProControllerContext& context, size_t num_boxes){
-    uint8_t box_x = 0, box_y = 0;
+bool AutoFossil::check_fossils_in_one_box(SingleSwitchProgramEnvironment& env, ProControllerContext& context){
+    AutoFossil_Descriptor::Stats& stats = env.current_stats<AutoFossil_Descriptor::Stats>();
+
+    uint8_t box_row = 1, box_col = 0;
+    bool next_cell_right = true;
     BoxDetector box_detector(COLOR_RED, &env.console.overlay());
+    BoxPageInfoWatcher info_watcher(&env.console.overlay());
     for(size_t i = 0; i < 30; i++){
-        box_detector.move_cursor(env.program_info(), env.console, context, box_x, box_y);
+        env.console.overlay().add_log("To cell: (" + std::to_string(box_row) + ", " + std::to_string(box_col) + ")");
+        box_detector.move_cursor(env.program_info(), env.console, context, box_row, box_col);
+
+        info_watcher.reset_state();
+        wait_until(env.console, context, WallClock::max(), {info_watcher});
+        
+        std::ostringstream os;
+        os << i + 1 << "/" << int(NUM_BOXES)*30 << ": " << info_watcher.info_str();
+        std::string log_str = os.str();
+        env.log(log_str);
+        env.console.overlay().add_log(log_str);
+        if (info_watcher.is_alpha()){
+            stats.alphas++;
+            env.update_stats();
+        }
+        if (info_watcher.is_shiny()){
+            stats.shinies++;
+            env.update_stats();
+        }
+
+        bool is_match = false;
+        switch (STOP_ON){
+        case PokemonLA::StopOn::Shiny:
+            is_match = info_watcher.is_shiny();
+            break;
+        case PokemonLA::StopOn::Alpha:
+            is_match = info_watcher.is_alpha();
+            break;
+        case PokemonLA::StopOn::ShinyOrAlpha:
+            is_match = info_watcher.is_shiny() || info_watcher.is_alpha();
+            break;
+        case PokemonLA::StopOn::ShinyAndAlpha:
+            is_match = info_watcher.is_shiny() && info_watcher.is_alpha();
+            break;
+        }
+        if (is_match){
+            send_program_notification(
+                env, FOUND_SHINY_OR_ALPHA,
+                Pokemon::COLOR_STAR_SHINY,
+                "Found " + info_watcher.info_str() + "!",
+                {}, "",
+                env.console.video().snapshot(), true
+            );
+            return true;
+        }
+
+        if (next_cell_right){
+            if (box_col == 5){
+                box_row++;
+                next_cell_right = false;
+            } else{
+                box_col++;
+            }
+        } else{
+            if (box_col == 0){
+                box_row++;
+                next_cell_right = true;
+            } else{
+                box_col--;
+            }
+        }
     }
+    return false;
 }
 
 }

SerialPrograms/Source/PokemonLZA/Programs/PokemonLZA_AutoFossil.h

@@ -9,7 +9,11 @@
 #define PokemonAutomation_PokemonLZA_AutoFossil_H
 
 #include "Common/Cpp/Options/ButtonOption.h"
+#include "Common/Cpp/Options/SimpleIntegerOption.h"
+#include "CommonFramework/Notifications/EventNotificationOption.h"
+#include "CommonFramework/Notifications/EventNotificationsTable.h"
 #include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h"
+#include "PokemonLA/Options/PokemonLA_MiscOptions.h"
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
@@ -34,7 +38,16 @@ class AutoFossil : public SingleSwitchProgramInstance{
 private:
     void revive_one_fossil(SingleSwitchProgramEnvironment& env, ProControllerContext& context);
 
-    void check_fossils_in_box(SingleSwitchProgramEnvironment& env, ProControllerContext& context, size_t num_boxes);
+    // return true if found a match
+    bool check_fossils_in_one_box(SingleSwitchProgramEnvironment& env, ProControllerContext& context);
+
+    PokemonLA::StopOnOption STOP_ON;
+
+    SimpleIntegerOption<uint8_t> NUM_BOXES;
+
+    EventNotificationOption FOUND_SHINY_OR_ALPHA;
+    EventNotificationOption NOTIFICATION_STATUS;
+    EventNotificationsOption NOTIFICATIONS;
 };