@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/skills/game-development/mobile-input-patterns/SKILL.md

@@ -0,0 +1,343 @@
+---
+name: mobile-input-patterns
+description: Touch input patterns for mobile games. Gestures, virtual joysticks, input abstraction layer, and accessibility considerations.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# Mobile Input Patterns Skill
+
+> Expert touch input patterns for Unity mobile games.
+
+---
+
+## When to Use
+
+- Implementing touch controls for mobile games
+- Creating virtual joysticks and buttons
+- Gesture recognition (swipe, pinch, tap)
+- Cross-platform input abstraction
+- Accessibility for mobile input
+
+---
+
+## Input Abstraction Layer
+
+### Interface Definition
+```csharp
+public interface IGameInput
+{
+    Vector2 Movement { get; }
+    Vector2 Aim { get; }
+    bool JumpPressed { get; }
+    bool ActionPressed { get; }
+    
+    event Action OnJump;
+    event Action OnAction;
+    event Action<Vector2> OnTap;
+    event Action<SwipeDirection> OnSwipe;
+}
+
+public enum SwipeDirection { Up, Down, Left, Right }
+```
+
+### Mobile Implementation
+```csharp
+public class MobileInput : MonoBehaviour, IGameInput
+{
+    [SerializeField] private Joystick _moveJoystick;
+    [SerializeField] private Joystick _aimJoystick;
+    [SerializeField] private Button _jumpButton;
+    
+    public Vector2 Movement => _moveJoystick.Direction;
+    public Vector2 Aim => _aimJoystick.Direction;
+    public bool JumpPressed { get; private set; }
+    public bool ActionPressed { get; private set; }
+    
+    public event Action OnJump;
+    public event Action OnAction;
+    public event Action<Vector2> OnTap;
+    public event Action<SwipeDirection> OnSwipe;
+    
+    void Awake()
+    {
+        _jumpButton.onClick.AddListener(() => OnJump?.Invoke());
+    }
+}
+```
+
+### Desktop Fallback
+```csharp
+public class DesktopInput : MonoBehaviour, IGameInput
+{
+    public Vector2 Movement => new(
+        Input.GetAxisRaw("Horizontal"),
+        Input.GetAxisRaw("Vertical")
+    );
+    
+    public Vector2 Aim => (Input.mousePosition - 
+        new Vector3(Screen.width/2, Screen.height/2)).normalized;
+    
+    public bool JumpPressed => Input.GetKeyDown(KeyCode.Space);
+    public bool ActionPressed => Input.GetMouseButtonDown(0);
+    
+    public event Action OnJump;
+    public event Action OnAction;
+    public event Action<Vector2> OnTap;
+    public event Action<SwipeDirection> OnSwipe;
+    
+    void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.Space)) OnJump?.Invoke();
+        if (Input.GetMouseButtonDown(0)) OnTap?.Invoke(Input.mousePosition);
+    }
+}
+```
+
+---
+
+## Gesture Recognition
+
+### Tap Detection
+```csharp
+// Single tap, double tap, long press
+public class TapDetector : MonoBehaviour
+{
+    [SerializeField] private float _doubleTapTime = 0.3f;
+    [SerializeField] private float _longPressTime = 0.5f;
+    
+    private float _lastTapTime;
+    private float _touchStartTime;
+    
+    public event Action<Vector2> OnTap;
+    public event Action<Vector2> OnDoubleTap;
+    public event Action<Vector2> OnLongPress;
+    
+    void Update()
+    {
+        if (Input.touchCount == 0) return;
+        Touch touch = Input.GetTouch(0);
+        
+        switch (touch.phase)
+        {
+            case TouchPhase.Began:
+                _touchStartTime = Time.time;
+                break;
+                
+            case TouchPhase.Stationary:
+                if (Time.time - _touchStartTime > _longPressTime)
+                {
+                    OnLongPress?.Invoke(touch.position);
+                    _touchStartTime = float.MaxValue; // Prevent re-trigger
+                }
+                break;
+                
+            case TouchPhase.Ended:
+                if (Time.time - _touchStartTime < _longPressTime)
+                {
+                    if (Time.time - _lastTapTime < _doubleTapTime)
+                        OnDoubleTap?.Invoke(touch.position);
+                    else
+                        OnTap?.Invoke(touch.position);
+                    
+                    _lastTapTime = Time.time;
+                }
+                break;
+        }
+    }
+}
+```
+
+### Swipe Detection
+```csharp
+public class SwipeDetector : MonoBehaviour
+{
+    [SerializeField] private float _minSwipeDistance = 50f;
+    [SerializeField] private float _maxSwipeTime = 0.5f;
+    
+    private Vector2 _startPos;
+    private float _startTime;
+    
+    public event Action<SwipeDirection, float> OnSwipe;
+    
+    void Update()
+    {
+        if (Input.touchCount == 0) return;
+        Touch touch = Input.GetTouch(0);
+        
+        switch (touch.phase)
+        {
+            case TouchPhase.Began:
+                _startPos = touch.position;
+                _startTime = Time.time;
+                break;
+                
+            case TouchPhase.Ended:
+                if (Time.time - _startTime > _maxSwipeTime) return;
+                
+                Vector2 delta = touch.position - _startPos;
+                if (delta.magnitude < _minSwipeDistance) return;
+                
+                SwipeDirection dir;
+                float velocity = delta.magnitude / (Time.time - _startTime);
+                
+                if (Mathf.Abs(delta.x) > Mathf.Abs(delta.y))
+                    dir = delta.x > 0 ? SwipeDirection.Right : SwipeDirection.Left;
+                else
+                    dir = delta.y > 0 ? SwipeDirection.Up : SwipeDirection.Down;
+                
+                OnSwipe?.Invoke(dir, velocity);
+                break;
+        }
+    }
+}
+```
+
+### Pinch (Zoom)
+```csharp
+public class PinchDetector : MonoBehaviour
+{
+    public event Action<float> OnPinch; // scale factor
+    
+    private float _initialDistance;
+    
+    void Update()
+    {
+        if (Input.touchCount != 2) return;
+        
+        Touch t0 = Input.GetTouch(0);
+        Touch t1 = Input.GetTouch(1);
+        
+        if (t0.phase == TouchPhase.Began || t1.phase == TouchPhase.Began)
+        {
+            _initialDistance = Vector2.Distance(t0.position, t1.position);
+        }
+        else if (t0.phase == TouchPhase.Moved || t1.phase == TouchPhase.Moved)
+        {
+            float currentDistance = Vector2.Distance(t0.position, t1.position);
+            float scale = currentDistance / _initialDistance;
+            OnPinch?.Invoke(scale);
+        }
+    }
+}
+```
+
+---
+
+## Virtual Joystick
+
+```csharp
+public class VirtualJoystick : MonoBehaviour, 
+    IPointerDownHandler, IDragHandler, IPointerUpHandler
+{
+    [SerializeField] private RectTransform _background;
+    [SerializeField] private RectTransform _handle;
+    [SerializeField] private float _handleRange = 50f;
+    [SerializeField] private float _deadZone = 0.15f;
+    
+    private Vector2 _input;
+    private Canvas _canvas;
+    
+    public Vector2 Direction => _input.magnitude > _deadZone ? _input : Vector2.zero;
+    
+    void Awake() => _canvas = GetComponentInParent<Canvas>();
+    
+    public void OnPointerDown(PointerEventData eventData)
+    {
+        OnDrag(eventData);
+    }
+    
+    public void OnDrag(PointerEventData eventData)
+    {
+        RectTransformUtility.ScreenPointToLocalPointInRectangle(
+            _background, eventData.position, 
+            _canvas.renderMode == RenderMode.ScreenSpaceOverlay ? null : _canvas.worldCamera,
+            out Vector2 localPos
+        );
+        
+        _input = Vector2.ClampMagnitude(localPos / _handleRange, 1f);
+        _handle.anchoredPosition = _input * _handleRange;
+    }
+    
+    public void OnPointerUp(PointerEventData eventData)
+    {
+        _input = Vector2.zero;
+        _handle.anchoredPosition = Vector2.zero;
+    }
+}
+```
+
+---
+
+## Accessibility Considerations
+
+| Guideline | Implementation |
+|-----------|----------------|
+| **Touch Target Size** | Min 48x48 dp (hardware pixels) |
+| **One-Hand Mode** | Optional UI repositioning |
+| **Haptic Feedback** | `Handheld.Vibrate()` on key actions |
+| **Customizable Controls** | Save joystick positions |
+| **Gesture Alternatives** | Buttons for all gestures |
+
+```csharp
+// Haptic feedback
+public static class HapticFeedback
+{
+    public static void Light()
+    {
+        #if UNITY_IOS
+        // iOS-specific haptic
+        #elif UNITY_ANDROID
+        Handheld.Vibrate();
+        #endif
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Tiny touch targets | Min 48dp touch areas |
+| Gesture-only controls | Provide button alternatives |
+| Fixed joystick position | Allow customization |
+| No haptic feedback | Add for key actions |
+| Ignore screen notches | Use safe area |
+
+---
+
+## Safe Area Handling
+
+```csharp
+public class SafeAreaHandler : MonoBehaviour
+{
+    private RectTransform _panel;
+    
+    void Awake()
+    {
+        _panel = GetComponent<RectTransform>();
+        ApplySafeArea();
+    }
+    
+    void ApplySafeArea()
+    {
+        Rect safeArea = Screen.safeArea;
+        
+        Vector2 anchorMin = safeArea.position;
+        Vector2 anchorMax = safeArea.position + safeArea.size;
+        
+        anchorMin.x /= Screen.width;
+        anchorMin.y /= Screen.height;
+        anchorMax.x /= Screen.width;
+        anchorMax.y /= Screen.height;
+        
+        _panel.anchorMin = anchorMin;
+        _panel.anchorMax = anchorMax;
+    }
+}
+```
+
+---
+
+> **Remember:** Test on real devices. Emulators don't have thumbs.

package/.agent/skills/game-development/monetization-strategy/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: monetization-strategy
+description: Expertise in game monetization models, IAP, Ads, and economy design.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# 💰 Monetization Strategy
+
+> **Purpose:** Design and implement sustainable revenue models for games.
+
+---
+
+## 1. Monetization Models
+
+| Model | Description | Best For |
+|-------|-------------|----------|
+| **F2P (Free-to-Play)** | Free access + IAP/Ads | Hypercasual, Mobile RPG, Multiplayer |
+| **Premium** | One-time purchase | Narrative games, PC/Console indies |
+| **Hybrid** | F2P + Subscription (Battle Pass) | Live service games |
+| **P2E (Play-to-Earn)** | Blockchain/Crypto based | Web3 games (Niche) |
+
+---
+
+## 2. In-App Purchases (IAP) Design
+
+### Types of Goods
+1.  **Consumables:** Currencies (Gold, Gems), Energy, Health potions.
+2.  **Non-Consumables:** Remove Ads, Level packs, Cosmetic skins.
+3.  **Subscriptions:** Battle Pass, VIP Status (Daily gems).
+
+### Implementation Pattern (Unity/Godot)
+- **StoreKit (iOS) / Google Play Billing (Android)**
+- **Wrapper:** Use Unity IAP or Godot's Payment plugins.
+- **Validation:** ALWAYS validate receipts on server-side (prevent hacks).
+
+```csharp
+// Unity IAP Example Pattern
+public void OnPurchaseComplete(Product product) {
+    if (ValidateReceipt(product.receipt)) {
+        UnlockContent(product.definition.id);
+    }
+}
+```
+
+---
+
+## 3. Advertising Strategy
+
+### Ad Formats
+1.  **Rewarded Video:** User watches ad → Gets reward (Best UX, High eCPM).
+2.  **Interstitial:** Full screen between levels (High churn risk if overused).
+3.  **Banner:** Static bottom bar (Low revenue, visual noise).
+
+### Best Practices
+- **Frequency Capping:** Limit ads to avoid rage-quitting (e.g., max 1 interstitial / 3 mins).
+- **Placement:** "Double Rewards" button at level end is highly effective.
+- **Mediation:** Use AdMob/AppLovin/IronSource mediation to maximize fill rate.
+
+---
+
+## 4. Game Economy Design
+
+### The Core Loop Interaction
+The economy must act as a distinct layer over the core gameplay loop.
+
+```
+Gameplay → Earn Currency → Upgrade/Buy → Better Gameplay
+```
+
+### Sinks & Faucets
+- **Faucet (Inflow):** Daily rewards, Level clear rewards, IAP.
+- **Sink (Outflow):** Upgrades, Consumables, Cosmetics.
+- **Balance:** Faucets must slightly outweigh Sinks initially, then tighten to encourage IAP.
+
+---
+
+## 5. Compliance & Ethics
+
+- **Disclosure:** Clearly mark ads and IAP.
+- **Drop Rates:** Must disclose gacha/lootbox probabilities (Legal requirement in many regions).
+- **Dark Patterns:** Avoid accidental purchases or misleading "x" buttons.
+
+---
+
+## Usage Example
+
+**User:** "How should I monetize my mobile puzzle game?"
+
+**Agent Response:**
+"For a puzzle game, a **Hybrid F2P** model is best:
+1.  **Core:** Free to play levels.
+2.  **Ads:** Rewarded Video for 'Extra Moves' or 'Hints'.
+3.  **IAP:** 'Remove Ads' pack and 'Coin Bundles' for power-ups.
+4.  **Strategy:** Do NOT use interstitials until level 10 to ensure retention."