@gripforgeai/mcp 0.1.9 → 0.1.11

package/dist/joystick-kit/godot.js

@@ -0,0 +1,146 @@
+export function godotJoystickFiles(c) {
+    return [{ path: 'gripforge/joystick/virtual_stick.gd', content: `extends Control
+## GripForge input.joystick: persistent analog state, one pointer per stick.
+signal axis_changed(value: Vector2)
+@export_range(0.0, 0.5) var deadzone: float = ${c.deadzone}
+@export var accent: Color = Color("${c.accent}")
+var axis := Vector2.ZERO
+var visual := Vector2.ZERO
+var pointer := -1
+
+func _ready() -> void:
+	mouse_filter = Control.MOUSE_FILTER_IGNORE
+	resized.connect(reset)
+
+static func radial(value: Vector2, zone: float) -> Vector2:
+	var magnitude := value.length()
+	if magnitude <= zone: return Vector2.ZERO
+	return value / magnitude * minf(1.0, (magnitude - zone) / (1.0 - zone))
+
+func update_pointer(screen_position: Vector2) -> void:
+	var local := get_global_transform_with_canvas().affine_inverse() * screen_position
+	var travel := minf(size.x, size.y) * 0.325
+	if travel <= 0.0: return
+	var raw := (local - size * 0.5) / travel
+	visual = raw.limit_length()
+	axis = radial(Vector2(raw.x, -raw.y), deadzone)
+	axis_changed.emit(axis)
+	queue_redraw()
+
+func _input(event: InputEvent) -> void:
+	if not is_visible_in_tree():
+		reset()
+		return
+	if event is InputEventScreenTouch:
+		if event.canceled and pointer == event.index:
+			reset()
+			get_viewport().set_input_as_handled()
+		elif event.pressed and not event.canceled and pointer == -1 and get_global_rect().has_point(event.position):
+			pointer = event.index
+			update_pointer(event.position)
+			get_viewport().set_input_as_handled()
+		elif not event.pressed and pointer == event.index:
+			reset()
+			get_viewport().set_input_as_handled()
+	elif event is InputEventScreenDrag and pointer == event.index:
+		update_pointer(event.position)
+		get_viewport().set_input_as_handled()
+	elif event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:
+		if event.pressed and pointer == -1 and get_global_rect().has_point(event.position):
+			pointer = -2
+			update_pointer(event.position)
+			get_viewport().set_input_as_handled()
+		elif not event.pressed and pointer == -2:
+			reset()
+			get_viewport().set_input_as_handled()
+	elif event is InputEventMouseMotion and pointer == -2:
+		update_pointer(event.position)
+		get_viewport().set_input_as_handled()
+
+func reset() -> void:
+	pointer = -1
+	axis = Vector2.ZERO
+	visual = Vector2.ZERO
+	axis_changed.emit(axis)
+	queue_redraw()
+
+func _notification(what: int) -> void:
+	if what == NOTIFICATION_APPLICATION_FOCUS_OUT or what == NOTIFICATION_EXIT_TREE:
+		reset()
+
+func _draw() -> void:
+	var radius := minf(size.x, size.y) * 0.5
+	draw_circle(size * 0.5, radius, Color(0.06, 0.08, 0.11, 0.72))
+	draw_arc(size * 0.5, maxf(0, radius - 1), 0, TAU, 64, Color(1, 1, 1, 0.22), 2, true)
+	draw_circle(size * 0.5 + visual * radius * 0.65, radius * 0.28, accent)
+` }, { path: 'gripforge/joystick/joystick_rig.gd', content: `extends CanvasLayer
+## Add this script to a CanvasLayer. No InputMap mutation or autoload required.
+const Stick = preload("res://gripforge/joystick/virtual_stick.gd")
+@export var dual: bool = ${c.layout === 'dual' ? 'true' : 'false'}
+@export_range(32, 160) var radius: float = ${c.radius}
+@export_range(0, 0.5) var deadzone: float = ${c.deadzone}
+var left: Control
+var right: Control
+
+func _ready() -> void:
+	layer = 20
+	left = Stick.new()
+	left.deadzone = deadzone
+	add_child(left)
+	if dual:
+		right = Stick.new()
+		right.deadzone = deadzone
+		add_child(right)
+	get_viewport().size_changed.connect(_layout)
+	_layout()
+
+func _layout() -> void:
+	var view := get_viewport().get_visible_rect().size
+	var r := minf(radius, maxf(24, (view.x - 72) / (4 if dual else 2)))
+	left.size = Vector2.ONE * r * 2
+	left.position = Vector2(24, maxf(0, view.y - 24 - r * 2))
+	left.reset()
+	if right:
+		right.size = left.size
+		right.position = Vector2(view.x - 24 - r * 2, left.position.y)
+		right.reset()
+
+func movement() -> Vector2:
+	return left.axis if is_instance_valid(left) else Vector2.ZERO
+
+func look() -> Vector2:
+	return right.axis if is_instance_valid(right) else Vector2.ZERO
+` }, { path: 'gripforge/joystick/joystick.tscn', content: `[gd_scene load_steps=2 format=3]
+[ext_resource type="Script" path="res://gripforge/joystick/joystick_rig.gd" id="1"]
+[node name="GripForgeJoystick" type="CanvasLayer"]
+script = ExtResource("1")
+` }, { path: 'gripforge/joystick/character_example.gd', content: `extends CharacterBody3D
+## Optional example; merge input reads into your own motor instead of running two motors.
+@export var joystick: CanvasLayer
+@export var camera: Node3D
+@export var speed: float = 5.0
+@export var gravity: float = 9.8
+func _physics_process(delta: float) -> void:
+	var axes: Vector2 = joystick.movement() if joystick else Vector2.ZERO
+	var yaw: float = camera.global_rotation.y if camera else global_rotation.y
+	var direction := Basis(Vector3.UP, yaw) * Vector3(axes.x, 0, -axes.y)
+	velocity.x = direction.x * speed
+	velocity.z = direction.z * speed
+	if not is_on_floor(): velocity.y -= gravity * delta
+	else: velocity.y = 0
+	move_and_slide()
+` }, { path: 'README.md', content: `# GripForge joystick · Godot 4.2+
+
+Copy gripforge/ into res://. Instance joystick.tscn in the gameplay scene.
+Read movement() and look() every physics frame. X is right; Y is forward/up.
+Assign the rig and camera in the optional CharacterBody3D example. A collider and
+floor are still supplied by your game; the joystick does not replace collision.
+
+Touch IDs are isolated; both sticks can be held simultaneously. Mouse testing is
+built in: you do not need to enable Emulate Touch From Mouse. Keep only one such
+emulation path active. Release, focus loss, resizing and removal reset the axes.
+The rig does not erase keyboard/gamepad bindings. Combine its movement vector with
+your existing input source in your motor (choose one source per frame, then clamp
+the combined length to one). Apply look as angular velocity times delta once.
+` }];
+}

package/dist/joystick-kit/index.js

@@ -0,0 +1,32 @@
+import { threeJoystickFiles } from './threejs.js';
+import { godotJoystickFiles } from './godot.js';
+import { unityJoystickFiles } from './unity.js';
+import { unrealJoystickFiles } from './unreal.js';
+export const joystickDefaults = { layout: 'dual', deadzone: .15, radius: 72, accent: '#ff681f' };
+/** Radial, continuous, unit-disc axes. Y is up/forward on every target. */
+export function joystickAxis(x, y, deadzone = .15) {
+    if (![x, y, deadzone].every(Number.isFinite) || deadzone < 0 || deadzone >= 1)
+        return { x: 0, y: 0 };
+    const length = Math.hypot(x, y);
+    if (length <= deadzone)
+        return { x: 0, y: 0 };
+    const scale = Math.min(1, (length - deadzone) / (1 - deadzone)) / length;
+    return { x: x * scale, y: y * scale };
+}
+export function createJoystickKit(target, options = {}) {
+    const config = { ...joystickDefaults, ...options };
+    if (!['threejs', 'godot', 'unity', 'unreal', 'all'].includes(target))
+        throw Error('Unknown joystick target.');
+    if (!['move', 'dual'].includes(config.layout) || !Number.isFinite(config.deadzone) || config.deadzone < 0 || config.deadzone > .5 ||
+        !Number.isFinite(config.radius) || config.radius < 32 || config.radius > 160 || !/^#[\da-f]{6}$/i.test(config.accent))
+        throw Error('Invalid joystick configuration.');
+    const targets = target === 'all' ? ['threejs', 'godot', 'unity', 'unreal'] : [target];
+    const factories = { threejs: threeJoystickFiles, godot: godotJoystickFiles, unity: unityJoystickFiles, unreal: unrealJoystickFiles };
+    return {
+        schema: 'gripforge.joystick-kit.v1', module: 'input.joystick', version: '1.0.0', credits: 0, config,
+        conventions: { axes: 'x right, y up/forward', range: 'unit disc; diagonals never exceed magnitude 1', deadzone: 'radial, rescaled continuously outside the dead zone', holding: 'value persists every frame until release/cancel/focus loss', ownership: 'one pointer per stick; movement and look can be held simultaneously', physics: 'Feeds the existing pawn/controller; examples are optional.' },
+        deliveries: targets.map(engine => ({ engine, files: factories[engine](config) })),
+        status: 'files_generated',
+        next: 'Write each delivery file at its relative path, then follow that target README. Install only one movement driver. Generation does not modify your project or claim an in-game verification.',
+    };
+}

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.
+` }];
+}