Rhythm components

Assets/Integration/DebugPrototypeController.cs

@@ -0,0 +1,102 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
+
+/** <summary>
+ * Prototype debug panel. Wires sliders and a restart button at runtime;
+ * also forces 1920×1080 fullscreen on launch and locks the main camera's
+ * viewport to a 16:9 aspect ratio.
+ * </summary>
+ */
+public class DebugPrototypeController : MonoBehaviour
+{
+    #region Inspector Fields — Scriptable Objects
+
+    [Header("Scriptable Objects")]
+    [Tooltip("Controls note appearance timing (note appearance beats slider).")]
+    [SerializeField] private RhythmVisualConfig _rhythmVisualConfig;
+
+    #endregion
+
+    #region Inspector Fields — Note Appearance Beats
+
+    [Header("Note Appearance Beats")]
+    [Tooltip("Slider that sets RhythmVisualConfig.NoteAppearanceBeats. " +
+             "Higher value = notes appear further ahead = more reaction time.")]
+    [SerializeField] private Slider _noteBeatsSlider;
+    [Tooltip("Optional label displaying the current beats value.")]
+    [SerializeField] private TMP_Text _noteBeatsLabel;
+    [Tooltip("Minimum note appearance beats.")]
+    [SerializeField] private float _noteBeatsMin = 0.5f;
+    [Tooltip("Maximum note appearance beats.")]
+    [SerializeField] private float _noteBeatsMax = 6f;
+
+    #endregion
+
+    #region Inspector Fields — Controls
+
+    [Header("Controls")]
+    [Tooltip("Reloads the scene at the specified build index.")]
+    [SerializeField] private Button _restartButton;
+    [Tooltip("Build index of the scene to load on restart.")]
+    [SerializeField] private int _gameSceneIndex;
+
+    #endregion
+
+    #region Lifecycle
+
+    private void Awake()
+    {
+        Screen.SetResolution(1920, 1080, FullScreenMode.FullScreenWindow);
+        SetupNoteBeatsSlider();
+        SetupRestartButton();
+    }
+
+    #endregion
+
+    #region Setup
+
+    private void SetupNoteBeatsSlider()
+    {
+        if (_noteBeatsSlider == null) return;
+
+        _noteBeatsSlider.minValue = _noteBeatsMin;
+        _noteBeatsSlider.maxValue = _noteBeatsMax;
+        _noteBeatsSlider.value = _rhythmVisualConfig != null ? _rhythmVisualConfig.NoteAppearanceBeats : 2f;
+
+        _noteBeatsSlider.onValueChanged.AddListener(OnNoteBeatsChanged);
+        RefreshNoteBeatsLabel(_noteBeatsSlider.value);
+    }
+
+    private void SetupRestartButton()
+    {
+        if (_restartButton == null) return;
+        _restartButton.onClick.AddListener(OnRestartClicked);
+    }
+
+    #endregion
+
+    #region Callbacks
+
+    private void OnNoteBeatsChanged(float value)
+    {
+        if (_rhythmVisualConfig != null)
+            _rhythmVisualConfig.NoteAppearanceBeats = value;
+
+        RefreshNoteBeatsLabel(value);
+    }
+
+    private void OnRestartClicked()
+    {
+        SceneManager.LoadScene(_gameSceneIndex);
+    }
+
+    private void RefreshNoteBeatsLabel(float value)
+    {
+        if (_noteBeatsLabel != null)
+            _noteBeatsLabel.text = $"Note Speed: {value:F2} beats";
+    }
+
+    #endregion
+}

Assets/Integration/TreeInputRhythmAdapter.cs

@@ -0,0 +1,77 @@
+using System;
+
+/** <summary>
+ * Adapts <see cref="IPlayerInputProvider"/> to <see cref="IRhythmInputProvider"/>
+ * so the existing tree game inputs drive the rhythm system without any new
+ * InputActions or action maps. Each directional action is mapped to a configurable
+ * rhythm lane index that <see cref="TreeRhythmController"/> converts back to a
+ * <see cref="NavigationAction"/> after the beat window check passes.
+ * </summary>
+ */
+public class TreeInputRhythmAdapter : IRhythmInputProvider
+{
+    #region Private Events
+
+    private event Action<int> _onLanePressed;
+    private event Action<int> _onLaneReleased;
+
+    #endregion
+
+    #region IRhythmInputProvider
+
+    /** <inheritdoc /> */
+    event Action<int> IRhythmInputProvider.OnLanePressed
+    {
+        add    => _onLanePressed += value;
+        remove => _onLanePressed -= value;
+    }
+
+    /** <inheritdoc /> */
+    event Action<int> IRhythmInputProvider.OnLaneReleased
+    {
+        add    => _onLaneReleased += value;
+        remove => _onLaneReleased -= value;
+    }
+
+    /** <inheritdoc /> */
+    public void Enable()  => _playerInput.Enable();
+
+    /** <inheritdoc /> */
+    public void Disable() => _playerInput.Disable();
+
+    #endregion
+
+    #region Fields
+
+    private readonly IPlayerInputProvider _playerInput;
+    private readonly int _leftLane;
+    private readonly int _submitLane;
+    private readonly int _rightLane;
+
+    #endregion
+
+    #region Constructor
+
+    /** <summary>
+     * Wires <see cref="IPlayerInputProvider"/> events to lane-indexed rhythm events.
+     * </summary>
+     * <param name="playerInput">The upstream tree game input source.</param>
+     * <param name="leftLane">Lane index emitted when NavLeft is pressed (default 0).</param>
+     * <param name="submitLane">Lane index emitted when Submit is pressed (default 1).</param>
+     * <param name="rightLane">Lane index emitted when NavRight is pressed (default 2).</param>
+     */
+    public TreeInputRhythmAdapter(IPlayerInputProvider playerInput,
+        int leftLane = 0, int submitLane = 1, int rightLane = 2)
+    {
+        _playerInput = playerInput;
+        _leftLane   = leftLane;
+        _submitLane = submitLane;
+        _rightLane  = rightLane;
+
+        _playerInput.OnNavLeft  += () => _onLanePressed?.Invoke(_leftLane);
+        _playerInput.OnNavRight += () => _onLanePressed?.Invoke(_rightLane);
+        _playerInput.OnSubmit   += () => _onLanePressed?.Invoke(_submitLane);
+    }
+
+    #endregion
+}