using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using DG.Tweening;
using TMPro;
using UnityEngine;

namespace AibisDream.MiniGame.Language
{
    /// <summary>
    /// Owns the post-output performance for Huoshan's three blocked logs. All memory
    /// distortion lives on the HuoshanMemory material; face / dialogue stay clean.
    /// </summary>
    public sealed class LogReleasePresentationController : MonoBehaviour
    {
        public enum PresentationState
        {
            Idle,
            LogOperation,
            FaceEntering,
            Memory,
            LieHolding,
            LieCracking,
            TruthResolving,
            TruthHolding,
            Returning
        }

        private enum MemoryKind
        {
            Office,
            Sunset,
            PrivateOffice
        }

        private readonly struct Preset
        {
            public readonly string Name;
            public readonly float BaseDistortion;

            public Preset(
                string name,
                float baseDistortion)
            {
                Name = name;
                BaseDistortion = baseDistortion;
            }
        }

        private static readonly Preset LightPreset = new Preset("Light", 0.10f);
        private static readonly Preset MediumPreset = new Preset("Medium", 0.20f);
        private static readonly Preset HeavyPreset = new Preset("Heavy", 0.35f);

        [Header("Scene References")]
        [SerializeField] private LanguageParticleManager particleManager;
        [SerializeField] private SpriteRenderer faceRenderer;
        [SerializeField] private Sprite errorFaceSprite;
        [Tooltip("可选。记忆演出不再驱动 noise；仅在进入/退出时清零遗留 Intensity，避免 glitch_transition 残留。")]
        [SerializeField] private SpriteNoiseGlitchController glitchController;
        [SerializeField] private RectTransform expressionScreenMaskRect;
        [SerializeField] private TMP_FontAsset screenFont;

        [Header("Memory Assets")]
        [SerializeField] private Sprite officeMemory;
        [SerializeField] private Sprite sunsetMemory;
        [SerializeField] private Sprite privateOfficeMemory;
        [SerializeField] private Material memoryMaterial;

        [Header("Memory Simulation")]
        [Tooltip("三档演出预设下记忆材质的轻微失真强度；随记忆透明度一起浮现。")]
        [SerializeField, Range(0f, 1f)] private float simGlitchLight = 0.28f;
        [SerializeField, Range(0f, 1f)] private float simGlitchMedium = 0.36f;
        [SerializeField, Range(0f, 1f)] private float simGlitchHeavy = 0.44f;

        [Header("Timing")]
        [SerializeField, Min(0.01f)] private float faceFadeDuration = 0.45f;
        [SerializeField, Min(0.01f)] private float memoryFadeDuration = 0.55f;
        [SerializeField, Min(0.01f)] private float memoryExitDuration = 0.45f;
        [SerializeField, Min(0f)] private float faceDipRatio = 0.015f;

        [Header("Screen Styling")]
        [SerializeField] private Color lieColor = new Color(0.66f, 0.94f, 1f, 1f);
        [SerializeField] private Color truthWarmColor = new Color(1f, 1f, 1f, 1f);
        [Tooltip("爆发段真话闪现与老虎机真话字符的暖色；需与谎话的冷白明显区分。")]
        [SerializeField] private Color truthAccentColor = new Color(1f, 0.84f, 0.6f, 1f);
        [Tooltip("结尾真假闪切时真心话帧的屏幕底色（电视头背景）。")]
        [SerializeField] private Color truthBackdropColor = new Color(0.30f, 0.20f, 0.10f, 0.78f);
        [Tooltip("结尾真假闪切时谎话帧的屏幕底色。")]
        [SerializeField] private Color lieBackdropColor = new Color(0.02f, 0.05f, 0.09f, 0.82f);
        [Tooltip("梳理完成后目标粒子与真话字的颜色；玩法阶段仍用粒子管理器原色。")]
        [SerializeField] private Color presentationResolvedColor = Color.white;
        [Header("Truth Attack")]
        [Tooltip("攻击词命中时覆盖记忆层的瞬时怒火色。使用深红而非粉红，避免与攻击文字争夺可读性。")]
        [SerializeField] private Color truthAttackFlashColor = new Color(0.48f, 0.01f, 0.025f, 1f);
        [Tooltip("攻击强度从 0 到 1 时，整屏红色冲击的透明度范围。")]
        [SerializeField] private Vector2 truthAttackFlashAlpha = new Vector2(0.14f, 0.40f);
        [SerializeField] private int screenGlowSortingOrder = 8;
        [SerializeField] private int screenTextSortingOrder = 18;

        private PresentationState state = PresentationState.Idle;
        private Preset currentPreset = LightPreset;
        private MemoryKind currentMemoryKind = MemoryKind.Office;
        private string currentLieKeyword = string.Empty;

        private Transform runtimeRoot;
        private SpriteRenderer memoryRendererA;
        private SpriteRenderer memoryRendererB;
        private SpriteRenderer activeMemoryRenderer;
        private SpriteRenderer scanlineRenderer;
        private SpriteRenderer screenDimRenderer;
        private SpriteMask screenSpriteMask;
        private TextMeshPro lieText;
        private TextMeshPro lieGhostText;
        private TextMeshPro actorFlashText;
        private TextMeshPro actorFlashChromaRed;
        private TextMeshPro actorFlashChromaCyan;
        private TextMeshPro truthFlashText;
        private TMPRectClipper truthFlashClipper;
        private bool truthFlashActive;
        private SpriteRenderer flickerBackdropRenderer;
        private Coroutine truthLieFlickerRoutine;
        private string truthWarmColorHex;
        private TMPRectClipper lieClipper;
        private TMPRectClipper lieGhostClipper;
        private TMPRectClipper actorFlashClipper;
        private TMPRectClipper actorFlashChromaRedClipper;
        private TMPRectClipper actorFlashChromaCyanClipper;
        private readonly List<TextMeshPro> actorScrollTexts = new List<TextMeshPro>();
        private readonly List<TMPRectClipper> actorScrollClippers = new List<TMPRectClipper>();
        private bool actorFlashActive;
        private int actorFlashCount;
        private Coroutine actorOverdriveRoutine;
        private Texture2D runtimeWhiteTexture;
        private Sprite runtimeWhiteSprite;
        private MaterialPropertyBlock memoryBlockA;
        private MaterialPropertyBlock memoryBlockB;
        private float memoryOpacityA;
        private float memoryOpacityB;
        private float saturation = 1f;
        private float brightness = 1f;
        private float contrast = 1f;
        private float vignette;
        private float noise;
        private float simGlitch;
        private float memoryBaseSimGlitch;
        private float horizontalTear;
        private float memoryImpact;
        private float memoryDamage;
        private float memoryOverdrive;
        private float memoryTearSeed;
        private Color memoryTint = Color.white;
        private Vector2 calmCenter = new Vector2(0.5f, 0.5f);
        private float calmRadius;
        private float calmFeather = 0.18f;
        private float effectStrength;
        private float memoryPushSpeed;
        private float memoryPushProgress;
        private float memoryZoom = 1f;
        private Vector3 memoryBasePosition;
        private Vector3 memoryBaseScale;
        private Vector3 faceBasePosition;
        private Sprite normalFaceSprite;
        private bool runtimeObjectsReady;
        private Coroutine lieShuffleRoutine;
        private Coroutine faceErrorRoutine;

        private static readonly int SaturationId = Shader.PropertyToID("_Saturation");
        private static readonly int BrightnessId = Shader.PropertyToID("_Brightness");
        private static readonly int ContrastId = Shader.PropertyToID("_Contrast");
        private static readonly int VignetteId = Shader.PropertyToID("_Vignette");
        private static readonly int NoiseId = Shader.PropertyToID("_Noise");
        private static readonly int SimGlitchId = Shader.PropertyToID("_SimGlitch");
        private static readonly int HorizontalTearId = Shader.PropertyToID("_HorizontalTear");
        private static readonly int MemoryImpactId = Shader.PropertyToID("_Impact");
        private static readonly int MemoryDamageId = Shader.PropertyToID("_Damage");
        private static readonly int MemoryOverdriveId = Shader.PropertyToID("_Overdrive");
        private static readonly int MemoryTearSeedId = Shader.PropertyToID("_TearSeed");
        private static readonly int ColorTintId = Shader.PropertyToID("_ColorTint");
        private static readonly int CalmCenterId = Shader.PropertyToID("_CalmCenter");
        private static readonly int CalmRadiusId = Shader.PropertyToID("_CalmRadius");
        private static readonly int CalmFeatherId = Shader.PropertyToID("_CalmFeather");
        private static readonly int EffectStrengthId = Shader.PropertyToID("_EffectStrength");
        private static readonly int OpacityId = Shader.PropertyToID("_Opacity");

        public PresentationState State => state;

        private void Awake()
        {
            EnsureRuntimeObjects();
            faceBasePosition = faceRenderer != null ? faceRenderer.transform.position : Vector3.zero;
            normalFaceSprite = faceRenderer != null ? faceRenderer.sprite : null;
            ForceCleanupImmediate(true);
        }

        private void Update()
        {
            if (!runtimeObjectsReady || activeMemoryRenderer == null || !activeMemoryRenderer.enabled)
                return;

            memoryPushProgress += Time.deltaTime * memoryPushSpeed;
            activeMemoryRenderer.transform.localScale =
                memoryBaseScale * (1f + memoryPushProgress) * memoryZoom;
            activeMemoryRenderer.transform.position = memoryBasePosition;

            ApplyMemoryBlocks();
        }

        public IEnumerator PrepareForNextRound()
        {
            EnsureRuntimeObjects();
            bool anythingVisible =
                (faceRenderer != null && faceRenderer.gameObject.activeSelf && faceRenderer.color.a > 0.001f) ||
                memoryOpacityA > 0.001f ||
                memoryOpacityB > 0.001f ||
                (lieText != null && lieText.gameObject.activeSelf) ||
                (actorFlashText != null && actorFlashText.gameObject.activeSelf) ||
                (truthFlashText != null && truthFlashText.gameObject.activeSelf) ||
                actorScrollTexts.Exists(text => text != null && text.gameObject.activeSelf);

            DOTween.Kill(this);
            StopAllCoroutines();
            state = PresentationState.Returning;

            if (!anythingVisible)
            {
                ForceCleanupImmediate(true);
                state = PresentationState.LogOperation;
                yield break;
            }

            const float duration = 0.35f;
            TweenMemoryOpacity(memoryRendererA, 0f, duration);
            TweenMemoryOpacity(memoryRendererB, 0f, duration);
            FadeText(lieText, 0f, duration);
            FadeText(lieGhostText, 0f, duration);
            FadeText(actorFlashText, 0f, duration);
            FadeText(actorFlashChromaRed, 0f, duration);
            FadeText(actorFlashChromaCyan, 0f, duration);
            FadeText(truthFlashText, 0f, duration);
            foreach (TextMeshPro text in actorScrollTexts)
                FadeText(text, 0f, duration);
            if (faceRenderer != null && faceRenderer.gameObject.activeSelf)
                faceRenderer.DOFade(0f, duration).SetEase(Ease.OutQuad).SetTarget(this);

            yield return new WaitForSeconds(duration);
            ForceCleanupImmediate(true);
            state = PresentationState.LogOperation;
        }

        public IEnumerator BeginFaceEntry(float duration = -1f)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(
                    nameof(BeginFaceEntry),
                    PresentationState.Idle,
                    PresentationState.LogOperation,
                    PresentationState.Returning))
            {
                yield break;
            }

            state = PresentationState.FaceEntering;
            // 梳理完成起：目标字切到白色（并取消加粗），玩法阶段颜色不受影响。
            particleManager?.ApplyPresentationResolvedVisuals(presentationResolvedColor);
            SilenceNoiseOverlayIfPresent();

            if (faceRenderer == null)
            {
                Debug.LogError("[LogReleasePresentation] 火山脸 SpriteRenderer 未配置；跳过脸淡入，避免阻塞 Yarn。");
                state = PresentationState.Memory;
                yield break;
            }

            faceRenderer.transform.position = faceBasePosition;
            faceRenderer.enabled = true;
            faceRenderer.gameObject.SetActive(true);
            Color faceColor = faceRenderer.color;
            faceColor.a = 0f;
            faceRenderer.color = faceColor;
            float fadeDuration = duration > 0f ? Mathf.Max(0.01f, duration) : faceFadeDuration;
            yield return faceRenderer.DOFade(1f, fadeDuration)
                .SetEase(Ease.OutQuad)
                .SetTarget(this)
                .WaitForCompletion();
        }

        public IEnumerator BeginMemory(
            string memoryKey,
            float fadeDuration = -1f,
            float pushSpeed = -1f,
            float horizontalSpeed = -1f,
            bool preserveGlitch = false,
            float targetOpacity = 1f)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!TryResolveMemory(memoryKey, out Sprite memorySprite, out MemoryKind kind))
            {
                Debug.LogError($"[LogReleasePresentation] 未知记忆图片“{memoryKey}”；命令安全结束。");
                yield break;
            }
            Preset preset = GetPresetForMemory(kind);

            if (!ExpectState(
                    nameof(BeginMemory),
                    PresentationState.Idle,
                    PresentationState.LogOperation,
                    PresentationState.FaceEntering,
                    PresentationState.Memory,
                    PresentationState.TruthHolding))
            {
                yield break;
            }

            currentPreset = preset;
            currentMemoryKind = kind;
            _ = horizontalSpeed;
            actorFlashCount = 0;
            memoryImpact = 0f;
            memoryDamage = 0f;
            memoryOverdrive = 0f;
            memoryTearSeed = 0f;
            state = PresentationState.Memory;
            // 兜底：跳过 face_fade_in 直进记忆时，目标字仍切到演出白。
            particleManager?.ApplyPresentationResolvedVisuals(presentationResolvedColor);
            // preserveGlitch 已弃用：进记忆后失真只走 HuoshanMemory 材质，不再保留 noise 叠层。
            _ = preserveGlitch;

            SpriteRenderer incoming = activeMemoryRenderer == memoryRendererA ? memoryRendererB : memoryRendererA;
            SpriteRenderer outgoing = activeMemoryRenderer;
            incoming.sprite = memorySprite;
            incoming.enabled = true;
            incoming.gameObject.SetActive(true);
            FitMemoryToView(incoming);
            activeMemoryRenderer = incoming;

            ConfigureMemoryLook(kind, preset);
            memoryBasePosition = incoming.transform.position;
            memoryBaseScale = incoming.transform.localScale;
            memoryPushSpeed = pushSpeed >= 0f
                ? pushSpeed
                : kind == MemoryKind.PrivateOffice ? 0.040f : 0.022f;
            memoryPushProgress = 0f;
            memoryZoom = 1f;
            float resolvedFadeDuration = fadeDuration > 0f
                ? Mathf.Max(0.01f, fadeDuration)
                : memoryFadeDuration;

            // 进记忆前的 glitch_transition noise → 透明叠层后淡出；
            // 记忆材质 _SimGlitch / Analog 随透明度一起浮现，完成交接。
            ReleaseNoiseOverlayIntoMemory(resolvedFadeDuration);
            SetMemoryOpacity(incoming, 0f);
            TweenMemoryOpacity(
                incoming,
                Mathf.Clamp01(targetOpacity),
                resolvedFadeDuration,
                Ease.Linear);
            if (outgoing != null && outgoing != incoming)
                TweenMemoryOpacity(outgoing, 0f, resolvedFadeDuration);

            yield return new WaitForSeconds(resolvedFadeDuration);
        }

        /// <summary>把当前记忆透明度推进到目标值（非等待），用于随对白逐段显影。</summary>
        public void SetActiveMemoryOpacity(float target, float duration)
        {
            EnsureRuntimeObjects();
            if (activeMemoryRenderer == null || !activeMemoryRenderer.enabled)
                return;

            TweenMemoryOpacity(
                activeMemoryRenderer,
                Mathf.Clamp01(target),
                Mathf.Max(0.01f, duration));
        }

        public void PrepareLieVisuals(float freezeDuration, float noiseTarget)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(nameof(PrepareLieVisuals), PresentationState.Memory))
                return;

            state = PresentationState.LieHolding;
            DOTween.Kill(this);
            float duration = Mathf.Max(0.01f, freezeDuration);
            // 谎话期间把模拟感压到目标值：记忆被伪装得"过分干净"。
            float resolved = Mathf.Clamp01(noiseTarget);
            memoryBaseSimGlitch = resolved;
            DOTween.To(() => simGlitch, value => simGlitch = value, resolved, duration)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
        }

        /// <summary>调节记忆材质的轻微失真扰动（非等待）。</summary>
        public void SetSimulationGlitch(float target, float duration)
        {
            EnsureRuntimeObjects();
            float resolved = Mathf.Clamp01(target);
            memoryBaseSimGlitch = resolved;
            DOTween.To(() => simGlitch, value => simGlitch = value, resolved, Mathf.Max(0.01f, duration))
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
        }

        public void SqueezeTruthCharacters(float duration, float jitter, float alpha)
        {
            if (!ExpectState(
                    nameof(SqueezeTruthCharacters),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            particleManager?.SetTargetParticlesAlpha(Mathf.Clamp01(alpha), Mathf.Max(0.01f, duration));
            particleManager?.BeginLieEdgeCompression(
                Mathf.Max(0.01f, duration),
                Mathf.Max(0f, jitter));
        }

        public void ShowLieKeyword(string keyword, float duration, float characterSpacing)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(ShowLieKeyword),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            currentLieKeyword = keyword ?? string.Empty;
            PositionScreenText();
            SetTextActive(lieText, currentLieKeyword, lieColor);
            lieText.characterSpacing = -26f;
            lieText.transform.localScale = new Vector3(1.35f, 0.62f, 1f);
            SetTextAlpha(lieText, 0f);
            float tweenDuration = Mathf.Max(0.01f, duration);
            DOTween.To(
                    () => lieText.characterSpacing,
                    value => lieText.characterSpacing = value,
                    characterSpacing,
                    tweenDuration)
                .SetEase(Ease.OutBack)
                .SetTarget(this);
            lieText.transform.DOScale(Vector3.one, tweenDuration)
                .SetEase(Ease.OutBack)
                .SetTarget(this);
            FadeText(lieText, 1f, Mathf.Min(0.14f, tweenDuration));
            if (lieGhostText != null)
                lieGhostText.gameObject.SetActive(false);
        }

        public void PlayScreenScanline(float duration, bool stalled)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(PlayScreenScanline),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;
            PlayScanline(Mathf.Max(0.01f, duration), stalled);
        }

        public void BeginLieCracking(float lieAlpha)
        {
            if (!ExpectState(
                    nameof(BeginLieCracking),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            state = PresentationState.LieCracking;
            if (lieText == null || !lieText.gameObject.activeSelf)
                return;
            Color dimmed = lieText.color;
            dimmed.a = Mathf.Clamp01(lieAlpha);
            lieText.color = dimmed;
        }

        public void PlayScreenDim(float alpha, float riseDuration, float fallDuration)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(PlayScreenDim),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;
            PulseScreenDim(alpha, riseDuration, fallDuration);
        }

        public void PlayMemoryJolt(float offset, float duration, float tear)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(PlayMemoryJolt),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving))
                return;
            horizontalTear = Mathf.Max(horizontalTear, Mathf.Clamp01(tear));
            if (activeMemoryRenderer == null)
                return;

            Transform target = activeMemoryRenderer.transform;
            target.DOKill();
            Vector3 origin = target.position;
            float totalDuration = Mathf.Max(0.02f, duration);
            Sequence sequence = DOTween.Sequence().SetTarget(this);
            sequence.Append(target.DOMoveX(origin.x + offset, totalDuration * 0.35f).SetEase(Ease.OutQuad));
            sequence.Append(target.DOMoveX(origin.x, totalDuration * 0.65f).SetEase(Ease.InOutQuad));
        }

        public IEnumerator LeakTruthFragment(string fragment, float duration)
        {
            if (!ExpectState(
                    nameof(LeakTruthFragment),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                yield break;

            string resolvedFragment = fragment ?? string.Empty;
            yield return ShuffleLieCharactersRoutine(
                resolvedFragment,
                Mathf.Max(0.01f, duration),
                0.045f);
        }

        public void StartLieCharacterShuffle(string characterPool, float duration, float interval)
        {
            if (!ExpectState(
                    nameof(StartLieCharacterShuffle),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            StopLieShuffleImmediate(false);
            lieShuffleRoutine = StartCoroutine(ShuffleLieCharactersRoutine(
                characterPool,
                Mathf.Max(0.01f, duration),
                Mathf.Max(0.02f, interval)));
        }

        public void CutMemoryAndGlitchImmediate()
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(CutMemoryAndGlitchImmediate),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthHolding))
                return;

            DOTween.Kill(this);
            StopActorOverdriveImmediate();
            memoryPushSpeed = 0f;
            memoryPushProgress = 0f;
            memoryZoom = 1f;
            memoryOpacityA = 0f;
            memoryOpacityB = 0f;
            horizontalTear = 0f;
            noise = 0f;
            simGlitch = 0f;
            effectStrength = 0f;
            memoryImpact = 0f;
            memoryDamage = 0f;
            memoryOverdrive = 0f;
            calmRadius = 0f;
            DisableMemoryRenderer(memoryRendererA);
            DisableMemoryRenderer(memoryRendererB);
            activeMemoryRenderer = null;
            StopTruthLieFlicker();
            SilenceNoiseOverlayIfPresent();
        }

        /// <summary>
        /// 演员大字闪现：glitch 一拍的瞬间隐藏抖动的粒子字，屏幕中央出现白色大字。
        /// 三次冲击逐级增强并累积记忆损伤；普通闪现结束后始终退回抖动粒子字。
        /// 只有 expression_actor_flash_in 会保持大字，用于明确的结尾定格。
        /// </summary>
        public IEnumerator FlashActorLie(
            string text,
            float holdDuration,
            float fontSize = 10.5f,
            float settledScaleValue = -1f,
            float punchScaleValue = -1f,
            float chromaDistance = -1f,
            float chromaAlpha = -1f,
            float impact = -1f,
            float glitchPeak = -1f,
            bool keepVisible = false)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(FlashActorLie), PresentationState.Memory))
                yield break;
            if (actorFlashActive)
            {
                Debug.LogWarning("[LogReleasePresentation] expression_actor_flash 在上一次闪现结束前被调用；已安全跳过。");
                yield break;
            }

            actorFlashActive = true;
            PulseFaceErrorSprite(Mathf.Max(0.1f, holdDuration));
            actorFlashCount = Mathf.Clamp(actorFlashCount + 1, 1, 3);
            int flashLevel = actorFlashCount;
            float flashProgress = flashLevel / 3f;
            float resolvedImpact = impact >= 0f ? Mathf.Clamp01(impact) : GetFlashImpact(flashLevel);
            float resolvedGlitchPeak = glitchPeak >= 0f
                ? Mathf.Clamp01(glitchPeak)
                : Mathf.Lerp(0.16f, 0.42f, flashProgress);
            float resolvedChromaAlpha = chromaAlpha >= 0f
                ? Mathf.Clamp01(chromaAlpha)
                : Mathf.Lerp(0.06f, 0.12f, flashProgress);
            float resolvedChromaDistance = chromaDistance >= 0f
                ? chromaDistance
                : Mathf.Lerp(0.006f, 0.014f, flashProgress);
            float resolvedSettledScale = settledScaleValue > 0f
                ? settledScaleValue
                : Mathf.Lerp(1.15f, 1.25f, flashProgress);
            float resolvedPunchScale = punchScaleValue > 0f
                ? punchScaleValue
                : resolvedSettledScale * Mathf.Lerp(1.28f, 1.42f, flashProgress);
            memoryDamage = Mathf.Max(memoryDamage, GetFlashDamage(flashLevel));
            memoryTearSeed = Mathf.Repeat(memoryTearSeed + 0.271f + flashLevel * 0.137f, 1f);
            StartCoroutine(PulseMemoryImpact(
                resolvedImpact,
                0.045f,
                Mathf.Max(0.05f, holdDuration - 0.08f),
                Mathf.Lerp(0.26f, 0.16f, flashProgress)));
            try
            {
                if (resolvedGlitchPeak > 0.001f)
                    StartCoroutine(PulseGlitch(resolvedGlitchPeak, 0.04f, 0.14f));

                particleManager?.SetTargetParticlesAlpha(0f, 0f);

                PositionScreenText();
                string value = text ?? string.Empty;
                float resolvedFontSize = Mathf.Max(0.1f, fontSize);
                actorFlashText.fontSize = resolvedFontSize;
                actorFlashChromaRed.fontSize = resolvedFontSize;
                actorFlashChromaCyan.fontSize = resolvedFontSize;
                SetTextActive(actorFlashText, value, Color.white);
                SetTextActive(actorFlashChromaRed, value, new Color(1f, 0.25f, 0.25f, resolvedChromaAlpha));
                SetTextActive(actorFlashChromaCyan, value, new Color(0.3f, 0.9f, 1f, resolvedChromaAlpha));
                Vector3 center = actorFlashText.transform.position;
                actorFlashChromaRed.transform.position = center + Vector3.left * resolvedChromaDistance;
                actorFlashChromaCyan.transform.position = center + Vector3.right * resolvedChromaDistance;

                const float punchDuration = 0.14f;
                Vector3 settledScale = Vector3.one * resolvedSettledScale;
                Vector3 punchScale = Vector3.one * resolvedPunchScale;
                actorFlashText.transform.localScale = punchScale;
                actorFlashChromaRed.transform.localScale = punchScale;
                actorFlashChromaCyan.transform.localScale = punchScale;
                actorFlashText.transform.DOScale(settledScale, punchDuration).SetEase(Ease.OutCubic).SetTarget(this);
                actorFlashChromaRed.transform.DOScale(settledScale, punchDuration).SetEase(Ease.OutCubic).SetTarget(this);
                actorFlashChromaCyan.transform.DOScale(settledScale, punchDuration).SetEase(Ease.OutCubic).SetTarget(this);

                yield return new WaitForSeconds(Mathf.Max(0.05f, holdDuration));
            }
            finally
            {
                actorFlashActive = false;
                bool holdForOverdrive = keepVisible;
                if (!holdForOverdrive)
                    HideActorFlashVisualsImmediate();
                if (!holdForOverdrive && state == PresentationState.Memory)
                    particleManager?.SetTargetParticlesAlpha(1f, 0f);
            }
        }

        /// <summary>
        /// 真话闪现：谎话大字之间，暖色完整真话带着细微抖动挣扎浮现一拍。
        /// 不推进谎话冲击等级、不累积记忆损伤；"被掐断"由紧随其后的 expression_glitch_pulse 表现。
        /// </summary>
        public IEnumerator FlashActorTruth(
            string text,
            float holdDuration,
            float fontSize = 8.5f,
            float alpha = 0.8f,
            float jitter = 0.02f)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(FlashActorTruth), PresentationState.Memory))
                yield break;
            if (truthFlashActive)
            {
                Debug.LogWarning("[LogReleasePresentation] expression_actor_truth_flash 在上一次闪现结束前被调用；已安全跳过。");
                yield break;
            }

            truthFlashActive = true;
            try
            {
                PositionScreenText();
                string value = text ?? string.Empty;
                truthFlashText.fontSize = Mathf.Max(0.1f, fontSize);
                Color warm = truthAccentColor;
                warm.a = 0f;
                SetTextActive(truthFlashText, value, warm);
                truthFlashText.transform.localScale = Vector3.one;
                FadeText(truthFlashText, Mathf.Clamp01(alpha), 0.09f);

                Vector3 origin = truthFlashText.transform.position;
                float shake = Mathf.Max(0f, jitter);
                float elapsed = 0f;
                float hold = Mathf.Max(0.05f, holdDuration);
                while (elapsed < hold && state == PresentationState.Memory)
                {
                    truthFlashText.transform.position = origin + new Vector3(
                        UnityEngine.Random.Range(-shake, shake),
                        UnityEngine.Random.Range(-shake, shake) * 0.6f,
                        0f);
                    elapsed += Time.deltaTime;
                    yield return null;
                }
                truthFlashText.transform.position = origin;
            }
            finally
            {
                truthFlashActive = false;
                HideTextImmediate(truthFlashText);
            }
        }

        /// <summary>
        /// 老虎机换字演出：聚焦字在 duration 内只从 charPool 里疯狂换字（非阻塞，节拍由 Yarn wait 控制）。
        /// truthPool 非空时其字符也混入换字池，并在主字上以真话暖色显示——真假字符交替闪烁。
        /// </summary>
        public void StartActorSlotMachine(
            string charPool,
            float duration,
            float interval,
            float fontSize = 14f,
            string truthPool = "")
        {
            EnsureRuntimeObjects();
            if (!ExpectState(nameof(StartActorSlotMachine), PresentationState.Memory))
                return;
            string pool = LanguageParticleManager.SanitizeSlotMachinePool(charPool);
            if (string.IsNullOrEmpty(pool))
            {
                Debug.LogWarning("[LogReleasePresentation] 演员老虎机字符池为空；已安全跳过。");
                return;
            }
            string truthCharacters = LanguageParticleManager.SanitizeSlotMachinePool(truthPool) ?? string.Empty;
            pool += truthCharacters;

            StopActorOverdriveImmediate();
            particleManager?.SetTargetParticlesAlpha(0f, 0f);
            float resolvedFontSize = Mathf.Max(0.1f, fontSize);
            actorFlashText.fontSize = resolvedFontSize;
            actorFlashChromaRed.fontSize = resolvedFontSize;
            actorFlashChromaCyan.fontSize = resolvedFontSize;
            actorOverdriveRoutine = StartCoroutine(ActorOverdriveRoutine(
                pool,
                Mathf.Max(0.05f, duration),
                Mathf.Max(0.02f, interval),
                truthCharacters));
            StartCoroutine(PulseGlitch(
                0.64f,
                Mathf.Max(0.05f, duration * 0.82f),
                Mathf.Max(0.05f, duration * 0.18f)));
        }

        public IEnumerator PlayActorWordHit(
            string text,
            float holdDuration,
            float fontSize = 18f,
            float punchScale = 1.55f)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(PlayActorWordHit), PresentationState.Memory))
                yield break;

            StopActorOverdriveImmediate();
            HideActorScrollImmediate();
            HideActorFlashVisualsImmediate();
            particleManager?.SetTargetParticlesAlpha(0f, 0f);
            PulseFaceErrorSprite(Mathf.Max(0.1f, holdDuration));
            PositionScreenText();

            string value = text ?? string.Empty;
            actorFlashText.fontSize = Mathf.Max(0.1f, fontSize);
            SetTextActive(actorFlashText, value, Color.white);
            actorFlashText.transform.localScale = Vector3.one * Mathf.Max(0.1f, punchScale);
            actorFlashText.transform.DOScale(Vector3.one, 0.065f)
                .SetEase(Ease.OutCubic)
                .SetTarget(actorFlashText);

            memoryTearSeed = Mathf.Repeat(memoryTearSeed + 0.239f, 1f);
            memoryImpact = 1f;
            yield return new WaitForSeconds(Mathf.Max(0.05f, holdDuration));

            HideTextImmediate(actorFlashText);
            actorFlashText.fontSize = 10.5f;
            particleManager?.SetTargetParticlesAlpha(1f, 0f);
            yield return new WaitForSeconds(0.025f);
        }

        public IEnumerator ScrollActorLies(
            string phraseList,
            float scrollDuration,
            float loopDuration,
            float holdDuration,
            float fontSize = 5.2f)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(ScrollActorLies), PresentationState.Memory))
                yield break;

            string[] phrases = ParseActorPhrases(phraseList);
            if (phrases.Length == 0)
            {
                Debug.LogWarning("[LogReleasePresentation] 向下刷屏词组为空；已安全跳过。");
                yield break;
            }

            StopActorOverdriveImmediate();
            HideActorFlashVisualsImmediate();
            HideActorScrollImmediate();
            particleManager?.SetTargetParticlesAlpha(0f, 0f);

            const int itemCount = 4;
            EnsureActorScrollTextPool(itemCount);

            Bounds screen = GetScreenBounds();
            float rowSpacing = screen.size.y / (itemCount - 1f);
            float wrapSpan = rowSpacing * itemCount;
            float speed = wrapSpan / Mathf.Max(0.20f, loopDuration);
            float[] yPositions = new float[itemCount];
            int[] phraseIndices = new int[itemCount];

            for (int i = 0; i < actorScrollTexts.Count; i++)
            {
                TextMeshPro text = actorScrollTexts[i];
                bool used = i < itemCount;
                text.gameObject.SetActive(used);
                if (!used)
                    continue;

                phraseIndices[i] = i % phrases.Length;
                yPositions[i] = screen.max.y + rowSpacing * (i - 1);
                text.fontSize = Mathf.Max(0.1f, fontSize);
                text.rectTransform.sizeDelta = screen.size;
                SetTextActive(text, phrases[phraseIndices[i]], new Color(1f, 1f, 1f, 0.92f));
                text.transform.position = new Vector3(screen.center.x, yPositions[i], screen.center.z);
                text.transform.localScale = Vector3.one;
            }

            float elapsed = 0f;
            float moveDuration = Mathf.Max(0.05f, scrollDuration);
            while (elapsed < moveDuration && state == PresentationState.Memory)
            {
                float delta = Time.deltaTime;
                for (int i = 0; i < itemCount; i++)
                {
                    TextMeshPro text = actorScrollTexts[i];
                    yPositions[i] -= speed * delta;
                    if (yPositions[i] < screen.min.y - rowSpacing)
                    {
                        yPositions[i] += wrapSpan;
                        phraseIndices[i] = (phraseIndices[i] + 1) % phrases.Length;
                        text.text = phrases[phraseIndices[i]];
                    }

                    Vector3 position = text.transform.position;
                    position.y = yPositions[i];
                    text.transform.position = position;
                }

                elapsed += delta;
                yield return null;
            }

            if (state == PresentationState.Memory)
                yield return new WaitForSeconds(Mathf.Max(0f, holdDuration));
            HideActorScrollImmediate();
        }

        public void SnapTruthImmediate(float peripheral, float calmTarget)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(SnapTruthImmediate),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            state = PresentationState.TruthResolving;
            StopLieShuffleImmediate(true);
            HideLieLayersImmediate();
            StopScanline();
            StopScreenDim();

            particleManager?.PrepareTruthReleaseFromLie();
            particleManager?.ApplyPresentationResolvedVisuals(presentationResolvedColor);
            particleManager?.SetCurrentPresentationPhraseAlpha(1f, 0f);
            Bounds truthBounds = particleManager != null
                ? particleManager.GetFinalTruthWorldBounds()
                : new Bounds(GetScreenBounds().center, Vector3.one);
            SetCalmField(truthBounds);
            effectStrength = Mathf.Clamp01(peripheral);
            calmRadius = Mathf.Clamp01(calmTarget);
            particleManager?.SnapTruthImmediate();
            state = PresentationState.TruthHolding;
        }

        /// <summary>真话聚合尝试（非等待）：目标字被慢慢拉向最终位置并按序逐字锁定，感觉即将成功。</summary>
        public void BeginTruthGatherAttempt(float target, float duration)
        {
            if (!ExpectState(nameof(BeginTruthGatherAttempt), PresentationState.Memory))
                return;
            particleManager?.BeginTruthGather(target, duration);
        }

        /// <summary>真话聚合被打断：目标字向外爆散并恢复乱跳（非等待）。</summary>
        public void ScatterTruthGatherAttempt(float burstDistance)
        {
            if (!ExpectState(nameof(ScatterTruthGatherAttempt), PresentationState.Memory))
                return;
            particleManager?.ScatterTruthGather(burstDistance);
        }

        /// <summary>真话聚合挣扎（非等待）：推进途中反复"够到又被拽回去"，字会锁上再崩开。</summary>
        public void BeginTruthStrainAttempt(float target, float duration, int tugs)
        {
            if (!ExpectState(nameof(BeginTruthStrainAttempt), PresentationState.Memory))
                return;
            particleManager?.BeginTruthStrain(target, duration, tugs);
        }

        /// <summary>真话聚合崩塌（非等待）：进度被拽回 0，所有字沿原路退回并恢复乱跳。</summary>
        public void CollapseTruthGatherAttempt(float duration)
        {
            if (!ExpectState(nameof(CollapseTruthGatherAttempt), PresentationState.Memory))
                return;
            particleManager?.CollapseTruthGather(duration);
        }

        /// <summary>火山脸错误闪红：聚合失败的报错信号（非等待）。</summary>
        public void PlayFaceErrorFlash(float duration, float intensity)
        {
            if (faceRenderer == null)
                return;

            _ = intensity; // 兼容旧 Yarn 参数；红屏 Sprite 本身决定最终颜色。
            float total = Mathf.Max(0.1f, duration);
            PulseFaceErrorSprite(total);
            DipFace(total * 0.8f, faceDipRatio * 1.6f);
        }

        private void PulseFaceErrorSprite(float duration)
        {
            if (faceRenderer == null || errorFaceSprite == null)
                return;

            if (faceErrorRoutine != null)
                StopCoroutine(faceErrorRoutine);
            if (faceRenderer.sprite != errorFaceSprite)
                normalFaceSprite = faceRenderer.sprite;
            faceRenderer.sprite = errorFaceSprite;
            faceErrorRoutine = StartCoroutine(RestoreFaceSpriteAfter(Mathf.Max(0.05f, duration)));
        }

        private IEnumerator RestoreFaceSpriteAfter(float duration)
        {
            yield return new WaitForSeconds(duration);
            RestoreFaceSpriteImmediate();
        }

        private void RestoreFaceSpriteImmediate()
        {
            if (faceRenderer != null && normalFaceSprite != null)
                faceRenderer.sprite = normalFaceSprite;
            faceErrorRoutine = null;
        }

        /// <summary>
        /// 结尾真假快速闪切（非等待）：真心话与谎话交替独占屏幕，两者的屏幕底色（电视头背景）不同，
        /// 越到后面切得越快，最后定格在真话帧。节奏由同长度的 Yarn wait 控制。
        /// </summary>
        public void StartTruthLieFlicker(
            string liePhrases,
            string truthPhrase,
            float duration,
            float interval,
            float fontSize)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(StartTruthLieFlicker), PresentationState.Memory))
                return;
            string[] lies = ParseActorPhrases(liePhrases);
            if (lies.Length == 0 || string.IsNullOrEmpty(truthPhrase))
            {
                Debug.LogWarning("[LogReleasePresentation] 真假闪切词组为空；已安全跳过。");
                return;
            }

            StopTruthLieFlicker();
            StopActorOverdriveImmediate();
            particleManager?.SetTargetParticlesAlpha(0f, 0f);
            truthLieFlickerRoutine = StartCoroutine(TruthLieFlickerRoutine(
                lies,
                truthPhrase,
                Mathf.Max(0.2f, duration),
                Mathf.Max(0.05f, interval),
                Mathf.Max(0.1f, fontSize)));
        }

        private IEnumerator TruthLieFlickerRoutine(
            string[] lies,
            string truthPhrase,
            float duration,
            float interval,
            float fontSize)
        {
            PositionScreenText();
            actorFlashText.fontSize = fontSize;
            actorFlashText.transform.localScale = Vector3.one;
            HideTextImmediate(actorFlashChromaRed);
            HideTextImmediate(actorFlashChromaCyan);
            ShowFlickerBackdrop();

            bool truthTurn = false;
            int lieIndex = 0;
            float elapsed = 0f;
            while (elapsed < duration && state == PresentationState.Memory)
            {
                ShowFlickerFrame(truthTurn, lies, lieIndex, truthPhrase);
                if (!truthTurn)
                    lieIndex++;
                truthTurn = !truthTurn;

                // 越到后面切得越快：真话越来越压不住
                float progress = Mathf.Clamp01(elapsed / duration);
                float step = Mathf.Lerp(interval, interval * 0.45f, progress);
                step = Mathf.Min(step, duration - elapsed);
                elapsed += step;
                yield return new WaitForSeconds(Mathf.Max(0.02f, step));
            }

            // 最后停在第一条谎话（"没问题"），交给 expression_lie_morph_truth 做 glitch 翻转
            if (state == PresentationState.Memory)
                ShowFlickerFrame(false, lies, 0, truthPhrase);
            truthLieFlickerRoutine = null;
        }

        private void ShowFlickerFrame(bool truth, string[] lies, int lieIndex, string truthPhrase)
        {
            if (truth)
            {
                Color warm = truthAccentColor;
                warm.a = 1f;
                SetTextActive(actorFlashText, truthPhrase, warm);
                SetFlickerBackdropColor(truthBackdropColor);
            }
            else
            {
                SetTextActive(actorFlashText, lies[lieIndex % lies.Length], Color.white);
                SetFlickerBackdropColor(lieBackdropColor);
            }
        }

        private void ShowFlickerBackdrop()
        {
            if (flickerBackdropRenderer == null)
                return;
            Bounds screen = GetScreenBounds();
            flickerBackdropRenderer.transform.position = screen.center;
            flickerBackdropRenderer.transform.localScale = new Vector3(screen.size.x, screen.size.y, 1f);
            flickerBackdropRenderer.enabled = true;
            flickerBackdropRenderer.gameObject.SetActive(true);
        }

        private void SetFlickerBackdropColor(Color color)
        {
            if (flickerBackdropRenderer != null)
                flickerBackdropRenderer.color = color;
        }

        private void HideFlickerBackdropImmediate()
        {
            if (flickerBackdropRenderer == null)
                return;
            flickerBackdropRenderer.enabled = false;
            flickerBackdropRenderer.gameObject.SetActive(false);
        }

        private void StopTruthLieFlicker()
        {
            if (truthLieFlickerRoutine != null)
            {
                StopCoroutine(truthLieFlickerRoutine);
                truthLieFlickerRoutine = null;
            }
            HideFlickerBackdropImmediate();
        }

        /// <summary>
        /// 定格的谎话被 glitch 翻转成真话（等待）：大字在乱跳中长度渐变、真假底色抢闪，
        /// 最后落在暖色真话并轻微收缩定住。后续由 expression_memory_cut + expression_truth_snap 收尾。
        /// </summary>
        public IEnumerator MorphLieToTruth(string lieValue, string truthValue, float duration)
        {
            EnsureRuntimeObjects();
            EnsureScreenTextClipMaterials();
            if (!ExpectState(nameof(MorphLieToTruth), PresentationState.Memory))
                yield break;

            string lie = lieValue ?? string.Empty;
            string truth = truthValue ?? string.Empty;
            string pool = lie + truth;
            if (pool.Length == 0 || truth.Length == 0)
            {
                Debug.LogWarning("[LogReleasePresentation] expression_lie_morph_truth 文本为空；已安全跳过。");
                yield break;
            }

            if (truthLieFlickerRoutine != null)
            {
                StopCoroutine(truthLieFlickerRoutine);
                truthLieFlickerRoutine = null;
            }
            StopActorOverdriveImmediate();
            particleManager?.SetTargetParticlesAlpha(0f, 0f);
            PositionScreenText();
            ShowFlickerBackdrop();
            HideTextImmediate(actorFlashChromaRed);
            HideTextImmediate(actorFlashChromaCyan);

            Vector3 origin = actorFlashText.transform.position;
            SetTextActive(actorFlashText, lie, Color.white);
            SetFlickerBackdropColor(lieBackdropColor);

            float total = Mathf.Max(0.2f, duration);
            float scrambleDuration = total * 0.7f;
            float elapsed = 0f;
            bool warmTick = false;
            while (elapsed < scrambleDuration && state == PresentationState.Memory)
            {
                float progress = Mathf.Clamp01(elapsed / scrambleDuration);
                int length = Mathf.Clamp(
                    Mathf.RoundToInt(Mathf.Lerp(Mathf.Max(1, lie.Length), truth.Length, progress)),
                    1,
                    Mathf.Max(1, truth.Length));
                warmTick = !warmTick;
                Color color = warmTick ? truthAccentColor : Color.white;
                color.a = 1f;
                SetTextActive(actorFlashText, BuildRandomActorText(pool, length), color);
                SetFlickerBackdropColor(warmTick ? truthBackdropColor : lieBackdropColor);
                actorFlashText.transform.position = origin +
                    (Vector3)(UnityEngine.Random.insideUnitCircle * Mathf.Lerp(0.01f, 0.05f, progress));

                float step = Mathf.Lerp(0.09f, 0.035f, progress);
                step = Mathf.Min(step, scrambleDuration - elapsed);
                elapsed += step;
                yield return new WaitForSeconds(Mathf.Max(0.02f, step));
            }

            if (state != PresentationState.Memory)
                yield break;

            actorFlashText.transform.position = origin;
            Color warm = truthAccentColor;
            warm.a = 1f;
            SetTextActive(actorFlashText, truth, warm);
            SetFlickerBackdropColor(truthBackdropColor);
            actorFlashText.transform.localScale = Vector3.one * 1.12f;
            actorFlashText.transform.DOScale(Vector3.one, 0.12f)
                .SetEase(Ease.OutCubic)
                .SetTarget(this);
            yield return new WaitForSeconds(Mathf.Max(0.05f, total - scrambleDuration));
        }

        /// <summary>
        /// 记忆材质上的瞬时失真脉冲（抬升 _SimGlitch 后回落），不再驱动 noise 叠层。
        /// 撕裂仍走 PlayMemoryTear / impact，避免两路抢同一参数。
        /// </summary>
        public void PlayGlitchPulse(float peak, float riseDuration, float fallDuration)
        {
            if (!ExpectState(
                    nameof(PlayGlitchPulse),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                return;
            StartCoroutine(PulseGlitch(
                Mathf.Clamp01(peak),
                Mathf.Max(0.01f, riseDuration),
                Mathf.Max(0.01f, fallDuration)));
        }

        /// <summary>
        /// 已弃用：屏幕 Glitch 请走 ExpressionManager.SetScreenGlitchLevel（屏幕自身材质）。
        /// 记忆阶段失真请用 PlayGlitchPulse / 记忆 impact。
        /// </summary>
        public void PlayScreenGlitch(float intensity, float duration)
        {
            _ = intensity;
            _ = duration;
        }

        public IEnumerator PlayTruthAttack(
            string text,
            float duration,
            float impact)
        {
            if (!ExpectState(
                    nameof(PlayTruthAttack),
                    PresentationState.Memory,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                yield break;

            float resolvedImpact = Mathf.Clamp01(impact);
            // Truth attacks inherit the memory-layer damage language used by actor hits:
            // each hit advances a deterministic tear layout and drives a short impact pulse.
            memoryDamage = Mathf.Max(
                memoryDamage,
                Mathf.Lerp(0.18f, 0.88f, resolvedImpact));
            memoryTearSeed = Mathf.Repeat(
                memoryTearSeed + 0.193f + resolvedImpact * 0.211f,
                1f);
            StartCoroutine(PulseMemoryImpact(
                Mathf.Lerp(0.24f, 1f, resolvedImpact),
                Mathf.Lerp(0.065f, 0.025f, resolvedImpact),
                Mathf.Lerp(0.035f, 0.12f, resolvedImpact),
                Mathf.Lerp(0.22f, 0.12f, resolvedImpact)));
            PlayMemoryJolt(
                Mathf.Lerp(0.018f, 0.075f, resolvedImpact),
                Mathf.Lerp(0.12f, 0.28f, resolvedImpact),
                Mathf.Lerp(0.025f, 0.16f, resolvedImpact));
            PlayGlitchPulse(
                Mathf.Lerp(0.10f, 0.58f, resolvedImpact),
                0.035f,
                Mathf.Lerp(0.10f, 0.22f, resolvedImpact));
            PlayMemoryTear(
                Mathf.Lerp(0.08f, 0.58f, resolvedImpact),
                Mathf.Lerp(0.14f, 0.36f, resolvedImpact));
            PulseTruthAttackFlash(
                Mathf.Lerp(
                    truthAttackFlashAlpha.x,
                    truthAttackFlashAlpha.y,
                    resolvedImpact),
                Mathf.Lerp(0.035f, 0.018f, resolvedImpact),
                Mathf.Lerp(0.18f, 0.30f, resolvedImpact));

            if (particleManager != null)
                yield return particleManager.PlayTruthAttackAndWait(text, duration, resolvedImpact);
        }

        public IEnumerator DestabilizeTruthPhrase(
            string text,
            float duration,
            float shakeAmplitude,
            float shakeSpeed,
            string colorHex)
        {
            if (!ExpectState(
                    nameof(DestabilizeTruthPhrase),
                    PresentationState.Memory,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                yield break;

            if (particleManager != null)
            {
                yield return particleManager.DestabilizeTruthPhraseAndWait(
                    text,
                    duration,
                    shakeAmplitude,
                    shakeSpeed,
                    colorHex);
            }
        }

        public IEnumerator SettleTruthPhrase(string text, float duration)
        {
            if (!ExpectState(
                    nameof(SettleTruthPhrase),
                    PresentationState.Memory,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                yield break;

            float settleDuration = Mathf.Max(0.08f, duration * 0.65f);
            DOTween.To(
                    () => simGlitch,
                    value => simGlitch = value,
                    memoryBaseSimGlitch,
                    settleDuration)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
            DOTween.To(
                    () => horizontalTear,
                    value => horizontalTear = value,
                    0f,
                    settleDuration)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);

            if (particleManager != null)
                yield return particleManager.SettleTruthPhraseAndWait(text, duration);
        }

        public IEnumerator BuildActorOverloadPeak(
            float riseDuration,
            float holdDuration,
            float zoom,
            float glitchPeak,
            float impact)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(nameof(BuildActorOverloadPeak), PresentationState.Memory))
                yield break;

            float rise = Mathf.Max(0.01f, riseDuration);
            float resolvedZoom = Mathf.Max(1f, zoom);
            float resolvedImpact = Mathf.Clamp01(impact);
            memoryTearSeed = Mathf.Repeat(memoryTearSeed + 0.347f, 1f);

            DOTween.To(() => memoryZoom, value => memoryZoom = value, resolvedZoom, rise)
                .SetEase(Ease.InQuad)
                .SetTarget(this);
            DOTween.To(() => memoryImpact, value => memoryImpact = value, resolvedImpact, rise)
                .SetEase(Ease.InQuad)
                .SetTarget(this);
            DOTween.To(() => memoryOverdrive, value => memoryOverdrive = value, 1f, rise)
                .SetEase(Ease.InQuad)
                .SetTarget(this);
            float peak = Mathf.Clamp01(glitchPeak);
            DOTween.To(
                    () => simGlitch,
                    value => simGlitch = value,
                    Mathf.Lerp(memoryBaseSimGlitch, 1f, peak),
                    rise)
                .SetEase(Ease.InQuad)
                .SetTarget(this);
            DOTween.To(
                    () => horizontalTear,
                    value => horizontalTear = value,
                    Mathf.Lerp(0.18f, 0.72f, peak),
                    rise)
                .SetEase(Ease.InQuad)
                .SetTarget(this);

            if (actorFlashText != null)
            {
                actorFlashText.transform.DOScale(
                        actorFlashText.transform.localScale * resolvedZoom,
                        rise)
                    .SetEase(Ease.InQuad)
                    .SetTarget(this);
            }
            if (actorFlashChromaRed != null)
            {
                actorFlashChromaRed.transform.DOScale(
                        actorFlashChromaRed.transform.localScale * resolvedZoom,
                        rise)
                    .SetEase(Ease.InQuad)
                    .SetTarget(this);
            }
            if (actorFlashChromaCyan != null)
            {
                actorFlashChromaCyan.transform.DOScale(
                        actorFlashChromaCyan.transform.localScale * resolvedZoom,
                        rise)
                    .SetEase(Ease.InQuad)
                    .SetTarget(this);
            }

            yield return new WaitForSeconds(rise);
            yield return new WaitForSeconds(Mathf.Max(0f, holdDuration));
        }

        public IEnumerator HoldTruthBlackout(float duration, float alpha)
        {
            if (!ExpectState(
                    nameof(HoldTruthBlackout),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                yield break;

            // 顿挫一拍：黑场盖住真假闪切的底色与大字
            StopTruthLieFlicker();
            HideTextImmediate(actorFlashText);
            HoldTruthBreakBlackout(alpha);
            yield return new WaitForSeconds(Mathf.Max(0.01f, duration));
        }

        public void SplitLieVisual(float duration, float distanceRatio, float stretchX, float squashY)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(SplitLieVisual),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving))
                return;
            if (lieText == null || !lieText.gameObject.activeSelf)
                return;

            Bounds screenBounds = GetScreenBounds();
            Vector3 lieOrigin = lieText.transform.position;
            float tweenDuration = Mathf.Max(0.01f, duration);
            float distance = screenBounds.extents.x * Mathf.Max(0f, distanceRatio);
            SetTextActive(lieGhostText, currentLieKeyword, truthWarmColor);
            lieGhostText.transform.position = lieOrigin + Vector3.left * 0.10f;
            lieGhostText.transform.localScale = Vector3.one;
            lieGhostText.characterSpacing = lieText.characterSpacing;
            SetTextAlpha(lieGhostText, 0.90f);
            lieText.transform.DOScale(
                    new Vector3(Mathf.Max(0.01f, stretchX), Mathf.Max(0.01f, squashY), 1f),
                    tweenDuration)
                .SetEase(Ease.InCubic)
                .SetTarget(this);
            lieText.transform.DOMoveX(lieOrigin.x + distance, tweenDuration)
                .SetEase(Ease.InCubic)
                .SetTarget(this);
            lieGhostText.transform.DOMoveX(lieOrigin.x - distance, tweenDuration)
                .SetEase(Ease.InCubic)
                .SetTarget(this);
            FadeText(lieText, 0f, tweenDuration);
            FadeText(lieGhostText, 0f, tweenDuration);
        }

        public void PlayTruthFlash(float alpha, float riseDuration, float holdDuration, float fallDuration)
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(PlayTruthFlash),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                return;
            PulseTruthBreakFlash(alpha, riseDuration, holdDuration, fallDuration);
        }

        public void PlayMemoryBrightnessPulse(float amount, float riseDuration, float fallDuration)
        {
            if (!ExpectState(
                    nameof(PlayMemoryBrightnessPulse),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                return;
            PulseMemoryRelease(amount, riseDuration, fallDuration);
        }

        public void PlayMemoryTear(float peak, float duration)
        {
            if (!ExpectState(
                    nameof(PlayMemoryTear),
                    PresentationState.Memory,
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving,
                    PresentationState.TruthHolding))
                return;
            horizontalTear = Mathf.Max(horizontalTear, Mathf.Clamp01(peak));
            DOTween.To(
                    () => horizontalTear,
                    value => horizontalTear = value,
                    0f,
                    Mathf.Max(0.01f, duration))
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
        }

        public void PlayFaceDip(float duration, float ratio)
        {
            if (!ExpectState(
                    nameof(PlayFaceDip),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking,
                    PresentationState.TruthResolving))
                return;
            DipFace(Mathf.Max(0.01f, duration), Mathf.Max(0f, ratio));
        }

        public void ReleaseTruthCharacters(float alphaDuration)
        {
            if (!ExpectState(
                    nameof(ReleaseTruthCharacters),
                    PresentationState.LieHolding,
                    PresentationState.LieCracking))
                return;

            state = PresentationState.TruthResolving;
            particleManager?.PrepareTruthReleaseFromLie();
            particleManager?.ApplyPresentationResolvedVisuals(presentationResolvedColor);
            particleManager?.SetTargetParticlesAlpha(1f, Mathf.Max(0.01f, alphaDuration));
            Bounds truthBounds = particleManager != null
                ? particleManager.GetFinalTruthWorldBounds()
                : new Bounds(GetScreenBounds().center, Vector3.one);
            SetCalmField(truthBounds);
        }

        public IEnumerator ResolveTruthCharacters(float duration, float peripheral, float calmTarget)
        {
            if (!ExpectState(nameof(ResolveTruthCharacters), PresentationState.TruthResolving))
                yield break;

            float resolveDuration = Mathf.Max(0.01f, duration);
            DOTween.To(
                    () => effectStrength,
                    value => effectStrength = value,
                    Mathf.Clamp01(peripheral),
                    resolveDuration)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
            calmRadius = 0f;
            DOTween.To(
                    () => calmRadius,
                    value => calmRadius = value,
                    Mathf.Clamp01(calmTarget),
                    resolveDuration)
                .SetEase(Ease.OutCubic)
                .SetTarget(this);
            brightness = Mathf.Max(brightness, currentMemoryKind == MemoryKind.Sunset ? 1.02f : brightness);

            if (particleManager != null)
                yield return particleManager.ResolveFocusAndWait(resolveDuration);
            else
                yield return new WaitForSeconds(resolveDuration);

            if (currentMemoryKind == MemoryKind.Sunset)
            {
                DOTween.To(() => saturation, value => saturation = value, 0.92f, 0.2f)
                    .SetEase(Ease.OutQuad)
                    .SetTarget(this);
            }

            HideLieLayersImmediate();
            StopScanline();
            StopScreenDim();
            ReleaseScreenTextClipMaterials();
            DOTween.To(() => simGlitch, value => simGlitch = value, memoryBaseSimGlitch, 0.18f)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
            DOTween.To(() => horizontalTear, value => horizontalTear = value, 0f, 0.18f)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
            state = PresentationState.TruthHolding;
        }

        public void TruthImpact()
        {
            EnsureRuntimeObjects();
            if (!ExpectState(nameof(TruthImpact), PresentationState.TruthHolding, PresentationState.TruthResolving))
                return;

            StartCoroutine(TruthImpactRoutine());
        }

        public IEnumerator EndMemory()
        {
            EnsureRuntimeObjects();
            if (!ExpectState(
                    nameof(EndMemory),
                    PresentationState.Memory,
                    PresentationState.LieCracking,
                    PresentationState.TruthHolding))
            {
                yield break;
            }

            state = PresentationState.Returning;
            TweenMemoryOpacity(memoryRendererA, 0f, memoryExitDuration);
            TweenMemoryOpacity(memoryRendererB, 0f, memoryExitDuration);
            HideLieLayersImmediate();
            StopScanline();
            StopScreenDim();
            SilenceNoiseOverlayIfPresent();
            DOTween.To(() => simGlitch, value => simGlitch = value, 0f, 0.12f)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);
            DOTween.To(() => horizontalTear, value => horizontalTear = value, 0f, 0.12f)
                .SetEase(Ease.OutQuad)
                .SetTarget(this);

            yield return new WaitForSeconds(memoryExitDuration);
            DisableMemoryRenderer(memoryRendererA);
            DisableMemoryRenderer(memoryRendererB);

            if (currentMemoryKind == MemoryKind.PrivateOffice)
                particleManager?.SetTargetParticlesAlpha(0.6f, 0.18f);

            state = PresentationState.TruthHolding;
        }

        public void ForceCleanupImmediate(bool hideFace)
        {
            DOTween.Kill(this);
            StopAllCoroutines();
            RestoreFaceSpriteImmediate();

            memoryOpacityA = 0f;
            memoryOpacityB = 0f;
            DisableMemoryRenderer(memoryRendererA);
            DisableMemoryRenderer(memoryRendererB);
            activeMemoryRenderer = null;
            HideLieLayersImmediate();
            StopScanline();
            StopScreenDim();
            ReleaseScreenTextClipMaterials();

            if (faceRenderer != null)
            {
                faceRenderer.transform.position = faceBasePosition;
                if (hideFace)
                {
                    Color faceColor = faceRenderer.color;
                    faceColor.a = 0f;
                    faceRenderer.color = faceColor;
                    faceRenderer.enabled = false;
                    faceRenderer.gameObject.SetActive(false);
                }
            }

            ResetNoiseOverlayForGlitchTransition();

            particleManager?.RestoreTargetPresentationDefaults();
            state = PresentationState.Idle;
            currentLieKeyword = string.Empty;
            memoryPushSpeed = 0f;
            memoryPushProgress = 0f;
            memoryZoom = 1f;
            horizontalTear = 0f;
            noise = 0f;
            simGlitch = 0f;
            memoryBaseSimGlitch = 0f;
            memoryImpact = 0f;
            memoryDamage = 0f;
            memoryOverdrive = 0f;
            calmRadius = 0f;
        }

        private static float GetFlashDamage(int flashLevel)
        {
            return flashLevel switch
            {
                1 => 0.18f,
                2 => 0.40f,
                _ => 0.66f
            };
        }

        private static float GetFlashImpact(int flashLevel)
        {
            return flashLevel switch
            {
                1 => 0.46f,
                2 => 0.72f,
                _ => 1f
            };
        }

        private IEnumerator PulseMemoryImpact(
            float peak,
            float riseDuration,
            float holdDuration,
            float fallDuration)
        {
            float start = memoryImpact;
            yield return DOTween.To(
                    () => memoryImpact,
                    value => memoryImpact = value,
                    Mathf.Clamp01(peak),
                    Mathf.Max(0.01f, riseDuration))
                .SetEase(Ease.OutQuad)
                .SetTarget(this)
                .WaitForCompletion();
            yield return new WaitForSeconds(Mathf.Max(0f, holdDuration));
            yield return DOTween.To(
                    () => memoryImpact,
                    value => memoryImpact = value,
                    start,
                    Mathf.Max(0.01f, fallDuration))
                .SetEase(Ease.OutCubic)
                .SetTarget(this)
                .WaitForCompletion();
        }

        private IEnumerator ActorOverdriveRoutine(string pool, float duration, float interval, string truthPool = "")
        {
            PositionScreenText();
            string initial = actorFlashText != null ? actorFlashText.text : string.Empty;
            int characterCount = Mathf.Max(1, string.IsNullOrEmpty(initial) ? 3 : initial.Length);
            float elapsed = 0f;
            float nextShuffle = 0f;

            while (elapsed < duration && state == PresentationState.Memory)
            {
                float progress = Mathf.Clamp01(elapsed / duration);
                float eased = progress * progress * (3f - 2f * progress);
                // 起点压低，让老虎机段有"从可辨认到失控"的爬升；峰值仍到 1
                memoryOverdrive = Mathf.Lerp(0.15f, 1f, eased);
                memoryDamage = Mathf.Max(memoryDamage, Mathf.Lerp(0.45f, 1f, eased));

                if (elapsed >= nextShuffle)
                {
                    string value = BuildRandomActorText(pool, characterCount);
                    SetActorOverdriveText(value, eased, truthPool);
                    memoryTearSeed = Mathf.Repeat(memoryTearSeed + 0.173f, 1f);
                    float acceleratingInterval = Mathf.Lerp(
                        interval,
                        Mathf.Max(0.02f, interval * 0.42f),
                        eased);
                    nextShuffle = elapsed + acceleratingInterval;
                }

                float pulse = 1f + Mathf.Sin(elapsed * Mathf.Lerp(12f, 29f, eased)) *
                    Mathf.Lerp(0.025f, 0.095f, eased);
                Vector3 scale = new Vector3(
                    pulse * Mathf.Lerp(1f, 1.16f, eased),
                    pulse * Mathf.Lerp(1f, 0.90f, eased),
                    1f);
                SetActorOverdriveScale(scale);

                elapsed += Time.deltaTime;
                yield return null;
            }

            if (state == PresentationState.Memory)
            {
                memoryImpact = 1f;
                memoryDamage = 1f;
                memoryOverdrive = 1f;
                SetActorOverdriveScale(new Vector3(1.18f, 0.88f, 1f));
            }
            actorOverdriveRoutine = null;
        }

        public static string ColorizeTruthCharacters(string value, string truthPool, string colorHex)
        {
            if (string.IsNullOrEmpty(value) || string.IsNullOrEmpty(truthPool))
                return value;
            var builder = new StringBuilder(value.Length * 8);
            foreach (char character in value)
            {
                if (truthPool.IndexOf(character) >= 0)
                    builder.Append("<color=#").Append(colorHex).Append('>').Append(character).Append("</color>");
                else
                    builder.Append(character);
            }
            return builder.ToString();
        }

        private static string BuildRandomActorText(string pool, int characterCount)
        {
            if (string.IsNullOrEmpty(pool))
                return string.Empty;

            char[] value = new char[Mathf.Max(1, characterCount)];
            for (int i = 0; i < value.Length; i++)
                value[i] = pool[UnityEngine.Random.Range(0, pool.Length)];
            return new string(value);
        }

        private void SetActorOverdriveText(string value, float progress, string truthPool = "")
        {
            // 主字用富文本按字符归属着色：真话字符=暖色，谎话字符=白。ghost 层保持整体色。
            truthWarmColorHex ??= ColorUtility.ToHtmlStringRGB(truthAccentColor);
            string mainValue = ColorizeTruthCharacters(value, truthPool, truthWarmColorHex);
            SetTextActive(actorFlashText, mainValue, Color.white);
            SetTextActive(
                actorFlashChromaRed,
                value,
                new Color(1f, 0.28f, 0.28f, Mathf.Lerp(0.05f, 0.14f, progress)));
            SetTextActive(
                actorFlashChromaCyan,
                value,
                new Color(0.25f, 0.9f, 1f, Mathf.Lerp(0.05f, 0.14f, progress)));

            Vector3 center = actorFlashText.transform.position;
            // 过载段保留轻色散即可，避免主体字被红青双影糊掉
            float chromaDistance = Mathf.Lerp(0.008f, 0.028f, progress);
            float verticalJitter = UnityEngine.Random.Range(-0.004f, 0.004f) * progress;
            actorFlashChromaRed.transform.position =
                center + Vector3.left * chromaDistance + Vector3.up * verticalJitter;
            actorFlashChromaCyan.transform.position =
                center + Vector3.right * chromaDistance - Vector3.up * verticalJitter;
        }

        private void SetActorOverdriveScale(Vector3 scale)
        {
            if (actorFlashText != null)
                actorFlashText.transform.localScale = scale;
            if (actorFlashChromaRed != null)
                actorFlashChromaRed.transform.localScale = scale;
            if (actorFlashChromaCyan != null)
                actorFlashChromaCyan.transform.localScale = scale;
        }

        private void StopActorOverdriveImmediate()
        {
            if (actorOverdriveRoutine == null)
                return;
            StopCoroutine(actorOverdriveRoutine);
            actorOverdriveRoutine = null;
        }

        public static string[] ParseActorPhrases(string phraseList)
        {
            if (string.IsNullOrWhiteSpace(phraseList))
                return Array.Empty<string>();

            string[] raw = phraseList.Split('|');
            var result = new List<string>(raw.Length);
            foreach (string item in raw)
            {
                string value = item.Trim();
                if (!string.IsNullOrEmpty(value))
                    result.Add(value);
            }
            return result.ToArray();
        }

        private void EnsureActorScrollTextPool(int count)
        {
            while (actorScrollTexts.Count < count)
            {
                int index = actorScrollTexts.Count;
                TextMeshPro text = CreateScreenText(
                    $"ActorScrollText_{index:00}",
                    3.2f,
                    screenTextSortingOrder - index % 2);
                TMPRectClipper clipper = text.gameObject.AddComponent<TMPRectClipper>();
                clipper.Initialize(text, expressionScreenMaskRect);
                actorScrollTexts.Add(text);
                actorScrollClippers.Add(clipper);
            }
        }

        private void HideActorScrollImmediate()
        {
            foreach (TextMeshPro text in actorScrollTexts)
                HideTextImmediate(text);
        }

        private IEnumerator TruthImpactRoutine()
        {
            float original = brightness;
            float peak = original + 0.18f;
            yield return DOTween.To(() => brightness, value => brightness = value, peak, 0.08f)
                .SetEase(Ease.OutQuad)
                .SetTarget(this)
                .WaitForCompletion();
            yield return DOTween.To(() => brightness, value => brightness = value, original, 0.18f)
                .SetEase(Ease.InQuad)
                .SetTarget(this)
                .WaitForCompletion();
        }

        /// <summary>记忆材质瞬时失真：抬升 _SimGlitch 后回到基线。</summary>
        private IEnumerator PulseGlitch(float peak, float riseDuration, float fallDuration)
        {
            float clampedPeak = Mathf.Clamp01(peak);
            if (clampedPeak <= 0.001f)
                yield break;

            float rise = Mathf.Max(0.01f, riseDuration);
            float fall = Mathf.Max(0.01f, fallDuration);
            float startSim = simGlitch;
            float restoreSim = memoryBaseSimGlitch > 0.001f ? memoryBaseSimGlitch : startSim;
            float targetSim = Mathf.Max(startSim, Mathf.Lerp(restoreSim, 1f, clampedPeak));

            yield return DOTween.To(() => simGlitch, value => simGlitch = value, targetSim, rise)
                .SetEase(Ease.OutQuad)
                .SetTarget(this)
                .WaitForCompletion();
            yield return DOTween.To(() => simGlitch, value => simGlitch = value, restoreSim, fall)
                .SetEase(Ease.InQuad)
                .SetTarget(this)
                .WaitForCompletion();
        }

        private void SilenceNoiseOverlayIfPresent()
        {
            if (glitchController == null)
                return;

            // OpaqueBackground 即使 Intensity=0 仍会写满不透明黑底。
            // 记忆阶段切到 TransparentOverlay，避免盖住画面。
            glitchController.SetCompositeMode(SpriteNoiseGlitchController.CompositeMode.TransparentOverlay);
            glitchController.Intensity = 0f;
            glitchController.SetAmbientNoise(0f, 320f, 0f);
            glitchController.ClearCalmField(true);
        }

        /// <summary>
        /// 进记忆交接：把进场前的 noise 从「不透明黑底」切成透明叠层并淡出，
        /// 让记忆材质自身的 _SimGlitch / Analog 接上失真，而不是突然掐断或继续盖住画面。
        /// </summary>
        private void ReleaseNoiseOverlayIntoMemory(float memoryFadeDuration)
        {
            if (glitchController == null)
                return;

            glitchController.SetCompositeMode(SpriteNoiseGlitchController.CompositeMode.TransparentOverlay);
            glitchController.SetAmbientNoise(0f, 320f, 0f);
            glitchController.ClearCalmField(true);

            float releaseDuration = Mathf.Clamp(memoryFadeDuration * 0.35f, 0.12f, 0.55f);
            if (glitchController.Intensity <= 0.001f)
            {
                glitchController.Intensity = 0f;
                return;
            }

            glitchController.TransitionTo(0f, releaseDuration);
        }

        private void ResetNoiseOverlayForGlitchTransition()
        {
            if (glitchController == null)
                return;

            SilenceNoiseOverlayIfPresent();
            // 回到 glitch_transition 原始合成；Layer 保持 Default，勿改 HuoshanScreen。
            glitchController.SetCompositeMode(SpriteNoiseGlitchController.CompositeMode.OpaqueBackground);
            glitchController.gameObject.layer = 0;
        }

        private IEnumerator ShuffleLieCharactersRoutine(
            string characterPool,
            float duration,
            float interval)
        {
            if (lieText == null || string.IsNullOrEmpty(currentLieKeyword))
                yield break;

            string original = currentLieKeyword;
            string pool = string.IsNullOrWhiteSpace(characterPool)
                ? original
                : characterPool.Replace(" ", string.Empty);
            if (string.IsNullOrEmpty(pool))
                pool = original;

            float elapsed = 0f;
            while (elapsed < duration)
            {
                float step = Mathf.Min(interval, duration - elapsed);
                elapsed += step;
                char[] characters = original.ToCharArray();
                int replacementCount = Mathf.Clamp(
                    Mathf.CeilToInt(characters.Length * 0.66f),
                    1,
                    characters.Length);
                int startIndex = UnityEngine.Random.Range(0, characters.Length);
                for (int i = 0; i < replacementCount; i++)
                {
                    int index = (startIndex + i) % characters.Length;
                    characters[index] = pool[UnityEngine.Random.Range(0, pool.Length)];
                }
                lieText.text = new string(characters);
                yield return new WaitForSeconds(step);
            }
            lieText.text = original;
            SetTextAlpha(lieText, 1f);
            lieShuffleRoutine = null;
        }

        private void StopLieShuffleImmediate(bool restoreKeyword)
        {
            if (lieShuffleRoutine != null)
            {
                StopCoroutine(lieShuffleRoutine);
                lieShuffleRoutine = null;
            }
            if (restoreKeyword && lieText != null && !string.IsNullOrEmpty(currentLieKeyword))
                lieText.text = currentLieKeyword;
        }

        private void DipFace(float duration, float ratio)
        {
            if (faceRenderer == null)
                return;

            faceRenderer.transform.DOKill();
            float height = faceRenderer.bounds.size.y;
            faceRenderer.transform.DOMoveY(faceBasePosition.y - height * ratio, Mathf.Max(0.06f, duration * 0.35f))
                .SetLoops(2, LoopType.Yoyo)
                .SetEase(Ease.InOutSine)
                .SetTarget(this)
                .OnComplete(() => faceRenderer.transform.position = faceBasePosition);
        }

        private void SetCalmField(Bounds truthBounds)
        {
            if (activeMemoryRenderer != null)
            {
                Bounds memoryBounds = activeMemoryRenderer.bounds;
                if (memoryBounds.size.x > 0.001f && memoryBounds.size.y > 0.001f)
                {
                    calmCenter = new Vector2(
                        Mathf.InverseLerp(memoryBounds.min.x, memoryBounds.max.x, truthBounds.center.x),
                        Mathf.InverseLerp(memoryBounds.min.y, memoryBounds.max.y, truthBounds.center.y));
                }
            }
            calmRadius = 0f;
            calmFeather = 0.20f;
        }

        private void ConfigureMemoryLook(MemoryKind kind, Preset preset)
        {
            saturation = kind switch
            {
                MemoryKind.Office => 0.82f,
                MemoryKind.Sunset => 0.96f,
                _ => 0.72f
            };
            brightness = kind switch
            {
                MemoryKind.Office => 0.94f,
                MemoryKind.Sunset => 0.94f,
                _ => 0.76f
            };
            contrast = kind == MemoryKind.PrivateOffice ? 1.20f : 1.08f;
            vignette = kind switch
            {
                MemoryKind.Office => 0.18f,
                MemoryKind.Sunset => 0.18f,
                _ => 0.46f
            };
            // 颗粒噪点与 noise 叠层均弃用；失真只走记忆材质 _SimGlitch。
            noise = 0f;
            simGlitch = preset.Name switch
            {
                "Medium" => simGlitchMedium,
                "Heavy" => simGlitchHeavy,
                _ => simGlitchLight
            };
            memoryBaseSimGlitch = simGlitch;
            horizontalTear = 0f;
            memoryTint = kind switch
            {
                MemoryKind.Office => new Color(0.83f, 0.92f, 1f, 1f),
                MemoryKind.Sunset => new Color(1f, 0.90f, 0.78f, 1f),
                _ => new Color(0.78f, 0.86f, 1f, 1f)
            };
            calmCenter = new Vector2(0.5f, 0.5f);
            calmRadius = 0f;
            calmFeather = 0.18f;
            effectStrength = preset.BaseDistortion;
            ApplyMemoryBlocks();
        }

        private void EnsureRuntimeObjects()
        {
            if (runtimeObjectsReady)
                return;

            if (particleManager == null)
                particleManager = GetComponentInChildren<LanguageParticleManager>(true);

            GameObject rootObject = new GameObject("LogReleasePresentation");
            runtimeRoot = rootObject.transform;
            runtimeRoot.SetParent(transform, false);

            runtimeWhiteTexture = new Texture2D(1, 1, TextureFormat.RGBA32, false)
            {
                name = "Huoshan Presentation White",
                filterMode = FilterMode.Bilinear,
                wrapMode = TextureWrapMode.Clamp,
                hideFlags = HideFlags.DontSave
            };
            runtimeWhiteTexture.SetPixel(0, 0, Color.white);
            runtimeWhiteTexture.Apply();
            runtimeWhiteSprite = Sprite.Create(
                runtimeWhiteTexture,
                new Rect(0f, 0f, 1f, 1f),
                new Vector2(0.5f, 0.5f),
                1f);
            runtimeWhiteSprite.name = "Huoshan Presentation White";
            runtimeWhiteSprite.hideFlags = HideFlags.DontSave;

            memoryRendererA = CreateMemoryRenderer("MemoryRendererA");
            memoryRendererB = CreateMemoryRenderer("MemoryRendererB");
            memoryBlockA = new MaterialPropertyBlock();
            memoryBlockB = new MaterialPropertyBlock();

            CreateScreenMask();
            lieText = CreateScreenText("LieKeyword", 4.1f, screenTextSortingOrder);
            lieGhostText = CreateScreenText("LieKeywordGhost", 4.1f, screenTextSortingOrder - 1);
            actorFlashText = CreateScreenText("ActorFlashKeyword", 10.5f, screenTextSortingOrder);
            actorFlashChromaRed = CreateScreenText("ActorFlashChromaRed", 10.5f, screenTextSortingOrder - 1);
            actorFlashChromaCyan = CreateScreenText("ActorFlashChromaCyan", 10.5f, screenTextSortingOrder - 1);
            truthFlashText = CreateScreenText("ActorTruthFlash", 8.5f, screenTextSortingOrder - 1);
            lieClipper = lieText.gameObject.AddComponent<TMPRectClipper>();
            lieGhostClipper = lieGhostText.gameObject.AddComponent<TMPRectClipper>();
            actorFlashClipper = actorFlashText.gameObject.AddComponent<TMPRectClipper>();
            actorFlashChromaRedClipper = actorFlashChromaRed.gameObject.AddComponent<TMPRectClipper>();
            actorFlashChromaCyanClipper = actorFlashChromaCyan.gameObject.AddComponent<TMPRectClipper>();
            truthFlashClipper = truthFlashText.gameObject.AddComponent<TMPRectClipper>();
            lieClipper.Initialize(lieText, expressionScreenMaskRect);
            lieGhostClipper.Initialize(lieGhostText, expressionScreenMaskRect);
            actorFlashClipper.Initialize(actorFlashText, expressionScreenMaskRect);
            actorFlashChromaRedClipper.Initialize(actorFlashChromaRed, expressionScreenMaskRect);
            actorFlashChromaCyanClipper.Initialize(actorFlashChromaCyan, expressionScreenMaskRect);
            truthFlashClipper.Initialize(truthFlashText, expressionScreenMaskRect);
            PositionScreenText();

            GameObject scanlineObject = new GameObject("ScreenScanline");
            scanlineObject.transform.SetParent(runtimeRoot, false);
            scanlineRenderer = scanlineObject.AddComponent<SpriteRenderer>();
            scanlineRenderer.sprite = runtimeWhiteSprite;
            scanlineRenderer.color = new Color(0.55f, 0.95f, 1f, 0f);
            scanlineRenderer.sortingLayerID = GetScreenSortingLayerId();
            scanlineRenderer.sortingOrder = screenTextSortingOrder - 2;
            scanlineRenderer.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
            scanlineRenderer.enabled = false;

            GameObject dimObject = new GameObject("ScreenBrightnessDip");
            dimObject.transform.SetParent(runtimeRoot, false);
            screenDimRenderer = dimObject.AddComponent<SpriteRenderer>();
            screenDimRenderer.sprite = runtimeWhiteSprite;
            screenDimRenderer.color = new Color(0.02f, 0.05f, 0.08f, 0f);
            screenDimRenderer.sortingLayerID = GetScreenSortingLayerId();
            screenDimRenderer.sortingOrder = screenGlowSortingOrder + 1;
            screenDimRenderer.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
            Bounds screen = GetScreenBounds();
            screenDimRenderer.transform.position = screen.center;
            screenDimRenderer.transform.localScale = new Vector3(screen.size.x, screen.size.y, 1f);
            screenDimRenderer.enabled = false;

            GameObject backdropObject = new GameObject("TruthLieFlickerBackdrop");
            backdropObject.transform.SetParent(runtimeRoot, false);
            flickerBackdropRenderer = backdropObject.AddComponent<SpriteRenderer>();
            flickerBackdropRenderer.sprite = runtimeWhiteSprite;
            flickerBackdropRenderer.color = lieBackdropColor;
            flickerBackdropRenderer.sortingLayerID = GetScreenSortingLayerId();
            // 底色在记忆/脸之上、屏幕暗脉冲（glow+1）与文字之下，顿挫黑场能盖住它
            flickerBackdropRenderer.sortingOrder = screenGlowSortingOrder;
            flickerBackdropRenderer.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
            flickerBackdropRenderer.transform.position = screen.center;
            flickerBackdropRenderer.transform.localScale = new Vector3(screen.size.x, screen.size.y, 1f);
            flickerBackdropRenderer.enabled = false;
            backdropObject.SetActive(false);

            runtimeObjectsReady = true;
        }

        private SpriteRenderer CreateMemoryRenderer(string objectName)
        {
            GameObject obj = new GameObject(objectName);
            obj.transform.SetParent(runtimeRoot, false);
            // 与粒子 / 屏幕同属 HuoshanScreen，进入 VolFx huoshan 合成；
            // 留在 Default 会被 sortingOrder 10 的不透明 noise 盖住。
            int huoshanScreen = LayerMask.NameToLayer("HuoshanScreen");
            if (huoshanScreen >= 0)
                obj.layer = huoshanScreen;
            SpriteRenderer renderer = obj.AddComponent<SpriteRenderer>();
            renderer.sharedMaterial = memoryMaterial;
            renderer.sortingOrder = 0;
            renderer.maskInteraction = SpriteMaskInteraction.None;
            renderer.enabled = false;
            obj.SetActive(false);
            return renderer;
        }

        private TextMeshPro CreateScreenText(string objectName, float fontSize, int sortingOrder)
        {
            GameObject obj = new GameObject(objectName);
            obj.transform.SetParent(runtimeRoot, false);
            RectTransform rect = obj.AddComponent<RectTransform>();
            TextMeshPro text = obj.AddComponent<TextMeshPro>();
            text.font = screenFont != null ? screenFont : TMP_Settings.defaultFontAsset;
            text.fontSize = fontSize;
            text.fontStyle = FontStyles.Normal;
            text.enableAutoSizing = false;
            text.enableWordWrapping = false;
            text.alignment = TextAlignmentOptions.Center;
            text.overflowMode = TextOverflowModes.Overflow;
            text.sortingLayerID = GetScreenSortingLayerId();
            text.sortingOrder = sortingOrder;
            text.text = string.Empty;
            obj.SetActive(false);
            return text;
        }

        private void CreateScreenMask()
        {
            GameObject maskObject = new GameObject("ExpressionScreenSpriteMask");
            maskObject.transform.SetParent(runtimeRoot, false);
            screenSpriteMask = maskObject.AddComponent<SpriteMask>();
            screenSpriteMask.sprite = runtimeWhiteSprite;
            screenSpriteMask.alphaCutoff = 0.01f;
            screenSpriteMask.isCustomRangeActive = true;
            int sortingLayer = GetScreenSortingLayerId();
            screenSpriteMask.frontSortingLayerID = sortingLayer;
            screenSpriteMask.frontSortingOrder = screenTextSortingOrder + 2;
            screenSpriteMask.backSortingLayerID = sortingLayer;
            screenSpriteMask.backSortingOrder = screenGlowSortingOrder - 1;
            AlignMaskToScreenRect(maskObject.transform);
        }

        private void PositionScreenText()
        {
            Bounds screen = GetScreenBounds();
            Vector3 center = screen.center;
            if (faceRenderer != null)
                center.z = faceRenderer.transform.position.z;

            PositionText(lieText, center, screen.size);
            PositionText(lieGhostText, center, screen.size);
            PositionText(actorFlashText, center, screen.size);
            PositionText(actorFlashChromaRed, center, screen.size);
            PositionText(actorFlashChromaCyan, center, screen.size);
            PositionText(truthFlashText, center, screen.size);
        }

        private void EnsureScreenTextClipMaterials()
        {
            lieClipper?.Initialize(lieText, expressionScreenMaskRect);
            lieGhostClipper?.Initialize(lieGhostText, expressionScreenMaskRect);
            actorFlashClipper?.Initialize(actorFlashText, expressionScreenMaskRect);
            actorFlashChromaRedClipper?.Initialize(actorFlashChromaRed, expressionScreenMaskRect);
            actorFlashChromaCyanClipper?.Initialize(actorFlashChromaCyan, expressionScreenMaskRect);
            truthFlashClipper?.Initialize(truthFlashText, expressionScreenMaskRect);
            foreach (TMPRectClipper clipper in actorScrollClippers)
                clipper?.Initialize(clipper.GetComponent<TextMeshPro>(), expressionScreenMaskRect);
        }

        private void ReleaseScreenTextClipMaterials()
        {
            lieClipper?.ReleaseMaterial();
            lieGhostClipper?.ReleaseMaterial();
            actorFlashClipper?.ReleaseMaterial();
            actorFlashChromaRedClipper?.ReleaseMaterial();
            actorFlashChromaCyanClipper?.ReleaseMaterial();
            truthFlashClipper?.ReleaseMaterial();
            foreach (TMPRectClipper clipper in actorScrollClippers)
                clipper?.ReleaseMaterial();
        }

        private static void PositionText(TextMeshPro text, Vector3 position, Vector2 size)
        {
            if (text == null)
                return;
            text.transform.position = position;
            RectTransform rect = text.rectTransform;
            rect.sizeDelta = size;
            rect.localScale = Vector3.one;
        }

        private void AlignMaskToScreenRect(Transform maskTransform)
        {
            Bounds screen = GetScreenBounds();
            maskTransform.position = screen.center;
            maskTransform.rotation = expressionScreenMaskRect != null
                ? expressionScreenMaskRect.rotation
                : Quaternion.identity;
            maskTransform.localScale = new Vector3(screen.size.x, screen.size.y, 1f);
        }

        /// <summary>
        /// 记忆图作为全屏背景：按主相机视野 cover 缩放（铺满、超出部分裁掉），
        /// 渲染顺序在脸后面（sortingOrder 0 vs 脸的 2），透过脸的透明区域露出。
        /// </summary>
        private void FitMemoryToView(SpriteRenderer renderer)
        {
            if (renderer == null || renderer.sprite == null)
                return;

            Vector2 viewportSize;
            Vector3 viewportCenter;
            Quaternion viewportRotation = Quaternion.identity;
            Camera viewCamera = Camera.main;
            if (viewCamera != null)
            {
                float planeZ = renderer.transform.position.z;
                float height = viewCamera.orthographic
                    ? viewCamera.orthographicSize * 2f
                    : 2f * Mathf.Abs(planeZ - viewCamera.transform.position.z) *
                      Mathf.Tan(viewCamera.fieldOfView * 0.5f * Mathf.Deg2Rad);
                viewportSize = new Vector2(height * viewCamera.aspect, height);
                viewportCenter = new Vector3(
                    viewCamera.transform.position.x,
                    viewCamera.transform.position.y,
                    planeZ);
            }
            else if (faceRenderer != null && faceRenderer.sprite != null)
            {
                Vector3 faceScale = faceRenderer.transform.lossyScale;
                Vector3 faceSpriteSize = faceRenderer.sprite.bounds.size;
                viewportSize = new Vector2(
                    Mathf.Abs(faceSpriteSize.x * faceScale.x),
                    Mathf.Abs(faceSpriteSize.y * faceScale.y));
                viewportCenter = faceRenderer.transform.position;
                viewportRotation = faceRenderer.transform.rotation;
            }
            else
            {
                Bounds screen = GetScreenBounds();
                float height = screen.size.y * 2.4f;
                viewportSize = new Vector2(height * 16f / 9f, height);
                viewportCenter = screen.center;
            }

            Vector2 spriteSize = renderer.sprite.bounds.size;
            float uniformScale = Mathf.Max(
                viewportSize.x / Mathf.Max(0.001f, spriteSize.x),
                viewportSize.y / Mathf.Max(0.001f, spriteSize.y));
            renderer.transform.SetPositionAndRotation(viewportCenter, viewportRotation);
            renderer.transform.localScale = Vector3.one * uniformScale;
        }

        private void ApplyMemoryBlocks()
        {
            ApplyMemoryBlock(memoryRendererA, memoryBlockA, memoryOpacityA);
            ApplyMemoryBlock(memoryRendererB, memoryBlockB, memoryOpacityB);
        }

        private void ApplyMemoryBlock(SpriteRenderer renderer, MaterialPropertyBlock block, float opacity)
        {
            if (renderer == null || block == null)
                return;

            renderer.GetPropertyBlock(block);
            block.SetFloat(SaturationId, saturation);
            block.SetFloat(BrightnessId, brightness);
            block.SetFloat(ContrastId, contrast);
            block.SetFloat(VignetteId, vignette);
            block.SetFloat(NoiseId, noise);
            // 模拟感随记忆自身透明度浮现/退场，避免淡入期间闪线突兀。
            block.SetFloat(SimGlitchId, simGlitch * opacity);
            block.SetFloat(HorizontalTearId, horizontalTear);
            block.SetFloat(MemoryImpactId, memoryImpact);
            block.SetFloat(MemoryDamageId, memoryDamage);
            block.SetFloat(MemoryOverdriveId, memoryOverdrive);
            block.SetFloat(MemoryTearSeedId, memoryTearSeed);
            block.SetColor(ColorTintId, memoryTint);
            block.SetVector(CalmCenterId, new Vector4(calmCenter.x, calmCenter.y, 0f, 0f));
            block.SetFloat(CalmRadiusId, calmRadius);
            block.SetFloat(CalmFeatherId, calmFeather);
            block.SetFloat(EffectStrengthId, effectStrength);
            block.SetFloat(OpacityId, opacity);
            renderer.SetPropertyBlock(block);
        }

        private void TweenMemoryOpacity(
            SpriteRenderer renderer,
            float target,
            float duration,
            Ease ease = Ease.OutQuad)
        {
            if (renderer == null)
                return;
            DOTween.Kill(renderer);
            DOTween.To(
                    () => GetMemoryOpacity(renderer),
                    value => SetMemoryOpacity(renderer, value),
                    Mathf.Clamp01(target),
                    Mathf.Max(0.01f, duration))
                .SetEase(ease)
                .SetTarget(renderer);
        }

        private float GetMemoryOpacity(SpriteRenderer renderer)
        {
            return renderer == memoryRendererA ? memoryOpacityA : memoryOpacityB;
        }

        private void SetMemoryOpacity(SpriteRenderer renderer, float opacity)
        {
            if (renderer == memoryRendererA)
                memoryOpacityA = opacity;
            else if (renderer == memoryRendererB)
                memoryOpacityB = opacity;
            ApplyMemoryBlocks();
        }

        private void DisableMemoryRenderer(SpriteRenderer renderer)
        {
            if (renderer == null)
                return;
            DOTween.Kill(renderer);
            renderer.enabled = false;
            renderer.gameObject.SetActive(false);
            renderer.sprite = null;
        }

        private void PlayScanline(float duration, bool stalled)
        {
            if (scanlineRenderer == null)
                return;

            Bounds screen = GetScreenBounds();
            scanlineRenderer.enabled = true;
            scanlineRenderer.gameObject.SetActive(true);
            scanlineRenderer.transform.localScale = new Vector3(screen.size.x, 0.035f, 1f);
            float y = stalled ? screen.center.y : screen.max.y;
            scanlineRenderer.transform.position = new Vector3(screen.center.x, y, screen.center.z);
            scanlineRenderer.color = new Color(0.55f, 0.95f, 1f, stalled ? 0.72f : 0.62f);
            scanlineRenderer.transform.DOKill();
            if (!stalled)
            {
                scanlineRenderer.transform.DOMoveY(screen.min.y, duration)
                    .SetEase(Ease.Linear)
                    .SetTarget(this)
                    .OnComplete(StopScanline);
            }
            else
            {
                scanlineRenderer.DOFade(0.15f, 0.055f)
                    .SetLoops(4, LoopType.Yoyo)
                    .SetTarget(this);
            }
        }

        private void StopScanline()
        {
            if (scanlineRenderer == null)
                return;
            scanlineRenderer.transform.DOKill();
            scanlineRenderer.DOKill();
            scanlineRenderer.enabled = false;
            scanlineRenderer.gameObject.SetActive(false);
        }

        private void PulseScreenDim(float alpha, float riseDuration, float fallDuration)
        {
            if (screenDimRenderer == null)
                return;

            screenDimRenderer.DOKill();
            screenDimRenderer.enabled = true;
            screenDimRenderer.gameObject.SetActive(true);
            screenDimRenderer.color = new Color(0.02f, 0.05f, 0.08f, 0f);
            Sequence sequence = DOTween.Sequence().SetTarget(this);
            sequence.Append(screenDimRenderer.DOFade(Mathf.Clamp01(alpha), Mathf.Max(0.01f, riseDuration)));
            sequence.Append(screenDimRenderer.DOFade(0f, Mathf.Max(0.01f, fallDuration)));
            sequence.OnComplete(StopScreenDim);
        }

        private void PulseTruthBreakFlash(
            float alpha,
            float riseDuration,
            float holdDuration,
            float fallDuration)
        {
            if (screenDimRenderer == null)
                return;

            screenDimRenderer.DOKill();
            screenDimRenderer.enabled = true;
            screenDimRenderer.gameObject.SetActive(true);
            screenDimRenderer.color = new Color(
                truthWarmColor.r,
                truthWarmColor.g,
                truthWarmColor.b,
                0f);
            Sequence sequence = DOTween.Sequence().SetTarget(this);
            sequence.Append(screenDimRenderer.DOFade(Mathf.Clamp01(alpha), Mathf.Max(0.01f, riseDuration)));
            sequence.AppendInterval(Mathf.Max(0f, holdDuration));
            sequence.Append(screenDimRenderer.DOFade(0f, Mathf.Max(0.01f, fallDuration)));
            sequence.OnComplete(StopScreenDim);
        }

        private void PulseTruthAttackFlash(float alpha, float riseDuration, float fallDuration)
        {
            if (screenDimRenderer == null)
                return;

            screenDimRenderer.DOKill();
            screenDimRenderer.enabled = true;
            screenDimRenderer.gameObject.SetActive(true);
            screenDimRenderer.color = new Color(
                truthAttackFlashColor.r,
                truthAttackFlashColor.g,
                truthAttackFlashColor.b,
                0f);

            Sequence sequence = DOTween.Sequence().SetTarget(this);
            sequence.Append(screenDimRenderer.DOFade(
                Mathf.Clamp01(alpha),
                Mathf.Max(0.01f, riseDuration)));
            sequence.Append(screenDimRenderer.DOFade(
                0f,
                Mathf.Max(0.01f, fallDuration)));
            sequence.OnComplete(StopScreenDim);
        }

        private void HoldTruthBreakBlackout(float alpha)
        {
            if (screenDimRenderer == null)
                return;

            screenDimRenderer.DOKill();
            screenDimRenderer.enabled = true;
            screenDimRenderer.gameObject.SetActive(true);
            screenDimRenderer.color = new Color(0.01f, 0.025f, 0.04f, Mathf.Clamp01(alpha));
        }

        private void PulseMemoryRelease(float amount, float riseDuration, float fallDuration)
        {
            float originalBrightness = brightness;
            Sequence sequence = DOTween.Sequence().SetTarget(this);
            sequence.Append(DOTween.To(
                () => brightness,
                value => brightness = value,
                originalBrightness + amount,
                Mathf.Max(0.01f, riseDuration)));
            sequence.Append(DOTween.To(
                () => brightness,
                value => brightness = value,
                originalBrightness,
                Mathf.Max(0.01f, fallDuration)));
        }

        private void StopScreenDim()
        {
            if (screenDimRenderer == null)
                return;
            screenDimRenderer.DOKill();
            screenDimRenderer.enabled = false;
            screenDimRenderer.gameObject.SetActive(false);
        }

        private void HideLieLayersImmediate()
        {
            StopLieShuffleImmediate(false);
            HideTextImmediate(lieText);
            HideTextImmediate(lieGhostText);
            HideActorFlashImmediate();
        }

        private void HideActorFlashImmediate()
        {
            StopActorOverdriveImmediate();
            StopTruthLieFlicker();
            actorFlashActive = false;
            actorFlashCount = 0;
            memoryImpact = 0f;
            memoryDamage = 0f;
            memoryOverdrive = 0f;
            HideActorFlashVisualsImmediate();
            HideActorScrollImmediate();
        }

        private void HideActorFlashVisualsImmediate()
        {
            if (actorFlashText != null)
                actorFlashText.fontSize = 10.5f;
            if (actorFlashChromaRed != null)
                actorFlashChromaRed.fontSize = 10.5f;
            if (actorFlashChromaCyan != null)
                actorFlashChromaCyan.fontSize = 10.5f;
            HideTextImmediate(actorFlashText);
            HideTextImmediate(actorFlashChromaRed);
            HideTextImmediate(actorFlashChromaCyan);
            truthFlashActive = false;
            HideTextImmediate(truthFlashText);
        }

        private static void HideTextImmediate(TextMeshPro text)
        {
            if (text == null)
                return;
            text.DOKill();
            text.text = string.Empty;
            text.gameObject.SetActive(false);
        }

        private static void SetTextActive(TextMeshPro text, string value, Color color)
        {
            if (text == null)
                return;
            text.gameObject.SetActive(true);
            text.enabled = true;
            text.text = value ?? string.Empty;
            text.color = color;
        }

        private static void SetTextAlpha(TextMeshPro text, float alpha)
        {
            if (text == null)
                return;
            Color color = text.color;
            color.a = Mathf.Clamp01(alpha);
            text.color = color;
        }

        private void FadeText(TextMeshPro text, float alpha, float duration)
        {
            if (text == null || !text.gameObject.activeSelf)
                return;
            text.DOFade(alpha, duration).SetEase(Ease.OutQuad).SetTarget(this);
        }

        private Bounds GetScreenBounds()
        {
            if (expressionScreenMaskRect == null)
                return particleManager != null
                    ? particleManager.GetScreenWorldBounds()
                    : new Bounds(transform.position, new Vector3(5.77f, 4.2f, 0f));

            Vector3[] corners = new Vector3[4];
            expressionScreenMaskRect.GetWorldCorners(corners);
            Bounds result = new Bounds(corners[0], Vector3.zero);
            for (int i = 1; i < corners.Length; i++)
                result.Encapsulate(corners[i]);
            return result;
        }

        private int GetScreenSortingLayerId()
        {
            Canvas canvas = expressionScreenMaskRect != null
                ? expressionScreenMaskRect.GetComponentInParent<Canvas>()
                : null;
            return canvas != null ? canvas.sortingLayerID : 0;
        }

        private bool TryResolveMemory(string key, out Sprite sprite, out MemoryKind kind)
        {
            switch ((key ?? string.Empty).Trim().ToLowerInvariant())
            {
                case "office":
                    sprite = officeMemory;
                    kind = MemoryKind.Office;
                    return sprite != null;
                case "sunset":
                    sprite = sunsetMemory;
                    kind = MemoryKind.Sunset;
                    return sprite != null;
                case "private_office":
                    sprite = privateOfficeMemory;
                    kind = MemoryKind.PrivateOffice;
                    return sprite != null;
                default:
                    sprite = null;
                    kind = MemoryKind.Office;
                    return false;
            }
        }

        private static Preset GetPresetForMemory(MemoryKind kind)
        {
            return kind switch
            {
                MemoryKind.Sunset => MediumPreset,
                MemoryKind.PrivateOffice => HeavyPreset,
                _ => LightPreset
            };
        }

        private bool ExpectState(string command, params PresentationState[] allowed)
        {
            for (int i = 0; i < allowed.Length; i++)
            {
                if (state == allowed[i])
                    return true;
            }

            Debug.LogWarning(
                $"[LogReleasePresentation] {command} 在状态 {state} 被调用；已安全跳过，不阻塞 Yarn。");
            return false;
        }

        private void OnDestroy()
        {
            DOTween.Kill(this);
            if (runtimeWhiteSprite != null)
                Destroy(runtimeWhiteSprite);
            if (runtimeWhiteTexture != null)
                Destroy(runtimeWhiteTexture);
        }
    }
}