Merge pull request #17 from monkeyman192/update/147803.1

Add functionality for adding commands to in-game terminal

Author: monkeyman192

LICENCE.md LICENSELICENCE.md renamed to LICENSE

@@ -0,0 +1,56 @@
+# /// script
+# dependencies = ["pymhf[gui]>=0.1.16"]
+#
+# [tool.pymhf]
+# exe = "NMS.exe"
+# steam_gameid = 275850
+# start_paused = false
+#
+# [tool.pymhf.gui]
+# always_on_top = true
+#
+# [tool.pymhf.logging]
+# log_dir = "."
+# log_level = "info"
+# window_name_override = "Instant scanning"
+# ///
+
+import logging
+import ctypes
+
+from pymhf import Mod
+from pymhf.core.hooking import on_key_release
+from pymhf.gui.decorators import BOOLEAN
+import nmspy.data.types as nms
+
+logger = logging.getLogger("InstantScan")
+
+
+class instantScan(Mod):
+    def __init__(self):
+        super().__init__()
+        self.should_be_instant = True
+
+    # Used to define a Boolean Type with a label in the Mod GUI, autogenerated by pyMHF.
+    @property
+    @BOOLEAN("Scanning is instant:")
+    def is_instant(self):
+        return self.should_be_instant
+
+    # Used to actually update the persisted value with the one input by the user in the GUI.
+    @is_instant.setter
+    def is_instant(self, value):
+        self.should_be_instant = value
+
+    # Also set a keyboard shortcut as an option instead of the button in the UI.
+    # When you press this button you will see that the checkboxin the UI will also change.
+    @on_key_release("o")
+    def toggle_instantness(self):
+        self.should_be_instant = not self.should_be_instant
+
+    @nms.cGcBinoculars.UpdateScanBarProgress.before
+    def set_no_scan(
+        self, this: ctypes._Pointer[nms.cGcBinoculars], lfScanProgress: float
+    ):
+        if self.should_be_instant and lfScanProgress < 1:
+            return (this, 1)

example_mods/instantScanning.py

@@ -0,0 +1,164 @@
+import ctypes
+import logging
+
+from pymhf import Mod
+from pymhf.gui import no_gui
+from pymhf.core.hooking import hook_manager
+from pymhf.core._types import DetourTime, CustomTriggerProtocol
+import nmspy.data.types as nms
+import nmspy.data.basic_types as basic
+from nmspy.terminal_parser import TerminalCommand, generate_full_description, split_key
+from nmspy.decorators import terminal_command
+
+logger = logging.getLogger("chat_bot")
+
+
+MOD_OPTION = "\n<TITLE>'/mod <><TITLE_BRIGHT>name option(s)<><TITLE>': configure a mod. Enter /mod <><TITLE_BRIGHT>name<><TITLE> to see options for each mod<>"
+MOD_LIST_OPTION = "\n<TITLE>'/modlist: display list of mods which can be configured via the terminal<>"
+
+
+@no_gui
+class textChatManager(Mod):
+    @terminal_command("Say some words.", "example")
+    def say(self, *words):
+        logger.info(f"I am saying the words: {' '.join(words)}")
+
+    @nms.cGcTextChatInput.ParseTextForCommands.before
+    def intercept_chat_message(
+        self,
+        this: ctypes._Pointer[nms.cGcTextChatManager],
+        lMessageText: ctypes._Pointer[basic.cTkFixedString[0x3FF]],
+    ):
+        """Parse the command and do something with it.
+        We will check for the message starting with `/mod` and recognise this as a command.
+        Use the custom callback system in pyMHF to send these commands to anything registered and detect if
+        nothing is registered for a given command and raise a helpful message.
+        """
+        if not lMessageText:
+            return
+        msg = str(lMessageText.contents)
+        if msg.startswith("/pymodlist"):
+            # List the available mods which have commands.
+            # Filter the keys then generate a set
+            mod_command_keys = list(
+                filter(
+                    lambda x: x.startswith("tc::"), hook_manager.custom_callbacks.keys()
+                )
+            )
+            mod_names = list(set(split_key(x)[0] for x in mod_command_keys))
+            mod_names.sort()
+            desc = "<TITLE>Available mods with commands<>"
+            for mod_name in mod_names:
+                desc += f"\n- <TITLE>{mod_name}<>"
+            lMessageText.contents.set(desc)
+        elif msg.startswith("/mod"):
+            # Get the mod name.
+            split_msg = msg.split(" ")[1:]
+            if len(split_msg) == 0:
+                # Invalid...
+                lMessageText.contents.set("Need to specify a mod!")
+                return
+            else:
+                if len(split_msg) == 1:
+                    # This is just the mod name. Show the help.
+                    mod_name = split_msg[0]
+                    mod_command_keys = list(
+                        filter(
+                            lambda x: x.startswith(f"tc::{mod_name}"),
+                            hook_manager.custom_callbacks.keys(),
+                        )
+                    )
+                    if not mod_command_keys:
+                        lMessageText.contents.set(
+                            f"The mod {mod_name!r} either doesn't exist or has no "
+                            "terminal commands registered"
+                        )
+                    else:
+                        command_funcs: dict[str, CustomTriggerProtocol] = {}
+                        for key in mod_command_keys:
+                            funcs = hook_manager.custom_callbacks[key].get(
+                                DetourTime.NONE, []
+                            )
+                            if len(funcs) > 1:
+                                logger.warning(
+                                    f"Multiple terminal commands have been defined with the key {key}"
+                                )
+                                return
+                            elif len(funcs) == 1:
+                                command_funcs[key] = list(funcs)[0]
+                        mod_desc = f"<TITLE>{mod_name!r} mod options:<>"
+                        for key, func in command_funcs.items():
+                            _, command = split_key(key)
+                            mod_desc += "\n" + generate_full_description(
+                                command, func._description
+                            )
+                        lMessageText.contents.set(mod_desc)
+                        return
+                elif len(split_msg) == 2:
+                    parsed_command = TerminalCommand(split_msg[0], split_msg[1], [])
+                elif len(split_msg) > 2:
+                    parsed_command = TerminalCommand(
+                        split_msg[0], split_msg[1], split_msg[2:]
+                    )
+                try:
+                    # Call the custom callback with the generated key.
+                    # If it doesn't exist we raise an exception which we catch and then show a message in the
+                    # terminal.
+                    hook_manager.call_custom_callbacks(
+                        parsed_command.callback_key,
+                        args=parsed_command.args,
+                        alert_nonexist=True,
+                    )
+                    lMessageText.contents.set(
+                        f"Ran command {parsed_command.command_name!r} for mod {parsed_command.mod_name!r}"
+                    )
+                except ValueError:
+                    lMessageText.contents.set(
+                        f"Invalid command {parsed_command.command_name!r} for mod {parsed_command.mod_name!r}"
+                    )
+                    # Let's get the list of actual commands for this mod.
+                    mod_command_keys = list(
+                        filter(
+                            lambda x: x.startswith(f"tc::{parsed_command.mod_name}"),
+                            hook_manager.custom_callbacks.keys(),
+                        )
+                    )
+                    if not mod_command_keys:
+                        lMessageText.contents.set(
+                            f"The mod {parsed_command.mod_name!r} either doesn't exist or has no "
+                            "terminal commands registered"
+                        )
+                    else:
+                        command_funcs: dict[str, CustomTriggerProtocol] = {}
+                        for key in mod_command_keys:
+                            funcs = hook_manager.custom_callbacks[key].get(
+                                DetourTime.NONE, []
+                            )
+                            if len(funcs) > 1:
+                                logger.warning(
+                                    f"Multiple terminal commands have been defined with the key {key}"
+                                )
+                                return
+                            elif len(funcs) == 1:
+                                command_funcs[key] = list(funcs)[0]
+                        mod_desc = f"<TITLE>{parsed_command.mod_name!r} mod options:<>"
+                        for key, func in command_funcs.items():
+                            _, command = split_key(key)
+                            mod_desc += "\n" + generate_full_description(
+                                command, func._description
+                            )
+                        lMessageText.contents.set(mod_desc)
+
+    @nms.cGcTextChatManager.Say.before
+    def say_chat_message(
+        self,
+        this: ctypes._Pointer[nms.cGcTextChatManager],
+        lsMessageBody: ctypes._Pointer[basic.cTkFixedString[0x3FF]],
+        lbSystemMessage: bool,
+    ):
+        if lsMessageBody:
+            msg = str(lsMessageBody.contents)
+            # Check for the message which the game generates for an invalid command and add the mod command.
+            if msg.startswith("<TITLE>") and msg.split("\n")[0].endswith("commands:"):
+                msg = msg + MOD_OPTION + MOD_LIST_OPTION
+                lsMessageBody.contents.set(msg)

nmspy/_internal_mods/textChatManager.py

@@ -260,7 +260,9 @@ class cTkFixedString(ctypes.Structure):
     value: bytes
 
     def set(self, val: str):
-        self.value = val[: self._size].encode()
+        """Set the value of the string."""
+        new_len = len(val)
+        self.value = val[: self._size].encode() + (self._size - new_len) * b"\x00"
 
     def __class_getitem__(cls: type["cTkFixedString"], key: int):
         _cls: type["cTkFixedString"] = types.new_class(

nmspy/data/basic_types.py

@@ -127,6 +127,17 @@ def LoadFromMetadata(
     ):
         pass
 
+    @function_hook(
+        "48 89 5C 24 ? 48 89 74 24 ? 48 89 54 24 ? 57 48 81 EC ? ? ? ? 44 8B 51"
+    )
+    def AddElement(
+        self,
+        this: "ctypes._Pointer[cGcNGuiLayer]",
+        lpElement: "ctypes._Pointer[cGcNGuiLayer]",
+        lbOnTheEnd: ctypes.c_int64,
+    ):
+        pass
+
 
 @partial_struct
 class cGcNGui(Structure):
@@ -892,15 +903,34 @@ def AddTimedMessage(
         pass
 
 
+@partial_struct
 class cGcSky(Structure):
     eStormState = enums.eStormState
 
+    mSunDirection: Annotated[basic.Vector3f, Field(basic.Vector3f, 0x500)]
+
     @function_hook("40 53 55 56 57 41 56 48 83 EC ? 4C 8B 15")
     def SetStormState(
         self, this: "ctypes._Pointer[cGcSky]", leNewState: c_enum32[eStormState]
     ):
         pass
 
+    @function_hook("40 53 48 83 EC ? 0F 28 C1 0F 29 7C 24 ? F3 0F 5E 05")
+    def SetSunAngle(self, this: "ctypes._Pointer[cGcSky]", lfAngle: ctypes.c_float):
+        pass
+
+    @function_hook(
+        "48 8B C4 48 89 58 ? 48 89 70 ? 55 57 41 54 41 56 41 57 48 8D A8 ? ? ? ? 48 81 EC ? ? ? ? 0F 29 70 ? 48 8B D9"
+    )
+    def Update(self, this: "ctypes._Pointer[cGcSky]", lfTimeStep: ctypes.c_float):
+        pass
+
+    @function_hook("48 8B C4 53 48 81 EC ? ? ? ? 4C 8B 05 ? ? ? ? 48 8B D9")
+    def UpdateSunPosition(
+        self, this: "ctypes._Pointer[cGcSky]", lfAngle: ctypes.c_float
+    ):
+        pass
+
 
 class sTerrainEditData(ctypes.Structure):
     mVoxelType: int
@@ -1028,7 +1058,7 @@ class cGcTextChatInput(Structure):
     def ParseTextForCommands(
         self,
         this: "ctypes._Pointer[cGcTextChatInput]",
-        lMessageText: ctypes._Pointer[basic.cTkFixedString[0x80]],
+        lMessageText: ctypes._Pointer[basic.cTkFixedString[0x3FF]],
     ):
         pass
 
@@ -1042,7 +1072,7 @@ def Construct(self, this: "ctypes._Pointer[cGcTextChatManager]"):
     def Say(
         self,
         this: "ctypes._Pointer[cGcTextChatManager]",
-        lsMessageBody: ctypes._Pointer[basic.cTkFixedString[0x80]],
+        lsMessageBody: ctypes._Pointer[basic.cTkFixedString[0x3FF]],
         lbSystemMessage: ctypes.c_bool,
     ):
         pass
@@ -1315,6 +1345,12 @@ def GeneratePlanetName(
         pass
 
 
+class cGcCreatureComponent(Structure):
+    @function_hook("48 8B C4 55 56 57 48 8D A8 ? ? ? ? 48 81 EC ? ? ? ? 48 8B 51")
+    def Prepare(self, this: "ctypes._Pointer[cGcCreatureComponent]"):
+        pass
+
+
 # Dummy values to copy and paste to make adding new things quicker...
 # class name(Structure):
 #     @function_hook("")

nmspy/data/types.py

@@ -1,35 +1,67 @@
-from pymhf.core._types import DetourTime
-from pymhf.core._types import HookProtocol
+from typing import Optional, Callable
+
+from pymhf.core._types import CustomTriggerProtocol, DetourTime
 
 
 class main_loop:
     @staticmethod
-    def before(func: HookProtocol):
+    def before(func: Callable) -> CustomTriggerProtocol:
         func._custom_trigger = "MAIN_LOOP"
         func._hook_time = DetourTime.BEFORE
-        return func
+        return func  # type: ignore
 
     @staticmethod
-    def after(func: HookProtocol):
+    def after(func: Callable) -> CustomTriggerProtocol:
         func._custom_trigger = "MAIN_LOOP"
         func._hook_time = DetourTime.AFTER
-        return func
+        return func  # type: ignore
 
 
-def on_fully_booted(func: HookProtocol):
+def on_fully_booted(func: Callable) -> CustomTriggerProtocol:
     """
     Configure the decorated function to be run once the game is considered
     "fully booted".
     This occurs when the games' internal state first changes to "mode selector"
     (ie. just before the game mode selection screen appears).
     """
     func._custom_trigger = "MODESELECTOR"
-    return func
+    return func  # type: ignore
 
 
 def on_state_change(state: str):
-    def _inner(func: HookProtocol):
+    def _inner(func: CustomTriggerProtocol):
         func._custom_trigger = state
         return func
 
     return _inner
+
+
+def terminal_command(
+    description: Optional[str] = None,
+    mod_override: Optional[str] = None,
+    command_override: Optional[str] = None,
+):
+    """Mark the function as a terminal command.
+    The mod name and terminal command will automatically be determined from the name of this function and the
+    name of the mod it belongs to.
+    To override the name of the command specify the ``command_override`` argument.
+    The optional ``description`` argument will be added to the help menu to aid users."""
+
+    # TODO: Use inspect to automatically get arguments and types if they have any to show in the description.
+    def _inner(func: Callable) -> CustomTriggerProtocol:
+        func_name = func.__qualname__
+        split_name = func_name.split(".")
+        if len(split_name) != 2:
+            raise ValueError(
+                "@terminal_command can only be used as a decorator for bound methods."
+            )
+        mod_name, command = split_name
+        if mod_override is not None:
+            mod_name = mod_override
+        if command_override is not None:
+            command = command_override
+        func._custom_trigger = f"tc::{mod_name.lower()}::{command.lower()}"
+        func._description = description
+        return func  # type: ignore
+
+    return _inner