From b4948cfb0547b0779804fbe9d1d2efccefbb4566 Mon Sep 17 00:00:00 2001
From: Baron Luca <baron_luca@hotmail.it>
Date: Wed, 19 Aug 2026 18:09:44 +0200
Subject: [PATCH] feat(gameplay): add accessible reactive stage

---
 docs/README.md                                |   1 +
 docs/development/reactive-stage.md            |  21 ++
 .../Gameplay/GameplayHighwayController.cs     |  40 ++-
 .../Runtime/Gameplay/GameplayReactiveStage.cs | 243 ++++++++++++++++++
 .../Gameplay/GameplayReactiveStage.cs.meta    |   2 +
 .../Tests/EditMode/GameplayHighwayTests.cs    |  52 ++++
 .../PlayMode/GameplayHighwayPlayModeTests.cs  |  26 ++
 .../HitTheKit/UI/Gameplay/GameplayHighway.uss |  24 ++
 .../UI/Gameplay/GameplayHighway.uxml          |   2 +
 9 files changed, 410 insertions(+), 1 deletion(-)
 create mode 100644 docs/development/reactive-stage.md
 create mode 100644 src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs
 create mode 100644 src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs.meta

diff --git a/docs/README.md b/docs/README.md
index 6c399dd..694819f 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -50,6 +50,7 @@ without creating an unreviewed second source of truth.
 - [Auto Tempo Coach](development/auto-tempo-coach.md)
 - [Audio and latency sound check](development/audio-latency-sound-check.md)
 - [Ghost Replay](development/ghost-replay.md)
+- [Accessible reactive stage](development/reactive-stage.md)
 - [Demo-song vertical slice](development/demo-song-vertical-slice.md)
 - [Keyboard hit matching](development/keyboard-hit-matching.md)
 - [Pad visuals](development/pad-visuals.md)
diff --git a/docs/development/reactive-stage.md b/docs/development/reactive-stage.md
new file mode 100644
index 0000000..066e5a0
--- /dev/null
+++ b/docs/development/reactive-stage.md
@@ -0,0 +1,21 @@
+# Accessible reactive stage
+
+The gameplay stage reacts to real runtime signals already produced by the hit matcher and score tracker. It does not own timing, scoring, input, or song state.
+
+## Signals
+
+- Combo selects a bounded energy band: calm, building, live, or peak.
+- The latest hit grade provides a short accent.
+- The latest drum pad selects the accent color already used by that lane.
+- Misses and unmatched inputs enter a visible recovery state.
+
+The stage uses text and geometric patterns as well as color. A miss therefore remains distinguishable in high-contrast and color-impaired viewing conditions.
+
+## Motion and intensity safety
+
+- Full visual intensity is capped at `0.78`.
+- `Reduce motion` replaces moving patterns with a steady composition and caps intensity at `0.22`.
+- Pulses last at least `0.18` seconds and the stage never alternates the full screen on/off.
+- `High contrast` increases outlines and preserves the textual stage state.
+
+All visuals are procedural UI Toolkit drawing. No commercial assets, per-frame material creation, telemetry, or additional gameplay systems are introduced.
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayHighwayController.cs b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayHighwayController.cs
index fcea386..3b98c37 100644
--- a/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayHighwayController.cs
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayHighwayController.cs
@@ -61,6 +61,7 @@ public sealed class GameplayHighwayController : MonoBehaviour
         private Label keyGuideSnareHiHatLabel;
         private Label keyGuideFloorKickLabel;
         private Label impactCueLabel;
+        private Label reactiveStageStatusLabel;
         private Button menuButton;
         private Button pauseButton;
         private Button resumeButton;
@@ -120,6 +121,7 @@ public sealed class GameplayHighwayController : MonoBehaviour
         private readonly List<DrumArticulation> chartArticulationChoices = new List<DrumArticulation>();
         private GameplayHighwaySurface surface;
         private GameplayKitSurface kitSurface;
+        private GameplayReactiveStageSurface reactiveStageSurface;
         private bool showInstructionalKit;
         private HitMatchingPrototype subscribedMatching;
         private readonly GameplayScoreTracker scoreTracker = new GameplayScoreTracker();
@@ -140,6 +142,9 @@ public sealed class GameplayHighwayController : MonoBehaviour
         private bool metronomeScheduled;
         private bool metronomeSeekedWhilePaused;
         private bool resultRecorded;
+        private HitGrade? latestStageGrade;
+        private bool latestStageWrongInput;
+        private float stagePulseDeadline;
         private GameplayAutoTempoRecommendation autoTempoRecommendation;
         private bool isChangingTempo;
         private readonly GameplayPracticeLoop practiceLoop = new GameplayPracticeLoop();
@@ -154,6 +159,9 @@ public sealed class GameplayHighwayController : MonoBehaviour
         public GameplayPresentationTheme Theme { get; private set; }
         public GameplayHighwaySurface Surface => surface;
         public GameplayKitSurface KitSurface => kitSurface;
+        public GameplayReactiveStageSurface ReactiveStageSurface => reactiveStageSurface;
+        public GameplayReactiveStageState ReactiveStageState => reactiveStageSurface?.State ??
+            GameplayReactiveStageCalculator.Calculate(0, null, null, 0, false, false, false);
         public bool IsInstructionalKitVisible => showInstructionalKit;
         public Texture2D ActiveBackground => BackgroundFor(Theme);
         public string EnvironmentTitle => GameplayEnvironmentProfile.For(Theme).Title;
@@ -273,6 +281,7 @@ private void SetTheme(GameplayPresentationTheme theme)
             }
 
             surface?.SetTheme(theme);
+            reactiveStageSurface?.SetTheme(theme);
             if (impactCueLabel != null)
                 impactCueLabel.style.top = Length.Percent(environment.StrikeRatio * 100f);
             if (kitSurface != null)
@@ -306,6 +315,7 @@ private void BindView()
             positionLabel = root.Q<Label>("song-position");
             judgmentLabel = root.Q<Label>("judgment-label");
             kitGuidanceLabel = root.Q<Label>("kit-guidance-label");
+            reactiveStageStatusLabel = root.Q<Label>("reactive-stage-status");
             environmentTitleLabel = root.Q<Label>("environment-title");
             environmentSubtitleLabel = root.Q<Label>("environment-subtitle");
             currentInputLabel = root.Q<Label>("current-input");
@@ -381,10 +391,12 @@ private void BindView()
             if (keyGuideFloorKickLabel != null) keyGuideFloorKickLabel.text = $"{preferences.FloorTomKey}/{preferences.KickKey}  TIMPANO / GRANCASSA";
 
             VisualElement highwayHost = root.Q<VisualElement>("highway-host");
+            VisualElement reactiveStageHost = root.Q<VisualElement>("reactive-stage-host");
             VisualElement kitVisualHost = root.Q<VisualElement>("kit-visual-host");
             VisualElement targetsHost = root.Q<VisualElement>("targets-host");
             VisualElement kickHost = root.Q<VisualElement>("kick-target-host");
-            if (highwayHost == null || kitVisualHost == null || targetsHost == null || kickHost == null)
+            if (highwayHost == null || reactiveStageHost == null || kitVisualHost == null ||
+                targetsHost == null || kickHost == null)
             {
                 Debug.LogError("Gameplay highway UXML is missing a required host element.", this);
                 enabled = false;
@@ -392,6 +404,10 @@ private void BindView()
             }
 
             highwayHost.Clear();
+            reactiveStageHost.Clear();
+            reactiveStageSurface = new GameplayReactiveStageSurface();
+            reactiveStageSurface.AddToClassList("reactive-stage-surface");
+            reactiveStageHost.Add(reactiveStageSurface);
             surface = new GameplayHighwaySurface { name = "gameplay-highway-surface" };
             surface.AddToClassList("highway-surface");
             highwayHost.Add(surface);
@@ -474,6 +490,19 @@ private void RefreshPresentation()
                 ? Mathf.Clamp01((deadline - Time.unscaledTime) / PulseDurationSeconds)
                 : 0;
             surface.SetFrame(upcoming, position, HighwayLookAheadSeconds, latestPulsePad, pulse, ghostReplay.Ghost);
+            PlayerPreferencesSnapshot preferences = PlayerPreferencesRuntime.Current.Snapshot;
+            float stagePulse = Mathf.Clamp01((stagePulseDeadline - Time.unscaledTime) /
+                GameplayReactiveStageCalculator.MinimumPulseDurationSeconds);
+            GameplayReactiveStageState stageState = GameplayReactiveStageCalculator.Calculate(
+                scoreTracker.Snapshot.Combo,
+                latestStageGrade,
+                latestPulsePad,
+                stagePulse,
+                latestStageWrongInput,
+                preferences.ReducedMotion,
+                preferences.HighContrast);
+            reactiveStageSurface?.SetState(stageState);
+            if (reactiveStageStatusLabel != null) reactiveStageStatusLabel.text = stageState.Label;
             if (ghostStatusLabel != null)
                 ghostStatusLabel.text = ghostReplay.HasGhost
                     ? $"GHOST ATTIVO · {ghostReplay.Ghost.Count} COLPI"
@@ -508,6 +537,9 @@ private void HandleInputProcessed(DrumInputEvent input, HitResult result)
             else CaptureGhostHit(input, result);
             latestPulsePad = input.Pad;
             pulseDeadlines[input.Pad] = Time.unscaledTime + PulseDurationSeconds;
+            stagePulseDeadline = Time.unscaledTime + GameplayReactiveStageCalculator.MinimumPulseDurationSeconds;
+            latestStageGrade = result?.Grade;
+            latestStageWrongInput = result == null;
             lastCalibrationSource = input.Source == DrumInputSource.Midi
                 ? DrumInputSource.Midi
                 : DrumInputSource.Keyboard;
@@ -550,6 +582,9 @@ public bool CaptureGhostHit(DrumInputEvent input, HitResult result) =>
         private void HandleHitResolved(HitResult result)
         {
             if (result == null) return;
+            latestStageGrade = result.Grade;
+            latestStageWrongInput = false;
+            stagePulseDeadline = Time.unscaledTime + GameplayReactiveStageCalculator.MinimumPulseDurationSeconds;
             performanceAnalyzer.Record(result.Note.Pad, result.Grade);
             errorMapAnalyzer?.Record(result);
             scoreTracker.Apply(result);
@@ -644,6 +679,9 @@ public void RestartRun()
             metronomeScheduled = false;
             pulseDeadlines.Clear();
             latestPulsePad = null;
+            latestStageGrade = null;
+            latestStageWrongInput = false;
+            stagePulseDeadline = 0;
             matching.RestartSession();
             songClock.RestartPlayback();
             RunState = GameplayRunState.Countdown;
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs
new file mode 100644
index 0000000..3d3873e
--- /dev/null
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs
@@ -0,0 +1,243 @@
+using System;
+using HitTheKit.Core;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace HitTheKit.Unity.Gameplay
+{
+    public enum GameplayStageEnergyBand
+    {
+        Calm,
+        Building,
+        Live,
+        Peak,
+        Recovery
+    }
+
+    public enum GameplayStagePattern
+    {
+        Steady,
+        Rays,
+        Chevrons,
+        Warning
+    }
+
+    public readonly struct GameplayReactiveStageState
+    {
+        public GameplayReactiveStageState(
+            GameplayStageEnergyBand band,
+            GameplayStagePattern pattern,
+            float intensity,
+            DrumPad? accentPad,
+            bool reducedMotion,
+            bool highContrast,
+            string label)
+        {
+            Band = band;
+            Pattern = pattern;
+            Intensity = intensity;
+            AccentPad = accentPad;
+            ReducedMotion = reducedMotion;
+            HighContrast = highContrast;
+            Label = label ?? throw new ArgumentNullException(nameof(label));
+        }
+
+        public GameplayStageEnergyBand Band { get; }
+        public GameplayStagePattern Pattern { get; }
+        public float Intensity { get; }
+        public DrumPad? AccentPad { get; }
+        public bool ReducedMotion { get; }
+        public bool HighContrast { get; }
+        public string Label { get; }
+    }
+
+    public static class GameplayReactiveStageCalculator
+    {
+        public const float MaximumIntensity = 0.78f;
+        public const float ReducedMotionMaximumIntensity = 0.22f;
+        public const float MinimumPulseDurationSeconds = 0.18f;
+
+        public static GameplayReactiveStageState Calculate(
+            int combo,
+            HitGrade? latestGrade,
+            DrumPad? latestPad,
+            float pulseIntensity,
+            bool wrongInput,
+            bool reducedMotion,
+            bool highContrast)
+        {
+            if (combo < 0) throw new ArgumentOutOfRangeException(nameof(combo));
+
+            float baseIntensity = combo >= 50 ? 0.62f
+                : combo >= 25 ? 0.50f
+                : combo >= 10 ? 0.36f
+                : combo >= 3 ? 0.24f
+                : 0.14f;
+            float pulse = Mathf.Clamp01(pulseIntensity);
+            bool recovery = pulse > 0f && (wrongInput || latestGrade == HitGrade.Miss);
+            float intensity = recovery
+                ? Mathf.Max(0.20f, baseIntensity * 0.62f)
+                : baseIntensity + GradeBoost(latestGrade) * pulse;
+            float cap = reducedMotion ? ReducedMotionMaximumIntensity : MaximumIntensity;
+            intensity = Mathf.Clamp(intensity, 0f, cap);
+
+            GameplayStageEnergyBand band = recovery ? GameplayStageEnergyBand.Recovery
+                : combo >= 50 ? GameplayStageEnergyBand.Peak
+                : combo >= 25 ? GameplayStageEnergyBand.Live
+                : combo >= 3 ? GameplayStageEnergyBand.Building
+                : GameplayStageEnergyBand.Calm;
+            GameplayStagePattern pattern = recovery ? GameplayStagePattern.Warning
+                : reducedMotion ? GameplayStagePattern.Steady
+                : combo >= 25 ? GameplayStagePattern.Chevrons
+                : combo >= 3 ? GameplayStagePattern.Rays
+                : GameplayStagePattern.Steady;
+
+            return new GameplayReactiveStageState(
+                band, pattern, intensity, latestPad, reducedMotion, highContrast, LabelFor(band));
+        }
+
+        private static float GradeBoost(HitGrade? grade)
+        {
+            switch (grade)
+            {
+                case HitGrade.Perfect: return 0.16f;
+                case HitGrade.Good: return 0.11f;
+                case HitGrade.Early:
+                case HitGrade.Late: return 0.06f;
+                case HitGrade.Miss:
+                case null: return 0f;
+                default: throw new ArgumentOutOfRangeException(nameof(grade));
+            }
+        }
+
+        private static string LabelFor(GameplayStageEnergyBand band)
+        {
+            switch (band)
+            {
+                case GameplayStageEnergyBand.Calm: return "PALCO · CALMO";
+                case GameplayStageEnergyBand.Building: return "PALCO · IN CRESCENDO";
+                case GameplayStageEnergyBand.Live: return "PALCO · LIVE";
+                case GameplayStageEnergyBand.Peak: return "PALCO · ON FIRE";
+                case GameplayStageEnergyBand.Recovery: return "PALCO · RIPRENDI IL GROOVE";
+                default: throw new ArgumentOutOfRangeException(nameof(band));
+            }
+        }
+    }
+
+    public sealed class GameplayReactiveStageSurface : VisualElement
+    {
+        private GameplayReactiveStageState state = GameplayReactiveStageCalculator.Calculate(
+            0, null, null, 0, false, false, false);
+        private GameplayPresentationTheme theme;
+
+        public GameplayReactiveStageSurface()
+        {
+            name = "gameplay-reactive-stage-surface";
+            pickingMode = PickingMode.Ignore;
+            generateVisualContent += Draw;
+        }
+
+        public GameplayReactiveStageState State => state;
+
+        public void SetTheme(GameplayPresentationTheme value)
+        {
+            theme = value;
+            MarkDirtyRepaint();
+        }
+
+        public void SetState(GameplayReactiveStageState value)
+        {
+            state = value;
+            MarkDirtyRepaint();
+        }
+
+        private void Draw(MeshGenerationContext context)
+        {
+            Rect bounds = contentRect;
+            if (bounds.width <= 1 || bounds.height <= 1) return;
+
+            Painter2D painter = context.painter2D;
+            GameplayThemePalette palette = GameplayThemePalette.For(theme);
+            Color accent = state.AccentPad.HasValue
+                ? GameplayHighwayLanes.Find(state.AccentPad.Value).Color
+                : palette.Strike;
+            float alpha = state.Intensity;
+            float outline = state.HighContrast ? 3f : 1.4f;
+
+            DrawBeam(painter, bounds, 0.04f, 0.34f, accent, alpha * 0.18f);
+            DrawBeam(painter, bounds, 0.96f, 0.66f, accent, alpha * 0.18f);
+            if (state.Pattern == GameplayStagePattern.Rays || state.Pattern == GameplayStagePattern.Chevrons)
+            {
+                DrawBeam(painter, bounds, 0.24f, 0.46f, palette.Strike, alpha * 0.12f);
+                DrawBeam(painter, bounds, 0.76f, 0.54f, palette.Strike, alpha * 0.12f);
+            }
+
+            if (state.Pattern == GameplayStagePattern.Chevrons)
+            {
+                for (int row = 0; row < 3; row++)
+                {
+                    float y = bounds.height * (0.62f + row * 0.075f);
+                    DrawChevron(painter, bounds.width * 0.12f, y, accent, alpha * 0.70f, outline);
+                    DrawChevron(painter, bounds.width * 0.88f, y, accent, alpha * 0.70f, outline);
+                }
+            }
+            else if (state.Pattern == GameplayStagePattern.Warning)
+            {
+                Color warning = new Color(1f, 0.34f, 0.28f, Mathf.Max(0.25f, alpha));
+                StrokeLine(painter, new Vector2(18f, bounds.height * 0.54f),
+                    new Vector2(18f, bounds.height * 0.86f), warning, warning.a, outline + 1f);
+                StrokeLine(painter, new Vector2(bounds.width - 18f, bounds.height * 0.54f),
+                    new Vector2(bounds.width - 18f, bounds.height * 0.86f), warning, warning.a, outline + 1f);
+            }
+
+            DrawCrowd(painter, bounds, accent, state.HighContrast ? 0.74f : 0.30f + alpha * 0.30f, outline);
+        }
+
+        private static void DrawChevron(Painter2D painter, float centerX, float y, Color color, float alpha, float width)
+        {
+            StrokeLine(painter, new Vector2(centerX - 42f, y), new Vector2(centerX, y - 16f), color, alpha, width);
+            StrokeLine(painter, new Vector2(centerX, y - 16f), new Vector2(centerX + 42f, y), color, alpha, width);
+        }
+
+        private static void DrawBeam(Painter2D painter, Rect bounds, float originX, float targetX,
+            Color color, float alpha)
+        {
+            painter.fillColor = WithAlpha(color, alpha);
+            painter.BeginPath();
+            painter.MoveTo(new Vector2(bounds.width * originX - 8f, 0));
+            painter.LineTo(new Vector2(bounds.width * originX + 8f, 0));
+            painter.LineTo(new Vector2(bounds.width * targetX + 90f, bounds.height));
+            painter.LineTo(new Vector2(bounds.width * targetX - 90f, bounds.height));
+            painter.ClosePath();
+            painter.Fill();
+        }
+
+        private static void DrawCrowd(Painter2D painter, Rect bounds, Color accent, float alpha, float width)
+        {
+            float baseline = bounds.height - 8f;
+            for (int index = 0; index < 18; index++)
+            {
+                float x = bounds.width * (index + 0.5f) / 18f;
+                float height = 13f + (index % 4) * 4f;
+                Color silhouette = index % 3 == 0
+                    ? WithAlpha(accent, alpha * 0.50f)
+                    : new Color(0.01f, 0.02f, 0.04f, alpha);
+                StrokeLine(painter, new Vector2(x, baseline), new Vector2(x, baseline - height),
+                    silhouette, silhouette.a, width + 3f);
+            }
+        }
+
+        private static void StrokeLine(Painter2D painter, Vector2 from, Vector2 to, Color color, float alpha, float width)
+        {
+            painter.strokeColor = WithAlpha(color, alpha);
+            painter.lineWidth = width;
+            painter.BeginPath();
+            painter.MoveTo(from);
+            painter.LineTo(to);
+            painter.Stroke();
+        }
+
+        private static Color WithAlpha(Color color, float alpha) =>
+            new Color(color.r, color.g, color.b, Mathf.Clamp01(alpha));
+    }
+}
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs.meta b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs.meta
new file mode 100644
index 0000000..5b141c3
--- /dev/null
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/Runtime/Gameplay/GameplayReactiveStage.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1fd60513b0364357b6198ad7fd910592
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/Tests/EditMode/GameplayHighwayTests.cs b/src/HitTheKit.Unity/Assets/HitTheKit/Tests/EditMode/GameplayHighwayTests.cs
index 79c5a63..6bc65ec 100644
--- a/src/HitTheKit.Unity/Assets/HitTheKit/Tests/EditMode/GameplayHighwayTests.cs
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/Tests/EditMode/GameplayHighwayTests.cs
@@ -218,5 +218,57 @@ public void Highway_uses_a_broad_impact_zone_and_bounded_multi_pass_note_glow()
             Assert.That(GameplayHighwaySurface.ImpactZoneHalfHeight, Is.GreaterThanOrEqualTo(8f));
             Assert.That(GameplayHighwaySurface.NoteGlowPasses, Is.InRange(2, 4));
         }
+
+        [Test]
+        public void Reactive_stage_builds_energy_from_combo_and_success_without_unbounded_flashes()
+        {
+            GameplayReactiveStageState calm = GameplayReactiveStageCalculator.Calculate(
+                0, null, null, 0, false, false, false);
+            GameplayReactiveStageState peak = GameplayReactiveStageCalculator.Calculate(
+                60, HitGrade.Perfect, DrumPad.Crash, 1, false, false, false);
+
+            Assert.That(calm.Band, Is.EqualTo(GameplayStageEnergyBand.Calm));
+            Assert.That(peak.Band, Is.EqualTo(GameplayStageEnergyBand.Peak));
+            Assert.That(peak.Pattern, Is.EqualTo(GameplayStagePattern.Chevrons));
+            Assert.That(peak.Intensity, Is.GreaterThan(calm.Intensity));
+            Assert.That(peak.Intensity, Is.LessThanOrEqualTo(GameplayReactiveStageCalculator.MaximumIntensity));
+            Assert.That(peak.AccentPad, Is.EqualTo(DrumPad.Crash));
+            Assert.That(GameplayReactiveStageCalculator.MinimumPulseDurationSeconds, Is.GreaterThanOrEqualTo(0.18f));
+        }
+
+        [Test]
+        public void Reactive_stage_uses_text_and_pattern_for_misses_and_respects_accessibility_preferences()
+        {
+            GameplayReactiveStageState recovery = GameplayReactiveStageCalculator.Calculate(
+                22, HitGrade.Miss, DrumPad.Snare, 1, false, true, true);
+
+            Assert.That(recovery.Band, Is.EqualTo(GameplayStageEnergyBand.Recovery));
+            Assert.That(recovery.Pattern, Is.EqualTo(GameplayStagePattern.Warning));
+            Assert.That(recovery.Label, Does.Contain("RIPRENDI IL GROOVE"));
+            Assert.That(recovery.Intensity, Is.LessThanOrEqualTo(
+                GameplayReactiveStageCalculator.ReducedMotionMaximumIntensity));
+            Assert.That(recovery.ReducedMotion, Is.True);
+            Assert.That(recovery.HighContrast, Is.True);
+
+            GameplayReactiveStageState afterPulse = GameplayReactiveStageCalculator.Calculate(
+                0, HitGrade.Miss, DrumPad.Snare, 0, false, true, true);
+            Assert.That(afterPulse.Band, Is.EqualTo(GameplayStageEnergyBand.Calm),
+                "Recovery feedback must not remain stuck after its bounded pulse.");
+        }
+
+        [Test]
+        public void Reactive_stage_calculation_is_deterministic_and_rejects_invalid_combo()
+        {
+            GameplayReactiveStageState first = GameplayReactiveStageCalculator.Calculate(
+                12, HitGrade.Good, DrumPad.Kick, 0.5f, false, false, false);
+            GameplayReactiveStageState second = GameplayReactiveStageCalculator.Calculate(
+                12, HitGrade.Good, DrumPad.Kick, 0.5f, false, false, false);
+
+            Assert.That(second.Band, Is.EqualTo(first.Band));
+            Assert.That(second.Pattern, Is.EqualTo(first.Pattern));
+            Assert.That(second.Intensity, Is.EqualTo(first.Intensity));
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+                GameplayReactiveStageCalculator.Calculate(-1, null, null, 0, false, false, false));
+        }
     }
 }
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/Tests/PlayMode/GameplayHighwayPlayModeTests.cs b/src/HitTheKit.Unity/Assets/HitTheKit/Tests/PlayMode/GameplayHighwayPlayModeTests.cs
index a8ad292..7ad5866 100644
--- a/src/HitTheKit.Unity/Assets/HitTheKit/Tests/PlayMode/GameplayHighwayPlayModeTests.cs
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/Tests/PlayMode/GameplayHighwayPlayModeTests.cs
@@ -46,6 +46,7 @@ public IEnumerator Gameplay_scene_uses_the_session_theme_and_does_not_expose_an_
             Assert.That(controller.TargetCount, Is.EqualTo(8));
             Assert.That(controller.Surface, Is.Not.Null);
             Assert.That(controller.KitSurface, Is.Not.Null);
+            Assert.That(controller.ReactiveStageSurface, Is.Not.Null);
             Assert.That(controller.KitSurface.PieceCount, Is.EqualTo(8));
             Assert.That(controller.IsInstructionalKitVisible, Is.False);
             Assert.That(controller.KitSurface.resolvedStyle.display, Is.EqualTo(DisplayStyle.None));
@@ -55,6 +56,8 @@ public IEnumerator Gameplay_scene_uses_the_session_theme_and_does_not_expose_an_
             Assert.That(app, Is.Not.Null);
             Assert.That(document.rootVisualElement.Q<VisualElement>("target-kick"), Is.Not.Null);
             Assert.That(document.rootVisualElement.Q<VisualElement>("gameplay-kit-surface"), Is.Not.Null);
+            Assert.That(document.rootVisualElement.Q<VisualElement>("gameplay-reactive-stage-surface"), Is.Not.Null);
+            Assert.That(document.rootVisualElement.Q<Label>("reactive-stage-status"), Is.Not.Null);
             Assert.That(document.rootVisualElement.Q<Label>("kit-guidance-label"), Is.Not.Null);
             Assert.That(document.rootVisualElement.Q<VisualElement>("results-overlay"), Is.Not.Null);
             Assert.That(document.rootVisualElement.Q<Label>("result-error-map"), Is.Not.Null);
@@ -104,6 +107,29 @@ public IEnumerator Ghost_replay_is_local_visual_only_and_does_not_change_score()
             Assert.That(controller.CurrentGhostTakeHitCount, Is.Zero);
         }
 
+        [UnityTest]
+        public IEnumerator Reactive_stage_respects_reduced_motion_and_high_contrast_in_the_real_scene()
+        {
+            PlayerPreferencesRuntime.Current.SetReducedMotion(true);
+            PlayerPreferencesRuntime.Current.SetHighContrast(true);
+            AsyncOperation load = SceneManager.LoadSceneAsync("GameplayPrototype", LoadSceneMode.Single);
+            while (!load.isDone) yield return null;
+            yield return null;
+
+            GameplayHighwayController controller = Object.FindAnyObjectByType<GameplayHighwayController>();
+            Assert.That(controller, Is.Not.Null);
+            Assert.That(controller.ReactiveStageSurface, Is.Not.Null);
+            Assert.That(controller.ReactiveStageState.ReducedMotion, Is.True);
+            Assert.That(controller.ReactiveStageState.HighContrast, Is.True);
+            Assert.That(controller.ReactiveStageState.Intensity, Is.LessThanOrEqualTo(
+                GameplayReactiveStageCalculator.ReducedMotionMaximumIntensity));
+
+            UIDocument gameplayDocument = controller.GetComponent<UIDocument>();
+            VisualElement app = gameplayDocument.rootVisualElement.Q<VisualElement>("gameplay-app");
+            Assert.That(app.ClassListContains("gameplay--reduced-motion"), Is.True);
+            Assert.That(app.ClassListContains("gameplay--high-contrast"), Is.True);
+        }
+
         [UnityTest]
         public IEnumerator Precision_grid_enables_the_colored_instructional_kit_from_settings()
         {
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uss b/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uss
index 41ab3da..ffe9c32 100644
--- a/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uss
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uss
@@ -21,6 +21,7 @@
 }
 
 .gameplay-background,
+.reactive-stage-host,
 .gameplay-vignette {
     position: absolute;
     left: 0;
@@ -31,8 +32,29 @@
 }
 
 .gameplay-background { opacity: 0.88; }
+.reactive-stage-host { opacity: 1; }
+.reactive-stage-surface { position: absolute; left: 0; top: 0; right: 0; bottom: 0; }
 .gameplay-vignette { background-color: rgba(0, 4, 12, 0.24); }
 
+.reactive-stage-status {
+    position: absolute;
+    top: 119px;
+    right: 28px;
+    min-width: 180px;
+    height: 24px;
+    padding-left: 12px;
+    padding-right: 12px;
+    -unity-text-align: middle-center;
+    color: var(--accent);
+    background-color: rgba(2, 8, 18, 0.78);
+    border-width: 1px;
+    border-color: var(--panel-border);
+    border-radius: 12px;
+    font-size: 9px;
+    -unity-font-style: bold;
+    letter-spacing: 1px;
+}
+
 .session-kicker {
     position: absolute;
     top: 119px;
@@ -604,6 +626,8 @@
 .gameplay--high-contrast .results-dialog,
 .gameplay--high-contrast .run-dialog { border-color: white; background-color: rgba(0, 0, 0, 0.97); }
 .gameplay--high-contrast Label { color: white; }
+.gameplay--high-contrast .reactive-stage-status { border-width: 2px; border-color: white; }
+.gameplay--reduced-motion .reactive-stage-host { opacity: 0.68; }
 .gameplay--reduced-motion .judgment { transition-duration: 0s; }
 .result-actions { flex-direction: row; }
 
diff --git a/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uxml b/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uxml
index 4708ff2..3f8954b 100644
--- a/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uxml
+++ b/src/HitTheKit.Unity/Assets/HitTheKit/UI/Gameplay/GameplayHighway.uxml
@@ -2,6 +2,7 @@
     <Style src="GameplayHighway.uss" />
     <ui:VisualElement name="gameplay-app" class="gameplay-shell theme--arcade-neon">
         <ui:VisualElement name="gameplay-background" class="gameplay-background" />
+        <ui:VisualElement name="reactive-stage-host" class="reactive-stage-host" />
         <ui:VisualElement class="gameplay-vignette" />
 
         <ui:VisualElement class="hud-top">
@@ -35,6 +36,7 @@
         </ui:VisualElement>
 
         <ui:Label name="session-kicker" text="MODALITÀ GIOCO · LA BATTERIA SUONA SOLO QUANDO LA COLPISCI" class="session-kicker" />
+        <ui:Label name="reactive-stage-status" text="PALCO · CALMO" class="reactive-stage-status" />
 
         <ui:VisualElement class="gameplay-content">
             <ui:VisualElement class="side-rail side-rail--left">