Add support for setting controller colors.

Author: Mysticial

Common/Cpp/Options/EditableTableOption.cpp

@@ -122,6 +122,8 @@ void EditableTableOption::clear(){
     m_current.clear();
 }
 void EditableTableOption::load_json(const JsonValue& json){
+//    cout << "EditableTableOption::load_json(): " << this << endl;
+
     const JsonArray* array = json.to_array();
     if (array == nullptr){
         return;
@@ -216,6 +218,9 @@ void EditableTableOption::insert_row(size_t index, std::unique_ptr<EditableTable
     }
     report_value_changed(this);
 }
+void EditableTableOption::append_row(std::unique_ptr<EditableTableRow> row){
+    insert_row((size_t)-1, std::move(row));
+}
 void EditableTableOption::clone_row(const EditableTableRow& row){
     {
         size_t index = row.m_index;

Common/Cpp/Options/EditableTableOption.h

@@ -97,6 +97,10 @@ class EditableTableOption : public ConfigOption{
     //  These reference are live in that they may be asynchronously changed.
     std::vector<std::shared_ptr<EditableTableRow>> current_refs() const;
 
+//    SpinLock& get_lock() const{
+//        return m_current_lock;
+//    }
+
     //  Return a copy of the entire table at the exact moment this is called.
     template <typename RowType>
     std::vector<std::unique_ptr<RowType>> copy_snapshot() const{
@@ -121,11 +125,15 @@ class EditableTableOption : public ConfigOption{
         }
         return ret;
     }
+
+    //  Lambda returns a boolean. False to continue running. True to stop.
     template <typename RowType, typename Lambda>
     void run_on_all_rows(Lambda function){
         ReadSpinLock lg(m_current_lock);
         for (auto& item : m_current){
-            function(static_cast<RowType&>(*item));
+            if (function(static_cast<RowType&>(*item))){
+                return;
+            }
         }
     }
 
@@ -144,6 +152,7 @@ class EditableTableOption : public ConfigOption{
 
     //  Undefined behavior to call these on rows that aren't part of the table.
     void insert_row(size_t index, std::unique_ptr<EditableTableRow> row);
+    void append_row(std::unique_ptr<EditableTableRow> row);
     void clone_row(const EditableTableRow& row);
     void remove_row(EditableTableRow& row);
 
@@ -176,6 +185,8 @@ class EditableTableOption_t : public EditableTableOption{
     std::vector<RowSnapshotType> snapshot() const{
         return EditableTableOption::snapshot<RowType, RowSnapshotType>();
     }
+
+    //  Lambda returns a boolean. False to continue running. True to stop.
     template <typename Lambda>
     void run_on_all_rows(Lambda function){
         EditableTableOption::run_on_all_rows<RowType>(std::move(function));

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp

@@ -10,13 +10,15 @@
 #include "Common/Cpp/Exceptions.h"
 #include "Common/Cpp/PanicDump.h"
 #include "Common/Microcontroller/DeviceRoutines.h"
-#include "Common/PokemonSwSh/PokemonProgramIDs.h"
+//#include "Common/PokemonSwSh/PokemonProgramIDs.h"
 #include "ClientSource/Libraries/MessageConverter.h"
 #include "ClientSource/Connection/SerialConnection.h"
 #include "ClientSource/Connection/PABotBase.h"
 #include "CommonFramework/GlobalSettingsPanel.h"
 #include "CommonFramework/Options/Environment/ThemeSelectorOption.h"
 #include "Controllers/ControllerTypeStrings.h"
+#include "NintendoSwitch/NintendoSwitch_Settings.h"
+#include "NintendoSwitch/Controllers/SerialPABotBase/NintendoSwitch_SerialPABotBase_WirelessController.h"
 #include "SerialPABotBase.h"
 #include "SerialPABotBase_Connection.h"
 
@@ -61,12 +63,12 @@ SerialPABotBase_Connection::SerialPABotBase_Connection(
         return;
     }
 
-    std::string name = port->systemLocation().toUtf8().data();
+    m_device_name = port->portName().toStdString();
     std::string error;
     try{
         set_status_line0("Connecting...", COLOR_DARKGREEN);
 
-        std::unique_ptr<SerialConnection> connection(new SerialConnection(name, PABB_BAUD_RATE));
+        std::unique_ptr<SerialConnection> connection(new SerialConnection(port->systemLocation().toStdString(), PABB_BAUD_RATE));
         m_botbase.reset(new PABotBase(m_logger, std::move(connection), nullptr));
     }catch (const ConnectionException& e){
         error = e.message();
@@ -211,14 +213,58 @@ ControllerModeStatus SerialPABotBase_Connection::read_device_specs(
 
     if (change_controller && program_iter->second.size() > 1){
         ControllerType desired_controller = change_controller.value();
+        switch (desired_controller){
+        case ControllerType::NintendoSwitch_WiredProController:
+        case ControllerType::NintendoSwitch_WirelessProController:
+        case ControllerType::NintendoSwitch_LeftJoycon:
+        case ControllerType::NintendoSwitch_RightJoycon:{
+            NintendoSwitch::ControllerProfile profile =
+                NintendoSwitch::ConsoleSettings::instance().CONTROLLER_SETTINGS.get_or_make_profile(
+                    m_device_name,
+                    desired_controller
+                );
+
+            NintendoSwitch::ControllerColors colors;
+            {
+                Color color(profile.body_color);
+                colors.body[0] = color.red();
+                colors.body[1] = color.green();
+                colors.body[2] = color.blue();
+            }
+            {
+                Color color(profile.button_color);
+                colors.buttons[0] = color.red();
+                colors.buttons[1] = color.green();
+                colors.buttons[2] = color.blue();
+            }
+            {
+                Color color(profile.left_grip);
+                colors.left_grip[0] = color.red();
+                colors.left_grip[1] = color.green();
+                colors.left_grip[2] = color.blue();
+            }
+            {
+                Color color(profile.right_grip);
+                colors.right_grip[0] = color.red();
+                colors.right_grip[1] = color.green();
+                colors.right_grip[2] = color.blue();
+            }
+
+            m_botbase->issue_request_and_wait(
+                NintendoSwitch::MessageControllerSetColors(desired_controller, colors),
+                nullptr
+            );
+        }
+        default:;
+        }
+
+
         uint32_t native_controller_id = controller_type_to_id(desired_controller);
         m_botbase->issue_request_and_wait(
             Microcontroller::DeviceRequest_change_controller_mode(native_controller_id),
             nullptr
         );
 
-
-
         //  Re-read the controller.
         logger.log("Reading Controller Mode...");
         uint32_t type_id = Microcontroller::read_controller_mode(*m_botbase);

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h

@@ -54,6 +54,7 @@ class SerialPABotBase_Connection : public ControllerConnection{
 
 private:
     SerialLogger m_logger;
+    std::string m_device_name;
 
     uint32_t m_protocol = 0;
     uint8_t m_program_id = 0;

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerSettings.cpp

@@ -4,8 +4,14 @@
  *
  */
 
+#include <chrono>
+#include "Common/CRC32.h"
 #include "NintendoSwitch_ControllerSettings.h"
 
+//#include <iostream>
+//using std::cout;
+//using std::endl;
+
 namespace PokemonAutomation{
 namespace NintendoSwitch{
 
@@ -17,6 +23,40 @@ struct OfficialJoyconColors{
     uint32_t left_buttons;
     uint32_t right_body;
     uint32_t right_buttons;
+
+    void write_to_profile(ControllerProfile& profile, ControllerType controller) const{
+        profile.official_name = name;
+        switch (controller){
+        case ControllerType::NintendoSwitch_WirelessProController:{
+            //  Set the grips to the joycon colors.
+            profile.left_grip = left_body;
+            profile.right_grip = right_body;
+
+            //  Average the two button colors.
+            uint32_t red = ((left_buttons >> 16) & 0xff) + ((right_buttons >> 16) & 0xff);
+            uint32_t green = ((left_buttons >> 8) & 0xff) + ((right_buttons >> 8) & 0xff);
+            uint32_t blue = ((left_buttons >> 0) & 0xff) + ((right_buttons >> 0) & 0xff);
+            red /= 2;
+            green /= 2;
+            blue /= 2;
+            profile.button_color = (red << 16) | (green << 8) | (blue << 0);
+
+            //  Pick something for the controller body.
+            profile.body_color = 0xd0d0d0;
+            break;
+        }
+        case ControllerType::NintendoSwitch_LeftJoycon:
+            profile.button_color = left_buttons;
+            profile.body_color = left_body;
+            break;
+        case ControllerType::NintendoSwitch_RightJoycon:
+            profile.button_color = right_buttons;
+            profile.body_color = right_body;
+            break;
+        default:;
+        }
+
+    }
 };
 
 const std::vector<OfficialJoyconColors>& OFFICIAL_JOYCON_COLORS(){
@@ -192,37 +232,9 @@ void ControllerSettingsRow::value_changed(void* object){
     try{
         m_pending_official_load++;
 
-        const OfficialJoyconColors& entry = OFFICIAL_JOYCON_COLORS()[index - 1];
-        switch (controller){
-        case ControllerType::NintendoSwitch_WirelessProController:{
-            //  Set the grips to the joycon colors.
-            left_grip.set(entry.left_body);
-            right_grip.set(entry.right_body);
-
-            //  Average the two button colors.
-            uint32_t red = ((entry.left_buttons >> 16) & 0xff) + ((entry.right_buttons >> 16) & 0xff);
-            uint32_t green = ((entry.left_buttons >> 8) & 0xff) + ((entry.right_buttons >> 8) & 0xff);
-            uint32_t blue = ((entry.left_buttons >> 0) & 0xff) + ((entry.right_buttons >> 0) & 0xff);
-            red /= 2;
-            green /= 2;
-            blue /= 2;
-            button_color.set((red << 16) | (green << 8) | (blue << 0));
-
-            //  Pick something for the controller body.
-            body_color.set(0xd0d0d0);
-
-            break;
-        }
-        case ControllerType::NintendoSwitch_LeftJoycon:
-            button_color.set(entry.left_buttons);
-            body_color.set(entry.left_body);
-            break;
-        case ControllerType::NintendoSwitch_RightJoycon:
-            button_color.set(entry.right_buttons);
-            body_color.set(entry.right_body);
-            break;
-        default:;
-        }
+        ControllerProfile profile{};
+        OFFICIAL_JOYCON_COLORS()[index - 1].write_to_profile(profile, controller);
+        this->set_profile(profile);
 
         m_pending_official_load--;
     }catch (...){
@@ -255,7 +267,60 @@ std::vector<std::string> ControllerSettingsTable::make_header() const{
 }
 
 
+ControllerProfile ControllerSettingsTable::get_or_make_profile(
+    const std::string& name,
+    ControllerType controller
+){
+//    cout << "ControllerSettingsTable::get_or_make_profile(): " << this << endl;
+
+    ControllerProfile profile{};
+
+    //  Only relevant to Switch controllers.
+    switch (controller){
+    case ControllerType::NintendoSwitch_WiredProController:
+    case ControllerType::NintendoSwitch_WirelessProController:
+    case ControllerType::NintendoSwitch_LeftJoycon:
+    case ControllerType::NintendoSwitch_RightJoycon:
+        break;
+    default:
+        return profile;
+    }
+
+    bool found = false;
+    this->run_on_all_rows([&, controller](ControllerSettingsRow& row){
+        if ((std::string)row.name != name){
+            return false;
+        }
+        if (row.controller != controller){
+            return false;
+        }
+
+        found = true;
+        profile = row;
+        return true;
+    });
+
+    if (found){
+        return profile;
+    }
+
+    const std::vector<OfficialJoyconColors>& DATABASE = OFFICIAL_JOYCON_COLORS();
+
+    uint64_t seed = std::chrono::high_resolution_clock::now().time_since_epoch().count();
+    seed = pabb_crc32(0, &seed, sizeof(seed));
+    seed %= DATABASE.size();
+
+    DATABASE[(size_t)seed].write_to_profile(profile, controller);
 
+    std::unique_ptr<ControllerSettingsRow> row(new ControllerSettingsRow(*this));
+    row->name.set(name);
+    row->controller.set(controller);
+    row->set_profile(profile);
+
+    this->append_row(std::move(row));
+
+    return profile;
+}
 
 
 

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ControllerSettings.h

@@ -7,8 +7,6 @@
 #ifndef PokemonAutomation_NintendoSwitch_ControllerSettings_H
 #define PokemonAutomation_NintendoSwitch_ControllerSettings_H
 
-#include <deque>
-#include <mutex>
 #include "Common/Cpp/Options/StringOption.h"
 #include "Common/Cpp/Options/ColorOption.h"
 #include "Common/Cpp/Options/EnumDropdownOption.h"
@@ -21,7 +19,13 @@ namespace NintendoSwitch{
 
 
 
-
+struct ControllerProfile{
+    uint32_t button_color;
+    uint32_t body_color;
+    uint32_t left_grip;
+    uint32_t right_grip;
+    std::string official_name;
+};
 
 class ControllerSettingsRow : public EditableTableRow, public ConfigOption::Listener{
 public:
@@ -30,7 +34,24 @@ class ControllerSettingsRow : public EditableTableRow, public ConfigOption::List
     virtual std::unique_ptr<EditableTableRow> clone() const override;
     virtual void value_changed(void* object) override;
 
-private:
+    operator ControllerProfile() const{
+        return {
+            button_color,
+            body_color,
+            left_grip,
+            right_grip,
+            official_color.slug(),
+        };
+    }
+    void set_profile(const ControllerProfile& profile){
+        button_color.set(profile.button_color);
+        body_color.set(profile.body_color);
+        left_grip.set(profile.left_grip);
+        right_grip.set(profile.right_grip);
+        official_color.set_by_slug(profile.official_name);
+    }
+
+public:
     StringCell name;
     EnumDropdownCell<ControllerType> controller;
     ColorCell button_color;
@@ -49,7 +70,10 @@ class ControllerSettingsTable : public EditableTableOption_t<ControllerSettingsR
     ControllerSettingsTable();
     virtual std::vector<std::string> make_header() const override;
 
-
+    ControllerProfile get_or_make_profile(
+        const std::string& name,
+        ControllerType controller
+    );
 
 };