@gripforgeai/mcp 0.1.10 → 0.1.12

package/dist/joystick-kit/threejs.js

@@ -0,0 +1,93 @@
+export function threeJoystickFiles(c) {
+    return [{ path: 'gripforge/joystick.mjs', content: `// GripForge input.joystick 1.0.0 — no framework or renderer dependency.
+export const defaults = ${JSON.stringify(c)};
+export function radialAxis(x,y,deadzone=defaults.deadzone) {
+  const m=Math.hypot(x,y);
+  if(!Number.isFinite(m)||m<=deadzone) return {x:0,y:0};
+  const k=Math.min(1,(m-deadzone)/(1-deadzone))/m;
+  return {x:x*k,y:y*k};
+}
+export function createJoystick({parent=document.body,...options}={}) {
+  const cfg={...defaults,...options};
+  if(!['move','dual'].includes(cfg.layout)||!Number.isFinite(cfg.deadzone)||cfg.deadzone<0||cfg.deadzone>.5||!Number.isFinite(cfg.radius)||cfg.radius<32||cfg.radius>160||!/^#[a-f0-9]{6}$/i.test(cfg.accent)) throw Error('Invalid joystick options');
+  const root=document.createElement('div');
+  root.dataset.gripforgeJoystick='';
+  Object.assign(root.style,{position:'fixed',inset:'0',pointerEvents:'none',zIndex:'30'});
+  const state={move:{x:0,y:0},look:{x:0,y:0}};
+  const sticks=[];
+  function make(name,right) {
+    const base=document.createElement('div'),thumb=document.createElement('div');
+    base.dataset.stick=name; base.setAttribute('aria-label',name==='move'?'Movement joystick':'Camera joystick');
+    base.setAttribute('role','group');
+    Object.assign(base.style,{position:'absolute',bottom:'max(24px, env(safe-area-inset-bottom))',width:'min('+cfg.radius*2+'px, calc((100vw - 72px) / 2))',aspectRatio:'1',borderRadius:'50%',background:'rgba(15,20,28,.72)',boxShadow:'inset 0 0 0 2px rgba(255,255,255,.22)',touchAction:'none',userSelect:'none',pointerEvents:'auto'});
+    base.style[right?'right':'left']='max(24px, env(safe-area-inset-'+(right?'right':'left')+'))';
+    Object.assign(thumb.style,{position:'absolute',left:'36%',top:'36%',width:'28%',height:'28%',borderRadius:'50%',background:cfg.accent,boxShadow:'0 0 16px '+cfg.accent+'55',pointerEvents:'none'});
+    base.append(thumb);root.append(base);
+    const stick={base,thumb,pointer:null}; sticks.push(stick);
+    function reset(){
+      const pointer=stick.pointer;stick.pointer=null;state[name]={x:0,y:0};thumb.style.transform='';
+      if(pointer!==null&&base.hasPointerCapture(pointer))base.releasePointerCapture(pointer);
+    }
+    stick.reset=reset;
+    function update(e){
+      const r=base.getBoundingClientRect(),travel=Math.min(r.width,r.height)*.325;
+      if(travel<=0){reset();return;}
+      const x=(e.clientX-r.left-r.width/2)/travel,y=-(e.clientY-r.top-r.height/2)/travel;
+      state[name]=radialAxis(x,y,cfg.deadzone);
+      const m=Math.max(1,Math.hypot(x,y));
+      thumb.style.transform='translate('+(x/m*travel)+'px,'+(-y/m*travel)+'px)';
+    }
+    base.addEventListener('pointerdown',e=>{
+      if(stick.pointer!==null||(e.pointerType==='mouse'&&e.button!==0))return;
+      e.preventDefault();e.stopPropagation();stick.pointer=e.pointerId;base.setPointerCapture(e.pointerId);update(e);
+    });
+    base.addEventListener('pointermove',e=>{if(stick.pointer===e.pointerId){e.preventDefault();e.stopPropagation();update(e);}});
+    for(const event of ['pointerup','pointercancel','lostpointercapture'])base.addEventListener(event,e=>{if(stick.pointer===e.pointerId){e.stopPropagation();reset();}});
+  }
+  make('move',false);if(cfg.layout==='dual')make('look',true);
+  parent.append(root);
+  const reset=()=>sticks.forEach(s=>s.reset());
+  const onVisibility=()=>{if(document.hidden)reset();};
+  window.addEventListener('blur',reset);window.addEventListener('resize',reset);document.addEventListener('visibilitychange',onVisibility);
+  return {root,read:()=>({move:{...state.move},look:{...state.look}}),reset,
+    dispose(){reset();window.removeEventListener('blur',reset);window.removeEventListener('resize',reset);document.removeEventListener('visibilitychange',onVisibility);root.remove();}};
+}
+// Optional GripForge KitHost bridge. Does not overwrite physical gamepad state.
+export function bindGripForgeInput(joystick,input,source='touch-joystick') {
+  if(typeof input.setVirtualAxis!=='function')throw Error('Update GripForge input.actions for named virtual axes.');
+  return {update(){const s=joystick.read();for(const [name,value] of Object.entries({move_x:s.move.x,move_y:s.move.y,look_x:s.look.x,look_y:s.look.y}))input.setVirtualAxis(name,value,source);},
+    dispose(){input.clearVirtualInput(source);joystick.reset();}};
+}
+` }, { path: 'gripforge/three-joystick-example.mjs', content: `import * as THREE from 'three';
+import { createJoystick } from './joystick.mjs';
+export const joystick=createJoystick();
+const forward=new THREE.Vector3(),right=new THREE.Vector3();
+// Feed this direction to your capsule/character motor's normal physics update.
+export function readMovement(camera) {
+  const {move,look}=joystick.read();
+  camera.getWorldDirection(forward);forward.y=0;
+  if(forward.lengthSq()<.00001)forward.set(0,0,-1);else forward.normalize();
+  right.crossVectors(forward,THREE.Object3D.DEFAULT_UP).normalize();
+  return {direction:new THREE.Vector3().addScaledVector(right,move.x).addScaledVector(forward,move.y),look};
+}
+// Each physics tick: motor.setDesiredDirection(readMovement(camera).direction).
+// Camera: yaw -= look.x * radiansPerSecond * dt; pitch += look.y * radiansPerSecond * dt.
+// On unmount: joystick.dispose(). No teleporting or replacement of collision/network code.
+` }, { path: 'README.md', content: `# GripForge joystick · Three.js
+
+Copy gripforge/ into your browser project. Import createJoystick() from joystick.mjs;
+call read() every simulation frame. The overlay works with touch and mouse, holds
+each finger independently and resets on release, cancellation, blur and disposal.
+Outputs are move/look vectors in a unit disc, X right and Y forward/up.
+
+The Three.js example converts movement to camera-relative world space. Pass that
+vector to your existing physics motor. Its look vector is an angular velocity;
+multiply by dt once. Destroy the overlay when unloading the game.
+
+For a GripForge KitHost use bindGripForgeInput(), call its update() before
+host.tick(), and dispose both the binding and joystick. Register look_x/look_y
+actions when using a camera kit. Virtual axes bypass the extra hardware noise
+threshold because the joystick already applies its radial deadzone. Physical
+gamepad state remains independent.
+` }];
+}

package/dist/joystick-kit/unity.js

@@ -0,0 +1,182 @@
+export function unityJoystickFiles(c) {
+    const dir = 'Assets/GripForge/Joystick/';
+    return [{ path: dir + 'GripForgeVirtualStick.cs', content: `using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace GripForge.Inputs {
+// One owner per stick; holding a finger does not require new drag events.
+public sealed class GripForgeVirtualStick : MonoBehaviour, IPointerDownHandler,
+    IDragHandler, IPointerUpHandler, IEndDragHandler, IInitializePotentialDragHandler {
+    [Range(0, .5f)] public float Deadzone = ${c.deadzone}f;
+    public RectTransform Thumb;
+    public Vector2 Axis { get; private set; }
+    int? owner;
+    RectTransform Rect => (RectTransform)transform;
+
+    public static Vector2 Radial(Vector2 value, float deadzone) {
+        float m = value.magnitude;
+        if (float.IsNaN(m) || float.IsInfinity(m) || m <= deadzone) return Vector2.zero;
+        return value / m * Mathf.Min(1, (m - deadzone) / (1 - deadzone));
+    }
+    public void OnInitializePotentialDrag(PointerEventData e) { e.useDragThreshold = false; }
+    public void OnPointerDown(PointerEventData e) {
+        if (owner.HasValue || e.button != PointerEventData.InputButton.Left) return;
+        owner = e.pointerId;
+        UpdatePointer(e);
+    }
+    public void OnDrag(PointerEventData e) { if (owner == e.pointerId) UpdatePointer(e); }
+    public void OnPointerUp(PointerEventData e) { if (owner == e.pointerId) ResetStick(); }
+    public void OnEndDrag(PointerEventData e) { if (owner == e.pointerId) ResetStick(); }
+    void UpdatePointer(PointerEventData e) {
+        if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(Rect, e.position, e.pressEventCamera, out Vector2 p)) return;
+        float travel = Mathf.Min(Rect.rect.width, Rect.rect.height) * .325f;
+        if (travel <= 0) { ResetStick(); return; }
+        Vector2 raw = (p - Rect.rect.center) / travel;
+        Axis = Radial(raw, Deadzone);
+        if (Thumb) Thumb.anchoredPosition = Vector2.ClampMagnitude(raw, 1) * travel;
+    }
+    public void ResetStick() { owner = null; Axis = Vector2.zero; if (Thumb) Thumb.anchoredPosition = Vector2.zero; }
+    void OnDisable() { ResetStick(); }
+    void OnApplicationFocus(bool focused) { if (!focused) ResetStick(); }
+    void OnApplicationPause(bool paused) { if (paused) ResetStick(); }
+    void OnRectTransformDimensionsChange() { ResetStick(); }
+}
+}
+` }, { path: dir + 'GripForgeJoystickRig.cs', content: `using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.EventSystems;
+#if ENABLE_INPUT_SYSTEM
+using UnityEngine.InputSystem.UI;
+#endif
+
+namespace GripForge.Inputs {
+// Add this component to a scene GameObject. It creates its own UI only.
+public sealed class GripForgeJoystickRig : MonoBehaviour {
+    public bool Dual = ${c.layout === 'dual' ? 'true' : 'false'};
+    [Range(32, 160)] public float Radius = ${c.radius}f;
+    [Range(0, .5f)] public float Deadzone = ${c.deadzone}f;
+    public Vector2 Move => left ? left.Axis : Vector2.zero;
+    public Vector2 Look => right ? right.Axis : Vector2.zero;
+    GripForgeVirtualStick left, right;
+    GameObject ui;
+    RectTransform safe;
+    Rect lastSafe;
+    Vector2Int lastScreen;
+    Texture2D circleTexture;
+    Sprite circle;
+
+    void Awake() {
+        circleTexture = new Texture2D(64, 64, TextureFormat.RGBA32, false);
+        circleTexture.wrapMode = TextureWrapMode.Clamp;
+        for (int y=0;y<64;y++) for (int x=0;x<64;x++) {
+            float alpha = Mathf.Clamp01(32 - Vector2.Distance(new Vector2(x+.5f,y+.5f), new Vector2(32,32)));
+            circleTexture.SetPixel(x,y,new Color(1,1,1,alpha));
+        }
+        circleTexture.Apply();
+        circle = Sprite.Create(circleTexture,new Rect(0,0,64,64),new Vector2(.5f,.5f),64);
+        ui = new GameObject("GripForge Joystick UI",typeof(RectTransform),typeof(Canvas),typeof(CanvasScaler),typeof(GraphicRaycaster));
+        ui.transform.SetParent(transform,false);
+        ui.GetComponent<Canvas>().renderMode = RenderMode.ScreenSpaceOverlay;
+        ui.GetComponent<Canvas>().sortingOrder = 20;
+        var scaler = ui.GetComponent<CanvasScaler>();
+        scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+        scaler.referenceResolution = new Vector2(1280,720); scaler.matchWidthOrHeight = .5f;
+        safe = new GameObject("Safe Area",typeof(RectTransform)).GetComponent<RectTransform>();
+        safe.SetParent(ui.transform,false);
+        left = MakeStick("Move",false);
+        if (Dual) right = MakeStick("Look",true);
+        // Reuse the game's EventSystem; do not replace configured input modules.
+        if (!FindObjectOfType<EventSystem>()) {
+            var events = new GameObject("GripForge EventSystem",typeof(EventSystem));
+            events.transform.SetParent(transform,false);
+#if ENABLE_INPUT_SYSTEM
+            var input = events.AddComponent<InputSystemUIInputModule>();
+            input.AssignDefaultActions();
+#else
+            events.AddComponent<StandaloneInputModule>();
+#endif
+        }
+        UpdateLayout();
+    }
+    GripForgeVirtualStick MakeStick(string name, bool rightSide) {
+        var go = new GameObject(name,typeof(RectTransform),typeof(Image),typeof(GripForgeVirtualStick));
+        var r = (RectTransform)go.transform; r.SetParent(safe,false);
+        r.anchorMin = r.anchorMax = new Vector2(rightSide ? 1 : 0,0);
+        r.pivot = new Vector2(.5f,.5f);
+        var image = go.GetComponent<Image>(); image.sprite = circle; image.color = new Color(.06f,.08f,.11f,.72f);
+        var thumb = new GameObject("Thumb",typeof(RectTransform),typeof(Image));
+        var tr = (RectTransform)thumb.transform; tr.SetParent(r,false);
+        tr.anchorMin = tr.anchorMax = tr.pivot = new Vector2(.5f,.5f);
+        var ti = thumb.GetComponent<Image>(); ti.sprite = circle; ti.raycastTarget = false;
+        ColorUtility.TryParseHtmlString("${c.accent}",out Color accent); ti.color = accent;
+        var stick = go.GetComponent<GripForgeVirtualStick>(); stick.Thumb = tr; stick.Deadzone = Deadzone;
+        return stick;
+    }
+    void Update() {
+        if (lastSafe != Screen.safeArea || lastScreen != new Vector2Int(Screen.width,Screen.height)) UpdateLayout();
+    }
+    void UpdateLayout() {
+        if (!safe || Screen.width <= 0 || Screen.height <= 0) return;
+        lastSafe = Screen.safeArea; lastScreen = new Vector2Int(Screen.width,Screen.height);
+        safe.anchorMin = new Vector2(lastSafe.xMin/Screen.width,lastSafe.yMin/Screen.height);
+        safe.anchorMax = new Vector2(lastSafe.xMax/Screen.width,lastSafe.yMax/Screen.height);
+        safe.offsetMin = safe.offsetMax = Vector2.zero;
+        Canvas.ForceUpdateCanvases();
+        float radius = Mathf.Min(Radius, Mathf.Max(24,(safe.rect.width-72)/(Dual?4:2)));
+        Layout(left,false,radius); if(right) Layout(right,true,radius);
+    }
+    void Layout(GripForgeVirtualStick stick, bool rightSide, float radius) {
+        var r = (RectTransform)stick.transform;
+        r.sizeDelta = Vector2.one * radius * 2;
+        r.anchoredPosition = new Vector2((rightSide?-1:1)*(24+radius),24+radius);
+        stick.Thumb.sizeDelta = Vector2.one * radius * .56f;
+        stick.ResetStick();
+    }
+    void OnEnable() { if(ui) ui.SetActive(true); }
+    void OnDisable() { if(ui) ui.SetActive(false); }
+    void OnDestroy() {
+        if(ui) Destroy(ui); if(circle) Destroy(circle); if(circleTexture) Destroy(circleTexture);
+    }
+}
+}
+` }, { path: dir + 'GripForgeJoystickMotorExample.cs', content: `using UnityEngine;
+namespace GripForge.Inputs {
+// Optional example. Prefer reading Joystick.Move in the motor already in your game.
+[RequireComponent(typeof(CharacterController))]
+public sealed class GripForgeJoystickMotorExample : MonoBehaviour {
+    public GripForgeJoystickRig Joystick;
+    public Transform View;
+    public float Speed = 5, Gravity = -20;
+    CharacterController motor;
+    float vertical;
+    void Awake() { motor = GetComponent<CharacterController>(); }
+    void Update() {
+        Vector2 axes = Joystick ? Joystick.Move : Vector2.zero;
+        float yaw = View ? View.eulerAngles.y : transform.eulerAngles.y;
+        Vector3 velocity = Quaternion.Euler(0,yaw,0) * new Vector3(axes.x,0,axes.y) * Speed;
+        if (motor.isGrounded && vertical < 0) vertical = -2;
+        vertical += Gravity * Time.deltaTime; velocity.y = vertical;
+        motor.Move(velocity * Time.deltaTime);
+    }
+}
+}
+` }, { path: 'README.md', content: `# GripForge joystick · Unity 2022.3 / Unity 6
+
+Copy Assets/GripForge/Joystick into your project. Install Unity UI (com.unity.ugui)
+if your project does not include it. Add GripForgeJoystickRig to a scene GameObject
+and press Play. It creates the overlay and reuses your EventSystem, or creates one
+with the enabled input backend (legacy or Input System). An existing EventSystem
+must have a working UI input module; do not add a second one.
+
+Read rig.Move and rig.Look each frame. X is right; Y is forward/up. Feed Move into
+your existing movement controller; multiply Look by your angular speed and deltaTime.
+The optional MotorExample requires the built-in Physics module and uses
+CharacterController.Move and gravity. Assign the
+rig and camera in the Inspector; do not run it alongside another movement motor.
+
+The two sticks have independent pointer ownership and a radial deadzone. Axes
+persist while held, reset when released, disabled, resized or focus is lost. The
+UI respects the safe area. The component does not rewrite gamepad/Input Actions.
+Disable/remove the rig to remove its controls. Mouse testing is supported.
+` }];
+}

package/dist/joystick-kit/unreal.js

@@ -0,0 +1,231 @@
+export function unrealJoystickFiles(c) {
+    const p = 'Plugins/GripForgeJoystick/';
+    const src = p + 'Source/GripForgeJoystick/';
+    return [{ path: p + 'GripForgeJoystick.uplugin', content: JSON.stringify({ FileVersion: 3, Version: 1, VersionName: '1.0.0', FriendlyName: 'GripForge Joystick', Description: 'Independent touch/mouse movement and look sticks for an existing Pawn.', Category: 'Input', CreatedBy: 'GripForge', CanContainContent: false, Modules: [{ Name: 'GripForgeJoystick', Type: 'Runtime', LoadingPhase: 'Default' }] }, null, 2) },
+        { path: src + 'GripForgeJoystick.Build.cs', content: `using UnrealBuildTool;
+public class GripForgeJoystick : ModuleRules {
+    public GripForgeJoystick(ReadOnlyTargetRules Target) : base(Target) {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        PublicDependencyModuleNames.AddRange(new string[]{"Core","CoreUObject","Engine","UMG"});
+        PrivateDependencyModuleNames.AddRange(new string[]{"Slate","SlateCore","InputCore","ApplicationCore"});
+    }
+}
+` }, { path: src + 'Private/GripForgeJoystickModule.cpp', content: `#include "Modules/ModuleManager.h"
+IMPLEMENT_MODULE(FDefaultModuleImpl, GripForgeJoystick)
+` }, { path: src + 'Public/GripForgeJoystickWidget.h', content: `#pragma once
+#include "CoreMinimal.h"
+#include "Blueprint/UserWidget.h"
+#include "GripForgeJoystickWidget.generated.h"
+class SGripForgeStick;
+
+UCLASS()
+class GRIPFORGEJOYSTICK_API UGripForgeJoystickWidget : public UUserWidget {
+    GENERATED_BODY()
+public:
+    bool bDual = ${c.layout === 'dual' ? 'true' : 'false'};
+    float Radius = ${c.radius.toFixed(4)}f;
+    float Deadzone = ${c.deadzone.toFixed(4)}f;
+    FLinearColor Accent = FLinearColor(FColor::FromHex(TEXT("${c.accent.slice(1)}")));
+    FVector2D GetMove() const;
+    FVector2D GetLook() const;
+    void ResetSticks();
+    virtual void ReleaseSlateResources(bool bReleaseChildren) override;
+protected:
+    virtual TSharedRef<SWidget> RebuildWidget() override;
+private:
+    TSharedPtr<SGripForgeStick> MoveStick, LookStick;
+};
+` }, { path: src + 'Private/GripForgeJoystickWidget.cpp', content: `#include "GripForgeJoystickWidget.h"
+#include "Widgets/SLeafWidget.h"
+#include "Widgets/SOverlay.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SBox.h"
+#include "Brushes/SlateRoundedBoxBrush.h"
+#include "Rendering/DrawElements.h"
+#include "Input/Reply.h"
+#include "InputCoreTypes.h"
+
+class SGripForgeStick : public SLeafWidget {
+public:
+    SLATE_BEGIN_ARGS(SGripForgeStick) : _Radius(72), _Deadzone(.15f), _Accent(FLinearColor::White) {}
+        SLATE_ARGUMENT(float, Radius)
+        SLATE_ARGUMENT(float, Deadzone)
+        SLATE_ARGUMENT(FLinearColor, Accent)
+    SLATE_END_ARGS()
+    void Construct(const FArguments& Args) {
+        Radius=Args._Radius; Deadzone=Args._Deadzone; Accent=Args._Accent;
+        SetCanTick(false);
+    }
+    FVector2D Axis = FVector2D::ZeroVector;
+    void Reset() { Owner=INDEX_NONE; OwnerUser=INDEX_NONE; Axis=Visual=FVector2D::ZeroVector; Invalidate(EInvalidateWidgetReason::Paint); }
+    static FVector2D Radial(FVector2D Value, float Zone) {
+        const double M=Value.Size();
+        return M<=Zone || !FMath::IsFinite(M) ? FVector2D::ZeroVector : Value/M*FMath::Min(1.0,(M-Zone)/(1.0-Zone));
+    }
+    virtual FVector2D ComputeDesiredSize(float) const override { return FVector2D(Radius*2); }
+    virtual int32 OnPaint(const FPaintArgs&, const FGeometry& G, const FSlateRect&, FSlateWindowElementList& Out, int32 Layer, const FWidgetStyle&, bool) const override {
+        const float R=FMath::Min(G.GetLocalSize().X,G.GetLocalSize().Y)*.5f;
+        const FVector2D C=G.GetLocalSize()*.5;
+        FSlateDrawElement::MakeBox(Out,Layer,G.ToPaintGeometry(FVector2D(R*2),FSlateLayoutTransform(C-FVector2D(R))),&Circle,ESlateDrawEffect::None,FLinearColor(.06f,.08f,.11f,.72f));
+        const float TR=R*.28f;
+        FSlateDrawElement::MakeBox(Out,Layer+1,G.ToPaintGeometry(FVector2D(TR*2),FSlateLayoutTransform(C+Visual*R*.65f-FVector2D(TR))),&Circle,ESlateDrawEffect::None,Accent);
+        return Layer+1;
+    }
+    virtual FReply OnMouseButtonDown(const FGeometry& G,const FPointerEvent& E) override { return E.GetEffectingButton()==EKeys::LeftMouseButton ? Begin(G,E) : FReply::Unhandled(); }
+    virtual FReply OnMouseMove(const FGeometry& G,const FPointerEvent& E) override { return Move(G,E); }
+    virtual FReply OnMouseButtonUp(const FGeometry&,const FPointerEvent& E) override { return E.GetEffectingButton()==EKeys::LeftMouseButton ? End(E) : FReply::Unhandled(); }
+    virtual FReply OnTouchStarted(const FGeometry& G,const FPointerEvent& E) override { return Begin(G,E); }
+    virtual FReply OnTouchMoved(const FGeometry& G,const FPointerEvent& E) override { return Move(G,E); }
+    virtual FReply OnTouchEnded(const FGeometry&,const FPointerEvent& E) override { return End(E); }
+    virtual void OnMouseCaptureLost(const FCaptureLostEvent&) override { Reset(); }
+private:
+    int32 Owner=INDEX_NONE, OwnerUser=INDEX_NONE;
+    float Radius=72, Deadzone=.15f;
+    FVector2D Visual=FVector2D::ZeroVector;
+    FLinearColor Accent;
+    const FSlateRoundedBoxBrush Circle{FLinearColor::White,1000.f};
+    bool Owns(const FPointerEvent& E) const { return Owner==(int32)E.GetPointerIndex() && OwnerUser==(int32)E.GetUserIndex(); }
+    void Update(const FGeometry& G,const FPointerEvent& E) {
+        const double Travel=FMath::Min(G.GetLocalSize().X,G.GetLocalSize().Y)*.325;
+        if(Travel<=0){Reset();return;}
+        const FVector2D Raw=(G.AbsoluteToLocal(E.GetScreenSpacePosition())-G.GetLocalSize()*.5)/Travel;
+        Visual=Raw/FMath::Max(1.0,Raw.Size());
+        Axis=Radial(FVector2D(Raw.X,-Raw.Y),Deadzone);
+        Invalidate(EInvalidateWidgetReason::Paint);
+    }
+    FReply Begin(const FGeometry& G,const FPointerEvent& E) {
+        if(Owner!=INDEX_NONE)return FReply::Handled();
+        Owner=E.GetPointerIndex(); OwnerUser=E.GetUserIndex(); Update(G,E);
+        return FReply::Handled().CaptureMouse(SharedThis(this));
+    }
+    FReply Move(const FGeometry& G,const FPointerEvent& E) { if(!Owns(E))return FReply::Unhandled(); Update(G,E); return FReply::Handled(); }
+    FReply End(const FPointerEvent& E) { if(!Owns(E))return FReply::Unhandled(); Reset(); return FReply::Handled().ReleaseMouseCapture(); }
+};
+
+TSharedRef<SWidget> UGripForgeJoystickWidget::RebuildWidget() {
+    auto Overlay=SNew(SOverlay).Visibility(EVisibility::SelfHitTestInvisible);
+    Overlay->AddSlot().HAlign(HAlign_Left).VAlign(VAlign_Bottom).Padding(24)[
+        SAssignNew(MoveStick,SGripForgeStick).Radius(Radius).Deadzone(Deadzone).Accent(Accent)];
+    if(bDual) Overlay->AddSlot().HAlign(HAlign_Right).VAlign(VAlign_Bottom).Padding(24)[
+        SAssignNew(LookStick,SGripForgeStick).Radius(Radius).Deadzone(Deadzone).Accent(Accent)];
+    return SNew(SSafeZone).Visibility(EVisibility::SelfHitTestInvisible)[Overlay];
+}
+FVector2D UGripForgeJoystickWidget::GetMove() const { return MoveStick.IsValid()?MoveStick->Axis:FVector2D::ZeroVector; }
+FVector2D UGripForgeJoystickWidget::GetLook() const { return LookStick.IsValid()?LookStick->Axis:FVector2D::ZeroVector; }
+void UGripForgeJoystickWidget::ResetSticks(){if(MoveStick)MoveStick->Reset();if(LookStick)LookStick->Reset();}
+void UGripForgeJoystickWidget::ReleaseSlateResources(bool bReleaseChildren){ResetSticks();Super::ReleaseSlateResources(bReleaseChildren);MoveStick.Reset();LookStick.Reset();}
+` }, { path: src + 'Public/GripForgeJoystickComponent.h', content: `#pragma once
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "GripForgeJoystickComponent.generated.h"
+class UGripForgeJoystickWidget;
+class APlayerController;
+
+UCLASS(ClassGroup=(Input), meta=(BlueprintSpawnableComponent))
+class GRIPFORGEJOYSTICK_API UGripForgeJoystickComponent : public UActorComponent {
+    GENERATED_BODY()
+public:
+    UGripForgeJoystickComponent();
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick") bool bDual = ${c.layout === 'dual' ? 'true' : 'false'};
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick",meta=(ClampMin="32",ClampMax="160")) float Radius = ${c.radius.toFixed(4)}f;
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick",meta=(ClampMin="0",ClampMax="0.5")) float Deadzone = ${c.deadzone.toFixed(4)}f;
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick") FLinearColor Accent = FLinearColor(FColor::FromHex(TEXT("${c.accent.slice(1)}")));
+    // Turn these off if your existing motor reads GetMove/GetLook itself.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick") bool bDriveMovement = true;
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick") bool bDriveLook = true;
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Joystick") float LookDegreesPerSecond = 120.f;
+    UFUNCTION(BlueprintPure, Category="Joystick") FVector2D GetMove() const;
+    UFUNCTION(BlueprintPure, Category="Joystick") FVector2D GetLook() const;
+    UFUNCTION(BlueprintCallable, Category="Joystick") void ResetInput();
+    virtual void Deactivate() override;
+    virtual void TickComponent(float Delta, ELevelTick TickType, FActorComponentTickFunction* ThisTick) override;
+protected:
+    virtual void BeginPlay() override;
+    virtual void EndPlay(const EEndPlayReason::Type Reason) override;
+private:
+    UPROPERTY(Transient) TObjectPtr<UGripForgeJoystickWidget> Widget;
+    TWeakObjectPtr<APlayerController> Controller;
+    FDelegateHandle FocusHandle, BackgroundHandle;
+    void RemoveWidget();
+};
+` }, { path: src + 'Private/GripForgeJoystickComponent.cpp', content: `#include "GripForgeJoystickComponent.h"
+#include "GripForgeJoystickWidget.h"
+#include "GameFramework/Pawn.h"
+#include "GameFramework/PlayerController.h"
+#include "GameFramework/PawnMovementComponent.h"
+#include "Misc/CoreDelegates.h"
+#include "Math/RotationMatrix.h"
+
+UGripForgeJoystickComponent::UGripForgeJoystickComponent(){bAutoActivate=true;PrimaryComponentTick.bCanEverTick=true;PrimaryComponentTick.TickGroup=TG_PrePhysics;}
+void UGripForgeJoystickComponent::BeginPlay(){
+    Super::BeginPlay();
+    FocusHandle=FCoreDelegates::ApplicationWillDeactivateDelegate.AddUObject(this,&UGripForgeJoystickComponent::ResetInput);
+    BackgroundHandle=FCoreDelegates::ApplicationWillEnterBackgroundDelegate.AddUObject(this,&UGripForgeJoystickComponent::ResetInput);
+    if(auto* Pawn=Cast<APawn>(GetOwner()))if(auto* Motor=Pawn->GetMovementComponent())Motor->AddTickPrerequisiteComponent(this);
+}
+void UGripForgeJoystickComponent::TickComponent(float Delta,ELevelTick TickType,FActorComponentTickFunction* ThisTick){
+    Super::TickComponent(Delta,TickType,ThisTick);
+    auto* Pawn=Cast<APawn>(GetOwner());
+    auto* PC=Pawn?Cast<APlayerController>(Pawn->GetController()):nullptr;
+    if(!PC || !Pawn->IsLocallyControlled() || !PC->IsLocalController()){RemoveWidget();return;}
+    // Possession may occur AFTER BeginPlay. Recreate on local controller changes.
+    if(Controller.Get()!=PC){RemoveWidget();Controller=PC;}
+    if(!Widget){
+        Widget=CreateWidget<UGripForgeJoystickWidget>(PC);
+        if(!Widget)return;
+        Widget->bDual=bDual;Widget->Radius=FMath::Clamp(Radius,32.f,160.f);Widget->Deadzone=FMath::Clamp(Deadzone,0.f,.5f);Widget->Accent=Accent;
+        Widget->SetVisibility(ESlateVisibility::SelfHitTestInvisible);
+        Widget->AddToPlayerScreen(20);
+    }
+    if(PC->IsPaused()){ResetInput();return;}
+    const FVector2D Move=GetMove(),Look=GetLook();
+    if(bDriveMovement && !PC->IsMoveInputIgnored()){
+        const FRotationMatrix Basis(FRotator(0,PC->GetControlRotation().Yaw,0));
+        Pawn->AddMovementInput(Basis.GetUnitAxis(EAxis::X),Move.Y);
+        Pawn->AddMovementInput(Basis.GetUnitAxis(EAxis::Y),Move.X);
+    }
+    if(bDriveLook && !PC->IsLookInputIgnored()){
+        // InputYaw/PitchScale belong to the game's controller, just as for other axes.
+        Pawn->AddControllerYawInput(Look.X*LookDegreesPerSecond*Delta);
+        Pawn->AddControllerPitchInput(-Look.Y*LookDegreesPerSecond*Delta);
+    }
+}
+FVector2D UGripForgeJoystickComponent::GetMove() const {return IsActive()&&Widget?Widget->GetMove():FVector2D::ZeroVector;}
+FVector2D UGripForgeJoystickComponent::GetLook() const {return IsActive()&&Widget?Widget->GetLook():FVector2D::ZeroVector;}
+void UGripForgeJoystickComponent::ResetInput(){if(Widget)Widget->ResetSticks();}
+void UGripForgeJoystickComponent::Deactivate(){RemoveWidget();Super::Deactivate();}
+void UGripForgeJoystickComponent::RemoveWidget(){if(Widget){Widget->ResetSticks();Widget->RemoveFromParent();Widget=nullptr;}Controller.Reset();}
+void UGripForgeJoystickComponent::EndPlay(const EEndPlayReason::Type Reason){
+    RemoveWidget();FCoreDelegates::ApplicationWillDeactivateDelegate.Remove(FocusHandle);FCoreDelegates::ApplicationWillEnterBackgroundDelegate.Remove(BackgroundHandle);
+    if(auto* Pawn=Cast<APawn>(GetOwner()))if(auto* Motor=Pawn->GetMovementComponent())Motor->RemoveTickPrerequisiteComponent(this);
+    Super::EndPlay(Reason);
+}
+` }, { path: 'README.md', content: `# GripForge joystick · Unreal Engine 5
+
+1. Copy Plugins/GripForgeJoystick into the project (not Engine). Compile the
+   runtime plugin with your UE version/toolchain, then reopen the editor. A
+   Blueprint-only project can add a C++ class first to enable project builds.
+2. Enable GripForge Joystick in Plugins if needed. On the actual possessed Pawn
+   Blueprint, Add Component → GripForge Joystick. It waits for local possession.
+3. Press Play. Left stick feeds your Pawn's existing AddMovementInput; right
+   stick feeds controller yaw/pitch. CharacterMovement still owns collision,
+   gravity, acceleration and network prediction. No GameMode replacement.
+
+Mouse and touch work directly through Slate; Use Mouse for Touch is not required.
+For a desktop mouse test, use Game and UI input mode and show the cursor in your
+PlayerController. Keep the game viewport focused. The plugin deliberately does
+not change your game's input mode/cursor. Native touch works in Game Only mode.
+Remove/disable the previous virtual joystick to avoid overlapping controls.
+
+For a custom motor disable Drive Movement/Drive Look and read Get Move/Get Look
+from the component every tick. Axes: X right, Y forward/up; magnitude <= 1. Apply
+look deltaTime once. Existing gamepad/keyboard actions are not overwritten.
+Deadzone, radius, color and dual-stick layout are set before the UI is created.
+The overlay respects Slate DPI/safe zones. Release, capture loss, application
+focus loss, losing possession and EndPlay reset the axes. Use Reset Input when
+opening your own modal menus. One component per locally controlled pawn.
+
+This is a source plugin, not a precompiled binary for every UE release. Compile
+for the target UE/platform and test in your real project before packaging.
+` }];
+}

package/dist/joystick-tools.js

@@ -0,0 +1,26 @@
+/** Identical deterministic delivery in the hosted MCP and npm client. */
+import { z } from 'zod/v4';
+import { createJoystickKit } from './joystick-kit/index.js';
+export const JOYSTICK_TOOL_NAMES = ['gripforge_joystick_kit'];
+export function registerJoystickTools(register, schema = z) {
+    const shape = {
+        target: schema.enum(['threejs', 'godot', 'unity', 'unreal', 'all']).describe('Engine delivery. all returns each of the four source kits.'),
+        layout: schema.enum(['move', 'dual']).default('dual').describe('One movement stick, or independent movement + camera sticks.'),
+        deadzone: schema.number().min(0).max(.5).default(.15).describe('Radial deadzone, continuously rescaled to a unit disc.'),
+        radius: schema.number().min(32).max(160).default(72).describe('Stick radius in CSS/UI logical pixels, before engine DPI scaling.'),
+        accent: schema.string().regex(/^#[\da-f]{6}$/i).default('#ff681f').describe('Thumb color, six-digit hexadecimal RGB.'),
+    };
+    register('gripforge_joystick_kit', {
+        title: 'Ready-to-use joystick · Unreal / Godot / Unity / Three.js',
+        description: 'Generate input.joystick source files and installation instructions: touch + mouse, independent dual sticks, radial deadzone, continuous holding and release/focus reset. Unreal runtime Pawn component, Godot CanvasLayer scene, Unity UI component, Three.js DOM controls + GripForge input.actions bridge. Feeds the existing movement controller rather than replacing physics, collision or networking. Returns files with relative path/content; the agent writes them into the target project and compiles/tests there. Does not install automatically, modify project settings or claim runtime validation. 0 credits.',
+        inputSchema: shape,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, async (args) => {
+        const parsed = schema.object(shape).safeParse(args);
+        if (!parsed.success)
+            return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+        const { target, ...config } = parsed.data;
+        const result = createJoystickKit(target, config);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }], structuredContent: result };
+    });
+}

package/dist/look.js

@@ -0,0 +1,6 @@
+/**
+ * Le rendu (« look ») des outils MCP : un paramètre à part du style de jeu. Même vocabulaire que
+ * `LOOKS` de `@gripforge/core` (look.ts) — `qa/look-check.mjs` vérifie que les deux listes concordent.
+ */
+export const LOOK_VALUES = ['stylized', 'painted', 'toon', 'anime', 'realistic', 'lowpoly', 'pixel'];
+export const LOOK_DESCRIPTION = 'Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default.';