oh my fucking god that parent with positions following thing took far too long 😭 anyway, yey! better icons and hierarchy changes!

Scripts/StandaloneMovementController.cpp

@@ -0,0 +1,199 @@
+#include "ScriptRuntime.h"
+#include "SceneObject.h"
+#include "ThirdParty/imgui/imgui.h"
+#include <unordered_map>
+
+namespace {
+struct ControllerState {
+    float pitch = 0.0f;
+    float yaw = 0.0f;
+    float verticalVelocity = 0.0f;
+    bool initialized = false;
+};
+
+std::unordered_map<int, ControllerState> g_states;
+
+glm::vec3 moveTuning = glm::vec3(4.5f, 7.5f, 6.5f);      // walk speed, run speed, jump
+glm::vec3 lookTuning = glm::vec3(0.12f, 200.0f, 0.0f);   // sensitivity, max delta clamp, reserved
+glm::vec3 capsuleTuning = glm::vec3(1.8f, 0.4f, 0.2f);   // height, radius, ground snap
+glm::vec3 gravityTuning = glm::vec3(-9.81f, 0.4f, 30.0f); // gravity, probe extra, max fall speed
+bool enableMouseLook = true;
+bool requireMouseButton = false;
+bool enforceCollider = true;
+bool enforceRigidbody = true;
+bool showDebug = false;
+
+ControllerState& getState(int id) {
+    return g_states[id];
+}
+
+void ensureComponents(ScriptContext& ctx, float height, float radius) {
+    if (!ctx.object) return;
+    if (enforceCollider) {
+        ctx.object->hasCollider = true;
+        ctx.object->collider.enabled = true;
+        ctx.object->collider.type = ColliderType::Capsule;
+        ctx.object->collider.convex = true;
+        ctx.object->collider.boxSize = glm::vec3(radius * 2.0f, height, radius * 2.0f);
+    }
+    if (enforceRigidbody) {
+        ctx.object->hasRigidbody = true;
+        ctx.object->rigidbody.enabled = true;
+        ctx.object->rigidbody.useGravity = true;
+        ctx.object->rigidbody.isKinematic = false;
+    }
+}
+} // namespace
+
+extern "C" void Script_OnInspector(ScriptContext& ctx) {
+    ctx.AutoSetting("moveTuning", moveTuning);
+    ctx.AutoSetting("lookTuning", lookTuning);
+    ctx.AutoSetting("capsuleTuning", capsuleTuning);
+    ctx.AutoSetting("gravityTuning", gravityTuning);
+    ctx.AutoSetting("enableMouseLook", enableMouseLook);
+    ctx.AutoSetting("requireMouseButton", requireMouseButton);
+    ctx.AutoSetting("enforceCollider", enforceCollider);
+    ctx.AutoSetting("enforceRigidbody", enforceRigidbody);
+    ctx.AutoSetting("showDebug", showDebug);
+
+    ImGui::TextUnformatted("Standalone Movement Controller");
+    ImGui::Separator();
+
+    bool changed = false;
+    changed |= ImGui::DragFloat3("Walk/Run/Jump", &moveTuning.x, 0.05f, 0.0f, 25.0f, "%.2f");
+    changed |= ImGui::DragFloat2("Look Sens/Clamp", &lookTuning.x, 0.01f, 0.0f, 500.0f, "%.2f");
+    changed |= ImGui::DragFloat3("Height/Radius/Snap", &capsuleTuning.x, 0.02f, 0.0f, 5.0f, "%.2f");
+    changed |= ImGui::DragFloat3("Gravity/Probe/MaxFall", &gravityTuning.x, 0.05f, -50.0f, 50.0f, "%.2f");
+    changed |= ImGui::Checkbox("Enable Mouse Look", &enableMouseLook);
+    changed |= ImGui::Checkbox("Hold RMB to Look", &requireMouseButton);
+    changed |= ImGui::Checkbox("Force Collider", &enforceCollider);
+    changed |= ImGui::Checkbox("Force Rigidbody", &enforceRigidbody);
+    changed |= ImGui::Checkbox("Show Debug", &showDebug);
+
+    if (changed) {
+        ctx.SaveAutoSettings();
+    }
+}
+
+void Begin(ScriptContext& ctx, float /*deltaTime*/) {
+    if (!ctx.object) return;
+    ControllerState& state = getState(ctx.object->id);
+    if (!state.initialized) {
+        state.pitch = ctx.object->rotation.x;
+        state.yaw = ctx.object->rotation.y;
+        state.verticalVelocity = 0.0f;
+        state.initialized = true;
+    }
+    ensureComponents(ctx, capsuleTuning.x, capsuleTuning.y);
+}
+
+void TickUpdate(ScriptContext& ctx, float deltaTime) {
+    if (!ctx.object) return;
+
+    ControllerState& state = getState(ctx.object->id);
+    ensureComponents(ctx, capsuleTuning.x, capsuleTuning.y);
+
+    const float walkSpeed = moveTuning.x;
+    const float runSpeed = moveTuning.y;
+    const float jumpStrength = moveTuning.z;
+    const float lookSensitivity = lookTuning.x;
+    const float maxMouseDelta = glm::max(5.0f, lookTuning.y);
+    const float height = capsuleTuning.x;
+    const float radius = capsuleTuning.y;
+    const float groundSnap = capsuleTuning.z;
+    const float gravity = gravityTuning.x;
+    const float probeExtra = gravityTuning.y;
+    const float maxFall = glm::max(1.0f, gravityTuning.z);
+
+    if (enableMouseLook) {
+        bool allowLook = !requireMouseButton || ImGui::IsMouseDown(ImGuiMouseButton_Right);
+        if (allowLook) {
+            ImGuiIO& io = ImGui::GetIO();
+            glm::vec2 delta(io.MouseDelta.x, io.MouseDelta.y);
+            float len = glm::length(delta);
+            if (len > maxMouseDelta) {
+                delta *= (maxMouseDelta / len);
+            }
+            state.yaw -= delta.x * 50.0f * lookSensitivity * deltaTime;
+            state.pitch -= delta.y * 50.0f * lookSensitivity * deltaTime;
+            state.pitch = std::clamp(state.pitch, -89.0f, 89.0f);
+        }
+    }
+
+    glm::quat q = glm::quat(glm::radians(glm::vec3(state.pitch, state.yaw, 0.0f)));
+    glm::vec3 forward = glm::normalize(q * glm::vec3(0.0f, 0.0f, -1.0f));
+    glm::vec3 right = glm::normalize(q * glm::vec3(1.0f, 0.0f, 0.0f));
+    glm::vec3 planarForward = glm::normalize(glm::vec3(forward.x, 0.0f, forward.z));
+    glm::vec3 planarRight = glm::normalize(glm::vec3(right.x, 0.0f, right.z));
+    if (!std::isfinite(planarForward.x) || glm::length(planarForward) < 1e-3f) {
+        planarForward = glm::vec3(0.0f, 0.0f, -1.0f);
+    }
+    if (!std::isfinite(planarRight.x) || glm::length(planarRight) < 1e-3f) {
+        planarRight = glm::vec3(1.0f, 0.0f, 0.0f);
+    }
+
+    glm::vec3 move(0.0f);
+    if (ImGui::IsKeyDown(ImGuiKey_W)) move += planarForward;
+    if (ImGui::IsKeyDown(ImGuiKey_S)) move -= planarForward;
+    if (ImGui::IsKeyDown(ImGuiKey_D)) move += planarRight;
+    if (ImGui::IsKeyDown(ImGuiKey_A)) move -= planarRight;
+    if (glm::length(move) > 0.001f) move = glm::normalize(move);
+
+    bool sprint = ImGui::IsKeyDown(ImGuiKey_LeftShift) || ImGui::IsKeyDown(ImGuiKey_RightShift);
+    float targetSpeed = sprint ? runSpeed : walkSpeed;
+    glm::vec3 velocity = move * targetSpeed;
+
+    float capsuleHalf = std::max(0.1f, height * 0.5f);
+    glm::vec3 physVel;
+    bool havePhysVel = ctx.GetRigidbodyVelocity(physVel);
+    if (havePhysVel) state.verticalVelocity = physVel.y;
+
+    glm::vec3 hitPos(0.0f);
+    glm::vec3 hitNormal(0.0f, 1.0f, 0.0f);
+    float hitDist = 0.0f;
+    float probeDist = capsuleHalf + probeExtra;
+    glm::vec3 rayStart = ctx.object->position + glm::vec3(0.0f, 0.1f, 0.0f);
+    bool hitGround = ctx.RaycastClosest(rayStart, glm::vec3(0.0f, -1.0f, 0.0f), probeDist,
+                                        &hitPos, &hitNormal, &hitDist);
+    bool grounded = hitGround && hitNormal.y > 0.25f &&
+                    hitDist <= capsuleHalf + groundSnap &&
+                    state.verticalVelocity <= 0.35f;
+    if (!hitGround) {
+        grounded = ctx.object->position.y <= capsuleHalf + 0.12f && state.verticalVelocity <= 0.35f;
+    }
+
+    if (grounded) {
+        state.verticalVelocity = 0.0f;
+        if (!havePhysVel) {
+            if (hitGround) {
+                ctx.object->position.y = std::max(ctx.object->position.y, hitPos.y + capsuleHalf);
+            } else {
+                ctx.object->position.y = capsuleHalf;
+            }
+        }
+        if (ImGui::IsKeyDown(ImGuiKey_Space)) {
+            state.verticalVelocity = jumpStrength;
+        }
+    } else {
+        state.verticalVelocity += gravity * deltaTime;
+    }
+
+    state.verticalVelocity = std::clamp(state.verticalVelocity, -maxFall, maxFall);
+    velocity.y = state.verticalVelocity;
+
+    glm::vec3 rotation(state.pitch, state.yaw, 0.0f);
+    ctx.object->rotation = rotation;
+    ctx.SetRigidbodyRotation(rotation);
+
+    if (!ctx.SetRigidbodyVelocity(velocity)) {
+        ctx.object->position += velocity * deltaTime;
+    }
+
+    if (showDebug) {
+        ImGui::Text("Move (%.2f, %.2f, %.2f)", velocity.x, velocity.y, velocity.z);
+        ImGui::Text("Grounded: %s", grounded ? "yes" : "no");
+    }
+}
+
+void Spec(ScriptContext& /*ctx*/, float /*deltaTime*/) {}
+void TestEditor(ScriptContext& /*ctx*/, float /*deltaTime*/) {}