401 lines
14 KiB
C#
401 lines
14 KiB
C#
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using System.Collections;
|
||
|
||
public class TrackKeyManager : MonoBehaviour
|
||
{
|
||
public static TrackKeyManager Instance { get; private set; }
|
||
|
||
// store note instance IDs (as strings) in queue order per track
|
||
// Format: trackIndex -> Queue of (noteId, noteType) tuples
|
||
private Dictionary<int, Queue<(string noteId, string noteType)>> trackKeyMappings =
|
||
new Dictionary<int, Queue<(string, string)>>();
|
||
|
||
// Track notes currently being judged to prevent double-judging the same note
|
||
// Format: trackIndex -> HashSet of note IDs being judged
|
||
private Dictionary<int, HashSet<string>> trackNotesBeingJudged = new Dictionary<int, HashSet<string>>();
|
||
|
||
// transient per-frame consumption: ensures one physical press only affects one note per track per frame
|
||
private Dictionary<int, int> trackConsumedFrame = new Dictionary<int, int>();
|
||
|
||
// track last frame we checked for focus loss
|
||
private int lastCheckedFrame = -1;
|
||
private bool lastFocusedState = true;
|
||
|
||
// --- Anti-deadlock housekeeping ---
|
||
// Some notes can be pooled/disabled without firing OnTriggerExit2D, leaving stale ids in the queue.
|
||
// To guarantee the track never blocks forever, each queued id gets a TTL.
|
||
// When TTL expires, we prune it as stale.
|
||
private readonly Dictionary<string, float> noteIdExpiry = new Dictionary<string, float>();
|
||
|
||
[Header("TrackKeyManager housekeeping")]
|
||
[Tooltip("Seconds a queued note id is allowed to stay without being removed. Prevents permanent deadlocks when OnTriggerExit2D is missed.")]
|
||
[Range(0.5f, 10f)]
|
||
public float queuedIdTtlSeconds = 3f;
|
||
|
||
[Tooltip("Maximum number of stale head entries to prune per track per call.")]
|
||
[Range(1, 20)]
|
||
public int pruneBatchSize = 5;
|
||
|
||
private Coroutine cleanupCoroutine;
|
||
|
||
private void Awake()
|
||
{
|
||
if (Instance == null)
|
||
{
|
||
Instance = this;
|
||
}
|
||
else
|
||
{
|
||
Destroy(gameObject);
|
||
}
|
||
|
||
// start periodic cleanup to defend against stale locks that can survive missed Unregister/Unlock calls
|
||
StartCleanupRoutine();
|
||
}
|
||
|
||
private void OnDestroy()
|
||
{
|
||
StopCleanupRoutine();
|
||
}
|
||
|
||
private void StartCleanupRoutine()
|
||
{
|
||
if (cleanupCoroutine == null)
|
||
cleanupCoroutine = StartCoroutine(CleanupStaleLocksRoutine());
|
||
}
|
||
|
||
private void StopCleanupRoutine()
|
||
{
|
||
if (cleanupCoroutine != null)
|
||
{
|
||
StopCoroutine(cleanupCoroutine);
|
||
cleanupCoroutine = null;
|
||
}
|
||
}
|
||
|
||
// Periodically scan locks and queued ids to remove stale entries that can cause deadlocks.
|
||
private IEnumerator CleanupStaleLocksRoutine()
|
||
{
|
||
while (true)
|
||
{
|
||
// run once per second (unscaled so it runs during pause)
|
||
yield return new WaitForSecondsRealtime(1f);
|
||
|
||
float now = Time.unscaledTime;
|
||
|
||
// 1) Prune head entries for all tracks (defensive)
|
||
var trackKeys = new List<int>(trackKeyMappings.Keys);
|
||
foreach (var ti in trackKeys)
|
||
{
|
||
PruneStaleHeads(ti);
|
||
}
|
||
|
||
// 2) Inspect locks and release any that reference ids that are expired or not present in any queue
|
||
var trackLockKeys = new List<int>(trackNotesBeingJudged.Keys);
|
||
foreach (var t in trackLockKeys)
|
||
{
|
||
var locks = trackNotesBeingJudged[t];
|
||
if (locks == null || locks.Count == 0) continue;
|
||
|
||
var toRemove = new List<string>();
|
||
|
||
foreach (var noteId in locks)
|
||
{
|
||
bool hasExpiry = noteIdExpiry.TryGetValue(noteId, out var expiry);
|
||
bool expired = hasExpiry && now > expiry;
|
||
|
||
// If expiry missing or expired, consider the id stale and remove lock
|
||
if (!hasExpiry || expired)
|
||
{
|
||
toRemove.Add(noteId);
|
||
continue;
|
||
}
|
||
|
||
// Also if the queues do not contain this id anywhere, it is likely stale
|
||
bool foundInQueues = false;
|
||
foreach (var qpair in trackKeyMappings)
|
||
{
|
||
foreach (var item in qpair.Value)
|
||
{
|
||
if (!string.IsNullOrEmpty(item.noteId) && item.noteId == noteId)
|
||
{
|
||
foundInQueues = true;
|
||
break;
|
||
}
|
||
}
|
||
if (foundInQueues) break;
|
||
}
|
||
if (!foundInQueues)
|
||
{
|
||
toRemove.Add(noteId);
|
||
}
|
||
}
|
||
|
||
foreach (var id in toRemove)
|
||
{
|
||
locks.Remove(id);
|
||
noteIdExpiry.Remove(id);
|
||
if (GameConfig.verboseLogs) Debug.LogWarning($"[TrackKeyManager] Cleanup: removed stale lock id={id} on track {t}");
|
||
}
|
||
|
||
// If locks become empty, remove dictionary entry to keep structure clean
|
||
if (locks.Count == 0)
|
||
{
|
||
trackNotesBeingJudged.Remove(t);
|
||
}
|
||
}
|
||
|
||
// 3) Defensive: if a track has no queued ids but has consumed-frame or locks, clear them
|
||
var allTracks = new HashSet<int>();
|
||
foreach (var k in trackKeyMappings.Keys) allTracks.Add(k);
|
||
foreach (var k in trackNotesBeingJudged.Keys) allTracks.Add(k);
|
||
foreach (var k in trackConsumedFrame.Keys) allTracks.Add(k);
|
||
|
||
foreach (var track in allTracks)
|
||
{
|
||
bool hasQueue = trackKeyMappings.ContainsKey(track) && trackKeyMappings[track].Count > 0;
|
||
bool hasLocks = trackNotesBeingJudged.ContainsKey(track) && trackNotesBeingJudged[track].Count > 0;
|
||
if (!hasQueue && hasLocks)
|
||
{
|
||
// clear locks for this track
|
||
trackNotesBeingJudged.Remove(track);
|
||
if (GameConfig.verboseLogs) Debug.LogWarning($"[TrackKeyManager] Cleanup: cleared locks for empty track {track}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void Update()
|
||
{
|
||
// Clear per-frame consumption dictionary when focus is regained or at frame boundaries
|
||
int currentFrame = Time.frameCount;
|
||
bool isFocused = Application.isFocused;
|
||
|
||
// If we've moved to a new frame or focus state changed, clear consumption tracking
|
||
if (lastCheckedFrame != currentFrame || (isFocused && !lastFocusedState))
|
||
{
|
||
// On focus regain, clear the consumed frame dictionary to allow input again
|
||
if (isFocused && !lastFocusedState)
|
||
{
|
||
trackConsumedFrame.Clear();
|
||
if (GameConfig.verboseLogs) Debug.Log("[TrackKeyManager] Focus regained, cleared track consumption");
|
||
}
|
||
}
|
||
|
||
lastCheckedFrame = currentFrame;
|
||
lastFocusedState = isFocused;
|
||
}
|
||
|
||
private void PruneStaleHeads(int trackIndex)
|
||
{
|
||
if (!trackKeyMappings.TryGetValue(trackIndex, out var q) || q == null || q.Count == 0)
|
||
return;
|
||
|
||
int pruned = 0;
|
||
float now = Time.unscaledTime;
|
||
|
||
while (q.Count > 0 && pruned < Mathf.Max(1, pruneBatchSize))
|
||
{
|
||
var head = q.Peek();
|
||
if (string.IsNullOrEmpty(head.noteId))
|
||
{
|
||
q.Dequeue();
|
||
pruned++;
|
||
continue;
|
||
}
|
||
|
||
// never prune if this id is currently locked for judgement
|
||
if (trackNotesBeingJudged.TryGetValue(trackIndex, out var locks) && locks != null && locks.Contains(head.noteId))
|
||
break;
|
||
|
||
// if an expiry exists and has passed, prune
|
||
if (noteIdExpiry.TryGetValue(head.noteId, out var expiry) && now > expiry)
|
||
{
|
||
q.Dequeue();
|
||
noteIdExpiry.Remove(head.noteId);
|
||
pruned++;
|
||
if (GameConfig.verboseLogs)
|
||
Debug.LogWarning($"[TrackKeyManager] Pruned stale head on track {trackIndex}: id={head.noteId} type={head.noteType} now={now:F2} expiry={expiry:F2}");
|
||
continue;
|
||
}
|
||
|
||
// head is still within TTL
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 当音符进入判定区域时，添加音符 id 到队列（包含note类型信息）
|
||
/// noteType: "tap" 或 "hold"
|
||
/// </summary>
|
||
public void RegisterKey(int trackIndex, string noteInstanceId, string noteType = "tap")
|
||
{
|
||
if (!trackKeyMappings.ContainsKey(trackIndex))
|
||
trackKeyMappings[trackIndex] = new Queue<(string, string)>();
|
||
|
||
trackKeyMappings[trackIndex].Enqueue((noteInstanceId, noteType));
|
||
|
||
// record/refresh TTL so the id can't block forever if exit/unregister is missed
|
||
if (!string.IsNullOrEmpty(noteInstanceId))
|
||
{
|
||
noteIdExpiry[noteInstanceId] = Time.unscaledTime + Mathf.Max(0.25f, queuedIdTtlSeconds);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 当音符离开判定区域时，移除音符 id
|
||
/// </summary>
|
||
public void UnregisterKey(int trackIndex, string noteInstanceId)
|
||
{
|
||
if (!trackKeyMappings.ContainsKey(trackIndex) || trackKeyMappings[trackIndex].Count == 0)
|
||
{
|
||
// still clear TTL record
|
||
if (!string.IsNullOrEmpty(noteInstanceId)) noteIdExpiry.Remove(noteInstanceId);
|
||
return;
|
||
}
|
||
|
||
// If the head matches, dequeue. Otherwise try to remove from queue by rebuilding it.
|
||
if (trackKeyMappings[trackIndex].Count > 0 && trackKeyMappings[trackIndex].Peek().noteId == noteInstanceId)
|
||
{
|
||
trackKeyMappings[trackIndex].Dequeue();
|
||
if (!string.IsNullOrEmpty(noteInstanceId)) noteIdExpiry.Remove(noteInstanceId);
|
||
return;
|
||
}
|
||
|
||
// Otherwise remove matching id if present (preserve order of others)
|
||
var q = trackKeyMappings[trackIndex];
|
||
var temp = new Queue<(string, string)>();
|
||
while (q.Count > 0)
|
||
{
|
||
var item = q.Dequeue();
|
||
if (item.noteId != noteInstanceId)
|
||
{
|
||
temp.Enqueue(item);
|
||
}
|
||
}
|
||
trackKeyMappings[trackIndex] = temp;
|
||
|
||
if (!string.IsNullOrEmpty(noteInstanceId)) noteIdExpiry.Remove(noteInstanceId);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取轨道当前排在队首的音符实例 id（队列头）
|
||
/// </summary>
|
||
public string GetCurrentNoteId(int trackIndex)
|
||
{
|
||
PruneStaleHeads(trackIndex);
|
||
|
||
if (trackKeyMappings.ContainsKey(trackIndex) && trackKeyMappings[trackIndex].Count > 0)
|
||
{
|
||
return trackKeyMappings[trackIndex].Peek().noteId;
|
||
}
|
||
return null; // 无音符
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前队头note的类型（"tap" 或 "hold"）
|
||
/// </summary>
|
||
public string GetCurrentNoteType(int trackIndex)
|
||
{
|
||
PruneStaleHeads(trackIndex);
|
||
|
||
if (trackKeyMappings.ContainsKey(trackIndex) && trackKeyMappings[trackIndex].Count > 0)
|
||
{
|
||
return trackKeyMappings[trackIndex].Peek().noteType;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Try to register a note as being judged on a track. Returns true if successful (no other note is currently being judged).
|
||
/// This prevents multiple notes on the same track from being judged by a single key press.
|
||
/// </summary>
|
||
public bool TryLockTrackForJudge(int trackIndex, string noteId)
|
||
{
|
||
if (trackIndex < 0) return false;
|
||
|
||
// Before locking, prune any expired heads so they can't block judgement.
|
||
PruneStaleHeads(trackIndex);
|
||
|
||
if (!trackNotesBeingJudged.ContainsKey(trackIndex))
|
||
{
|
||
trackNotesBeingJudged[trackIndex] = new HashSet<string>();
|
||
}
|
||
|
||
// If there are already notes being judged on this track, reject
|
||
if (trackNotesBeingJudged[trackIndex].Count > 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Lock this note
|
||
trackNotesBeingJudged[trackIndex].Add(noteId);
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Release the lock for a note on a track. Call this after judgment is complete.
|
||
/// </summary>
|
||
public void UnlockTrackForJudge(int trackIndex, string noteId)
|
||
{
|
||
if (trackIndex < 0) return;
|
||
|
||
if (trackNotesBeingJudged.ContainsKey(trackIndex))
|
||
{
|
||
trackNotesBeingJudged[trackIndex].Remove(noteId);
|
||
}
|
||
|
||
// also clear any expiry record for this note id (it has finished its lifecycle)
|
||
if (!string.IsNullOrEmpty(noteId)) noteIdExpiry.Remove(noteId);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Try to mark this track as consumed for the current frame. Returns true if this call
|
||
/// successfully consumes the track (no other note on the same track has consumed this frame).
|
||
/// </summary>
|
||
public bool TryConsumeTrackForFrame(int trackIndex)
|
||
{
|
||
if (trackIndex < 0) return false;
|
||
int currentFrame = Time.frameCount;
|
||
|
||
// If the recorded frame is old or invalid, allow consumption
|
||
if (!trackConsumedFrame.ContainsKey(trackIndex))
|
||
{
|
||
trackConsumedFrame[trackIndex] = currentFrame;
|
||
return true;
|
||
}
|
||
|
||
// If we're in a different frame, reset and allow
|
||
int recordedFrame = trackConsumedFrame[trackIndex];
|
||
if (recordedFrame != currentFrame)
|
||
{
|
||
trackConsumedFrame[trackIndex] = currentFrame;
|
||
return true;
|
||
}
|
||
|
||
// Same frame, already consumed - reject
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Force reset the consumption state (useful for testing or specific scenarios)
|
||
/// </summary>
|
||
public void ResetConsumptionState()
|
||
{
|
||
trackConsumedFrame.Clear();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Force clear all track locks and per-frame consumption state.
|
||
/// Used to simulate a global input release (e.g. when ending playback).
|
||
/// </summary>
|
||
public void ClearAllLocks()
|
||
{
|
||
trackNotesBeingJudged.Clear();
|
||
trackConsumedFrame.Clear();
|
||
noteIdExpiry.Clear();
|
||
if (GameConfig.verboseLogs) Debug.Log("[TrackKeyManager] ClearAllLocks called: cleared locks and consumption state");
|
||
}
|
||
}
|