Merge pull request #37 from TheUltimateKerbonaut/master

Added new tp commands
aaronkirkham · Oct 30, 2020 · 6c28bab · 6c28bab
2 parents f454f9e + 095f446
commit 6c28bab
Show file tree

Hide file tree

Showing 9 changed files with 82 additions and 31 deletions.
diff --git a/README.md b/README.md
@@ -19,6 +19,8 @@ Spawn anything and everything, vehicles, characters, animals, props. Enable infi
    - `tp save <name>` - Save current coordinates as named location
    - `tp <name>` - Go to saved named location
    - `tp delete <name>` - Delete saved named location
+   - `tp get <name>` - Prints position of named location
+   - `tp printpos` - Prints current player position
 
 ### Controls
  - `Tilde` (\`~) or `F1` - Toggle the input box

diff --git a/src/commands/command.h b/src/commands/command.h
@@ -5,8 +5,8 @@
 class ICommand
 {
   public:
-    virtual const char*              GetCommand() = 0;
-    virtual void                     Init(){};
-    virtual bool                     Handler(const std::string& arguments)  = 0;
-    virtual std::vector<std::string> GetHints(const std::string& arguments) = 0;
+    virtual const char*						GetCommand() = 0;
+    virtual void							Init(){};
+    virtual std::pair<bool, std::string>	Handler(const std::string& arguments)  = 0; // Returns success, and command output (if any)
+    virtual std::vector<std::string>		GetHints(const std::string& arguments) = 0;
 };
diff --git a/src/commands/event.h b/src/commands/event.h
@@ -10,16 +10,16 @@ class EventCommand : public ICommand
         return "event";
     }
 
-    virtual bool Handler(const std::string& arguments) override
+    virtual std::pair<bool, std::string> Handler(const std::string& arguments) override
     {
         using namespace jc;
 
         if (arguments == "load_game" || arguments == "new_game" || arguments == "continue_game") {
-            return false;
+            return {false, ""};
         }
 
         meow_hook::func_call<void>(GetAddress(SEND_EVENT), arguments.c_str(), nullptr);
-        return true;
+        return {true, ""};
     }
 
     virtual std::vector<std::string> GetHints(const std::string& arguments) override

diff --git a/src/commands/skin.h b/src/commands/skin.h
@@ -10,15 +10,15 @@ class SkinCommand : public ICommand
         return "skin";
     }
 
-    virtual bool Handler(const std::string& arguments) override
+    virtual std::pair<bool, std::string> Handler(const std::string& arguments) override
     {
         std::vector<jc::CSpawnSystem::SResourceDef*, jc::allocator<jc::CSpawnSystem::SResourceDef*>> resources;
         if (jc::CSpawnSystem::instance().GetMatchingResources(arguments, &resources)) {
             jc::CPlayerManager::instance().GetLocalPlayerCharacter()->ChangeSkin(resources[0]->m_resourcePath);
-            return true;
+            return {true, ""};
         }
 
-        return false;
+        return {false, ""};
     }
 
     virtual std::vector<std::string> GetHints(const std::string& arguments) override

diff --git a/src/commands/spawn.h b/src/commands/spawn.h
@@ -10,11 +10,11 @@ class SpawnCommand : public ICommand
         return "spawn";
     }
 
-    virtual bool Handler(const std::string &arguments) override
+    virtual std::pair<bool, std::string> Handler(const std::string &arguments) override
     {
         if (arguments == "rico_debug" || arguments == "rico_preview_debug" || arguments == "rico_cow_skin"
             || arguments == "rico_cow_skin_debug") {
-            return false;
+            return {false, ""};
         }
 
         auto  local_player = jc::CPlayerManager::instance().m_localPlayer;
@@ -27,7 +27,7 @@ class SpawnCommand : public ICommand
 
         // NOTE(aaronlad): spawn flag 0x8000 will prevent auto despawn
         jc::CSpawnSystem::instance().Spawn(arguments, transform, [](const jc::spawned_objects &objects, void *) {});
-        return true;
+        return {true, ""};
     }
 
     virtual std::vector<std::string> GetHints(const std::string &arguments) override

diff --git a/src/commands/teleport.h b/src/commands/teleport.h
@@ -19,20 +19,37 @@ class TeleportCommand : public ICommand
         m_saveFile.load("savedcoords.txt");
     }
 
-    virtual bool Handler(const std::string& arguments) override
+    virtual std::pair<bool, std::string> Handler(const std::string& arguments) override
     {
         if (arguments.find("save ") != std::string::npos) {
             char name[128] = {0};
             if (sscanf_s(arguments.c_str(), "save %[^\n]s", &name, 128) == 1) {
                 auto& transform = jc::CPlayerManager::instance().GetLocalPlayerCharacter()->m_worldTransform;
                 m_saveFile.set(name, "%f %f %f", transform.m[3].x, transform.m[3].y, transform.m[3].z);
-                return true;
+                return {true, ""};
             }
         } else if (arguments.find("delete ") != std::string::npos) {
             char name[128] = {0};
             if (sscanf_s(arguments.c_str(), "delete %[^\n]s", &name, 128) == 1) {
                 m_saveFile.remove(name);
-                return true;
+                return {true, ""};
+            }
+        } else if (arguments.find("printpos") != std::string::npos) {
+            auto&             transform = jc::CPlayerManager::instance().GetLocalPlayerCharacter()->m_worldTransform;
+            const std::string pos = std::to_string((int)transform.m[3].x) + " " + std::to_string((int)transform.m[3].y)
+                                    + " " + std::to_string((int)transform.m[3].z);
+            return {true, pos};
+        } else if (arguments.find("get") != std::string::npos) {
+            char name[128] = {0};
+            if (sscanf_s(arguments.c_str(), "get %[^\n]s", &name, 128) == 1) {
+                CVector3f position;
+                if (m_saveFile.get(name, "%f %f %f", &position.x, &position.y, &position.z)) {
+                    const std::string pos = std::to_string((int)position.x) + " " + std::to_string((int)position.y)
+                                            + " " + std::to_string((int)position.z);
+                    return {true, pos};
+                } else {
+                    return {false, ""};
+                }
             }
         } else {
             static auto Teleport = [](CVector3f& position) {
@@ -55,28 +72,30 @@ class TeleportCommand : public ICommand
             CVector3f position;
             if (sscanf_s(arguments.c_str(), "%f %f %f", &position.x, &position.y, &position.z) == 3) {
                 Teleport(position);
-                return true;
+                return {true, ""};
             }
             // try read saved position from coords file
             else {
                 char name[128] = {0};
                 if (sscanf_s(arguments.c_str(), "%[^\n]s", &name, 128) == 1) {
                     if (m_saveFile.get(name, "%f %f %f", &position.x, &position.y, &position.z)) {
                         Teleport(position);
-                        return true;
+                        return {true, ""};
                     }
                 }
             }
         }
 
-        return false;
+        return {false, ""};
     }
 
     virtual std::vector<std::string> GetHints(const std::string& arguments) override
     {
         static std::array hints{
             "save",
             "delete",
+			"printpos", 
+			"get"
         };
 
         std::vector<std::string> result;

diff --git a/src/commands/world.h b/src/commands/world.h
@@ -10,7 +10,7 @@ class WorldCommand : public ICommand
         return "world";
     }
 
-    virtual bool Handler(const std::string& arguments) override
+    virtual std::pair<bool, std::string> Handler(const std::string& arguments) override
     {
         using namespace jc;
 
@@ -25,32 +25,32 @@ class WorldCommand : public ICommand
             if (sscanf_s(arguments.c_str(), "time %f", &time) == 1) {
                 time = std::clamp(time, -24.0f, 24.0f);
                 meow_hook::func_call<void>(GetAddress(WORLDTIME_SET_TIME), WorldTime, time, 2);
-                return true;
+                return {true, ""};
             }
         }
         // time scale
         else if (arguments.find("timescale ") != std::string::npos) {
             float timescale = 1.0f;
             if (sscanf_s(arguments.c_str(), "timescale %f", &timescale) == 1) {
                 *(float*)((char*)WorldTime + 0xE4) = std::clamp(timescale, -1000.0f, 1000.0f);
-                return true;
+                return {true, ""};
             }
         }
         // gravity
         else if (arguments.find("gravity ") != std::string::npos) {
             float gravity = DEFAULT_GRAVITY;
             if (sscanf_s(arguments.c_str(), "gravity %f", &gravity) == 1) {
                 *(float*)((char*)hnpkWorld + 0x974) = std::clamp(gravity, -5000.0f, 5000.0f);
-                return true;
+                return {true, ""};
             }
         }
         // reset gravity
         else if (arguments.find("resetgravity") != std::string::npos) {
             *(float*)((char*)hnpkWorld + 0x974) = DEFAULT_GRAVITY;
-            return true;
+            return {true, ""};
         }
 
-        return false;
+        return {false, ""};
     }
 
     virtual std::vector<std::string> GetHints(const std::string& arguments) override

diff --git a/src/input.cpp b/src/input.cpp
@@ -36,6 +36,11 @@ void Input::EnableInput(bool toggle)
         hud_bottom_left->m_state = toggle ? 1 : 2;
     }
 
+	// clear last command onput if re-toggling
+    if (toggle) {
+        m_commandOutput = "";
+	}
+
     if (toggle) {
         // resets keys so we don't have keys stuck after giving input back
         jc::NInput::CManagerBase::instance().LoseFocus();
@@ -50,17 +55,22 @@ void Input::Draw()
     auto debug_renderer = jc::CRenderEngine::instance().m_debugRenderer;
 
     if (m_drawInput && debug_renderer) {
+
+		const bool bDrawCommandOutput = (m_commandOutput != "");
+
         // draw hints
         if (m_cmd && m_hints.size() > 0) {
             const auto  count = std::clamp<uint32_t>(((uint32_t)m_hints.size() - m_hintPage), 0, NUM_HINTS_PER_PAGE);
             const float total_height = (HINT_ITEM_HEIGHT * count);
-
-            debug_renderer->DebugRectGradient({0, (0.94f - total_height - 0.02f)}, {0.5f, 0.94f}, 0xB4000000,
+            const float output_offset = (float)bDrawCommandOutput * HINT_ITEM_HEIGHT;
+            debug_renderer->DebugRectGradient({0, (0.94f - total_height - 0.02f - output_offset)},
+                                              {0.5f, 0.94f - output_offset*2},
+                                              0xB4000000,
                                               0x00000000);
 
             for (uint32_t i = 0; i < count; ++i) {
                 // draw current hint
-                const float y = (0.9325f - total_height + (HINT_ITEM_HEIGHT * i));
+                const float y = (0.9325f - total_height + (HINT_ITEM_HEIGHT * i) - output_offset);
                 Graphics::Get()->DrawString(m_hints[i + m_hintPage], 0.0195f, y, FONT_SIZE_HINT, 0xFFFFFFFF);
 
                 if ((i + m_hintPage) == m_selectedHint) {
@@ -69,6 +79,15 @@ void Input::Draw()
             }
         }
 
+		// draw last command output
+        if (bDrawCommandOutput) {
+
+			debug_renderer->DebugRectGradient({0, (0.94f - HINT_ITEM_HEIGHT - 0.02f)}, {0.5f, 0.94f}, 0xB4000000, 0x00000000);
+
+            const float y = (0.9325f - HINT_ITEM_HEIGHT);
+            Graphics::Get()->DrawString(m_commandOutput, 0.0195f, y, FONT_SIZE_HINT, 0xFF808080); // Grey colour
+		}
+
         // draw current input text
         debug_renderer->DebugRectGradient({0, 0.95f}, {0.5f, 1}, 0xE1000000, 0x00000000);
         Graphics::Get()->DrawString(m_history[0], 0.0195f, 0.965f, FONT_SIZE_INPUT, 0xFFFFFFFF);
@@ -230,12 +249,20 @@ bool Input::FeedEvent(uint32_t message, WPARAM wParam, LPARAM lParam)
                         }
 
                         const auto input_text = m_history[0];
+                        bool       bDidCommandReturnOutput = false;
                         m_history[0]          = "";
                         m_currentHistory      = 0;
 
                         if (m_cmd) {
-                            if (m_cmd->Handler(m_cmdArguments)) {
+                            auto commandResult = m_cmd->Handler(m_cmdArguments);
+                            auto commandSuccess = commandResult.first;
+                            auto commandOutput = commandResult.second;
+                            if (commandSuccess) { // If successful
                                 AddToHistory(input_text);
+								if (commandOutput != "") {
+                                    m_commandOutput = commandOutput;
+                                    bDidCommandReturnOutput = true;
+								}
                             }
                         } else if (m_fnCommands.size() > 0) {
                             const auto it = m_fnCommands.find(m_cmdText);
@@ -244,11 +271,13 @@ bool Input::FeedEvent(uint32_t message, WPARAM wParam, LPARAM lParam)
                                 AddToHistory(input_text);
                             }
                         }
-
+						
                         m_cmd = nullptr;
                         m_cmdText.clear();
                         m_cmdArguments.clear();
-                        EnableInput(false);
+                        if (!bDidCommandReturnOutput) {
+							EnableInput(false);
+						}
                         break;
                     }
 

diff --git a/src/input.h b/src/input.h
@@ -23,6 +23,7 @@ class Input : public Singleton<Input>
     std::string              m_cmdText        = "";
     std::string              m_cmdArguments   = "";
     std::vector<std::string> m_hints;
+    std::string              m_commandOutput  = "";
     int32_t                  m_selectedHint   = -1;
     int32_t                  m_hintPage       = 0;
     bool                     m_controlPressed = false;