508 lines
24 KiB
C#
508 lines
24 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using PixelCrushers; // For Saver
|
|
using Sirenix.OdinInspector; // For ReadOnly/Button attributes (Optional: remove if not using Odin)
|
|
using UnityEngine;
|
|
using Random = UnityEngine.Random;
|
|
|
|
namespace Beyond // Ensure this namespace matches your project
|
|
{
|
|
[RequireComponent(typeof(Collider))]
|
|
public class BarkPlayer : Saver
|
|
{
|
|
#region Inspector Fields
|
|
|
|
[Header("Bark Configuration")]
|
|
[Tooltip("The indices of the BarkEntries in BarkManager's list to play sequentially.")]
|
|
public int[] barkManagerEntryIndices = new int[0];
|
|
|
|
[Tooltip("Delay in seconds after one bark's audio finishes before starting the next bark WITHIN THE SAME entry sequence.")]
|
|
[Min(0f)]
|
|
public float delayBetweenBarks = 0.5f;
|
|
|
|
[Tooltip("Delay in seconds after ALL barks in one entry sequence finish before starting the NEXT entry sequence.")]
|
|
[Min(0f)]
|
|
public float delayBetweenEntries = 5.0f;
|
|
|
|
[Tooltip("Play barks within each entry in a random order (shuffled when the entry starts).")]
|
|
public bool shuffleOrder = false;
|
|
|
|
[Header("Trigger Settings")]
|
|
[Tooltip("Layers that can activate this bark trigger.")]
|
|
public LayerMask triggeringLayers;
|
|
|
|
[Header("Activation")]
|
|
[Tooltip("If true, the BarkPlayer will be active automatically when the game starts or when loaded without existing save data for it.")]
|
|
public bool startAutomaticallyOnLoad = false;
|
|
|
|
// Runtime state fields remain private but visible for debugging if needed
|
|
[Header("Runtime State (Read Only)")]
|
|
[SerializeField, ReadOnly] // Use Sirenix ReadOnly or remove if not using Odin
|
|
private bool _runtime_IsStarted = false; // Tracks the current operational state
|
|
|
|
[SerializeField, ReadOnly]
|
|
private int currentEntryArrayIndex = 0; // Index for barkManagerEntryIndices array
|
|
|
|
[SerializeField, ReadOnly]
|
|
private int nextBarkSequenceIndex = 0; // Index for playbackOrder (within current entry)
|
|
|
|
[SerializeField, ReadOnly]
|
|
private bool isTriggeringObjectInside = false; // Is a valid object currently inside?
|
|
|
|
#endregion
|
|
|
|
#region Internal Variables
|
|
|
|
private List<int> playbackOrder; // Stores the bark order for the CURRENTLY active entry
|
|
private bool isInitialized = false;
|
|
private Collider triggerCollider;
|
|
private BarkManager barkManager; // Cached reference
|
|
private Coroutine currentPlaybackCoroutine = null;
|
|
private Transform currentTriggererTransform = null; // Transform of the object inside
|
|
|
|
#endregion
|
|
|
|
#region Save Data Structure
|
|
|
|
[System.Serializable]
|
|
public class BarkPlayerData
|
|
{
|
|
public bool savedIsStarted; // Tracks the saved state from _runtime_IsStarted
|
|
public int savedCurrentEntryArrayIndex;
|
|
public int savedNextBarkSequenceIndex;
|
|
public bool wasShuffled; // Tracks shuffle setting at time of save
|
|
}
|
|
private BarkPlayerData m_saveData = new BarkPlayerData();
|
|
|
|
#endregion
|
|
|
|
#region Unity Lifecycle Methods
|
|
|
|
public override void Awake()
|
|
{
|
|
_runtime_IsStarted = startAutomaticallyOnLoad;
|
|
base.Awake();
|
|
|
|
triggerCollider = GetComponent<Collider>();
|
|
if (!triggerCollider.isTrigger)
|
|
{
|
|
Debug.LogWarning($"BarkPlayer on {gameObject.name}: Collider was not set to 'Is Trigger'. Forcing it.", this);
|
|
triggerCollider.isTrigger = true;
|
|
}
|
|
|
|
if (triggeringLayers.value == 0)
|
|
{
|
|
int playerLayer = LayerMask.NameToLayer("Player");
|
|
if (playerLayer != -1)
|
|
{
|
|
triggeringLayers = LayerMask.GetMask("Player");
|
|
Debug.LogWarning($"BarkPlayer on {gameObject.name}: Triggering Layers not set in inspector, defaulting to 'Player' layer.", this);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Triggering Layers is not set in the inspector, and the default 'Player' layer was not found. This trigger will likely not activate.", this);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
barkManager = BarkManager.Instance;
|
|
if (barkManager == null)
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Could not find BarkManager instance! Disabling component.", this);
|
|
enabled = false;
|
|
return;
|
|
}
|
|
|
|
currentEntryArrayIndex = Mathf.Clamp(m_saveData.savedCurrentEntryArrayIndex, 0, Mathf.Max(0, barkManagerEntryIndices.Length - 1));
|
|
|
|
if (barkManagerEntryIndices == null || barkManagerEntryIndices.Length == 0)
|
|
{
|
|
Debug.LogWarning($"BarkPlayer ({gameObject.name}): No Bark Manager Entry Indices provided. Disabling.", this);
|
|
enabled = false;
|
|
return;
|
|
}
|
|
for (int i = 0; i < barkManagerEntryIndices.Length; i++)
|
|
{
|
|
if (barkManagerEntryIndices[i] < 0 || barkManagerEntryIndices[i] >= barkManager.m_barks.Length)
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Invalid Bark Manager Entry Index {barkManagerEntryIndices[i]} at array position {i}. Max index is {barkManager.m_barks.Length - 1}. Disabling.", this);
|
|
enabled = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
isInitialized = true;
|
|
CheckForAutoStartIfInside(); // Check immediately if conditions are met
|
|
}
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
Collider col = GetComponent<Collider>();
|
|
if (col != null)
|
|
{
|
|
Gizmos.color = isTriggeringObjectInside ? new Color(1f, 0.5f, 0.5f, 0.4f) : new Color(0.5f, 1f, 0.5f, 0.3f);
|
|
if (col is BoxCollider box) Gizmos.DrawCube(transform.TransformPoint(box.center), Vector3.Scale(box.size, transform.lossyScale));
|
|
else if (col is SphereCollider sphere) Gizmos.DrawSphere(transform.TransformPoint(sphere.center), sphere.radius * MaxComponent(transform.lossyScale));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Trigger Handling
|
|
|
|
private void OnTriggerEnter(Collider other)
|
|
{
|
|
// Only ignore if not initialized or component is disabled
|
|
if (!isInitialized || !enabled) return;
|
|
|
|
// --- Layer Check ---
|
|
int otherLayer = other.gameObject.layer;
|
|
if ((triggeringLayers.value & (1 << otherLayer)) == 0)
|
|
{
|
|
return; // Layer not in mask, ignore this trigger event
|
|
}
|
|
|
|
// --- Check if already processing an object ---
|
|
// This prevents multiple triggering objects from interfering. Only the first one in matters.
|
|
if (isTriggeringObjectInside && other.transform != currentTriggererTransform)
|
|
{
|
|
// If another object enters while one is already tracked, ignore the new one.
|
|
// If it's the *same* object re-entering (somehow), this check might be too strict,
|
|
// but standard OnTriggerEnter/Exit should handle one object at a time.
|
|
return;
|
|
}
|
|
if (isTriggeringObjectInside) return; // Simplified: if already tracking one, ignore others.
|
|
|
|
// --- Valid Trigger - Mark presence ---
|
|
// We set these REGARDLESS of _runtime_IsStarted so state is correct when StartPlayer() is called
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Triggering object '{other.name}' entered (tracking presence).", this);
|
|
isTriggeringObjectInside = true;
|
|
currentTriggererTransform = other.transform; // Store the transform for barking
|
|
|
|
// --- Start Playback Coroutine if player is started and not already running ---
|
|
// This handles the case where the player enters *after* StartPlayer() has been called
|
|
if (_runtime_IsStarted && currentPlaybackCoroutine == null)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Player is active. Starting playback loop due to new entry.", this);
|
|
// Apply potentially loaded/saved array index before starting loop
|
|
currentEntryArrayIndex = Mathf.Clamp(m_saveData.savedCurrentEntryArrayIndex, 0, Mathf.Max(0, barkManagerEntryIndices.Length - 1));
|
|
// nextBarkSequenceIndex will be set by PrepareEntrySequence inside the coroutine
|
|
currentPlaybackCoroutine = StartCoroutine(ContinuousPlaybackLoop());
|
|
}
|
|
// If !_runtime_IsStarted, isTriggeringObjectInside is now true,
|
|
// and CheckForAutoStartIfInside() (called by StartPlayer()) will pick it up.
|
|
}
|
|
|
|
|
|
private void OnTriggerExit(Collider other)
|
|
{
|
|
if (!isInitialized || !enabled) return;
|
|
|
|
int otherLayer = other.gameObject.layer;
|
|
if ((triggeringLayers.value & (1 << otherLayer)) == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (other.transform == currentTriggererTransform)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Tracked triggering object '{other.name}' exited.", this);
|
|
isTriggeringObjectInside = false;
|
|
currentTriggererTransform = null;
|
|
|
|
if (currentPlaybackCoroutine != null)
|
|
{
|
|
StopCoroutine(currentPlaybackCoroutine);
|
|
currentPlaybackCoroutine = null;
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Stopping playback loop due to exit.", this);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Playback Logic
|
|
|
|
private bool PrepareEntrySequence(int entryIndexToPrepare)
|
|
{
|
|
if (barkManager == null) return false;
|
|
|
|
int barkCount = barkManager.GetBarkCountInEntry(entryIndexToPrepare);
|
|
if (barkCount <= 0)
|
|
{
|
|
Debug.LogWarning($"BarkPlayer ({gameObject.name}): BarkEntry {entryIndexToPrepare} (from array index {currentEntryArrayIndex}) has no barks. Skipping entry.", this);
|
|
playbackOrder = new List<int>();
|
|
nextBarkSequenceIndex = 0;
|
|
return false;
|
|
}
|
|
|
|
playbackOrder = Enumerable.Range(0, barkCount).ToList();
|
|
if (shuffleOrder)
|
|
{
|
|
for (int i = playbackOrder.Count - 1; i > 0; i--)
|
|
{
|
|
int j = Random.Range(0, i + 1);
|
|
(playbackOrder[i], playbackOrder[j]) = (playbackOrder[j], playbackOrder[i]);
|
|
}
|
|
}
|
|
|
|
// Apply saved index ONLY if the loaded entry array index matches the current one
|
|
// AND if the shuffle setting at time of save matches current.
|
|
// If shuffle setting changed, it's safer to restart the entry.
|
|
if (currentEntryArrayIndex == m_saveData.savedCurrentEntryArrayIndex && shuffleOrder == m_saveData.wasShuffled)
|
|
{
|
|
nextBarkSequenceIndex = Mathf.Clamp(m_saveData.savedNextBarkSequenceIndex, 0, playbackOrder.Count);
|
|
}
|
|
else
|
|
{
|
|
nextBarkSequenceIndex = 0;
|
|
}
|
|
// Clear the saved next bark index after applying it or deciding not to,
|
|
// so it's not incorrectly reused if we loop back to this entry without saving/loading.
|
|
// m_saveData.savedNextBarkSequenceIndex = 0; // Reconsider this - only clear on actual load/new entry start.
|
|
|
|
return true;
|
|
}
|
|
|
|
private IEnumerator ContinuousPlaybackLoop()
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Starting playback loop.", this);
|
|
|
|
if (barkManagerEntryIndices == null || barkManagerEntryIndices.Length == 0)
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Cannot start loop, entry indices array is empty or null.", this);
|
|
currentPlaybackCoroutine = null;
|
|
yield break;
|
|
}
|
|
|
|
// Outer loop: Continues as long as a valid triggering object is inside AND player is started
|
|
while (isTriggeringObjectInside && currentTriggererTransform != null && _runtime_IsStarted) // Added _runtime_IsStarted check here too
|
|
{
|
|
if (currentEntryArrayIndex >= barkManagerEntryIndices.Length)
|
|
{
|
|
currentEntryArrayIndex = 0;
|
|
if (barkManagerEntryIndices.Length == 0)
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Entry indices array became empty during loop?", this);
|
|
currentPlaybackCoroutine = null; // Ensure it's cleared
|
|
yield break;
|
|
}
|
|
}
|
|
|
|
int currentManagerEntryIndex = barkManagerEntryIndices[currentEntryArrayIndex];
|
|
bool canPlayEntry = PrepareEntrySequence(currentManagerEntryIndex);
|
|
|
|
if (!canPlayEntry)
|
|
{
|
|
currentEntryArrayIndex++;
|
|
m_saveData.savedNextBarkSequenceIndex = 0; // Ensure next time this entry is loaded (if looping), it starts fresh
|
|
yield return null;
|
|
continue;
|
|
}
|
|
|
|
while (nextBarkSequenceIndex < playbackOrder.Count && isTriggeringObjectInside && currentTriggererTransform != null && _runtime_IsStarted)
|
|
{
|
|
while (barkManager.IsPlaying && isTriggeringObjectInside && _runtime_IsStarted)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (!isTriggeringObjectInside || currentTriggererTransform == null || !_runtime_IsStarted) break;
|
|
|
|
int barkIndexToPlay = playbackOrder[nextBarkSequenceIndex];
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Playing Bark {nextBarkSequenceIndex + 1}/{playbackOrder.Count} (Actual Index: {barkIndexToPlay}) from Entry {currentManagerEntryIndex}.", this);
|
|
|
|
AudioClip playedClip = barkManager.PlayBark(currentManagerEntryIndex, currentTriggererTransform, barkIndexToPlay);
|
|
nextBarkSequenceIndex++;
|
|
|
|
float waitTime = delayBetweenBarks;
|
|
if (playedClip != null) { waitTime += Mathf.Max(0f, playedClip.length); }
|
|
|
|
if (waitTime > 0)
|
|
{
|
|
float timer = 0f;
|
|
while (timer < waitTime && isTriggeringObjectInside && currentTriggererTransform != null && _runtime_IsStarted)
|
|
{
|
|
timer += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
if (!isTriggeringObjectInside || currentTriggererTransform == null || !_runtime_IsStarted) break;
|
|
}
|
|
|
|
if (isTriggeringObjectInside && currentTriggererTransform != null && _runtime_IsStarted)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Finished sequence for Entry {currentManagerEntryIndex}.", this);
|
|
currentEntryArrayIndex++;
|
|
m_saveData.savedNextBarkSequenceIndex = 0; // Reset for next entry
|
|
|
|
if (currentEntryArrayIndex >= barkManagerEntryIndices.Length)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Finished all entries in the array. Looping back.", this);
|
|
currentEntryArrayIndex = 0;
|
|
}
|
|
|
|
if (delayBetweenEntries > 0)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Waiting {delayBetweenEntries}s before next entry.", this);
|
|
float timer = 0f;
|
|
while (timer < delayBetweenEntries && isTriggeringObjectInside && currentTriggererTransform != null && _runtime_IsStarted)
|
|
{
|
|
timer += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
if (!isTriggeringObjectInside || currentTriggererTransform == null || !_runtime_IsStarted) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Playback loop finished.", this);
|
|
// Only clear if this instance of the coroutine is the one stopping.
|
|
// If StopPlayer() was called, it would have already nulled currentPlaybackCoroutine.
|
|
if (currentPlaybackCoroutine == this.currentPlaybackCoroutine) // Check if this is still the active coroutine
|
|
{
|
|
currentPlaybackCoroutine = null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Control Methods
|
|
|
|
[Button]
|
|
public void StartPlayer()
|
|
{
|
|
if (!_runtime_IsStarted)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Player Runtime Explicitly Started.", this);
|
|
_runtime_IsStarted = true;
|
|
// Clear any previously saved next bark index when explicitly starting,
|
|
// unless shuffle settings are the same and we are on the same entry.
|
|
// This is tricky. For now, CheckForAutoStartIfInside will rely on PrepareEntrySequence
|
|
// to correctly determine if it should resume.
|
|
// m_saveData.savedNextBarkSequenceIndex = 0; // Maybe too aggressive.
|
|
|
|
if (isInitialized)
|
|
{
|
|
CheckForAutoStartIfInside();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Player Runtime was already started.", this);
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void StopPlayer()
|
|
{
|
|
if (_runtime_IsStarted)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Player Runtime Explicitly Stopped.", this);
|
|
_runtime_IsStarted = false;
|
|
|
|
if (currentPlaybackCoroutine != null)
|
|
{
|
|
StopCoroutine(currentPlaybackCoroutine);
|
|
currentPlaybackCoroutine = null;
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Stopping active playback loop due to StopPlayer call.", this);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckForAutoStartIfInside()
|
|
{
|
|
// This is called from Start() and StartPlayer()
|
|
if (_runtime_IsStarted && isTriggeringObjectInside && currentTriggererTransform != null && currentPlaybackCoroutine == null && isInitialized)
|
|
{
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Conditions met for auto-start. Object inside, player started, no active coroutine. Starting playback loop.", this);
|
|
// Ensure currentEntryArrayIndex is correctly set from save data before starting
|
|
// (it should already be from Start() or ApplyData(), but good to be sure)
|
|
currentEntryArrayIndex = Mathf.Clamp(m_saveData.savedCurrentEntryArrayIndex, 0, Mathf.Max(0, barkManagerEntryIndices.Length - 1));
|
|
// nextBarkSequenceIndex will be determined by PrepareEntrySequence
|
|
currentPlaybackCoroutine = StartCoroutine(ContinuousPlaybackLoop());
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Save System Integration (Pixel Crushers Saver)
|
|
|
|
public override string RecordData()
|
|
{
|
|
m_saveData.savedIsStarted = this._runtime_IsStarted;
|
|
m_saveData.savedCurrentEntryArrayIndex = this.currentEntryArrayIndex;
|
|
// Only save nextBarkSequenceIndex if a coroutine is running and we are "mid-sequence"
|
|
// Otherwise, it should be 0 for the next entry.
|
|
if (currentPlaybackCoroutine != null && nextBarkSequenceIndex > 0 && nextBarkSequenceIndex < (playbackOrder?.Count ?? 0))
|
|
{
|
|
m_saveData.savedNextBarkSequenceIndex = this.nextBarkSequenceIndex;
|
|
}
|
|
else
|
|
{
|
|
// If not actively playing a sequence or at the start/end, save 0.
|
|
// This means when loading, it will either start the currentEntryArrayIndex from the beginning,
|
|
// or if currentEntryArrayIndex was incremented after an entry finished, it will start the *new* entry from beginning.
|
|
m_saveData.savedNextBarkSequenceIndex = 0;
|
|
}
|
|
m_saveData.wasShuffled = this.shuffleOrder;
|
|
|
|
return SaveSystem.Serialize(m_saveData);
|
|
}
|
|
|
|
public override void ApplyData(string s)
|
|
{
|
|
if (string.IsNullOrEmpty(s))
|
|
{
|
|
_runtime_IsStarted = startAutomaticallyOnLoad;
|
|
m_saveData = new BarkPlayerData(); // Ensure fresh save data container
|
|
m_saveData.savedIsStarted = _runtime_IsStarted; // Sync with runtime
|
|
m_saveData.savedCurrentEntryArrayIndex = 0;
|
|
m_saveData.savedNextBarkSequenceIndex = 0;
|
|
m_saveData.wasShuffled = shuffleOrder; // Use current inspector setting
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): No save data, using startAutomaticallyOnLoad ({_runtime_IsStarted}).", this);
|
|
return;
|
|
}
|
|
|
|
var loadedData = SaveSystem.Deserialize<BarkPlayerData>(s);
|
|
if (loadedData != null)
|
|
{
|
|
m_saveData = loadedData;
|
|
this._runtime_IsStarted = m_saveData.savedIsStarted;
|
|
// currentEntryArrayIndex and nextBarkSequenceIndex will be used by Start() and PrepareEntrySequence()
|
|
Debug.Log($"BarkPlayer ({gameObject.name}): Applied loaded data. Started={_runtime_IsStarted}, EntryIdx={m_saveData.savedCurrentEntryArrayIndex}, BarkIdx={m_saveData.savedNextBarkSequenceIndex}, WasShuffled={m_saveData.wasShuffled}.", this);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"BarkPlayer ({gameObject.name}): Failed to deserialize save data. Using defaults.", this);
|
|
_runtime_IsStarted = startAutomaticallyOnLoad;
|
|
m_saveData = new BarkPlayerData();
|
|
m_saveData.savedIsStarted = _runtime_IsStarted;
|
|
m_saveData.savedCurrentEntryArrayIndex = 0;
|
|
m_saveData.savedNextBarkSequenceIndex = 0;
|
|
m_saveData.wasShuffled = shuffleOrder;
|
|
}
|
|
|
|
// After applying data, if loaded state is 'stopped', ensure coroutine is also stopped.
|
|
// CheckForAutoStartIfInside in Start() will handle restarting if needed.
|
|
if (!this._runtime_IsStarted && currentPlaybackCoroutine != null)
|
|
{
|
|
StopCoroutine(currentPlaybackCoroutine);
|
|
currentPlaybackCoroutine = null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
private float MaxComponent(Vector3 v) => Mathf.Max(Mathf.Max(v.x, v.y), v.z);
|
|
#endregion
|
|
}
|
|
} |