@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/ui-imgui/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: ui-imgui
+description: Generates and modifies Unity IMGUI editor code such as EditorWindows, custom Inspectors, PropertyDrawers, and OnGUI scripts. Use for IMGUI or OnGUI or maintaining existing IMGUI code.
+---
+
+**Before proceeding:** If the user is asking about creating a **new** editor window, custom inspector, or PropertyDrawer without explicitly mentioning IMGUI/OnGUI, recommend using UI Toolkit (CreateGUI) instead, as it's the modern approach. Only proceed with IMGUI if:
+- User is modifying existing IMGUI code
+- User explicitly requests IMGUI/immediate mode
+- The project exclusively uses IMGUI for editor tools
+
+When activated, read the reference files:
+- [references/templates.md](references/templates.md) — EditorWindow, Inspector, PropertyDrawer templates
+- [references/gui-elements.md](references/gui-elements.md) — GUI elements, layout groups, styling
+
+## When to Use This Skill
+
+**IMPORTANT:** This skill is for **legacy IMGUI code only**. Use this skill when:
+
+- User is maintaining/updating **existing** IMGUI editor code (files with `OnGUI()`, `OnInspectorGUI()`)
+- User **explicitly requests** IMGUI/immediate mode GUI
+- Project exclusively uses IMGUI for all editor tools
+
+**Do NOT use this skill for:**
+- New editor windows (use UI Toolkit with `CreateGUI()` instead)
+- New custom inspectors (use UI Toolkit instead)
+- Requests that don't explicitly mention IMGUI or OnGUI
+
+**Legacy IMGUI is used for:**
+- **Editor windows** — `EditorWindow` classes with `OnGUI()`
+- **Custom inspectors** — `Editor`, `PropertyDrawer` classes with `OnInspectorGUI()`
+- **Debug overlays** — `OnGUI()` in MonoBehaviour (runtime)
+
+IMGUI is **not** for runtime game UI — use UI Toolkit or uGUI instead.
+
+## Scope
+
+**Generate only what is requested (for legacy IMGUI code):**
+
+| Request | Output | Note |
+|---------|--------|------|
+| Editor window (IMGUI/OnGUI) | `EditorWindow` with `OnGUI()` | Only if explicitly IMGUI |
+| Custom inspector (IMGUI) | `Editor` with `OnInspectorGUI()` | Only if explicitly IMGUI |
+| Property drawer (IMGUI) | `PropertyDrawer` with `OnGUI()` | Only if explicitly IMGUI |
+| Debug overlay | `MonoBehaviour` with `OnGUI()` | Runtime debugging |
+| Update existing IMGUI script | Modify existing OnGUI code | Always appropriate |
+
+**Clarify if ambiguous:**
+- "inspector" → Custom Editor for a specific type, or PropertyDrawer? **Also ask:** Should this use UI Toolkit (modern) or IMGUI (legacy)?
+- "editor window" → **First ask:** Should this use UI Toolkit (modern/CreateGUI) or IMGUI (legacy/OnGUI)?
+- "tool window" → EditorWindow with what functionality? Which UI system?
+
+## Conventions
+
+**Follow project patterns first.** Search existing editor scripts before applying defaults.
+
+| Type | Convention | Good | Bad |
+|------|------------|------|-----|
+| Script names | PascalCase | `MyToolWindow.cs` | `my-tool-window.cs` |
+| EditorWindow | `[Name]Window.cs` | `LevelEditorWindow.cs` | `LevelEditor.cs` |
+| Custom Editor | `[Type]Editor.cs` | `EnemyEditor.cs` | `EnemyInspector.cs` |
+| PropertyDrawer | `[Type]Drawer.cs` | `RangeDrawer.cs` | `RangePropertyDrawer.cs` |
+| Location | `Editor` folder | `Assets/Editor/` | `Assets/Scripts/` |
+
+**Editor folder is required** — Scripts using `UnityEditor` namespace must be in an `Editor` folder or they will fail to build.
+
+## Workflow
+
+1. **Analyze** — Determine script type needed (EditorWindow, Editor, PropertyDrawer, etc.)
+2. **Search** — Find existing editor scripts to match patterns
+3. **Follow project patterns** — Match folder structure and naming
+4. **Create script** — Use appropriate base class and attributes
+5. **Implement OnGUI** — Build the interface with layout groups
+
+## Script Structure
+
+### EditorWindow
+```
+[MenuItem attribute] → adds to menu
+ShowWindow() static method → opens window
+OnGUI() → draws interface
+OnEnable/OnDisable → initialization/cleanup
+```
+
+### Custom Editor
+```
+[CustomEditor attribute] → targets component type
+OnInspectorGUI() → draws inspector
+OnEnable() → cache SerializedProperties
+serializedObject.Update/ApplyModifiedProperties → undo support
+```
+
+### PropertyDrawer
+```
+[CustomPropertyDrawer attribute] → targets type or attribute
+OnGUI(Rect, SerializedProperty, GUIContent) → draws property
+GetPropertyHeight() → custom height if needed
+```
+
+## Key Rules
+
+- **Cache GUIStyle objects** — never create new GUIStyle in OnGUI (causes memory allocation every frame)
+- **Use SerializedProperty** — for proper undo/redo support in inspectors
+- **Call ApplyModifiedProperties()** — after any serialized object changes
+- **Use EditorGUILayout** — for editor scripts (auto-layout)
+- **Use GUILayout** — for runtime OnGUI
+- **Begin/End pairs** — always match BeginHorizontal with EndHorizontal, etc.
+- **Editor folder required** — scripts fail to build if not in Editor folder
+
+## Layout Basics
+
+**Horizontal grouping:**
+```csharp
+EditorGUILayout.BeginHorizontal();
+// elements appear side by side
+EditorGUILayout.EndHorizontal();
+```
+
+**Vertical grouping:**
+```csharp
+EditorGUILayout.BeginVertical("box");
+// elements appear stacked, with box style
+EditorGUILayout.EndVertical();
+```
+
+**Scroll view:**
+```csharp
+scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
+// scrollable content
+EditorGUILayout.EndScrollView();
+```
+
+**Foldout section:**
+```csharp
+showSection = EditorGUILayout.Foldout(showSection, "Section Name");
+if (showSection)
+{
+    EditorGUI.indentLevel++;
+    // section content
+    EditorGUI.indentLevel--;
+}
+```
+
+## Common Patterns
+
+**Button with action:**
+```csharp
+if (GUILayout.Button("Do Something"))
+{
+    // action here
+}
+```
+
+**Property field with label:**
+```csharp
+EditorGUILayout.PropertyField(myProperty, new GUIContent("Label"));
+```
+
+**Object reference field:**
+```csharp
+myObject = (MyType)EditorGUILayout.ObjectField("Label", myObject, typeof(MyType), true);
+```
+
+**Disabled group:**
+```csharp
+EditorGUI.BeginDisabledGroup(condition);
+// disabled elements
+EditorGUI.EndDisabledGroup();
+```
+
+## Best Practices
+
+- Use `SerializedObject` and `SerializedProperty` for undo support
+- Cache property references in `OnEnable()`
+- Use `EditorUtility.SetDirty()` only for non-serialized changes
+- Use `Undo.RecordObject()` before modifying objects directly
+- Use `EditorStyles` for consistent appearance
+- Use `GUILayout.FlexibleSpace()` to push elements apart
+
+See `references/templates.md` for complete script templates.
+See `references/gui-elements.md` for full element reference.

package/skills/ui-imgui/references/gui-elements.md

@@ -0,0 +1,156 @@
+# IMGUI Elements and Layout
+
+## Common GUI Elements
+
+| Method | Use Case |
+|--------|----------|
+| `GUILayout.Label()` | Text display |
+| `GUILayout.Button()` | Clickable button |
+| `GUILayout.TextField()` | Text input |
+| `GUILayout.TextArea()` | Multi-line text input |
+| `GUILayout.Toggle()` | Checkbox |
+| `GUILayout.Slider()` | Value slider |
+| `GUILayout.SelectionGrid()` | Button grid selection |
+| `GUILayout.Toolbar()` | Toolbar buttons |
+
+## Editor-Specific Elements
+
+| Method | Use Case |
+|--------|----------|
+| `EditorGUILayout.PropertyField()` | Serialized property (auto) |
+| `EditorGUILayout.ObjectField()` | Object reference |
+| `EditorGUILayout.IntField()` | Integer input |
+| `EditorGUILayout.FloatField()` | Float input |
+| `EditorGUILayout.Vector3Field()` | Vector3 input |
+| `EditorGUILayout.ColorField()` | Color picker |
+| `EditorGUILayout.CurveField()` | Animation curve |
+| `EditorGUILayout.EnumPopup()` | Enum dropdown |
+| `EditorGUILayout.Popup()` | String dropdown |
+| `EditorGUILayout.Foldout()` | Collapsible section |
+| `EditorGUILayout.HelpBox()` | Info/warning/error box |
+
+## Layout Groups
+
+```csharp
+// Horizontal
+GUILayout.BeginHorizontal();
+GUILayout.Button("Left");
+GUILayout.Button("Right");
+GUILayout.EndHorizontal();
+
+// Vertical
+GUILayout.BeginVertical();
+GUILayout.Button("Top");
+GUILayout.Button("Bottom");
+GUILayout.EndVertical();
+
+// Scroll View
+scrollPos = GUILayout.BeginScrollView(scrollPos);
+// ... content
+GUILayout.EndScrollView();
+
+// Area (absolute positioning)
+GUILayout.BeginArea(new Rect(10, 10, 200, 100));
+// ... content
+GUILayout.EndArea();
+```
+
+## Editor Layout Groups
+
+```csharp
+// Foldout section
+showSection = EditorGUILayout.Foldout(showSection, "Section");
+if (showSection)
+{
+    EditorGUI.indentLevel++;
+    // ... content
+    EditorGUI.indentLevel--;
+}
+
+// Horizontal with flex space
+EditorGUILayout.BeginHorizontal();
+GUILayout.Label("Label");
+GUILayout.FlexibleSpace();
+GUILayout.Button("Action");
+EditorGUILayout.EndHorizontal();
+
+// Box group
+EditorGUILayout.BeginVertical("box");
+// ... content
+EditorGUILayout.EndVertical();
+```
+
+## Layout Options
+
+```csharp
+// Fixed width
+GUILayout.Button("Wide", GUILayout.Width(200));
+
+// Fixed height
+GUILayout.Button("Tall", GUILayout.Height(50));
+
+// Min/Max
+GUILayout.Button("Flex", GUILayout.MinWidth(100), GUILayout.MaxWidth(300));
+
+// Expand
+GUILayout.Button("Fill", GUILayout.ExpandWidth(true));
+```
+
+## Styling
+
+```csharp
+// Built-in styles
+GUILayout.Label("Bold", EditorStyles.boldLabel);
+GUILayout.Label("Large", EditorStyles.largeLabel);
+GUILayout.Label("Mini", EditorStyles.miniLabel);
+GUILayout.Label("Centered", EditorStyles.centeredGreyMiniLabel);
+
+// Custom style (cache this, don't create in OnGUI)
+private GUIStyle _headerStyle;
+private GUIStyle HeaderStyle => _headerStyle ??= new GUIStyle(EditorStyles.boldLabel)
+{
+    fontSize = 16,
+    alignment = TextAnchor.MiddleCenter
+};
+```
+
+## Spacing and Separators
+
+```csharp
+// Fixed space
+GUILayout.Space(10);
+
+// Flexible space (pushes elements apart)
+GUILayout.FlexibleSpace();
+
+// Horizontal line
+EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
+
+// Editor separator
+EditorGUILayout.Separator();
+```
+
+## Disabled Groups
+
+```csharp
+EditorGUI.BeginDisabledGroup(someCondition);
+// ... disabled elements
+EditorGUI.EndDisabledGroup();
+
+// Or with using
+using (new EditorGUI.DisabledGroupScope(someCondition))
+{
+    // ... disabled elements
+}
+```
+
+## Change Check
+
+```csharp
+EditorGUI.BeginChangeCheck();
+value = EditorGUILayout.IntField("Value", value);
+if (EditorGUI.EndChangeCheck())
+{
+    // Value changed, do something
+}
+```

package/skills/ui-imgui/references/templates.md

@@ -0,0 +1,141 @@
+# IMGUI Templates
+
+## EditorWindow
+
+```csharp
+using UnityEditor;
+using UnityEngine;
+
+public class MyToolWindow : EditorWindow
+{
+    [MenuItem("Tools/My Tool")]
+    public static void ShowWindow()
+    {
+        GetWindow<MyToolWindow>("My Tool");
+    }
+
+    private void OnGUI()
+    {
+        GUILayout.Label("My Tool", EditorStyles.boldLabel);
+
+        // Your GUI here
+    }
+}
+```
+
+## Custom Inspector
+
+```csharp
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(MyComponent))]
+public class MyComponentEditor : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        DrawDefaultInspector();
+
+        MyComponent component = (MyComponent)target;
+
+        if (GUILayout.Button("Do Something"))
+        {
+            component.DoSomething();
+        }
+    }
+}
+```
+
+## SerializedProperty Pattern (Undo Support)
+
+```csharp
+[CustomEditor(typeof(MyComponent))]
+public class MyComponentEditor : Editor
+{
+    private SerializedProperty myProperty;
+
+    private void OnEnable()
+    {
+        myProperty = serializedObject.FindProperty("myField");
+    }
+
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+
+        EditorGUILayout.PropertyField(myProperty);
+
+        serializedObject.ApplyModifiedProperties();
+    }
+}
+```
+
+## PropertyDrawer
+
+```csharp
+using UnityEditor;
+using UnityEngine;
+
+[CustomPropertyDrawer(typeof(MyData))]
+public class MyDataDrawer : PropertyDrawer
+{
+    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+    {
+        EditorGUI.BeginProperty(position, label, property);
+
+        position = EditorGUI.PrefixLabel(position, label);
+
+        var fieldProp = property.FindPropertyRelative("field");
+        EditorGUI.PropertyField(position, fieldProp, GUIContent.none);
+
+        EditorGUI.EndProperty();
+    }
+}
+```
+
+## ScriptableWizard
+
+```csharp
+using UnityEditor;
+using UnityEngine;
+
+public class MyWizard : ScriptableWizard
+{
+    public string objectName = "New Object";
+    public int count = 1;
+
+    [MenuItem("Tools/My Wizard")]
+    static void CreateWizard()
+    {
+        DisplayWizard<MyWizard>("Create Objects", "Create", "Cancel");
+    }
+
+    void OnWizardCreate()
+    {
+        // Execute when "Create" clicked
+    }
+
+    void OnWizardUpdate()
+    {
+        // Validate input
+        isValid = !string.IsNullOrEmpty(objectName) && count > 0;
+    }
+}
+```
+
+## Debug Overlay (Runtime)
+
+```csharp
+using UnityEngine;
+
+public class DebugOverlay : MonoBehaviour
+{
+    private void OnGUI()
+    {
+        GUILayout.BeginArea(new Rect(10, 10, 200, 100));
+        GUILayout.Label($"FPS: {1f / Time.deltaTime:F1}");
+        GUILayout.Label($"Time: {Time.time:F2}");
+        GUILayout.EndArea();
+    }
+}
+```

package/skills/ui-ugui/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: ui-ugui
+description: Understands, edits, and generates Unity uGUI Canvas hierarchies, RectTransforms, Layout Groups, and prefab UI. Use for requests involving Canvas, uGUI, RectTransform, or prefab UI files.
+---
+
+Understand existing Unity uGUI, make targeted edits, and generate new Canvas-based hierarchies.
+
+When working with ScrollRect/ScrollView, read the reference file:
+- [references/scrollview-setup.md](references/scrollview-setup.md) — Required hierarchy, setup rules, and common failures
+
+## Scope
+
+Determine what the user is asking for:
+
+| Request Type | Action |
+|--------------|--------|
+| Question about UI | **Understand** — analyze hierarchy, explain structure |
+| Change specific element | **Edit** — targeted modification only |
+| Create new UI | **Generate** — create new hierarchy |
+| Fix/improve existing UI | **Edit** — modify existing, don't rebuild |
+
+**Generate only what is requested:**
+
+| Request | Output |
+|---------|--------|
+| UI layout | Prefab or scene hierarchy only |
+| "with code" / "with logic" / "functional" | Hierarchy + scripts |
+
+**These do NOT imply scripts:**
+- "proper buttons" → well-configured Button components
+- "working UI" → valid hierarchy that renders
+- "menu screen" → visual layout only
+
+## Critical Rules
+
+**Namespace disambiguation:**
+- Always use fully qualified type names when creating or referencing UI components
+- `UnityEngine.UI.Image`, not `Image`
+- `UnityEngine.UI.Button`, not `Button`
+- Other namespaces in the project can cause ambiguous type errors
+
+**Verify before modifying:**
+- Always check what exists before making changes
+- Confirm parent objects exist before adding children
+- Verify components are present before modifying properties
+- Never assume hierarchy state — query it first
+
+**Incremental fixes over rebuilds:**
+- When fixing issues, make targeted corrections
+- Never destroy and recreate entire hierarchies to fix problems — destroyed objects cause null reference cascades
+- Prefer identifying the specific broken property and fixing only that over rewriting large sections
+- **When a fix fails, revert the change** before trying an alternative approach
+
+**One change at a time:**
+- Make a single change, then verify the result
+- Do not batch multiple unrelated modifications
+- Be careful not to inadvertently modify or remove adjacent elements when editing a specific one
+- If something fails, understand why before trying alternatives
+- Avoid "shotgun debugging" with multiple simultaneous changes
+
+**Color and visibility:**
+- **Ensure text is readable by default:** When choosing colors, ensure text contrasts with its background — but respect intentional low-contrast uses (disabled states, placeholder text, decorative elements)
+- **Check visibility for new elements:** After creating UI elements, verify they have non-zero size and are within parent bounds. Elements intentionally created hidden (for later toggling, animation, etc.) are fine
+
+**Specification adherence:**
+- **Honor user specifications exactly:** When the user provides pixel dimensions, hex colors, positions, spacing, or other exact values, apply them precisely — do not approximate or substitute
+- **Minimize unrelated changes:** When editing, avoid changing properties the user didn't ask about unless a related adjustment is necessary for the fix to work
+
+## Conventions
+
+**Follow project patterns first.** Search existing files before applying defaults.
+
+| Type | Convention | Good | Bad |
+|------|------------|------|-----|
+| GameObject names | PascalCase | `SubmitButton` | `submit-button` |
+| Prefab paths | Feature folders | `Assets/UI/Inventory/` | `Assets/Prefabs/UI/` |
+
+## Workflow
+
+1. **Verify state** — Check what exists in the scene/hierarchy before any action.
+2. **Analyze** — Determine exactly what's needed. No extras.
+3. **Search** — Find existing prefabs, canvases, assets. Don't assume paths.
+4. **Follow project patterns** — Match folder structure and naming.
+5. **Create or edit** — Build structure with proper anchoring, or make targeted edits.
+6. **Confirm result** — Verify the change worked before moving on.
+
+## Canvas Setup
+
+Every UI needs a Canvas:
+
+```
+Canvas (Screen Space - Overlay or Camera)
+├── CanvasScaler (Scale With Screen Size recommended)
+├── GraphicRaycaster
+└── [UI Content]
+```
+
+**CanvasScaler settings:**
+- Default to UI Scale Mode "Scale With Screen Size" unless the project has a specific reason for "Constant Pixel Size" (e.g., pixel-art, fixed-resolution targets)
+- Reference Resolution: Match project standards (e.g., 1920x1080)
+- When creating a Canvas with Screen Space - Camera, **read the camera's reference resolution** first
+- Match Width Or Height: 0.5 (balanced)
+- If an existing Canvas uses "Constant Pixel Size", flag it and ask the user before changing
+- Prefer anchors and Layout Groups over absolute pixel positions for layout
+
+## Layout and anchoring
+
+Layout Groups, Layout Elements, and RectTransform anchoring: [references/layout-and-anchors.md](references/layout-and-anchors.md).
+## Common Components
+
+| Component | Use Case |
+|-----------|----------|
+| `Image` | Backgrounds, icons |
+| `RawImage` | Render textures, videos |
+| `Text (TMP)` | All text (use TextMeshPro) |
+| `Button` | Clickable elements |
+| `Toggle` | Checkboxes, radio buttons |
+| `Slider` | Value ranges |
+| `ScrollRect` | Scrollable content |
+| `InputField (TMP)` | Text input |
+
+## Best Practices
+
+- Use TextMeshPro for all text (not legacy Text)
+- WorldSpace UI that have text should also use Text Mesh Pro, be sure to review the project and import the TMP essentials if they are not present in the project
+- If the TextMeshPro Essentials were imported be sure to close the TMP Importer Windows and the Import Unity Package Window once the assets are imported
+- Organize hierarchy logically (Header, Content, Footer)
+- Use Layout Groups instead of manual positioning where possible
+- Set Raycast Target = false on non-interactive images
+- Use sprite atlases for performance
+
+**Never use** `EditorApplication.ExecuteMenuItem("Window/TextMeshPro/Import TMP Essential Resources")`, unless the user asks for an interactive TMP Essentials installation. It opens a modal dialog that blocks whatever invoked it until a human dismisses it.
+
+**Do not use** `AssetDatabase.ImportPackage()` for TMP resources, instead `TMP_PackageResourceImporter.ImportResources()` is the canonical non-interactive API.
+
+## Interaction Readiness
+
+Before completing any UI that contains interactive elements, verify:
+
+1. **EventSystem** must exist in the scene (exactly one)
+2. **GraphicRaycaster** must be on the Canvas
+3. **Raycast Target = true** on interactive elements (and false on non-interactive ones to avoid blocking)
+4. **Button.onClick should be wired** (via inspector or script) — only when scripts or logic were requested
+
+If the first three are missing, interactive elements will exist visually but fail silently.
+
+## Understanding
+
+When the user asks questions about existing UI:
+
+**Read the hierarchy first.** Don't assume — always inspect the scene or prefab before answering.
+
+**Analyze structure:**
+- Identify the Canvas and its render mode
+- Map the parent-child relationships
+- Identify which Layout Groups control which children
+- Check RectTransform anchor configurations
+
+**Answer questions about:**
+- "What does this button do?" → Explain component, hierarchy position, event wiring
+- "How is this laid out?" → Describe Layout Groups, anchoring, hierarchy
+- "Why is this invisible?" → Check size, anchors, parent bounds, component state
+- "What controls this element's size?" → Trace Layout Group settings or anchors
+
+## Editing
+
+For targeted changes to existing UI:
+
+**Read before editing.** Always inspect the current state first.
+
+**Edit workflow:**
+1. Verify the target object exists
+2. Identify the specific property or component to change
+3. Make the minimal change required
+4. Verify the result before proceeding
+
+**Never destroy to fix:**
+- Destroying objects cascades to null references elsewhere
+- Fix properties in place rather than recreating
+- If an element must be removed, update all references first
+
+## C# (Only When Requested)
+
+- Use fully qualified UI types to avoid namespace conflicts
+- Use `[SerializeField]` for inspector references
+- Cache component references in Awake()
+- Use events/delegates for button callbacks
+- Place scripts in same folder as prefabs (follow project patterns)
+
+**Component references:**
+- Verify referenced objects exist before accessing them
+- Handle cases where serialized references may be null
+- When wiring up references, confirm the target component is present
+
+## Error Recovery
+
+When something goes wrong:
+
+**Stop and diagnose:**
+- Identify the exact error or symptom
+- Determine the root cause before attempting fixes
+- Do not make speculative changes
+
+**Fix incrementally:**
+- Address one issue at a time
+- Verify each fix before moving to the next
+- Keep track of what was changed
+
+**Avoid destructive patterns:**
+- "Start fresh" strategies destroy working elements along with broken ones
+- Rebuilding entire hierarchies creates more problems than it solves
+- Prefer surgical fixes to wholesale replacements
+
+**When stuck:**
+- Re-verify the current state of the hierarchy
+- Check if previous changes were actually applied
+- Consider if the approach itself is wrong rather than the implementation