chore: Project Restructuring & Theatre

2026-05-13 12:24:48 +02:00
parent 4070916c1f
commit e96d0bf6e6
2145 changed files with 20957 additions and 44792 deletions
@@ -0,0 +1,255 @@
+using UnityEngine;
+using System;
+using Unheimlich.Features.Player;
+using Unheimlich.Features.Dialogue;
+using Unheimlich.Features.Dialogue.UI;
+using Unheimlich.Features.Dialogue.Data;
+using Unheimlich.Core.Utils;
+
+namespace Unheimlich.Features.Dialogue
+{
+    /// <summary>
+    /// Manages gaze-based focus detection for dialogue choices using raycasts.
+    /// </summary>
+    public class DialogueFocusSystem
+{
+    private readonly DialogueManager _manager;
+    private readonly Camera _mainCamera;
+    private readonly CameraEffects _cameraEffects;
+    
+    private ChoiceFocusHandler _currentFocusedHandler;
+    private float _focusTimer = 0f;
+    private float _retentionTimer = 0f;
+    private float _raycastTimer = 0f;
+    private bool _isFocusLocked = false;
+
+    private readonly LayerMask _choiceLayer;
+    private readonly float _focusRange;
+    private readonly float _focusTime;
+    private readonly float _raycastInterval;
+    private readonly float _recoveryDuration;
+    private readonly float _focusRetentionTime;
+    private readonly float _fallbackShakeIntensity;
+
+    public event Action<DialogueChoiceData> OnChoiceMade;
+
+    public DialogueFocusSystem(
+        DialogueManager manager,
+        Camera mainCamera,
+        CameraEffects cameraEffects,
+        LayerMask choiceLayer,
+        float focusRange,
+        float focusTime,
+        float raycastInterval,
+        float recoveryDuration,
+        float focusRetentionTime,
+        float fallbackShakeIntensity)
+    {
+        _manager = manager;
+        _mainCamera = mainCamera;
+        _cameraEffects = cameraEffects;
+        _choiceLayer = choiceLayer;
+        _focusRange = focusRange;
+        _focusTime = focusTime;
+        _raycastInterval = raycastInterval;
+        _recoveryDuration = recoveryDuration;
+        _focusRetentionTime = focusRetentionTime;
+        _fallbackShakeIntensity = fallbackShakeIntensity;
+    }
+
+    /// <summary>
+    /// Updates the focus detection system. Should be called every frame during active dialogue.
+    /// Performs raycasts at configured intervals to detect choice focus.
+    /// </summary>
+    public void Update()
+    {
+        if (!_manager.IsDialogueActive || !_manager.CurrentDialogueUI.AreChoicesVisible())
+            return;
+
+        _raycastTimer += Time.deltaTime;
+        if (_raycastTimer >= _raycastInterval)
+        {
+            CheckForChoiceFocus();
+            _raycastTimer = 0f;
+        }
+    }
+
+    /// <summary>
+    /// Performs raycast from camera center to detect focused dialogue choices.
+    /// Manages focus state transitions, retention timers, visual feedback, and choice selection.
+    /// Implements stabilization to prevent rapid focus switching between choices.
+    /// </summary>
+    private void CheckForChoiceFocus()
+    {
+        if (_isFocusLocked)
+        {
+            if (_retentionTimer > 0f) 
+                _retentionTimer -= Time.deltaTime;
+            else
+                _isFocusLocked = false;
+            return; 
+        }
+
+        if (_mainCamera == null)
+            return;
+
+        ChoiceFocusHandler hitHandler = null;
+        
+        if (RaycastHelper.RaycastFromCameraCenter(_mainCamera, _focusRange, _choiceLayer, out RaycastHit hit))
+        {
+            hitHandler = hit.collider.GetComponent<ChoiceFocusHandler>();
+            
+            if (_cameraEffects != null && hitHandler != null)
+                _cameraEffects.ApplyAimAssist(hit.collider.bounds.center);
+        }
+        
+        if (hitHandler != _currentFocusedHandler)
+        {
+            _retentionTimer -= Time.deltaTime;
+            
+            if (hitHandler != null && _retentionTimer <= 0f)
+            {
+                if (_currentFocusedHandler != null)
+                {
+                    _currentFocusedHandler.ResetFeedback(_recoveryDuration);
+                    ResetAllUnfocusEffects();
+                }
+
+                _currentFocusedHandler = hitHandler;
+                _focusTimer = 0f;
+                _retentionTimer = _focusRetentionTime;
+
+                if (_cameraEffects != null)
+                    _cameraEffects.LockAim(true);
+                
+                ApplyUnfocusEffectToOthers(hitHandler);
+                
+                DialogueAnimationSettings settings = _manager.CurrentAnimationSettings;
+                bool shouldRotate = settings == null || settings.EnableRotation;
+                if (shouldRotate && _manager.CurrentDialogueUI != null)
+                {
+                    float focusSpeed = settings != null ? settings.FocusRotationSpeed : 60f;
+                    _manager.CurrentDialogueUI.RotationAnimation(focusSpeed);
+                }
+            }
+        }
+        else if (hitHandler != null)
+        {
+            _retentionTimer = _focusRetentionTime;
+        }
+
+        bool isFocusActive = _currentFocusedHandler != null && (_retentionTimer > 0f); 
+
+        if (isFocusActive)
+        {
+            _focusTimer += Time.deltaTime;
+            float progress = _focusTimer / _focusTime;
+
+            _currentFocusedHandler.ApplyFocusFeedback(progress);
+            
+            DialogueAnimationSettings currentSettings = _manager.CurrentAnimationSettings;
+            bool shouldShake = currentSettings == null || currentSettings.EnableCameraShakeOnFocus;
+            
+            if (shouldShake && _cameraEffects != null)
+            {
+                float shakeIntensity = currentSettings != null ? currentSettings.CameraShakeIntensity : _fallbackShakeIntensity;
+                float shakeSmoothness = currentSettings != null ? currentSettings.CameraShakeSmoothness : 10f;
+                _cameraEffects.ShakeCamera(progress / shakeIntensity, shakeSmoothness);
+            }
+            
+            if (_focusTimer >= _focusTime)
+            {
+                ChoiceFocusHandler selectedHandler = _currentFocusedHandler;
+                
+                if (selectedHandler.DialogueData != null)
+                {
+                    OnChoiceMade?.Invoke(selectedHandler.DialogueData);
+                    DialogueNode nextNode = selectedHandler.GetNextNode();
+                    _manager.GoToNextNode(nextNode);
+                }
+                
+                DialogueAnimationSettings settings = _manager.CurrentAnimationSettings;
+                bool shouldRotate = settings == null || settings.EnableRotation;
+                if (shouldRotate && _manager.CurrentDialogueUI != null)
+                {
+                    float normalSpeed = settings != null ? settings.NormalRotationSpeed : 36f;
+                    _manager.CurrentDialogueUI.RotationAnimation(normalSpeed);
+                }
+                    
+                ResetAnimationTimers();
+                ResetAllUnfocusEffects();
+                
+                selectedHandler.ResetFeedback(_recoveryDuration);
+                
+                if (_cameraEffects != null)
+                    _cameraEffects.LockAim(false);
+            }
+        }
+        else if (_currentFocusedHandler != null && _retentionTimer <= 0f)
+        {
+            _currentFocusedHandler.ResetFeedback(_recoveryDuration);
+            ResetAllUnfocusEffects();
+            
+            DialogueAnimationSettings settings = _manager.CurrentAnimationSettings;
+            bool shouldRotate = settings == null || settings.EnableRotation;
+            if (shouldRotate && _manager.CurrentDialogueUI != null)
+            {
+                float normalSpeed = settings != null ? settings.NormalRotationSpeed : 36f;
+                _manager.CurrentDialogueUI.RotationAnimation(normalSpeed);
+            }
+
+            ResetAnimationTimers();
+            
+            if (_cameraEffects != null)
+                _cameraEffects.LockAim(false);
+        }
+    }
+    
+    private void ApplyUnfocusEffectToOthers(ChoiceFocusHandler focusedHandler)
+    {
+        if (_manager.CurrentDialogueUI == null || _manager.CurrentDialogueUI.ChoiceContainer == null)
+            return;
+        
+        DialogueAnimationSettings settings = _manager.CurrentAnimationSettings;
+        float shakeSlowdown = settings != null ? settings.UnfocusedShakeSpeedMultiplier : 0.3f;
+        
+        foreach (Transform child in _manager.CurrentDialogueUI.ChoiceContainer.transform)
+        {
+            ChoiceFocusHandler handler = child.GetComponent<ChoiceFocusHandler>();
+            if (handler != null && handler != focusedHandler)
+            {
+                handler.SetShakeSpeedMultiplier(shakeSlowdown);
+                handler.ApplySketchFade();
+            }
+        }
+    }
+    
+    private void ResetAllUnfocusEffects()
+    {
+        if (_manager.CurrentDialogueUI == null || _manager.CurrentDialogueUI.ChoiceContainer == null)
+            return;
+        
+        foreach (Transform child in _manager.CurrentDialogueUI.ChoiceContainer.transform)
+        {
+            ChoiceFocusHandler handler = child.GetComponent<ChoiceFocusHandler>();
+            if (handler != null)
+            {
+                handler.SetShakeSpeedMultiplier(1f);
+                handler.ResetSketchFade();
+            }
+        }
+    }
+
+    private void ResetAnimationTimers()
+    {
+        _currentFocusedHandler = null;
+        _focusTimer = 0f;
+        _retentionTimer = 0f; 
+    }
+    
+    public void UnlockFocus()
+    {
+        _isFocusLocked = false;
+    }
+}
+}