537 lines
21 KiB
C#
537 lines
21 KiB
C#
using UnityEngine;
|
|
using TMPro;
|
|
using System.Collections; // Documentation text normalized.
|
|
using System.Collections.Generic; // For List
|
|
|
|
public class AnimationController : MonoBehaviour
|
|
{
|
|
[HideInInspector] public bool isGlobalController = false;
|
|
|
|
public static AnimationController Global;
|
|
|
|
public GameObject redEffect; // Documentation text normalized.
|
|
public GameObject greenEffect; // Documentation text normalized.
|
|
public GameObject yellowEffect; // Documentation text normalized.
|
|
public GameObject purpleEffect; // Documentation text normalized.
|
|
public GameObject blueEffect; // Documentation text normalized.
|
|
|
|
private Animator redAnimator;
|
|
private Animator greenAnimator;
|
|
private Animator yellowAnimator;
|
|
private Animator purpleAnimator;
|
|
private Animator blueAnimator;
|
|
|
|
// Scene object used as particle source (must be assigned in scene or found automatically)
|
|
public GameObject hit_particular_object;
|
|
public GameObject hit_ring_object;
|
|
|
|
[Header("Inspector")]
|
|
public string redColorHex = "#FF9390";
|
|
public string greenColorHex = "#38F6CA";
|
|
public string yellowColorHex = "#FFE1A2";
|
|
public string purpleColorHex = "#F083E4";
|
|
public string blueColorHex = "#7AF9FF";
|
|
[Header("Inspector")]
|
|
public float holdParticleInterval = 0.2f;
|
|
|
|
private Coroutine holdParticleCoroutine;
|
|
private bool holdActive = false;
|
|
private string currentHoldColor;
|
|
private bool isHolding = false;
|
|
private WaitForSeconds cachedHoldWait;
|
|
private float cachedHoldWaitSeconds = -1f;
|
|
private static bool loggedMissingHitParticleSource;
|
|
|
|
// Track active particle instances for immediate cleanup
|
|
private List<GameObject> activeParticles = new List<GameObject>();
|
|
|
|
[Header("Inspector")]
|
|
public GameObject perfect_judge_prefab;
|
|
public GameObject great_judge_prefab;
|
|
public GameObject good_judge_prefab;
|
|
public GameObject miss_judge_prefab;
|
|
[Header("Inspector")]
|
|
// Documentation text normalized.
|
|
public TextMeshProUGUI red_track_judgementText;
|
|
public TextMeshProUGUI green_track_judgementText;
|
|
public TextMeshProUGUI yellow_track_judgementText;
|
|
public TextMeshProUGUI purple_track_judgementText;
|
|
public TextMeshProUGUI blue_track_judgementText;
|
|
|
|
public void StartHoldParticles(string color)
|
|
{
|
|
// Prefer the Global controller if available so Start/Stop always affect the same instance
|
|
if (AnimationController.Global != null && AnimationController.Global != this)
|
|
{
|
|
AnimationController.Global.InternalStartHoldParticles(color);
|
|
return;
|
|
}
|
|
|
|
InternalStartHoldParticles(color);
|
|
}
|
|
|
|
public void StopHoldParticles()
|
|
{
|
|
if (AnimationController.Global != null && AnimationController.Global != this)
|
|
{
|
|
AnimationController.Global.InternalStopHoldParticles();
|
|
return;
|
|
}
|
|
|
|
InternalStopHoldParticles();
|
|
}
|
|
|
|
// Internal implementations operate on this instance
|
|
private void InternalStartHoldParticles(string color)
|
|
{
|
|
if (holdActive) return;
|
|
|
|
holdActive = true;
|
|
currentHoldColor = color;
|
|
|
|
if (holdParticleCoroutine != null)
|
|
{
|
|
StopCoroutine(holdParticleCoroutine);
|
|
}
|
|
|
|
holdParticleCoroutine = StartCoroutine(HoldParticleRoutine(color));
|
|
}
|
|
|
|
private void InternalStopHoldParticles()
|
|
{
|
|
holdActive = false;
|
|
|
|
if (holdParticleCoroutine != null)
|
|
{
|
|
try { StopCoroutine(holdParticleCoroutine); } catch { }
|
|
holdParticleCoroutine = null;
|
|
}
|
|
|
|
// Immediately destroy all active particle instances
|
|
foreach (var p in activeParticles)
|
|
{
|
|
if (p != null)
|
|
{
|
|
Destroy(p);
|
|
}
|
|
}
|
|
activeParticles.Clear();
|
|
}
|
|
|
|
private IEnumerator HoldParticleRoutine(string color)
|
|
{
|
|
while (holdActive)
|
|
{
|
|
float waitSeconds = Mathf.Max(0.01f, holdParticleInterval);
|
|
if (cachedHoldWait == null || !Mathf.Approximately(cachedHoldWaitSeconds, waitSeconds))
|
|
{
|
|
cachedHoldWaitSeconds = waitSeconds;
|
|
cachedHoldWait = new WaitForSeconds(waitSeconds);
|
|
}
|
|
yield return cachedHoldWait;
|
|
if (!holdActive) break;
|
|
PlayDestroyAnimation(color);
|
|
}
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (isGlobalController)
|
|
{
|
|
if (Global != null && Global != this)
|
|
{
|
|
Debug.LogWarning("[AnimationController] Duplicate global detected, destroying self");
|
|
Destroy(this);
|
|
return;
|
|
}
|
|
|
|
Global = this;
|
|
DontDestroyOnLoad(gameObject);
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log("[AnimationController] Global AnimationController registered");
|
|
}
|
|
|
|
// Animator cache
|
|
redAnimator = redEffect != null ? redEffect.GetComponent<Animator>() : null;
|
|
greenAnimator = greenEffect != null ? greenEffect.GetComponent<Animator>() : null;
|
|
yellowAnimator = yellowEffect != null ? yellowEffect.GetComponent<Animator>() : null;
|
|
purpleAnimator = purpleEffect != null ? purpleEffect.GetComponent<Animator>() : null;
|
|
blueAnimator = blueEffect != null ? blueEffect.GetComponent<Animator>() : null;
|
|
|
|
// If the scene object reference was not assigned on this instance (common when this script is on a prefab),
|
|
// try to locate a scene object automatically so runtime instances can still use a shared particle source.
|
|
if (hit_particular_object == null)
|
|
{
|
|
// First try a tag-based lookup. Designer should assign the scene particle source a tag "HitParticleSource".
|
|
try
|
|
{
|
|
var byTag = GameObject.FindWithTag("HitParticleSource");
|
|
if (byTag != null)
|
|
{
|
|
hit_particular_object = byTag;
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log("AnimationController: assigned hit_particular_object via tag 'HitParticleSource'.");
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
// Next try common names if tag not used
|
|
if (hit_particular_object == null)
|
|
{
|
|
var byName = GameObject.Find("HitParticleSource") ?? GameObject.Find("hit_particular_object") ?? GameObject.Find("Hit_Particle_Source");
|
|
if (byName != null)
|
|
{
|
|
hit_particular_object = byName;
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log("AnimationController: assigned hit_particular_object via GameObject.Find by name.");
|
|
}
|
|
}
|
|
|
|
if (hit_particular_object == null)
|
|
{
|
|
if (JudgeManager.IsDebugEnabled)
|
|
Debug.LogWarning("AnimationController: hit_particular_object not assigned in Inspector and automatic lookup failed.\n" +
|
|
"You can either assign a scene object to 'hit_particular_object' on the prefab instance in the scene,\n" +
|
|
"or tag the scene particle source with 'HitParticleSource', or place a GameObject named 'HitParticleSource' in the scene.");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void PlayDestroyAnimation(string color)
|
|
{
|
|
// Only use the scene object as the template. No prefab fallback.
|
|
if (hit_particular_object == null)
|
|
{
|
|
if (!loggedMissingHitParticleSource)
|
|
{
|
|
loggedMissingHitParticleSource = true;
|
|
Debug.LogError("hit_particular_object is null. Assign a scene particle source to AnimationController.hit_particular_object or tag a GameObject 'HitParticleSource'.");
|
|
}
|
|
// As a fallback, trigger the Animator-based effects
|
|
TriggerAnimatorEffect(color);
|
|
return;
|
|
}
|
|
|
|
GameObject source = hit_particular_object;
|
|
|
|
// choose spawn position: prefer per-color effect transform if available
|
|
Vector3 spawnPos = transform.position;
|
|
Transform parentTransform = null;
|
|
switch (color)
|
|
{
|
|
case "red": if (redEffect != null) { spawnPos = redEffect.transform.position; parentTransform = redEffect.transform; } break;
|
|
case "green": if (greenEffect != null) { spawnPos = greenEffect.transform.position; parentTransform = greenEffect.transform; } break;
|
|
case "yellow": if (yellowEffect != null) { spawnPos = yellowEffect.transform.position; parentTransform = yellowEffect.transform; } break;
|
|
case "purple": if (purpleEffect != null) { spawnPos = purpleEffect.transform.position; parentTransform = purpleEffect.transform; } break;
|
|
case "blue": if (blueEffect != null) { spawnPos = blueEffect.transform.position; parentTransform = blueEffect.transform; } break;
|
|
}
|
|
|
|
// Documentation text normalized.
|
|
Color trackColor;
|
|
string hexCode = GetHexCodeForColor(color);
|
|
|
|
// Documentation text normalized.
|
|
if (!ColorUtility.TryParseHtmlString(hexCode, out trackColor))
|
|
{
|
|
trackColor = Color.white;
|
|
if (JudgeManager.IsDebugEnabled) Debug.LogWarning($"Failed to parse hex color for '{color}' ({hexCode}). Using white.");
|
|
}
|
|
|
|
SpawnJudgePrefabByTrackText(color);
|
|
// Instantiate a copy of the scene object
|
|
GameObject particleInstance = Instantiate(source, spawnPos, Quaternion.identity);
|
|
if (particleInstance == null)
|
|
{
|
|
Debug.LogError("Failed to instantiate hit_particular_object");
|
|
TriggerAnimatorEffect(color);
|
|
return;
|
|
}
|
|
|
|
particleInstance.SetActive(true);
|
|
|
|
// Find all ParticleSystems on the instance (root + children) and set their startColor
|
|
var systems = particleInstance.GetComponentsInChildren<ParticleSystem>(true);
|
|
if (systems != null && systems.Length > 0)
|
|
{
|
|
float maxLifetime = 0f;
|
|
foreach (var ps in systems)
|
|
{
|
|
var main = ps.main;
|
|
// Set start color (works for most setups)
|
|
main.startColor = trackColor;
|
|
// Play the system
|
|
ps.Play();
|
|
// determine lifetime (use constantMax for safety)
|
|
var lifetime = main.startLifetime;
|
|
float life = lifetime.constantMax;
|
|
if (life <= 0f) life = lifetime.constant; // fallback
|
|
if (life > maxLifetime) maxLifetime = life;
|
|
}
|
|
|
|
// Optionally parent the instance under the effect object so it moves with UI/slot
|
|
if (parentTransform != null)
|
|
{
|
|
particleInstance.transform.SetParent(parentTransform, true);
|
|
}
|
|
|
|
// Destroy after max lifetime + small buffer
|
|
Destroy(particleInstance, Mathf.Max(0.5f, maxLifetime + 0.1f));
|
|
|
|
// Track for immediate cleanup
|
|
activeParticles.Add(particleInstance);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("No ParticleSystem components found on hit_particular_object instance");
|
|
Destroy(particleInstance);
|
|
TriggerAnimatorEffect(color);
|
|
}
|
|
|
|
// NEW: instantiate and play ring effect (overlay) if assigned
|
|
if (hit_ring_object != null)
|
|
{
|
|
GameObject ringInstance = Instantiate(hit_ring_object, spawnPos, Quaternion.identity);
|
|
if (ringInstance != null)
|
|
{
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log($"AnimationController: instantiated hit_ring_object '{ringInstance.name}' at {spawnPos}. parentTransform={(parentTransform != null ? parentTransform.name : "null")} ");
|
|
|
|
// Parent before activation to avoid transform surprises when Simulation Space = Local
|
|
if (parentTransform != null)
|
|
{
|
|
ringInstance.transform.SetParent(parentTransform, false);
|
|
// keep world position at spawnPos
|
|
ringInstance.transform.position = spawnPos;
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log("AnimationController: ringInstance parent set to " + parentTransform.name);
|
|
}
|
|
|
|
// Activate after parenting
|
|
ringInstance.SetActive(true);
|
|
|
|
var ringSystems = ringInstance.GetComponentsInChildren<ParticleSystem>(true);
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log("AnimationController: ringSystems count=" + (ringSystems != null ? ringSystems.Length : 0));
|
|
if (ringSystems != null && ringSystems.Length > 0)
|
|
{
|
|
float ringMaxLife = 0f;
|
|
foreach (var rps in ringSystems)
|
|
{
|
|
var rmain = rps.main;
|
|
// log important runtime properties for debugging
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log($"ring PS: {rps.gameObject.name} simulationSpace={rmain.simulationSpace} startLifetime={rmain.startLifetime.constant} startColor={rmain.startColor.color}");
|
|
|
|
// reuse same track color
|
|
rmain.startColor = trackColor;
|
|
rps.Play();
|
|
var rlifetime = rmain.startLifetime;
|
|
float rlife = rlifetime.constantMax;
|
|
if (rlife <= 0f) rlife = rlifetime.constant;
|
|
if (rlife > ringMaxLife) ringMaxLife = rlife;
|
|
|
|
// Also log emission rate if available
|
|
try
|
|
{
|
|
var emission = rps.emission;
|
|
var rate = emission.rateOverTime;
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log($"ring PS emission rateOverTime.constant (approx) = {rate.constant}");
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
Destroy(ringInstance, Mathf.Max(0.5f, ringMaxLife + 0.1f));
|
|
|
|
// Track for immediate cleanup
|
|
activeParticles.Add(ringInstance);
|
|
}
|
|
else
|
|
{
|
|
if (JudgeManager.IsDebugEnabled) Debug.LogWarning("hit_ring_object has no ParticleSystem components");
|
|
Destroy(ringInstance);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Failed to instantiate hit_ring_object");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Documentation text normalized.
|
|
private string GetHexCodeForColor(string color)
|
|
{
|
|
switch (color)
|
|
{
|
|
case "red": return redColorHex;
|
|
case "green": return greenColorHex;
|
|
case "yellow": return yellowColorHex;
|
|
case "purple": return purpleColorHex;
|
|
case "blue": return blueColorHex;
|
|
default: return "#FFFFFF"; // Documentation text normalized.
|
|
}
|
|
}
|
|
|
|
private void TriggerAnimatorEffect(string color)
|
|
{
|
|
// Fallback to original Animator triggers if particle source missing
|
|
switch (color)
|
|
{
|
|
case "red":
|
|
if (redAnimator != null)
|
|
{
|
|
redAnimator.ResetTrigger("PlayRedDestroy");
|
|
redAnimator.SetTrigger("PlayRedDestroy");
|
|
}
|
|
break;
|
|
case "green":
|
|
if (greenAnimator != null)
|
|
{
|
|
greenAnimator.ResetTrigger("PlayGreenDestroy");
|
|
greenAnimator.SetTrigger("PlayGreenDestroy");
|
|
}
|
|
break;
|
|
case "yellow":
|
|
if (yellowAnimator != null)
|
|
{
|
|
yellowAnimator.ResetTrigger("PlayYellowDestroy");
|
|
yellowAnimator.SetTrigger("PlayYellowDestroy");
|
|
}
|
|
break;
|
|
case "purple":
|
|
if (purpleAnimator != null)
|
|
{
|
|
purpleAnimator.ResetTrigger("PlayPurpleDestroy");
|
|
purpleAnimator.SetTrigger("PlayPurpleDestroy");
|
|
}
|
|
break;
|
|
case "blue":
|
|
if (blueAnimator != null)
|
|
{
|
|
blueAnimator.ResetTrigger("PlayBlueDestroy");
|
|
blueAnimator.SetTrigger("PlayBlueDestroy");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Documentation text normalized.
|
|
/// </summary>
|
|
private void SpawnJudgePrefabByTrackText(string color)
|
|
{
|
|
TextMeshProUGUI targetText = null;
|
|
Transform spawnPoint = null;
|
|
|
|
// Documentation text normalized.
|
|
switch (color)
|
|
{
|
|
case "red": targetText = red_track_judgementText; spawnPoint = redEffect != null ? redEffect.transform : null; break;
|
|
case "green": targetText = green_track_judgementText; spawnPoint = greenEffect != null ? greenEffect.transform : null; break;
|
|
case "yellow": targetText = yellow_track_judgementText; spawnPoint = yellowEffect != null ? yellowEffect.transform : null; break;
|
|
case "purple": targetText = purple_track_judgementText; spawnPoint = purpleEffect != null ? purpleEffect.transform : null; break;
|
|
case "blue": targetText = blue_track_judgementText; spawnPoint = blueEffect != null ? blueEffect.transform : null; break;
|
|
}
|
|
if (targetText != null && spawnPoint != null)
|
|
{
|
|
// Documentation text normalized.
|
|
if (JudgeManager.IsDebugEnabled) Debug.Log($"判定 {color} 当前读取到的文字为 [{targetText.text}]");
|
|
}
|
|
|
|
// Documentation text normalized.
|
|
if (targetText != null && spawnPoint != null && !string.IsNullOrEmpty(targetText.text))
|
|
{
|
|
DoExecutePrefabSpawn(targetText.text, spawnPoint);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Documentation text normalized.
|
|
/// </summary>
|
|
private void DoExecutePrefabSpawn(string judgeResult, Transform spawnTransform)
|
|
{
|
|
GameObject prefabToUse = null;
|
|
|
|
// Documentation text normalized.
|
|
if (judgeResult.Contains("Perfect")) prefabToUse = perfect_judge_prefab;
|
|
else if (judgeResult.Contains("Great")) prefabToUse = great_judge_prefab;
|
|
else if (judgeResult.Contains("Good")) prefabToUse = good_judge_prefab;
|
|
else if (judgeResult.Contains("Miss")) prefabToUse = miss_judge_prefab;
|
|
|
|
if (prefabToUse != null)
|
|
{
|
|
// Documentation text normalized.
|
|
GameObject instance = Instantiate(prefabToUse, spawnTransform.position, Quaternion.identity);
|
|
|
|
// Documentation text normalized.
|
|
Destroy(instance, 1.0f);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Public API to prewarm particle instances. Call during loading/pause time to avoid hitch on first use.
|
|
/// This will instantiate the configured scene particle sources (hit_particular_object / hit_ring_object)
|
|
/// and briefly play their ParticleSystems to force any internal setup.
|
|
/// </summary>
|
|
public void PrewarmParticles(int perTemplate = 2)
|
|
{
|
|
// start coroutine to avoid blocking main thread with many instantiations
|
|
StartCoroutine(PrewarmCoroutine(perTemplate));
|
|
}
|
|
|
|
private IEnumerator PrewarmCoroutine(int perTemplate)
|
|
{
|
|
// List of templates to warm
|
|
var templates = new List<GameObject>();
|
|
if (hit_particular_object != null) templates.Add(hit_particular_object);
|
|
if (hit_ring_object != null) templates.Add(hit_ring_object);
|
|
|
|
for (int i = 0; i < templates.Count; i++)
|
|
{
|
|
var prefab = templates[i];
|
|
for (int j = 0; j < perTemplate; j++)
|
|
{
|
|
GameObject inst = null;
|
|
try
|
|
{
|
|
inst = Instantiate(prefab, this.transform);
|
|
inst.SetActive(true);
|
|
var systems = inst.GetComponentsInChildren<ParticleSystem>(true);
|
|
if (systems != null)
|
|
{
|
|
foreach (var ps in systems)
|
|
{
|
|
try { ps.Play(); } catch { }
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
// wait a frame to allow any internal initialization to run
|
|
yield return null;
|
|
|
|
// stop and destroy the instance to free memory - the warmup work is done
|
|
if (inst != null)
|
|
{
|
|
var systems = inst.GetComponentsInChildren<ParticleSystem>(true);
|
|
if (systems != null)
|
|
{
|
|
foreach (var ps in systems)
|
|
{
|
|
try { ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); } catch { }
|
|
}
|
|
}
|
|
Destroy(inst);
|
|
}
|
|
|
|
// small yield to spread work across frames
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
yield break;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Public routine variant that callers can yield on to wait until prewarm completes.
|
|
/// Use this when you need to ensure particle templates are fully instantiated and torn down
|
|
/// before proceeding (to avoid hiccups at first real use).
|
|
/// </summary>
|
|
public IEnumerator PrewarmParticlesRoutine(int perTemplate = 2)
|
|
{
|
|
yield return StartCoroutine(PrewarmCoroutine(perTemplate));
|
|
}
|
|
}
|