Complete reorga

2026-03-09 17:55:23 +01:00
parent d9326e48cc
commit 10faf74405
703 changed files with 13040 additions and 1533 deletions
@@ -0,0 +1,115 @@
+using UnityEngine;
+using Unheimlich.Features.DetectiveBoard.Data;
+using Unheimlich.Features.DetectiveBoard;
+
+namespace Unheimlich.Features.DetectiveBoard
+{
+    /// <summary>
+    /// Unlocks a clue when a specific audio source plays or finishes playing.
+    /// Useful for triggering clues based on environmental sounds, dialogue, or hallucinations.
+    /// </summary>
+    [RequireComponent(typeof(AudioSource))]
+    public class ClueUnlockOnAudio : MonoBehaviour
+    {
+        public enum UnlockTrigger
+        {
+            OnPlay,
+            OnFinish,
+            OnTimeReached
+        }
+        
+        [Header("Clue Configuration")]
+        [Tooltip("The clue to unlock")]
+        [SerializeField] private ClueData _clueToUnlock;
+        
+        [Header("Audio Trigger")]
+        [Tooltip("When to unlock the clue")]
+        [SerializeField] private UnlockTrigger _trigger = UnlockTrigger.OnPlay;
+        
+        [Tooltip("Time in seconds to wait before unlocking (only for OnTimeReached)")]
+        [SerializeField] private float _unlockTime = 1f;
+        
+        private AudioSource _audioSource;
+        private bool _hasUnlocked;
+        private bool _isMonitoring;
+        private float _currentTime;
+        
+        private void Awake()
+        {
+            _audioSource = GetComponent<AudioSource>();
+        }
+        
+        private void OnEnable()
+        {
+            if (_audioSource != null && _audioSource.isPlaying)
+            {
+                StartMonitoring();
+            }
+        }
+        
+        private void Update()
+        {
+            if (!_isMonitoring || _hasUnlocked)
+                return;
+            
+            if (_audioSource == null || !_audioSource.isPlaying)
+            {
+                if (_trigger == UnlockTrigger.OnFinish && _isMonitoring)
+                {
+                    UnlockClue();
+                }
+                _isMonitoring = false;
+                return;
+            }
+            
+            _currentTime = _audioSource.time;
+            
+            if (_trigger == UnlockTrigger.OnTimeReached && _currentTime >= _unlockTime)
+            {
+                UnlockClue();
+            }
+        }
+        
+        /// <summary>
+        /// Call this when the audio starts playing.
+        /// </summary>
+        public void OnAudioPlay()
+        {
+            StartMonitoring();
+            
+            if (_trigger == UnlockTrigger.OnPlay)
+            {
+                UnlockClue();
+            }
+        }
+        
+        private void StartMonitoring()
+        {
+            _isMonitoring = true;
+            _currentTime = 0f;
+        }
+        
+        private void UnlockClue()
+        {
+            if (_hasUnlocked || _clueToUnlock == null)
+                return;
+            
+            if (DetectiveBoardManager.Instance != null)
+            {
+                DetectiveBoardManager.Instance.UnlockClue(_clueToUnlock);
+                _hasUnlocked = true;
+                
+                Debug.Log($"[ClueUnlockOnAudio] Unlocked clue: {_clueToUnlock.Title} via audio trigger");
+            }
+        }
+        
+        /// <summary>
+        /// Resets the unlock state.
+        /// </summary>
+        public void ResetUnlock()
+        {
+            _hasUnlocked = false;
+            _isMonitoring = false;
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fcedba870c1ea9642a272a53148bb933
@@ -0,0 +1,60 @@
+using UnityEngine;
+using Unheimlich.Features.DetectiveBoard.Data;
+using Unheimlich.Core.Interaction;
+using Unheimlich.Features.DetectiveBoard;
+using Unheimlich.Features.Items;
+
+namespace Unheimlich.Features.DetectiveBoard
+{
+    /// <summary>
+    /// Unlocks a clue when the player interacts with this object.
+    /// Can work standalone (extends InteractableBase) or piggyback on an existing InspectableItem.
+    /// </summary>
+    public class ClueUnlockOnInteraction : InteractableBase
+    {
+        [Header("Clue Configuration")]
+        [Tooltip("The clue to unlock when player interacts")]
+        [SerializeField] private ClueData _clueToUnlock;
+        
+        [Tooltip("Only unlock once")]
+        [SerializeField] private bool _unlockOnlyOnce = true;
+        
+        private bool _hasUnlocked;
+        private InspectableItem _inspectableItem;
+        
+        private void Awake()
+        {
+            _inspectableItem = GetComponent<InspectableItem>();
+        }
+        
+        public override void Interact()
+        {
+            if (_unlockOnlyOnce && _hasUnlocked)
+            {
+                if (_inspectableItem != null)
+                    _inspectableItem.Interact();
+                return;
+            }
+            
+            if (_clueToUnlock == null)
+            {
+                Debug.LogError("[ClueUnlockOnInteraction] No clue data assigned!");
+                if (_inspectableItem != null)
+                    _inspectableItem.Interact();
+                return;
+            }
+            
+            if (DetectiveBoardManager.Instance != null)
+            {
+                DetectiveBoardManager.Instance.UnlockClue(_clueToUnlock);
+                _hasUnlocked = true;
+                
+            }
+            
+            if (_inspectableItem != null)
+            {
+                _inspectableItem.Interact();
+            }
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cca584f48d1f0ab429416470fd01d543
@@ -0,0 +1,105 @@
+using UnityEngine;
+using Unheimlich.Features.DetectiveBoard.Data;
+using Unheimlich.Features.DetectiveBoard;
+
+namespace Unheimlich.Features.DetectiveBoard
+{
+    /// <summary>
+    /// Generic trigger to unlock clues on the detective board.
+    /// Can be triggered by any game event: dialogue, object interaction, audio cue, hallucination, etc.
+    /// Simply call UnlockClue() when the trigger condition is met.
+    /// </summary>
+    public class ClueUnlockTrigger : MonoBehaviour
+    {
+        [Header("Clue Configuration")]
+        [Tooltip("The clue data to unlock when triggered")]
+        [SerializeField] private ClueData _clueToUnlock;
+        
+        [Header("Trigger Settings")]
+        [Tooltip("Automatically unlock on Start()")]
+        [SerializeField] private bool _unlockOnStart;
+        
+        [Tooltip("Unlock when this GameObject is enabled")]
+        [SerializeField] private bool _unlockOnEnable;
+        
+        [Tooltip("Delay before unlocking (useful for sequencing)")]
+        [SerializeField] private float _unlockDelay;
+        
+        [Tooltip("Show debug messages")]
+        [SerializeField] private bool _debugMode;
+        
+        private bool _hasUnlocked;
+        
+        private void Start()
+        {
+            if (_unlockOnStart)
+            {
+                UnlockClue();
+            }
+        }
+        
+        private void OnEnable()
+        {
+            if (_unlockOnEnable && !_hasUnlocked)
+            {
+                UnlockClue();
+            }
+        }
+        
+        /// <summary>
+        /// Unlocks the associated clue. Can be called from external scripts, events, or animations.
+        /// </summary>
+        public void UnlockClue()
+        {
+            if (_hasUnlocked)
+            {
+                if (_debugMode)
+                    Debug.LogWarning($"[ClueUnlockTrigger] Clue '{_clueToUnlock?.Title}' already unlocked!");
+                return;
+            }
+            
+            if (_clueToUnlock == null)
+            {
+                Debug.LogError("[ClueUnlockTrigger] No clue data assigned!");
+                return;
+            }
+            
+            if (_unlockDelay > 0f)
+            {
+                Invoke(nameof(UnlockClueImmediate), _unlockDelay);
+            }
+            else
+            {
+                UnlockClueImmediate();
+            }
+        }
+        
+        private void UnlockClueImmediate()
+        {
+            if (DetectiveBoardManager.Instance != null)
+            {
+                DetectiveBoardManager.Instance.UnlockClue(_clueToUnlock);
+                _hasUnlocked = true;
+                
+                if (_debugMode)
+                    Debug.Log($"[ClueUnlockTrigger] Unlocked clue: {_clueToUnlock.Title}");
+                
+                OnClueUnlocked?.Invoke();
+            }
+            else
+            {
+                Debug.LogError("[ClueUnlockTrigger] DetectiveBoardManager not found!");
+            }
+        }
+        
+        /// <summary>
+        /// Resets the unlock state (useful for testing).
+        /// </summary>
+        public void ResetUnlock()
+        {
+            _hasUnlocked = false;
+        }
+        
+        public event System.Action OnClueUnlocked;
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 61b90106a531ea840b670f368e2c8aa9
@@ -0,0 +1,217 @@
+using UnityEngine;
+using Unheimlich.Core;
+using Unheimlich.World.CameraSystem;
+using Unheimlich.Features.Player;
+using Unheimlich.Features.OctoArms;
+using InputManager = Unheimlich.Core.Input.InputManager;
+using Unheimlich.Features.DetectiveBoard.UI;
+using Unheimlich.Features.Dialogue.UI;
+
+namespace Unheimlich.Features.DetectiveBoard
+{
+    /// <summary>
+    /// Controls player interaction with the detective board.
+    /// </summary>
+    public class DetectiveBoardController : Singleton<DetectiveBoardController>
+    {
+        [Header("Settings")]
+        [SerializeField] private float _activationRange = 2f;
+        [SerializeField] private LayerMask _boardLayer;
+        [SerializeField] private CameraPanSettings _playerAlignmentSettings;
+        
+        [Header("Virtual Camera")]
+        [SerializeField] private DetectiveBoardVirtualCamera _virtualCamera;
+        
+        private bool _isBoardActive;
+        private CameraHeadBob _cameraHeadBob;
+        
+        public bool IsBoardActive => _isBoardActive;
+        
+        protected override void OnAwake()
+        {
+            _cameraHeadBob = FindFirstObjectByType<CameraHeadBob>();
+        }
+        
+        void Start()
+        {
+            if(_virtualCamera == null)
+                _virtualCamera = DetectiveBoardVirtualCamera.Instance;
+        }
+
+        private void Update()
+        {
+            if (_isBoardActive)
+            {
+                HandleBoardInteraction();
+            }
+            else
+            {
+                CheckForBoardActivation();
+            }
+        }
+        
+        private void CheckForBoardActivation()
+        {
+            if (PlayerController.Instance == null || 
+                PlayerController.Instance.PlayerCamera == null || 
+                DetectiveBoardCanvas.Instance == null)
+                return;
+            
+            var camera = PlayerController.Instance.PlayerCamera;
+            var boardTransform = DetectiveBoardCanvas.Instance.transform;
+            
+            float distanceToBoard = Vector3.Distance(camera.transform.position, boardTransform.position);
+            if (distanceToBoard > _activationRange)
+                return;
+            
+            Ray ray = new Ray(camera.transform.position, camera.transform.forward);
+            if (Physics.Raycast(ray, out RaycastHit hit, _activationRange, _boardLayer))
+            {
+                bool isLookingAtBoard = (hit.transform == boardTransform) || 
+                                        (boardTransform.IsChildOf(hit.transform)) ||
+                                        (hit.transform.IsChildOf(boardTransform));
+                
+                if (isLookingAtBoard)
+                {
+                    var interactAction = InputManager.GetInteractAction();
+                    if (interactAction != null && interactAction.WasPressedThisFrame())
+                    {
+                        ActivateBoard();
+                    }
+                }
+            }
+        }
+        
+        public void ActivateBoard()
+        {
+            if (_isBoardActive || 
+                PlayerController.Instance?.PlayerCamera == null || 
+                PlayerController.Instance?.CameraPanController == null ||
+                DetectiveBoardCanvas.Instance == null ||
+                DetectiveBoardVirtualCamera.Instance == null)
+            {
+                Debug.LogError("[DetectiveBoardController] Missing required references!");
+                return;
+            }
+            
+            _isBoardActive = true;
+            
+            if (PlayerController.Instance.Movement != null)
+            {
+                PlayerController.Instance.Movement.enabled = false;
+            }
+            
+            OctoIkArmsImproved arms = PlayerController.Instance.GetComponentInChildren<OctoIkArmsImproved>();
+            if (arms != null)
+            {
+                arms.HideArms(3f);
+            }
+            
+            InputManager.SetContext(InputManager.InputContext.Listening);
+            
+            if (_cameraHeadBob != null)
+            {
+                _cameraHeadBob.SetMode(HeadBobMode.Disabled);
+            }
+            
+            if (CrosshairController.Instance != null)
+            {
+                CrosshairController.Instance.Hide();
+            }
+            
+            Cursor.lockState = CursorLockMode.None;
+            Cursor.visible = true;
+            
+            var cameraPan = PlayerController.Instance.CameraPanController;
+            var originalSettings = cameraPan.Settings;
+            
+            if (_playerAlignmentSettings != null)
+                cameraPan.Settings = _playerAlignmentSettings;
+            
+            cameraPan.SaveOriginalState();
+            
+            cameraPan.AlignToTarget(DetectiveBoardCanvas.Instance.transform, () =>
+            {
+                DetectiveBoardVirtualCamera.Instance.ActivateFromPlayerPosition(
+                    PlayerController.Instance.PlayerCamera, 
+                    DetectiveBoardCanvas.Instance.transform,
+                    DetectiveBoardCanvas.Instance.BoardRenderer
+                );
+                
+                if (_playerAlignmentSettings != null)
+                    cameraPan.Settings = originalSettings;
+            });
+        }
+        
+        private void HandleBoardInteraction()
+        {
+            var exitAction = InputManager.GetExitAction();
+            if (exitAction != null && exitAction.WasPressedThisFrame())
+            {
+                DeactivateBoard();
+            }
+        }
+        
+        public void DeactivateBoard()
+        {
+            if (!_isBoardActive || DetectiveBoardVirtualCamera.Instance == null)
+                return;
+            
+            _isBoardActive = false;
+            
+            DetectiveBoardVirtualCamera.Instance.Deactivate(() =>
+            {
+                var cameraPan = PlayerController.Instance?.CameraPanController;
+                if (cameraPan != null)
+                {
+                    OctoIkArmsImproved arms = PlayerController.Instance.GetComponentInChildren<OctoIkArmsImproved>();
+                    if (arms != null)
+                    {
+                        arms.ShowArms(3f);
+                    }
+                    
+                    cameraPan.ReturnToOriginalPosition(() =>
+                    {
+                        if (PlayerController.Instance?.Movement != null)
+                        {
+                            PlayerController.Instance.Movement.enabled = true;
+                        }
+                    });
+                }
+                else if (PlayerController.Instance?.Movement != null)
+                {
+                    PlayerController.Instance.Movement.enabled = true;
+                }
+            });
+            
+            InputManager.SetContext(InputManager.InputContext.Normal);
+            
+            RestoreHeadBob();
+            
+            if (CrosshairController.Instance != null)
+            {
+                CrosshairController.Instance.Show();
+            }
+            
+            Cursor.lockState = CursorLockMode.Locked;
+            Cursor.visible = false;
+        }
+        
+        private void RestoreHeadBob()
+        {
+            if (_cameraHeadBob == null)
+                return;
+            
+            _cameraHeadBob.ClearOverride();
+        }
+        
+        private void OnDrawGizmosSelected()
+        {
+            if (DetectiveBoardCanvas.Instance == null)
+                return;
+            
+            Gizmos.color = _isBoardActive ? Color.green : Color.yellow;
+            Gizmos.DrawWireSphere(DetectiveBoardCanvas.Instance.transform.position, _activationRange);
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9f9f72364623a2a4bb50f02537fd2e72
@@ -0,0 +1,191 @@
+using System.Collections.Generic;
+using UnityEngine;
+using Unheimlich.Core;
+using Unheimlich.Features.DetectiveBoard.Data;
+
+namespace Unheimlich.Features.DetectiveBoard
+{
+    /// <summary>
+    /// Manages the detective board state and clue unlocking system.
+    /// Tracks unlocked clues, connections, certainty levels, and eliminated hypotheses.
+    /// Does NOT affect game progression - purely interpretive tool for the player.
+    /// </summary>
+    public class DetectiveBoardManager : Singleton<DetectiveBoardManager>
+    {
+        public enum CertaintyLevel
+        {
+            Uncertain,
+            Possible,
+            Confident,
+            Certain
+        }
+        
+        public class ClueState
+        {
+            public ClueData Data;
+            public bool IsUnlocked;
+            public bool IsEliminated;
+        }
+        
+        public class Connection
+        {
+            public string FromClueID;
+            public string ToClueID;
+            public CertaintyLevel Certainty;
+            public bool IsEliminated;
+        }
+        
+        [Header("References")]
+        
+        private Dictionary<string, ClueState> _clueStates = new Dictionary<string, ClueState>();
+        private List<Connection> _connections = new List<Connection>();
+        
+        public IReadOnlyDictionary<string, ClueState> ClueStates => _clueStates;
+        public IReadOnlyList<Connection> Connections => _connections;
+        
+        /// <summary>
+        /// Unlocks a clue on the detective board. Can be triggered by any in-game event.
+        /// </summary>
+        public void UnlockClue(ClueData clueData)
+        {
+            if (clueData == null)
+            {
+                Debug.LogError("[DetectiveBoardManager] Attempted to unlock null clue!");
+                return;
+            }
+            
+            if (!_clueStates.ContainsKey(clueData.ClueID))
+            {
+                _clueStates[clueData.ClueID] = new ClueState
+                {
+                    Data = clueData,
+                    IsUnlocked = true,
+                    IsEliminated = false
+                };
+                
+                OnClueUnlocked?.Invoke(clueData);
+            }
+            else if (!_clueStates[clueData.ClueID].IsUnlocked)
+            {
+                _clueStates[clueData.ClueID].IsUnlocked = true;
+                OnClueUnlocked?.Invoke(clueData);
+            }
+        }
+        
+        /// <summary>
+        /// Returns a list of all currently unlocked clues.
+        /// Used by DetectiveBoardCanvas to display already-unlocked clues on initialization.
+        /// </summary>
+        public List<ClueData> GetUnlockedClues()
+        {
+            List<ClueData> unlockedClues = new List<ClueData>();
+            foreach (var state in _clueStates.Values)
+            {
+                if (state.IsUnlocked)
+                {
+                    unlockedClues.Add(state.Data);
+                }
+            }
+            return unlockedClues;
+        }
+        
+        /// <summary>
+        /// Unlocks a clue by its ID string.
+        /// </summary>
+        public void UnlockClueByID(string clueID)
+        {
+            if (_clueStates.TryGetValue(clueID, out ClueState state))
+            {
+                if (!state.IsUnlocked)
+                {
+                    state.IsUnlocked = true;
+                    OnClueUnlocked?.Invoke(state.Data);
+                }
+            }
+            else
+            {
+                Debug.LogWarning($"[DetectiveBoardManager] Clue ID '{clueID}' not found!");
+            }
+        }
+        
+        /// <summary>
+        /// Registers a clue in the system without unlocking it.
+        /// </summary>
+        public void RegisterClue(ClueData clueData)
+        {
+            if (clueData == null || _clueStates.ContainsKey(clueData.ClueID))
+                return;
+            
+            _clueStates[clueData.ClueID] = new ClueState
+            {
+                Data = clueData,
+                IsUnlocked = false,
+                IsEliminated = false
+            };
+        }
+        
+        /// <summary>
+        /// Creates a connection between two clues.
+        /// </summary>
+        public void CreateConnection(string fromClueID, string toClueID, CertaintyLevel certainty = CertaintyLevel.Uncertain)
+        {
+            if (!_clueStates.ContainsKey(fromClueID) || !_clueStates.ContainsKey(toClueID))
+            {
+                Debug.LogWarning($"[DetectiveBoardManager] Cannot create connection - one or both clues not found!");
+                return;
+            }
+            
+            Connection existing = _connections.Find(c => 
+                (c.FromClueID == fromClueID && c.ToClueID == toClueID) ||
+                (c.FromClueID == toClueID && c.ToClueID == fromClueID));
+            
+            if (existing != null)
+            {
+                existing.Certainty = certainty;
+            }
+            else
+            {
+                _connections.Add(new Connection
+                {
+                    FromClueID = fromClueID,
+                    ToClueID = toClueID,
+                    Certainty = certainty,
+                    IsEliminated = false
+                });
+                
+                OnConnectionCreated?.Invoke(fromClueID, toClueID);
+            }
+        }
+        
+        /// <summary>
+        /// Marks a clue as eliminated (incorrect hypothesis).
+        /// </summary>
+        public void EliminateClue(string clueID)
+        {
+            if (_clueStates.TryGetValue(clueID, out ClueState state))
+            {
+                state.IsEliminated = true;
+                OnClueEliminated?.Invoke(clueID);
+            }
+        }
+        
+        /// <summary>
+        /// Marks a connection as eliminated.
+        /// </summary>
+        public void EliminateConnection(string fromClueID, string toClueID)
+        {
+            Connection connection = _connections.Find(c => 
+                (c.FromClueID == fromClueID && c.ToClueID == toClueID) ||
+                (c.FromClueID == toClueID && c.ToClueID == fromClueID));
+            
+            if (connection != null)
+            {
+                connection.IsEliminated = true;
+            }
+        }
+        
+        public event System.Action<ClueData> OnClueUnlocked;
+        public event System.Action<string, string> OnConnectionCreated;
+        public event System.Action<string> OnClueEliminated;
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4b187cdccaa498441a752e8f49ff4290