// GameManager.cs
public static GameManager Instance { get; private set; }

private void Awake()
{
    if (Instance == null)
    {
        Instance = this;
    }
    else
    {
        Destroy(gameObject);
        return;
    }
}

public bool IsGameOver { get; private set; }
public bool IsPaused { get; private set; }
public bool IsInMainMenu { get; private set; }

if (GameManager.Instance.IsGameOver || GameManager.Instance.IsPaused) return;

private bool hasGroundJump;  // 是否有地面跳跃机会
private bool hasAirJump;     // 是否有空中跳跃机会

private void HandleInput()
{
    bool wantJump = false;

    if (Input.GetMouseButtonDown(0))
    {
        if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
            return;  // 防止点击UI时触发跳跃
        wantJump = true;
    }
    if (Input.GetKeyDown(KeyCode.Space))
        wantJump = true;

    if (wantJump)
    {
        if (hasGroundJump)
        {
            DoJump(jumpForce);
            hasGroundJump = false;
            hasAirJump = true;
        }
        else if (hasAirJump)
        {
            DoJump(jumpForce * 0.85f);  // 二段跳力度衰减
            hasAirJump = false;
        }
    }
}

private void HandleAutoBounce()
{
    if (!isGrounded) return;

    bounceTimer += Time.deltaTime;
    if (bounceTimer >= bounceInterval)
    {
        rb.velocity = new Vector2(rb.velocity.x, bounceForce);
        bounceTimer = 0f;
    }
}

private void FixedUpdate()
{
    wasGrounded = isGrounded;

    if (transform.position.y <= groundY + 0.5f && rb.velocity.y <= 0.1f)
    {
        rb.velocity = new Vector2(rb.velocity.x, 0f);
        rb.position = new Vector2(rb.position.x, groundY + 0.5f);
        isGrounded = true;

        if (!wasGrounded)
        {
            hasGroundJump = true;
            hasAirJump = false;
            TriggerSquash(true);  // 触发着地压扁动画
        }
    }
    else
    {
        isGrounded = false;
    }
}

private void HandleSquashStretch()
{
    if (!isSquashing)
    {
        transform.localScale = Vector3.Lerp(transform.localScale, originalScale, Time.deltaTime * 10f);
        return;
    }

    squashTimer += Time.deltaTime;
    float t = squashTimer / squashDuration;

    if (t >= 1f)
    {
        isSquashing = false;
        transform.localScale = originalScale;
        return;
    }

    float squash = Mathf.Sin(t * Mathf.PI);
    if (squashIsLand)  // 着地：横向拉伸，纵向压扁
    {
        transform.localScale = new Vector3(
            originalScale.x * (1f + squash * squashAmount),
            originalScale.y * (1f - squash * squashAmount),
            originalScale.z
        );
    }
    else  // 起跳：纵向拉伸，横向收缩
    {
        transform.localScale = new Vector3(
            originalScale.x * (1f - squash * squashAmount * 0.7f),
            originalScale.y * (1f + squash * squashAmount),
            originalScale.z
        );
    }
}

public enum WeaponType { Pea, CornCannon, MachineGun }

private void HandleShooting()
{
    fireTimer += Time.deltaTime;
    float fireRate = currentWeapon == WeaponType.MachineGun ? machineGunFireRate :
                     currentWeapon == WeaponType.CornCannon ? cornFireRate : peaFireRate;
    if (fireTimer >= fireRate)
    {
        GameObject prefab = currentWeapon == WeaponType.MachineGun ? machineGunBulletPrefab :
                            currentWeapon == WeaponType.CornCannon ? cornBulletPrefab : peaBulletPrefab;
        if (prefab != null && firePoint != null)
            Instantiate(prefab, firePoint.position, firePoint.rotation);
        fireTimer = 0f;
    }
}

private void Update()
{
    if (!isGrounded)
    {
        // 阶段1：从空中下落
        transform.Translate(Vector3.down * fallSpeed * Time.deltaTime);
        if (transform.position.y <= groundY + 0.5f)
        {
            isGrounded = true;
            transform.position = new Vector3(transform.position.x, groundY + 0.5f, transform.position.z);
        }
    }
    else
    {
        // 阶段2：地面移动 + 空闲动画
        float speed = GameManager.Instance.GetCurrentScrollSpeed() + moveSpeed;
        transform.Translate(Vector3.left * speed * Time.deltaTime);
        HandleIdleAnimation();
    }
}

public void TakeDamage(int dmg)
{
    health -= dmg;
    if (health <= 0)
    {
        GameManager.Instance.AddScore(scoreValue);
        Destroy(gameObject);
    }
    else
    {
        if (mainSpriteRenderer != null)
        {
            mainSpriteRenderer.color = hitColor;  // 变红
            Invoke(nameof(ResetColor), hitFlashDuration);  // 0.1秒后恢复
        }
    }
}

private void HandleIdleAnimation()
{
    float t = Mathf.Sin(Time.time * idleSquashSpeed);
    float squashY = 1f - t * idleSquashAmount;
    float squashX = 1f + t * idleSquashAmount * 0.5f;

    transform.localScale = new Vector3(originalScale.x * squashX, originalScale.y * squashY, originalScale.z);

    float offsetY = originalScale.y * (1f - squashY) * 0.5f;
    transform.position = new Vector3(originalPosition.x, originalPosition.y + offsetY, originalPosition.z);
}

private void IncreaseDifficulty()
{
    difficultyLevel++;
    currentSpawnInterval = Mathf.Max(minSpawnInterval, currentSpawnInterval - spawnIntervalReduction);
    currentMoveSpeedBonus += moveSpeedIncrease;
    currentHealthBonus += healthIncrease;
    currentScoreBonus += scoreValueIncrease;
}

private void Start()
{
    rb.velocity = transform.right * speed;  // 沿发射方向飞行
}

private void Explode()
{
    if (explosionEffect != null)
        Instantiate(explosionEffect, transform.position, Quaternion.identity);

    Collider2D[] hitColliders = Physics2D.OverlapCircleAll(transform.position, explosionRadius);
    foreach (Collider2D collider in hitColliders)
    {
        if (collider.CompareTag("Enemy"))
        {
            Enemy enemy = collider.GetComponent<Enemy>();
            if (enemy != null)
                enemy.TakeDamage(damage);
        }
    }
    Destroy(gameObject);
}

private void HandleAnimation()
{
    if (bulletSprites == null || bulletSprites.Length == 0) return;

    animationTimer += Time.deltaTime;
    if (animationTimer >= animationSpeed)
    {
        currentSpriteIndex = (currentSpriteIndex + 1) % bulletSprites.Length;
        spriteRenderer.sprite = bulletSprites[currentSpriteIndex];
        animationTimer = 0f;
    }
}

private void CheckIfOutOfBounds()
{
    if (transform.position.x > Camera.main.transform.position.x + Camera.main.orthographicSize * 2f ||
        transform.position.x < Camera.main.transform.position.x - Camera.main.orthographicSize * 2f ||
        transform.position.y > Camera.main.transform.position.y + Camera.main.orthographicSize ||
        transform.position.y < Camera.main.transform.position.y - Camera.main.orthographicSize)
    {
        Destroy(gameObject);
    }
}

private void Update()
{
    if (!isGrounded)
    {
        transform.Translate(Vector3.down * fallSpeed * Time.deltaTime);
        if (transform.position.y <= groundY + 0.8f)
        {
            isGrounded = true;
            transform.position = new Vector3(transform.position.x, groundY + 0.8f, transform.position.z);
        }
    }
    else
    {
        float scrollSpeed = GameManager.Instance.GetCurrentScrollSpeed();
        transform.Translate(Vector3.left * scrollSpeed * Time.deltaTime);
    }
}

private void SpawnPowerup()
{
    GameObject powerupPrefab = powerupPrefabs[Random.Range(0, powerupPrefabs.Length)];
    float spawnX = Camera.main.transform.position.x + spawnDistance;
    float spawnY = Random.Range(minSpawnHeight, maxSpawnHeight);
    Vector3 spawnPosition = new Vector3(spawnX, spawnY, 0f);
    Instantiate(powerupPrefab, spawnPosition, Quaternion.identity);
}

[Header("Scroll Multipliers")]
public float cloudScrollMultiplier = 0.2f;
public float backLayerScrollMultiplier = 0.5f;
public float grassLayerScrollMultiplier = 1f;
public float dirtLayerScrollMultiplier = 1f;

private void ScrollLayerGroup(Transform[] layers, float multiplier, float deltaTime)
{
    float movement = currentScrollSpeed * multiplier * deltaTime;

    foreach (Transform layer in layers)
    {
        layer.Translate(Vector2.left * movement);

        SpriteRenderer spriteRenderer = layer.GetComponent<SpriteRenderer>();
        if (spriteRenderer != null)
        {
            float spriteWidth = spriteRenderer.bounds.size.x;
            if (layer.position.x < -spriteWidth)
            {
                float rightmostX = FindRightmostPosition(layers, spriteWidth);
                layer.position = new Vector3(rightmostX + spriteWidth, layer.position.y, layer.position.z);
            }
        }
    }
}

private void IncreaseSpeed()
{
    currentScrollSpeed = Mathf.Min(maxScrollSpeed, currentScrollSpeed + scrollSpeedIncreaseRate);
}

private bool isUpdatingSpeedToggles;  // 防止递归触发

private void OnNormalSpeedChanged(bool isOn)
{
    if (isUpdatingSpeedToggles) return;  // 程序修改时跳过

    if (isOn)
    {
        GameManager.Instance.SetGameSpeed(1f);
        isUpdatingSpeedToggles = true;
        mediumSpeedToggle.isOn = false;
        fastSpeedToggle.isOn = false;
        isUpdatingSpeedToggles = false;
    }
    else
    {
        isUpdatingSpeedToggles = true;
        normalSpeedToggle.isOn = true;  // 阻止取消选中
        isUpdatingSpeedToggles = false;
    }
}

private void UpdateJumpHint()
{
    if (player != null && player.HasJumpedOnce)
    {
        jumpHintText.gameObject.SetActive(false);  // 首次跳跃后永久隐藏
        jumpHintHidden = true;
        return;
    }
    float t = (Mathf.Sin(Time.time * pulseSpeed) + 1f) / 2f;
    jumpHintText.fontSize = Mathf.RoundToInt(Mathf.Lerp(minFontSize, maxFontSize, t));
}

public void RestartGame()
{
    if (Score > bestScore)
    {
        bestScore = Score;
        PlayerPrefs.SetInt("BestScore", bestScore);
    }
    PlayerPrefs.SetInt("SkipMainMenu", 1);
    SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}

public void ReturnToMainMenu()
{
    Time.timeScale = 0f;
    SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}

if (GameManager.Instance.IsGameOver || GameManager.Instance.IsPaused) return;

if (transform.position.y <= groundY + 0.5f && rb.velocity.y <= 0.1f)

if (isUpdatingSpeedToggles) return;
isUpdatingSpeedToggles = true;
// 修改其他 Toggle...
isUpdatingSpeedToggles = false;

float rightmostX = FindRightmostPosition(layers, spriteWidth);
layer.position = new Vector3(rightmostX + spriteWidth, layer.position.y, layer.position.z);

if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
    return;

using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using TMPro;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

public class AiChat : MonoBehaviour
{
    [Header("UI 绑定")]
    [SerializeField] public TMP_InputField inputField;       // 问题输入框
    [SerializeField] public Button submitButton;             // 提交按钮
    [SerializeField] Text answerText;                 // 答案文本框
    [SerializeField] Toggle ttsToggle;                // 语音合成开关

    [Header("API Settings")]
    [SerializeField] string apiUrl = "接口链接";
    [SerializeField] string apiKey = "密钥";

    [Header("Chat Settings")]
    [SerializeField] public string askTag = "";
    [SerializeField] public AIChatAssistant getRAGChat;


    private bool isStreaming = false;
    private Coroutine streamCoroutine;
    private StringBuilder fullResponse = new StringBuilder();

    void Start()
    {
        //判断网络状态
        if (Application.internetReachability != NetworkReachability.NotReachable)
        {
            // 原：绑定按钮点击事件
            // submitButton.onClick.AddListener(OnSubmitClicked);

            // 当前已被RAGC模块劫持
            submitButton.onClick.AddListener(OnSubmitClick);
            // 直接监听RAGChat组件
            submitButton.onClick.AddListener(() => StartCoroutine(getRAGChat.SubmitQuestion()));

            // 初始状态设置
            submitButton.interactable = true;
            answerText.text = "等待输入问题...";
            //默认打开语音合成开关
            ttsToggle.isOn = true;
        }
        else
        {
            answerText.text = "请检查网络连接！";
        }
    }

    // 点击劫持方法
    void OnSubmitClick()
    {
        getRAGChat.questionInput = inputField.text;
    }

    public void OnSubmitClicked()
    {
        if (string.IsNullOrWhiteSpace(inputField.text))
        {
            answerText.text = "<color=#FF0000>请输入有效问题！</color>";
            return;
        }

        // 如果已有请求在进行中，先停止
        if (isStreaming && streamCoroutine != null)
        {
            StopCoroutine(streamCoroutine);
        }

        // 重置状态
        isStreaming = true;
        fullResponse.Clear();
        answerText.text = "思考中...";
        submitButton.interactable = false;

        // 开始流式请求
        streamCoroutine = StartCoroutine(StreamChatCompletion(inputField.text));
    }

    IEnumerator StreamChatCompletion(string userMessage)
    {
        // 准备请求数据
        var requestData = new RequestData
        {
            messages = new List<Message>
            {
                new Message { role = "user", content = userMessage + "，" + askTag }
            },
            stream = true
        };

        string jsonPayload = JsonUtility.ToJson(requestData);
        byte[] payloadBytes = Encoding.UTF8.GetBytes(jsonPayload);

        // 创建Web请求
        using (UnityWebRequest request = new UnityWebRequest(apiUrl, "POST"))
        {
            request.uploadHandler = new UploadHandlerRaw(payloadBytes);
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SetRequestHeader("Content-Type", "application/json");
            request.SetRequestHeader("Authorization", "Bearer " + apiKey);
            request.disposeDownloadHandlerOnDispose = true;

            // 发送请求
            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.ConnectionError ||
                request.result == UnityWebRequest.Result.ProtocolError)
            {
                Debug.LogError($"API Error: {request.error}");
                Debug.LogError($"Response Code: {request.responseCode}");
                Debug.LogError($"Response: {request.downloadHandler.text}");
                answerText.text = $"<color=#FF0000>请求失败: {request.error}</color>";
                isStreaming = false;
                submitButton.interactable = true;
                yield break;
            }

            // 获取完整响应
            string rawResponse = request.downloadHandler.text;
            Debug.Log($"Raw API Response: {rawResponse}");

            // 处理响应
            if (string.IsNullOrEmpty(rawResponse))
            {
                answerText.text = "<color=#FFA500>服务器返回空响应</color>";
                yield break;
            }

            // 分割响应行
            string[] responseLines = rawResponse.Split('\n');
            bool receivedValidResponse = false;

            foreach (string line in responseLines)
            {
                if (string.IsNullOrWhiteSpace(line)) continue;

                string trimmedLine = line.Trim();

                // 检查结束标记
                if (trimmedLine == "[DONE]")
                {
                    Debug.Log("Received [DONE] marker");
                    break;
                }

                // 处理SSE格式 (data: {...})
                string jsonStr = trimmedLine;
                if (trimmedLine.StartsWith("data:"))
                {
                    jsonStr = trimmedLine.Substring(5).Trim();
                }

                // 跳过事件标记
                if (jsonStr == "event:message") continue;

                try
                {
                    // 反转义处理
                    string unescapedStr = jsonStr
                        .Replace("\\\"", "\"")
                        .Replace("\\\\", "\\")
                        .Replace("\\n", "\n")
                        .Replace("\\r", "\r")
                        .Replace("\\t", "\t");

                    // 移除多余的双引号
                    if (unescapedStr.StartsWith("\"") && unescapedStr.EndsWith("\""))
                    {
                        unescapedStr = unescapedStr.Substring(1, unescapedStr.Length - 2);
                    }

                    // 调试输出
                    Debug.Log($"Processing line: {unescapedStr}");

                    // 解析JSON
                    var response = JsonUtility.FromJson<StreamResponse>(unescapedStr);

                    // 提取内容
                    if (response.choices != null && response.choices.Length > 0)
                    {
                        if (response.choices[0].delta != null &&
                            !string.IsNullOrEmpty(response.choices[0].delta.content))
                        {
                            string content = response.choices[0].delta.content;
                            fullResponse.Append(content);
                            answerText.text = fullResponse.ToString();
                            receivedValidResponse = true;
                        }
                    }
                }
                catch (Exception e)
                {
                    Debug.LogWarning($"解析错误: {e.Message}\n原始数据: {jsonStr}");
                }

                yield return null; // 确保UI更新
            }

            // 完成处理
            isStreaming = false;
            submitButton.interactable = true;

            // 文本转语音 —————————
            // 校验是否打开自动语音合成 —————————————————————————————————
            if (ttsToggle.isOn) UITTSController.Instance.OnConvertClick();

            if (!receivedValidResponse)
            {
                // 尝试提取错误信息
                if (rawResponse.Contains("error"))
                {
                    try
                    {
                        var errorResponse = JsonUtility.FromJson<ErrorResponse>(rawResponse);
                        answerText.text = $"<color=#FF0000>API错误: {errorResponse.error.message}</color>";
                    }
                    catch
                    {
                        answerText.text = $"<color=#FF0000>未知API错误: {rawResponse}</color>";
                    }
                }
                else if (fullResponse.Length > 0)
                {
                    answerText.text = fullResponse.ToString();
                }
                else
                {
                    answerText.text = $"<color=#FFA500>未收到有效响应，原始数据:\n{rawResponse}</color>";
                }
            }
        }
    }

    // 请求数据结构
    [System.Serializable]
    private class RequestData
    {
        public List<Message> messages;
        public bool stream;
    }

    [System.Serializable]
    private class Message
    {
        public string role;
        public string content;
    }

    // 响应数据结构
    [System.Serializable]
    private class StreamResponse
    {
        public string id;
        public string @object;
        public int created;
        public string model;
        public Choice[] choices;
    }

    [System.Serializable]
    private class Choice
    {
        public int index;
        public Delta delta;
        public object logprobs;
        public string finish_reason;
    }

    [System.Serializable]
    private class Delta
    {
        public string content;
    }

    // 错误响应结构
    [System.Serializable]
    private class ErrorResponse
    {
        public ErrorInfo error;
    }

    [System.Serializable]
    private class ErrorInfo
    {
        public string message;
        public string type;
        public string code;
    }
}

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class AudioManager : MonoBehaviour
{
    private AudioSource audioSource;

    void Awake()
    {
        audioSource = gameObject.AddComponent<AudioSource>();
    }

    public IEnumerator DownloadAndPlayAudio(string url)
    {
        Debug.Log($"开始下载音频: {url}");

        // 强制指定MIME类型
        using (UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, AudioType.MPEG))
        {
            ((DownloadHandlerAudioClip)www.downloadHandler).streamAudio = true;
            ((DownloadHandlerAudioClip)www.downloadHandler).compressed = false;

            // 添加超时控制
            www.timeout = 15;
            var operation = www.SendWebRequest();

            while (!operation.isDone)
            {
                Debug.Log($"下载进度: {www.downloadProgress:P}");
                yield return null;
            }

            if (www.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError($"下载失败: {www.error}，响应头: {www.GetResponseHeaders()}");
                yield break;
            }

            Debug.Log($"音频下载完成，长度: {www.downloadedBytes} bytes");
            AudioClip clip = DownloadHandlerAudioClip.GetContent(www);

            if (clip == null || clip.length == 0)
            {
                Debug.LogError("音频解码失败");
                yield break;
            }

            audioSource.clip = clip;
            audioSource.Play();
            Debug.Log("音频开始播放");
        }

        using (UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, AudioType.MPEG))
        {

            yield return www.SendWebRequest();

            if (www.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError($"音频下载失败: {www.error}");
                yield break;
            }

            AudioClip clip = DownloadHandlerAudioClip.GetContent(www);
            audioSource.clip = clip;
            audioSource.Play();
        }
    }

    public void TogglePause()
    {
        if (audioSource.isPlaying)
        {
            audioSource.Pause();
        }
        else
        {
            audioSource.UnPause();
        }
    }

    public void StopPlayback()
    {
        audioSource.Stop();
    }

    public bool IsPlaying()
    {
        return audioSource.isPlaying;
    }

    public float GetPlaybackProgress()
    {
        if (audioSource.clip == null || Mathf.Approximately(audioSource.clip.length, 0f))
        {
            return 0f;
        }
        return Mathf.Clamp01(audioSource.time / audioSource.clip.length);
    }
}

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class BaiduTTSController : MonoBehaviour
{
    // 在百度云控制台获取的实际凭证
    private const string CLIENT_ID = "ID";
    private const string CLIENT_SECRET = "密钥";
    private string accessToken = "";

    // 异步获取Access Token
    public IEnumerator GetAccessToken()
    {
        string url = $"百度智能云链接client_id={CLIENT_ID}&client_secret={CLIENT_SECRET}";

        using (UnityWebRequest www = UnityWebRequest.Get(url))
        {
            yield return www.SendWebRequest();

            if (www.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError($"Token请求失败: {www.error}");
                yield break;
            }

            TokenResponse response = JsonUtility.FromJson<TokenResponse>(www.downloadHandler.text);
            accessToken = response.access_token;
        }
    }

    // 创建语音合成任务
    public IEnumerator CreateTTSTask(string text, System.Action<string> callback)
    {
        string apiUrl = $"接口链接access_token={accessToken}";

        CreateTaskRequest requestData = new CreateTaskRequest
        {
            text = text,
            format = "mp3-16k",
            voice = 0,
            lang = "zh",
            speed = 5,
            pitch = 5,
            volume = 5
        };

        using (UnityWebRequest www = new UnityWebRequest(apiUrl, "POST"))
        {
            byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(JsonUtility.ToJson(requestData));
            www.uploadHandler = new UploadHandlerRaw(bodyRaw);
            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            if (www.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError($"任务创建失败: {www.error}");
                yield break;
            }

            TaskCreateResponse response = JsonUtility.FromJson<TaskCreateResponse>(www.downloadHandler.text);
            callback?.Invoke(response.task_id);
        }
    }

    // 查询任务状态
    public IEnumerator QueryTaskStatus(string taskId, System.Action<string> callback)
    {
        string apiUrl = $"接口链接access_token={accessToken}";

        QueryTaskRequest requestData = new QueryTaskRequest
        {
            task_ids = new string[] { taskId }
        };

        using (UnityWebRequest www = new UnityWebRequest(apiUrl, "POST"))
        {
            byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(JsonUtility.ToJson(requestData));
            www.uploadHandler = new UploadHandlerRaw(bodyRaw);
            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            if (www.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError($"状态查询失败: {www.error}");
                yield break;
            }

            TaskQueryResponse response = JsonUtility.FromJson<TaskQueryResponse>(www.downloadHandler.text);
            if (response.tasks_info.Length > 0 && response.tasks_info[0].task_status == "Success")
            {
                callback?.Invoke(response.tasks_info[0].task_result.speech_url);
            }

            if (response.tasks_info.Length > 0 && response.tasks_info[0].task_status == "Success")
            {
                string audioUrl = response.tasks_info[0].task_result.speech_url;

                Debug.Log($"获取音频地址: {audioUrl}");


                // 添加URL预验证
                using (UnityWebRequest headRequest = UnityWebRequest.Head(audioUrl))
                {
                    yield return headRequest.SendWebRequest();
                    if (headRequest.result == UnityWebRequest.Result.Success)
                    {
                        callback?.Invoke(audioUrl);
                    }
                    else
                    {
                        Debug.LogError($"音频地址不可用: {headRequest.error}");
                    }
                }
            }

        }
    }

    // 数据模型
    [System.Serializable]
    private class TokenResponse
    {
        public string access_token;
    }

    [System.Serializable]
    private class CreateTaskRequest
    {
        public string text;
        public string format;
        public int voice;
        public string lang;
        public int speed;
        public int pitch;
        public int volume;
    }

    [System.Serializable]
    private class TaskCreateResponse
    {
        public string task_id;
    }

    [System.Serializable]
    private class QueryTaskRequest
    {
        public string[] task_ids;
    }

    [System.Serializable]
    private class TaskQueryResponse
    {
        public TaskInfo[] tasks_info;
    }

    [System.Serializable]
    private class TaskInfo
    {
        public string task_status;
        public TaskResult task_result;
    }

    [System.Serializable]
    private class TaskResult
    {
        public string speech_url;
    }
}