feat: add Keyboard mode

README.md

@@ -54,6 +54,7 @@
 - Unlock Cosmetics (Hats, Visors, Skins, Pets, Nameplates, Cosmicubes, Bundles)
 - Full Resolution (The game runs at half resolution by default)
 - UwUify Game
+- Keyboard Mode
 
 ### Other
 

src/core/ModuleManager.ts

@@ -1,5 +1,6 @@
 import { BaseModule } from "./BaseModule";
 
+import { KeyboardModule } from "../modules/Keyboard";
 import { PassiveModule } from "../modules/Passive";
 import { PlayerModule } from "../modules/Player";
 import { ShipModule } from "../modules/Ship";
@@ -12,6 +13,7 @@ export class ModuleManager {
 
     // prettier-ignore
     private static modules: BaseModule[] = [
+        new KeyboardModule(),
         new PassiveModule(),
         new PlayerModule(),
         new ShipModule(),

src/data/State.ts

@@ -9,5 +9,6 @@ export const State = {
 
     unlockCosmetics: false,
     disableAnalytics: false,
-    uwuifyMode: false
+    uwuifyMode: false,
+    keyboardMode: false
 };

src/i18n/localization/de.json

@@ -39,8 +39,7 @@
             "full_resolution": "Volle Auflösung",
             "disable_analytics": "Disable Analytics",
 
-            "uwuify": "UwU?",
-            "select_platform": "Select Platform"
+            "uwuify": "UwU?"
         },
         "other": {
             "language": "Select Language",

src/i18n/localization/en.json

@@ -40,7 +40,8 @@
             "disable_analytics": "Disable Analytics",
 
             "uwuify": "UwU?",
-            "select_platform": "Select Platform"
+            "keyboard_mode": "Keyboard Mode",
+            "keyboard_mode_note": "Requires a physical keyboard. Touch controls may not work."
         },
         "other": {
             "language": "Select Language",

src/modules/Keyboard.ts

@@ -0,0 +1,70 @@
+import { AssemblyHelper } from "../core/AssemblyHelper";
+import { BaseModule } from "../core/BaseModule";
+import { State } from "../data/State";
+
+export class KeyboardModule extends BaseModule {
+    name = "Keyboard";
+
+    // Classes
+    private ActiveInputManager!: Il2Cpp.Class;
+
+    // Methods
+    private ActiveInputManager_UpdateActiveControlType!: Il2Cpp.Method;
+    private ActiveInputManager_OnLastActiveControllerChanged!: Il2Cpp.Method;
+    private ActiveInputManager_ShouldEnableTouch!: Il2Cpp.Method;
+    private HudManager_SetTouchType!: Il2Cpp.Method;
+
+    private keyboardInputValue!: Il2Cpp.ValueType;
+    private keyboardControlValue!: Il2Cpp.ValueType;
+
+    public init(): void {
+        this.ActiveInputManager = AssemblyHelper.AssemblyCSharp.class("ActiveInputManager");
+
+        this.ActiveInputManager_UpdateActiveControlType = this.ActiveInputManager.method<void>("UpdateActiveControlType", 0);
+        this.ActiveInputManager_OnLastActiveControllerChanged = this.ActiveInputManager.method<void>("OnLastActiveControllerChanged", 2);
+        this.ActiveInputManager_ShouldEnableTouch = this.ActiveInputManager.method<boolean>("ShouldEnableTouch", 0);
+
+        // Nested enum
+        const InputType = AssemblyHelper.AssemblyCSharp.class("ActiveInputManager/InputType");
+        this.keyboardInputValue = InputType.field<Il2Cpp.ValueType>("Keyboard").value;
+
+        const ControlTypes = AssemblyHelper.AssemblyCSharp.class("ControlTypes");
+        this.keyboardControlValue = ControlTypes.field<Il2Cpp.ValueType>("Keyboard").value;
+
+        const HudManager = AssemblyHelper.AssemblyCSharp.class("HudManager");
+        this.HudManager_SetTouchType = HudManager.method<void>("SetTouchType", 1);
+    }
+
+    public initHooks(): void {
+        const module = this;
+
+        this.ActiveInputManager_UpdateActiveControlType.implementation = function (): void {
+            if (!State.keyboardMode) return this.method<void>("UpdateActiveControlType").invoke();
+            module.setKeyboardMode();
+        };
+
+        this.ActiveInputManager_OnLastActiveControllerChanged.implementation = function (player, controller): void {
+            if (!State.keyboardMode) return this.method<void>("OnLastActiveControllerChanged").invoke(player, controller);
+            module.setKeyboardMode();
+        };
+
+        this.ActiveInputManager_ShouldEnableTouch.implementation = function (): boolean {
+            if (!State.keyboardMode) return this.method<boolean>("ShouldEnableTouch").invoke();
+            return false;
+        };
+
+        // type: ControlTypes enum
+        // @ts-ignore
+        this.HudManager_SetTouchType.implementation = function (type: Il2Cpp.ValueType): void {
+            const returnArg = State.keyboardMode ? module.keyboardControlValue : type;
+            this.method<void>("SetTouchType").invoke(returnArg);
+        };
+    }
+
+    /**
+     * Sets `ActiveInputManager.currentControlType` to `ActiveInputManager.InputType.Keyboard`
+     */
+    private setKeyboardMode(): void {
+        this.ActiveInputManager.field("currentControlType").value = this.keyboardInputValue;
+    }
+}

src/ui/tabs/PassiveTab.ts

@@ -43,5 +43,12 @@ export class PassiveTab {
                 })
             )
         );
+
+        add(
+            layout.toggle(I18n.t("menu.functions.keyboard_mode"), (state: boolean) => {
+                State.keyboardMode = state;
+            })
+        );
+        add(layout.textView(I18n.t("menu.functions.keyboard_mode_note")));
     }
 }

src/utils/UnityUtils.ts

@@ -184,6 +184,14 @@ export class UnityUtils {
         return component.method<void>("set_enabled").invoke(state);
     }
 
+    /**
+     * Wrapper over `m_CachedPtr` field
+     *
+     * Use it to check whether a Unity Object has been destroyed
+     * but still returns a non-zero address
+     *
+     * @param object
+     */
     static cachedPtr(object: Il2Cpp.Object): Il2Cpp.Pointer {
         return object.field<Il2Cpp.Pointer>("m_CachedPtr").value;
     }