Keyboard FCE.

Author: Mysticial

SerialPrograms/CMakeLists.txt

@@ -685,6 +685,7 @@ file(GLOB MAIN_SOURCES
     Source/ComputerPrograms/Framework/ComputerProgramSession.h
     Source/ComputerPrograms/Framework/ComputerProgramWidget.cpp
     Source/ComputerPrograms/Framework/ComputerProgramWidget.h
+    Source/Controllers/Controller.cpp
     Source/Controllers/Controller.h
     Source/Controllers/ControllerConnection.cpp
     Source/Controllers/ControllerConnection.h

SerialPrograms/Source/Controllers/Controller.cpp

@@ -0,0 +1,27 @@
+/*  Controller
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "Common/Cpp/Exceptions.h"
+#include "Controller.h"
+
+namespace PokemonAutomation{
+
+
+
+void AbstractController::throw_bad_cast(const char* desired_typename){
+    throw UserSetupError(
+        logger(),
+        std::string("Incompatible Controller:\n\n") +
+        "Required:\n    " + desired_typename + "\n"
+        "Actual:\n    " + name()
+    );
+}
+
+
+
+}
+
+

SerialPrograms/Source/Controllers/Controller.h

@@ -42,6 +42,23 @@ class AbstractController{
     virtual RecursiveThrottler& logging_throttler() = 0;
 
 
+public:
+    template <typename ControllerType>
+    ControllerType* cast(){
+        return dynamic_cast<ControllerType*>(this);
+    }
+    template <typename ControllerType>
+    ControllerType& cast_with_exception(){
+        ControllerType* controller = dynamic_cast<ControllerType*>(this);
+        if (!controller){
+            throw_bad_cast(ControllerType::NAME);
+        }
+        return *controller;
+    }
+private:
+    void throw_bad_cast(const char* desired_typename);
+
+
 public:
     //  Static Information
 
@@ -210,6 +227,12 @@ class ControllerContext final : public CancellableScope{
     {
         attach(parent);
     }
+    template <typename T>
+    ControllerContext(ControllerContext<T>& context)
+        : m_controller(context.controller().template cast_with_exception<Type>())
+    {
+        attach(context);
+    }
     virtual ~ControllerContext(){
         detach();
     }
@@ -267,6 +290,9 @@ class ControllerContext final : public CancellableScope{
 
 
 
+using AbstractControllerContext = ControllerContext<AbstractController>;
+
+
 
 
 }

SerialPrograms/Source/NintendoSwitch/NintendoSwitch_ConsoleHandle.h

@@ -43,16 +43,7 @@ class ConsoleHandle : public VideoStream{
 
     template <typename ControllerType = AbstractController>
     ControllerType& controller(){
-        ControllerType* ret = dynamic_cast<ControllerType*>(&m_controller);
-        if (ret){
-            return *ret;
-        }
-        throw UserSetupError(
-            logger(),
-            std::string("Incompatible Controller:\n\n") +
-            "Required:\n    " + ControllerType::NAME + "\n"
-            "Actual:\n    " + m_controller.name()
-        );
+        return m_controller.cast_with_exception<ControllerType>();
     }
 
     operator Logger&(){ return logger(); }

SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Settings.cpp

@@ -151,6 +151,7 @@ ConsoleSettings::ConsoleSettings()
         PA_ADD_OPTION(SWITCH1_KEYBOARD_ENTRY0);
         PA_ADD_OPTION(SWITCH2_DIGIT_ENTRY0);
         PA_ADD_OPTION(SWITCH2_KEYBOARD_ENTRY0);
+        PA_ADD_OPTION(KEYBOARD_CONTROLLER_TIMINGS);
     }
     PA_ADD_STATIC(KEYBOARD_SECTION);
     PA_ADD_OPTION(KEYBOARD_MAPPINGS);

SerialPrograms/Source/NintendoSwitch/NintendoSwitch_Settings.h

@@ -59,6 +59,7 @@ class ConsoleSettings : public BatchOption{
     KeyboardEntryTimingsOption  SWITCH1_KEYBOARD_ENTRY0;
     DigitEntryTimingsOption     SWITCH2_DIGIT_ENTRY0;
     KeyboardEntryTimingsOption  SWITCH2_KEYBOARD_ENTRY0;
+    KeyboardControllerTimingsOption KEYBOARD_CONTROLLER_TIMINGS;
 
     SectionDividerOption KEYBOARD_SECTION;
     KeyboardMappingOption KEYBOARD_MAPPINGS;

SerialPrograms/Source/NintendoSwitch/Options/NintendoSwitch_CodeEntrySettingsOption.cpp

@@ -131,6 +131,35 @@ KeyboardEntryTimingsOption::KeyboardEntryTimingsOption(bool switch2)
 
 
 
+KeyboardControllerTimingsOption::KeyboardControllerTimingsOption()
+    : GroupOption(
+        "Keyboard Controller Timings",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        GroupOption::EnableMode::ALWAYS_ENABLED, true
+    )
+    , TIME_UNIT(
+        "<b>Time Unit:</b><br>Timesteps should increment in multiples of this unit.",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        PreloadSettings::instance().DEVELOPER_MODE ? "24 ms" : "40 ms"
+    )
+    , HOLD(
+        "<b>Hold:</b><br>Duration to hold each key press down.",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        "48 ms"
+    )
+    , COOLDOWN(
+        "<b>Hold:</b><br>Do not reuse a key until this long after it is reused.",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        "24 ms"
+    )
+{
+    PA_ADD_OPTION(TIME_UNIT);
+    PA_ADD_OPTION(HOLD);
+    PA_ADD_OPTION(COOLDOWN);
+}
+
+
+
 
 
 

SerialPrograms/Source/NintendoSwitch/Options/NintendoSwitch_CodeEntrySettingsOption.h

@@ -58,6 +58,16 @@ class KeyboardEntryTimingsOption : public GroupOption{
     MillisecondsOption COOLDOWN;
 };
 
+class KeyboardControllerTimingsOption : public GroupOption{
+public:
+    KeyboardControllerTimingsOption();
+
+public:
+    MillisecondsOption TIME_UNIT;
+    MillisecondsOption HOLD;
+    MillisecondsOption COOLDOWN;
+};
+
 
 
 

SerialPrograms/Source/NintendoSwitch/Programs/FastCodeEntry/NintendoSwitch_KeyboardCodeEntry.cpp

@@ -23,6 +23,118 @@ namespace NintendoSwitch{
 namespace FastCodeEntry{
 
 
+
+
+void keyboard_enter_code(
+    ConsoleHandle& console, AbstractControllerContext& context,
+    KeyboardLayout keyboard_layout, const std::string& code,
+    bool include_plus
+){
+    auto* keyboard = context->cast<HidControllers::Keyboard>();
+    if (keyboard){
+        HidControllers::KeyboardContext subcontext(context);
+        keyboard_enter_code(console, subcontext, code, include_plus);
+        return;
+    }
+
+    auto* procon = context->cast<ProController>();
+    if (procon){
+        ProControllerContext subcontext(context);
+        keyboard_enter_code(console, subcontext, keyboard_layout, code, include_plus);
+        return;
+    }
+
+    throw UserSetupError(
+        console, "Unsupported controller type."
+    );
+}
+
+
+
+
+
+void keyboard_enter_code(
+    ConsoleHandle& console, HidControllers::KeyboardContext& context,
+    const std::string& code,
+    bool include_plus
+){
+    using namespace HidControllers;
+
+    Milliseconds delay = ConsoleSettings::instance().KEYBOARD_CONTROLLER_TIMINGS.TIME_UNIT;
+    Milliseconds hold = ConsoleSettings::instance().KEYBOARD_CONTROLLER_TIMINGS.HOLD;
+    Milliseconds cool = ConsoleSettings::instance().KEYBOARD_CONTROLLER_TIMINGS.COOLDOWN;
+
+    static const std::map<char, KeyboardKey> MAP{
+        {'1', KeyboardKey::KEY_1},
+        {'2', KeyboardKey::KEY_2},
+        {'3', KeyboardKey::KEY_3},
+        {'4', KeyboardKey::KEY_4},
+        {'5', KeyboardKey::KEY_5},
+        {'6', KeyboardKey::KEY_6},
+        {'7', KeyboardKey::KEY_7},
+        {'8', KeyboardKey::KEY_8},
+        {'9', KeyboardKey::KEY_9},
+        {'0', KeyboardKey::KEY_0},
+
+        {'Q', KeyboardKey::KEY_Q},
+        {'W', KeyboardKey::KEY_W},
+        {'E', KeyboardKey::KEY_E},
+        {'R', KeyboardKey::KEY_R},
+        {'T', KeyboardKey::KEY_T},
+        {'Y', KeyboardKey::KEY_Y},
+        {'U', KeyboardKey::KEY_U},
+        {'P', KeyboardKey::KEY_P},
+
+        {'A', KeyboardKey::KEY_A},
+        {'S', KeyboardKey::KEY_S},
+        {'D', KeyboardKey::KEY_D},
+        {'F', KeyboardKey::KEY_F},
+        {'G', KeyboardKey::KEY_G},
+        {'H', KeyboardKey::KEY_H},
+        {'J', KeyboardKey::KEY_J},
+        {'K', KeyboardKey::KEY_K},
+        {'L', KeyboardKey::KEY_L},
+
+        {'X', KeyboardKey::KEY_X},
+        {'C', KeyboardKey::KEY_C},
+        {'V', KeyboardKey::KEY_V},
+        {'B', KeyboardKey::KEY_B},
+        {'N', KeyboardKey::KEY_N},
+        {'M', KeyboardKey::KEY_M},
+    };
+
+    for (char ch : code){
+        auto iter = MAP.find(ch);
+        if (iter == MAP.end()){
+            throw_and_log<OperationFailedException>(
+                console, ErrorReport::NO_ERROR_REPORT,
+                "Invalid code character."
+            );
+        }
+        context->issue_key(&context, delay, hold, cool, iter->second);
+    }
+
+    if (include_plus){
+        context->issue_key(&context, delay, hold, cool, KeyboardKey::KEY_ENTER);
+        context->issue_key(&context, delay, hold, cool, KeyboardKey::KEY_ENTER);
+        context->issue_key(&context, delay, hold, cool, KeyboardKey::KEY_ENTER);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 struct KeyboardEntryPosition{
     uint8_t row;
     uint8_t col;

SerialPrograms/Source/NintendoSwitch/Programs/FastCodeEntry/NintendoSwitch_KeyboardCodeEntry.h

@@ -8,6 +8,7 @@
 #define PokemonAutomation_NintendoSwitch_KeyboardCodeEntry_H
 
 #include <string>
+#include "Controllers/HidControllers/HID_Keyboard.h"
 #include "NintendoSwitch/Options/NintendoSwitch_CodeEntrySettingsOption.h"
 #include "NintendoSwitch/Controllers/NintendoSwitch_ProController.h"
 #include "NintendoSwitch/NintendoSwitch_ConsoleHandle.h"
@@ -18,6 +19,19 @@ namespace FastCodeEntry{
 
 
 
+//  Automatically select between keyboard or pro controller depending on the
+//  controller type.
+void keyboard_enter_code(
+    ConsoleHandle& console, AbstractControllerContext& context,
+    KeyboardLayout keyboard_layout, const std::string& code,
+    bool include_plus
+);
+
+void keyboard_enter_code(
+    ConsoleHandle& console, HidControllers::KeyboardContext& context,
+    const std::string& code,
+    bool include_plus
+);
 void keyboard_enter_code(
     ConsoleHandle& console, ProControllerContext& context,
     KeyboardLayout keyboard_layout, const std::string& code,