refactor stop button logic

Author: Gin

Common/Cpp/Options/ButtonOption.cpp

@@ -8,6 +8,7 @@
 #include <atomic>
 #include "Common/Cpp/Containers/Pimpl.tpp"
 #include "Common/Cpp/Concurrency/SpinLock.h"
+#include "Common/Cpp/StringTools.h"
 //#include "Common/Cpp/Json/JsonValue.h"
 #include "ButtonOption.h"
 
@@ -178,6 +179,68 @@ void ButtonOption::set_label(std::string label){
 
 
 
+struct DeferredStopButtonOption::Data{
+    std::atomic<bool> m_stop_requested;
+    std::string m_ready_text;
+    std::string m_pressed_text;
+
+    Data(const std::string& iteration_name)
+        : m_stop_requested(false)
+        , m_ready_text("Stop after Current " + StringTools::capitalize(iteration_name))
+        , m_pressed_text("Program will stop after current " + StringTools::uncapitalize(iteration_name) + "...")
+    {}
+};
+
+
+DeferredStopButtonOption::ResetOnExit::ResetOnExit(DeferredStopButtonOption& button)
+    : m_button(button)
+{
+    button.reset_and_ready();
+}
+
+DeferredStopButtonOption::ResetOnExit::~ResetOnExit(){
+    m_button.set_idle();
+}
+
+
+DeferredStopButtonOption::~DeferredStopButtonOption(){
+}
+
+DeferredStopButtonOption::DeferredStopButtonOption(
+    const std::string& iteration_name,
+    int button_height,
+    int text_size
+)
+    : ButtonOption(
+        "<b>Stop after current " + StringTools::uncapitalize(iteration_name) + ":",
+        ButtonCell::DISABLED,
+        "Stop after Current " + StringTools::capitalize(iteration_name),
+        button_height,
+        text_size
+    )
+    , m_data(CONSTRUCT_TOKEN, iteration_name)
+{}
+
+bool DeferredStopButtonOption::should_stop() const{
+    return m_data->m_stop_requested.load(std::memory_order_relaxed);
+}
+
+void DeferredStopButtonOption::reset_and_ready(){
+    m_data->m_stop_requested.store(false, std::memory_order_relaxed);
+    this->set_enabled(true);
+    this->set_text(m_data->m_ready_text);
+}
+
+void DeferredStopButtonOption::set_idle(){
+    this->set_enabled(false);
+    this->set_text(m_data->m_ready_text);
+}
+
+void DeferredStopButtonOption::press_button(){
+    m_data->m_stop_requested.store(true, std::memory_order_relaxed);
+    this->set_enabled(false);
+    this->set_text(m_data->m_pressed_text);
+}
 
 
 }

Common/Cpp/Options/ButtonOption.h

@@ -26,7 +26,7 @@ class ButtonCell : public ConfigOption{
     };
 
 public:
-    ~ButtonCell();
+    virtual ~ButtonCell();
     ButtonCell(const ButtonCell& x);
     ButtonCell(
         std::string text,
@@ -55,7 +55,7 @@ class ButtonCell : public ConfigOption{
     int button_height() const;
     int text_size() const;
 
-    void press_button();
+    virtual void press_button();
 
 //    virtual void load_json(const JsonValue& json) override;
 //    virtual JsonValue to_json() const override;
@@ -75,7 +75,7 @@ class ButtonCell : public ConfigOption{
 
 class ButtonOption : public ButtonCell{
 public:
-    ~ButtonOption();
+    virtual ~ButtonOption();
     ButtonOption(const ButtonOption& x) = delete;
     ButtonOption(
         std::string label,  // the description of the button, shown on the left side of the button
@@ -104,6 +104,62 @@ class ButtonOption : public ButtonCell{
 
 
 
+//  A button that allows graceful stopping after completing the current unit of work.
+//  This button manages its own state and can be queried to determine if a stop has been requested.
+//
+//  Usage:
+//    1. Add as a member: DeferredStopButtonOption STOP_BUTTON;
+//    2. In constructor: PA_ADD_OPTION(STOP_BUTTON);
+//    3. At program start:
+//       STOP_BUTTON.reset_and_enable();
+//       DeferredStopButtonOption::ResetOnExit reset_on_exit(STOP_BUTTON);
+//    4. In main loop: if (STOP_BUTTON.should_stop()) break;
+//    5. On program exit: ResetOnExit will automatically reset the button via RAII
+class DeferredStopButtonOption : public ButtonOption{
+public:
+    virtual ~DeferredStopButtonOption();
+    DeferredStopButtonOption(const DeferredStopButtonOption& x) = delete;
+
+    //  iteration_name: The name of the unit of work (e.g., "Batch", "Round", "Iteration")
+    //  Used to construct button text like "Stop after Current Batch"
+    //  Can be capitalized or uncapitalized.
+    DeferredStopButtonOption(
+        const std::string& iteration_name = "Iteration",
+        int button_height = 0,
+        int text_size = 16
+    );
+
+    //  RAII guard to automatically reset button when program exits
+    //  Define this guard at beginning of a program running session.
+    class ResetOnExit{
+    public:
+        ResetOnExit(DeferredStopButtonOption& button);
+        ~ResetOnExit();
+    private:
+        DeferredStopButtonOption& m_button;
+    };
+
+    //  Called by the program to check if user has pressed the button to
+    //  request a stop.
+    bool should_stop() const;
+
+    virtual void press_button() override;
+
+private:
+    //  Reset the button to be ready to press during a program run.
+    //  This is usually called by ResetOnExit.
+    void reset_and_ready();
+
+    //  Set button to idle statle after whena program finishes running.
+    //  This is usually called by ResetOnExit.
+    void set_idle();
+
+    friend ResetOnExit;
+    struct Data;
+    Pimpl<Data> m_data;
+};
+
+
 
 }
 #endif

SerialPrograms/Source/PokemonLZA/Programs/Farming/PokemonLZA_JacintheInfiniteFarmer.cpp

@@ -95,12 +95,8 @@ std::unique_ptr<StatsTracker> JacintheInfiniteFarmer_Descriptor::make_stats() co
 }
 
 
-JacintheInfiniteFarmer::~JacintheInfiniteFarmer(){
-    STOP_AFTER_CURRENT.remove_listener(*this);
-}
-
 JacintheInfiniteFarmer::JacintheInfiniteFarmer()
-    : m_stop_after_current(false)
+    : STOP_AFTER_CURRENT("Round")
     , NUM_ROUNDS(
         "<b>Number of Rounds to Run:</b><br>"
         "Zero will run until 'Stop after Current Round' is pressed or the program is manually stopped.</b>",
@@ -137,35 +133,9 @@ JacintheInfiniteFarmer::JacintheInfiniteFarmer()
     PA_ADD_OPTION(NUM_ROUNDS);
     PA_ADD_OPTION(GO_HOME_WHEN_DONE);
     PA_ADD_OPTION(NOTIFICATIONS);
-
-    STOP_AFTER_CURRENT.set_idle();
-    STOP_AFTER_CURRENT.add_listener(*this);
-}
-
-
-
-JacintheInfiniteFarmer::StopButton::StopButton()
-    : ButtonOption(
-      "<b>Stop after current round:",
-      "Stop after current round",
-      0, 16
-    )
-{}
-void JacintheInfiniteFarmer::StopButton::set_idle(){
-    this->set_enabled(false);
-    this->set_text("Stop after Current Round");
-}
-void JacintheInfiniteFarmer::StopButton::set_ready(){
-    this->set_enabled(true);
-    this->set_text("Stop after Current Round");
-}
-void JacintheInfiniteFarmer::StopButton::set_pressed(){
-    this->set_enabled(false);
-    this->set_text("Program will stop after current round...");
 }
 
 
-
 bool JacintheInfiniteFarmer::talk_to_jacinthe(SingleSwitchProgramEnvironment& env, ProControllerContext& context){
     JacintheInfiniteFarmer_Descriptor::Stats& stats = env.current_stats<JacintheInfiniteFarmer_Descriptor::Stats>();
 
@@ -217,7 +187,7 @@ bool JacintheInfiniteFarmer::talk_to_jacinthe(SingleSwitchProgramEnvironment& en
             // - When we lose to Jacinthe, we have some dialog after the battle and returns to the overworld.
             env.log("Detected A button.");
             env.console.overlay().add_log("Button A Detected");
-            if (m_stop_after_current.load(std::memory_order_relaxed)){
+            if (STOP_AFTER_CURRENT.should_stop()){
                 return true; // true means the program should stop
             }
 
@@ -234,7 +204,7 @@ bool JacintheInfiniteFarmer::talk_to_jacinthe(SingleSwitchProgramEnvironment& en
             seen_selection_arrow = true;
             // This is when Jacinthe is asking whether you want
             // to start the battle or continue the battle
-            if (m_stop_after_current.load(std::memory_order_relaxed)){
+            if (STOP_AFTER_CURRENT.should_stop()){
                 env.console.overlay().add_log("Dialog Choice: Cancel");
                 pbf_press_button(context, BUTTON_B, 160ms, 80ms);
             } else{
@@ -331,41 +301,20 @@ void JacintheInfiniteFarmer::run_round(SingleSwitchProgramEnvironment& env, ProC
 }
 
 
-class JacintheInfiniteFarmer::ResetOnExit{
-public:
-    ResetOnExit(StopButton& button)
-        : m_button(button)
-    {}
-    ~ResetOnExit(){
-        m_button.set_idle();
-    }
-
-private:
-    StopButton& m_button;
-};
-
-void JacintheInfiniteFarmer::on_press(){
-    global_logger_tagged().log("Stop after current requested...");
-    m_stop_after_current.store(true, std::memory_order_relaxed);
-    STOP_AFTER_CURRENT.set_pressed();
-}
-
 void JacintheInfiniteFarmer::program(SingleSwitchProgramEnvironment& env, ProControllerContext& context){
     assert_16_9_720p_min(env.logger(), env.console);
 
     JacintheInfiniteFarmer_Descriptor::Stats& stats = env.current_stats<JacintheInfiniteFarmer_Descriptor::Stats>();
-    m_stop_after_current.store(false, std::memory_order_relaxed);
-    STOP_AFTER_CURRENT.set_ready();
-    ResetOnExit reset_button_on_exit(STOP_AFTER_CURRENT);
+
+    DeferredStopButtonOption::ResetOnExit reset_on_exit(STOP_AFTER_CURRENT);
     pbf_mash_button(context, BUTTON_B, 1000ms);
 
 //    auto lobby = env.console.video().snapshot();
 
     while (true){
         send_program_status_notification(env, NOTIFICATION_STATUS_UPDATE);
         if (NUM_ROUNDS != 0 && stats.rounds >= NUM_ROUNDS) {
-            m_stop_after_current.store(true, std::memory_order_relaxed);
-            STOP_AFTER_CURRENT.set_pressed();
+            break;
         }
         if (talk_to_jacinthe(env, context)){
             break;

SerialPrograms/Source/PokemonLZA/Programs/Farming/PokemonLZA_JacintheInfiniteFarmer.h

@@ -7,7 +7,6 @@
 #ifndef PokemonAutomation_PokemonLZA_JacintheInfiniteFarmer_H
 #define PokemonAutomation_PokemonLZA_JacintheInfiniteFarmer_H
 
-#include <atomic>
 #include "Common/Cpp/Options/BooleanCheckBoxOption.h"
 #include "Common/Cpp/Options/SimpleIntegerOption.h"
 #include "Common/Cpp/Options/ButtonOption.h"
@@ -36,12 +35,10 @@ class JacintheInfiniteFarmer_Descriptor : public SingleSwitchProgramDescriptor{
 };
 
 
-class JacintheInfiniteFarmer : public SingleSwitchProgramInstance, public ButtonListener{
+class JacintheInfiniteFarmer : public SingleSwitchProgramInstance{
 public:
-    ~JacintheInfiniteFarmer();
     JacintheInfiniteFarmer();
 
-    virtual void on_press() override;
     virtual void program(SingleSwitchProgramEnvironment& env, ProControllerContext& context) override;
 
 private:
@@ -58,17 +55,7 @@ class JacintheInfiniteFarmer : public SingleSwitchProgramInstance, public Button
     void run_round(SingleSwitchProgramEnvironment& env, ProControllerContext& context);
 
 private:
-    class StopButton : public ButtonOption{
-    public:
-        StopButton();
-        void set_idle();
-        void set_ready();
-        void set_pressed();
-    };
-    class ResetOnExit;
-
-    std::atomic<bool> m_stop_after_current;
-    StopButton STOP_AFTER_CURRENT;
+    DeferredStopButtonOption STOP_AFTER_CURRENT;
     SimpleIntegerOption<uint32_t> NUM_ROUNDS;
     GoHomeWhenDoneOption GO_HOME_WHEN_DONE;