com.amanotes.magictilescore 0.4.2

package/Docs/Widget2D-System-Guide.md

@@ -0,0 +1,450 @@
+# Widget2D System Guide
+
+## 🎯 System Overview
+
+Widget2D provides a responsive UI layout system for Unity with automatic component resizing, screen adaptation, and flexible transformation pipelines. Core to rhythm games requiring precise positioning and scaling across different screen sizes.
+
+## 🏗️ Core Architecture
+
+### Widget2D (Base Component)
+```csharp
+public partial class Widget2D : MonoBehaviour
+```
+- **Component target system** with automatic size application to `RectTransform`, `SpriteRenderer`, `BoxCollider2D`, `TextMeshPro`
+- **Listener notification** via `ISizeListener` interface for custom resize handling
+- **Visual debugging** with configurable gizmos and editor tools
+- **Partial class design** separating size management, component handling, and listener systems
+
+### Screen2D (Screen Adaptation)
+```csharp
+public class Screen2D : Widget2D
+```
+**Responsive Features:**
+- `fitWidthToHeight` (0-1) - Blend between fit-width and fit-height scaling
+- **Runtime screen change detection** with automatic size updates
+- **Original size preservation** for consistent scaling ratios
+- **Aspect ratio calculation** maintaining visual consistency
+
+### WidgetTransform (Layout System)
+```csharp
+public partial class WidgetTransform : MonoBehaviour, ISizeListener
+```
+**Transform Pipeline:**
+1. **SizeHandler** - Source-relative sizing with ratio/delta controls
+2. **ScaleHandler** - Transform scaling with fit/fill modes
+3. **AlignHandler** - Position alignment with offset and self-align
+
+## 🎮 Component Handler System
+
+### WidgetHandler (Type Registry)
+```csharp
+public partial class WidgetHandler
+```
+**Supported Components:**
+- `RectTransform` - `sizeDelta` property control
+- `SpriteRenderer` - Direct size manipulation via `SetSize()`
+- `BoxCollider2D/BoxCollider` - Scale-aware size calculation and application
+- `TextMeshPro/TextMeshProUGUI` - RectTransform-based sizing
+
+**Extensible Design:**
+```csharp
+WidgetHandler.RegisterHandler<YourComponent>(
+    (component, size) => {
+        // Custom size application logic
+        component.customProperty = size;
+    }
+);
+```
+
+## 🎵 MT3 Tile System Integration
+
+### TileContext - The Data Bridge
+
+`TileContext` serves as the central data hub connecting rhythm game logic with visual tile representation:
+
+```csharp
+public sealed class TileContext
+{
+    public readonly int index;           // Tile sequence number
+    public readonly SongNote note;       // Musical note data
+    public readonly RhythmContext context;  // Game state reference
+    
+    // Runtime State
+    public float progress = 0f;          // Hold tile progress (0-1)
+    public float accuracy = -1;          // Touch accuracy score
+    public TileStatus Status { get; set; } // None, Touching, End, Missed
+    
+    // Visual Integration
+    public RhythmTile view { get; private set; }    // Attached tile visual
+    public Transform viewTrans { get; private set; } // Transform cache
+}
+```
+
+**Key Features:**
+- **Immutable Core**: `index`, `note`, and `context` are readonly for data integrity
+- **Status Management**: Automatic listener notification on status changes
+- **View Lifecycle**: Handles attachment/detachment of visual components
+- **Progress Tracking**: Real-time progress calculation using `context.GetDistanceAtTime()`
+
+**Status Flow:**
+```
+None → Touching → End
+  ↓      ↓        ↓
+Missed ← → (status change triggers RefreshTileStatus())
+```
+
+### MT3Tile2 - Modular Base Implementation
+
+**Partial Class Architecture:**
+```csharp
+// Size Management Partial
+partial class MT3Tile2
+{
+    public Widget2D widget;
+    protected virtual void RefreshTileSize()
+    {
+        if (tileContext == null || widget == null) return;
+        var screen = context.game.GetComponent<Screen2D>();
+        widget.width = 1f / context.nLanes * screen.width;
+    }
+}
+
+// Touch Handling Partial  
+partial class MT3Tile2: IPointerDownHandler, IPointerMoveHandler, IPointerUpHandler
+{
+    public void OnPointerDown(PointerEventData eventData) { /* Touch logic */ }
+    public void OnPointerMove(PointerEventData eventData) { /* Move tracking */ }
+    public void OnPointerUp(PointerEventData eventData) { /* Release handling */ }
+}
+
+// Core Rhythm Behavior
+public partial class MT3Tile2 : RhythmBehaviour
+{
+    public virtual void OnAttach(TileContext tile)
+    {
+        AttachTileData();      // Calculate size and position
+        RefreshTileStatus();   // Update visual state
+        RefreshTileSize();     // Apply screen adaptation
+    }
+}
+```
+
+### Screen Adaptation Flow
+
+**1. Screen2D Detection:**
+```csharp
+// Screen2D automatically detects screen changes
+private void Update()
+{
+    var currentSize = GetCurrentScreenSize();
+    if (Vector2.Distance(currentSize, _lastScreenSize) > 1f)
+    {
+        _lastScreenSize = currentSize;
+        UpdateScreenSize(); // Triggers cascade update
+    }
+}
+```
+
+**2. Tile Width Calculation:**
+```csharp
+// MT3Tile2 receives screen-relative width
+protected virtual void RefreshTileSize()
+{
+    var screen = context.game.GetComponent<Screen2D>();
+    widget.width = 1f / context.nLanes * screen.width;  // Equal lane distribution
+}
+```
+
+**3. Automatic Component Updates:**
+```csharp
+// Widget2D automatically applies to all target components
+public void Refresh()
+{
+    ApplySizeToComponents();  // Updates SpriteRenderer, Colliders, etc.
+    NotifyListeners();        // Triggers ISizeListener callbacks
+}
+```
+
+## 🔧 TileAnchor System - Smart Positioning
+
+### Real-World Example from TileLong
+
+`TileAnchor` provides dynamic positioning for tile elements based on calculated tile dimensions:
+
+```csharp
+public class TileAnchor : MonoBehaviour
+{
+    [SerializeField] internal MT3Tile2 tile;
+    [SerializeField] [Range(0f, 1f)] private float slideMultiplier;   // Position along slide length
+    [SerializeField] [Range(-1f, 1f)] private float shortMultiplier;  // Offset from short tile height
+    
+    public void Refresh()
+    {
+        if (tile == null) return;
+        var tileData = tile.tileData;
+        if (tileData == null) return;
+        
+        var slideLength = tileData.slideLength;      // Calculated slide distance
+        var shortLength = tile.config.shortTileHeight; // Base tile height
+        var length = shortLength * shortMultiplier + slideLength * slideMultiplier;
+        transform.localPosition = new Vector3(0, length, 0);
+    }
+}
+```
+
+### TileLong Integration Example
+
+In the `TileLong` prefab hierarchy:
+
+```
+Tile-Long (Root)
+├── Widget2D (Screen adaptation)
+├── TileLong (Behavior script)
+├── Bottom (Container)
+│   ├── bg (SpriteRenderer - Background)
+│   ├── fill (SpriteRenderer - Progress fill)
+│   └── miss (SpriteRenderer - Miss state)
+├── arrow (SwipeArrow with TileAnchor)
+│   └── TileAnchor: slideMultiplier = 1.0, shortMultiplier = 0.0
+├── Index (Debug text with TileAnchor)
+│   └── TileAnchor: slideMultiplier = 1.0, shortMultiplier = 0.65
+└── Info (Additional UI with TileAnchor)
+    └── TileAnchor: slideMultiplier = 0.0, shortMultiplier = -0.5
+```
+
+**Usage Patterns:**
+
+1. **Arrow Positioning** (`slideMultiplier = 1.0`):
+   - Positions at the end of the slide area
+   - Perfect for swipe direction indicators
+   - Auto-adjusts when tile length changes
+
+2. **Debug Text** (`slideMultiplier = 1.0, shortMultiplier = 0.65`):
+   - Positions at slide end + 65% of short tile height
+   - Provides consistent spacing above the tile
+   - Useful for tile index display
+
+3. **Info Elements** (`slideMultiplier = 0.0, shortMultiplier = -0.5`):
+   - Positions at slide start - 50% of short tile height
+   - Creates space below the tile
+   - Good for additional UI elements
+
+### TileLong OnAttach Integration
+
+```csharp
+public override void OnAttach(TileContext tile)
+{
+    base.OnAttach(tile);
+    
+    // Set Widget2D height to calculated total length
+    widget.height = tileData.totalLength;
+    
+    // Refresh all anchors with new tile data
+    for (var i = 0; i < anchors.Count; i++)
+    {
+        anchors[i].tile = this;    // Provide tile reference
+        anchors[i].Refresh();      // Calculate new positions
+    }
+}
+```
+
+## 🎮 Handler System Details
+
+### SizeHandler (Proportional Sizing)
+```csharp
+[Serializable] public class SizeHandler
+{
+    public AxisFilter axis = AxisFilter.None;
+    [Range(0f, 2f)] public float percentX = 1f;
+    [Range(0f, 2f)] public float percentY = 1f;
+    public bool keepRatio = false;
+    public Vector2 delta = Vector2.zero;
+}
+```
+**Features:**
+- **Percentage-based sizing** - Relative to source widget dimensions
+- **Ratio preservation** - Maintains aspect ratio when enabled
+- **Delta adjustments** - Fixed pixel offsets for fine-tuning
+- **Axis filtering** - Apply to X, Y, or both axes independently
+
+**Calculation Logic:**
+```csharp
+var newSize = inputSize;
+if (axis.HasFlag(AxisFilter.X)) newSize.x = inputSize.x * percentX + delta.x;
+if (axis.HasFlag(AxisFilter.Y)) newSize.y = inputSize.y * percentY + delta.y;
+
+if (keepRatio && axis == AxisFilter.Both)
+{
+    var ratio = Mathf.Min(newSize.x / originalSize.x, newSize.y / originalSize.y);
+    newSize = originalSize * ratio;
+}
+```
+
+### ScaleHandler (Transform Scaling)
+```csharp
+[Serializable] public class ScaleHandler  
+{
+    public AxisFilter axis = AxisFilter.None;
+    [Range(0f, 5f)] public float scaleX = 1f;
+    [Range(0f, 5f)] public float scaleY = 1f;
+    [Range(0f, 1f)] public float fitParameter = 0f;
+}
+```
+**Features:**
+- **Independent scaling** - Separate X/Y axis control
+- **Ratio preservation** - Uniform scaling with fit/fill blend
+- `fitParameter` (0-1) - Fit (show all) to Fill (cover all) interpolation
+
+**Fit/Fill Logic:**
+```csharp
+var fitScale = Mathf.Min(scaledRatioX, scaledRatioY);    // Fit: shows all content
+var fillScale = Mathf.Max(scaledRatioX, scaledRatioY);   // Fill: fills entire area
+var finalScale = Mathf.Lerp(fitScale, fillScale, fitParameter);
+```
+
+### AlignHandler (Position Control)
+```csharp
+[Serializable] public class AlignHandler
+{
+    public AxisFilter axis = AxisFilter.None;
+    [Range(-1f, 2f)] public float alignX = 0.5f;
+    [Range(-1f, 2f)] public float alignY = 0.5f;
+    public Vector2 offset = Vector2.zero;
+    public Vector2 selfAlign = Vector2.zero;
+}
+```
+**Features:**
+- `alignX/Y` (-1 to 2) - **Extended range** for positioning beyond source bounds
+  - `0.0` = Left/Bottom edge
+  - `0.5` = Center (default)
+  - `1.0` = Right/Top edge  
+  - `< 0` = Outside left/bottom
+  - `> 1` = Outside right/top
+- `offset` - Fixed world-space position adjustment
+- `selfAlign` - Self-centering offset based on own size
+- **Pivot-aware positioning** - Respects source widget pivot settings
+
+**Position Calculation:**
+```csharp
+var inputOffset = inputWidget.size;
+inputOffset.Scale(inputWidget.pivot);  // NEW: Pivot consideration
+
+var alignOffsetX = inputSize.x * (alignX - 0.5f);
+var selfAlignOffsetX = outputSize.x * selfAlign.x * 0.5f;
+newPos.x = inputPos.x + alignOffsetX + offset.x + selfAlignOffsetX;
+```
+
+## 🎵 Real-World Usage Examples
+
+### Screen Adaptation (MT3Game)
+```csharp
+// Main screen with 10.8x19.2 design size
+Screen2D screen = GetComponent<Screen2D>();
+screen.fitWidthToHeight = 1f; // Full height fitting
+// Automatically adapts to device screen ratios
+```
+**Use Case:** Main game area that scales consistently across iPhone/iPad/Android devices
+
+### Perfect Area Positioning
+```csharp
+// PerfectArea: 10.8x4.8 widget positioned at 25% screen height
+WidgetTransform perfectArea;
+perfectArea.source = gameScreen;        // Reference to main screen
+perfectArea.scale.axis = AxisFilter.Y;
+perfectArea.scale.scaleY = 0.25f;       // 25% of screen height
+perfectArea.align.axis = AxisFilter.Y;
+perfectArea.align.alignY = 0.25f;       // Position at 25% from bottom
+```
+**Use Case:** Hit detection area that maintains consistent size relative to screen
+
+### Responsive UI Elements
+```csharp
+// Tile-Start: 2.7x4.8 with ratio-preserved scaling
+WidgetTransform tileStart;
+tileStart.source = gameScreen;
+tileStart.size.keepRatio = true;        // Preserve aspect ratio
+tileStart.size.percentX = 0.25f;        // 25% of screen width
+```
+**Use Case:** UI elements that scale proportionally while maintaining visual consistency
+
+### Dynamic Tile Sizing
+```csharp
+// TileLong: Dynamic height based on note duration
+public override void OnAttach(TileContext tile)
+{
+    base.OnAttach(tile);
+    widget.height = tileData.totalLength;  // Calculated from note duration
+    
+    // Update all anchor positions
+    for (var i = 0; i < anchors.Count; i++)
+    {
+        anchors[i].tile = this;
+        anchors[i].Refresh();
+    }
+}
+```
+**Use Case:** Hold tiles that adapt length based on musical note duration
+
+## 🚀 Implementation Best Practices
+
+### 1. Component Setup
+```csharp
+// Add Widget2D to any GameObject requiring responsive sizing
+var widget = gameObject.AddComponent<Widget2D>();
+
+// Screen2D for main game areas
+var screen = gameObject.AddComponent<Screen2D>();
+screen.fitWidthToHeight = 1f;  // Adjust based on design requirements
+```
+
+### 2. Hierarchical Layouts
+```csharp
+// Parent-child responsive relationships
+var parentWidget = parent.GetComponent<Widget2D>();
+var childTransform = child.AddComponent<WidgetTransform>();
+childTransform.source = parentWidget;
+childTransform.size.percentX = 0.5f;    // 50% of parent width
+childTransform.align.alignX = 0.5f;     // Center horizontally
+```
+
+### 3. Custom Component Support
+```csharp
+// Extend WidgetHandler for new component types
+WidgetHandler.RegisterHandler<YourCustomComponent>(
+    (component, size) => {
+        // Apply size to your custom component
+        component.customWidth = size.x;
+        component.customHeight = size.y;
+        component.RefreshLayout();
+    }
+);
+```
+
+### 4. Editor Integration
+```csharp
+#if UNITY_EDITOR
+private void OnValidate()
+{
+    // Auto-refresh in editor for immediate feedback
+    EditorApplication.delayCall += Refresh;
+}
+
+private void OnDrawGizmosSelected()
+{
+    // Visual debugging in scene view
+    if (widget != null) widget.DrawGizmosSelected();
+}
+#endif
+```
+
+## 🎯 Key Benefits
+
+1. **Zero Boilerplate**: Tiles adapt to screen size without manual calculations
+2. **Consistent Scaling**: All components scale together via single Widget2D
+3. **Designer Friendly**: Visual setup in prefabs, minimal code changes
+4. **Runtime Adaptive**: Handles device rotation and screen changes automatically  
+5. **Extensible**: Easy to add new tile types or components
+6. **Data-Driven**: TileContext bridges game logic with visual representation
+7. **Modular Architecture**: Partial classes separate concerns cleanly
+
+This architecture demonstrates excellent separation of concerns, where **data drives behavior**, **Widget2D handles presentation**, and **minimal inheritance provides maximum reusability**. The system achieves complex screen adaptation through declarative configuration rather than imperative code.

package/Docs/Widget2D-System-Guide.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3744a84ff158e4567875f5349784d773
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Docs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 819279cca79214a42b679c21b30b821b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/AdjustHueEditor.cs

@@ -0,0 +1,90 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Amanotes.MagicTilesCore
+{
+    [CustomEditor(typeof(AdjustHue))]
+    public class AdjustHueEditor : Editor
+    {
+        private AdjustHue adjustHue;
+        
+        private void OnEnable()
+        {
+            adjustHue = (AdjustHue)target;
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            
+            // Draw default inspector
+            DrawDefaultInspector();
+            
+            EditorGUILayout.Space();
+            
+            // Draw preset color rectangles
+            EditorGUILayout.LabelField("Quick Hue Presets (Click to Apply)", EditorStyles.boldLabel);
+            
+            var presets = adjustHue.GetPresets();
+            const float colorRectSize = 30f;
+            const float spacing = 5f;
+            
+            EditorGUILayout.BeginHorizontal();
+            
+            for (int i = 0; i < presets.Length; i++)
+            {
+                var presetHue = presets[i];
+                // Convert hue (0-255) to HSV with S=100%, V=100%
+                float hue01 = presetHue / 255f;
+                var presetColor = Color.HSVToRGB(hue01, 1f, 1f);
+                
+                // Create a rect for the color button
+                var rect = GUILayoutUtility.GetRect(colorRectSize, colorRectSize, GUILayout.Width(colorRectSize), GUILayout.Height(colorRectSize));
+                
+                // Draw the color rectangle
+                EditorGUI.DrawRect(rect, presetColor);
+                
+                // Handle click
+                if (Event.current.type == EventType.MouseDown && rect.Contains(Event.current.mousePosition))
+                {
+                    adjustHue.SetHue(presetHue);
+                    EditorUtility.SetDirty(adjustHue);
+                    Event.current.Use();
+                }
+                
+                // Add spacing between rectangles
+                if (i < presets.Length - 1)
+                {
+                    GUILayout.Space(spacing);
+                }
+            }
+            
+            EditorGUILayout.EndHorizontal();
+            
+            // Show hue values under the rectangles
+            EditorGUILayout.BeginHorizontal();
+            for (int i = 0; i < presets.Length; i++)
+            {
+                var labelRect = GUILayoutUtility.GetRect(colorRectSize, 16f, GUILayout.Width(colorRectSize));
+                EditorGUI.LabelField(labelRect, presets[i].ToString(), EditorStyles.centeredGreyMiniLabel);
+                
+                if (i < presets.Length - 1)
+                {
+                    GUILayout.Space(spacing);
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            EditorGUILayout.Space();
+            
+            // Refresh button
+            if (GUILayout.Button("Refresh Component List"))
+            {
+                adjustHue.RefreshComponentList();
+                EditorUtility.SetDirty(adjustHue);
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

package/Editor/AdjustHueEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 141bb8056d5294c7a875836761b91ed7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: