C# / .NET / Unity 应用开发

// 程序入口
using System;

class Program {
    static void Main(string[] args) {
        Console.WriteLine("Hello, C#!");
    }
}

// 变量声明（类型推断）
int score = 100;
double pi = 3.14159;
bool isActive = true;
string name = "Player1";
var health = 100;  // 编译器自动推断为 int

// 数组
int[] scores = new int[5];
string[] names = { "Alice", "Bob", "Carol" };

// 列表（动态数组）
using System.Collections.Generic;
List<int> scores = new List<int>();
scores.Add(90);
scores.Add(85);
scores.Remove(90);

// 属性
class Player {
    public string Name { get; set; }
    public int Health {
        get { return health; }
        set { health = Math.Max(0, value); }
    }
    private int health;
}

// 条件与循环（与 C++ 几乎相同）
if (score >= 90) {
    Console.WriteLine("优秀");
} else if (score >= 60) {
    Console.WriteLine("及格");
} else {
    Console.WriteLine("不及格");
}

for (int i = 0; i < 10; i++) {
    Console.WriteLine(i);
}

foreach (var n in names) {  // C# 特有的 foreach
    Console.WriteLine(n);
}

// 函数
static int Add(int a, int b) => a + b;  // 表达式体（lambda 风格）

// 继承与多态
class Entity {
    public virtual void Update() {  // virtual 允许重写
        Console.WriteLine("Entity Update");
    }
}

class Player : Entity {  // 单继承
    public override void Update() {  // override 重写
        Console.WriteLine("Player Update");
    }
}

// 接口
interface IDamageable {
    void TakeDamage(int amount);
}

class Enemy : Entity, IDamageable {  // 单继承 + 多接口
    public void TakeDamage(int amount) {
        Console.WriteLine($"Enemy took {amount} damage");  // 字符串插值
    }
}

// 委托与事件（Unity 中大量使用）
delegate void OnScoreChanged(int newScore);

class ScoreManager {
    public event OnScoreChanged ScoreChanged;
    private int score;
    public int Score {
        get => score;
        set {
            score = value;
            ScoreChanged?.Invoke(score);  // ?. 空条件运算符
        }
    }
}

using System;            // 基础类型、Console、Math、DateTime
using System.IO;         // 文件读写：File、StreamReader
using System.Linq;       // LINQ：查询集合的链式语法
using System.Collections.Generic;  // List、Dictionary、Queue
using System.Threading;  // 多线程、异步
using System.Text.Json;  // JSON 序列化
using System.Net.Http;   // HTTP 请求

// LINQ 用于高效查询和转换集合
var notes = new List<SongNote> {
    new SongNote { Time = 1000, X = 100, Y = 200, Type = 0 },
    new SongNote { Time = 2500, X = 300, Y = 150, Type = 1 },
    new SongNote { Time = 4000, X = 500, Y = 300, Type = 0 },
};

// 筛选时间大于 2000ms 的音符
var lateNotes = notes.Where(n => n.Time > 2000).ToList();

// 按时间排序
var sorted = notes.OrderBy(n => n.Time).ToList();

// 计算平均 X 坐标
double avgX = notes.Average(n => n.X);

// 分组统计各类型数量
var groups = notes.GroupBy(n => n.Type)
                   .Select(g => new { Type = g.Key, Count = g.Count() });

// 异步加载资源是 Unity 和 .NET 游戏开发的核心技能
using System.IO;
using System.Threading.Tasks;

class BeatmapLoader {
    // async：标记为异步方法
    // Task<T>：返回一个异步任务，最终得到 T 类型结果
    public async Task<string> LoadBeatmapAsync(string path) {
        // await：等待异步操作完成，不阻塞主线程
        using var reader = new StreamReader(path);
        return await reader.ReadToEndAsync();
    }
}

// 调用方式
var loader = new BeatmapLoader();
string content = await loader.LoadBeatmapAsync("song.osu");

// 在 Hierarchy 中创建一个空对象，命名为 "GameManager"
// 添加 C# 脚本组件，这是 Unity 的标准工作流

using UnityEngine;

public class GameManager : MonoBehaviour {  // 继承 MonoBehaviour 才能成为组件
    // Start 在对象第一次更新前调用（类似构造函数）
    void Start() {
        Debug.Log("游戏开始！");  // 在 Console 窗口输出
    }

    // Update 每帧调用一次（60 FPS = 每秒 60 次）
    void Update() {
        // 每帧执行的逻辑
    }
}

using UnityEngine;

public class LifeCycleDemo : MonoBehaviour {
    // 脚本被加载时调用一次（即使对象未激活）
    void Awake() {
        Debug.Log("Awake: 对象初始化");
    }

    // 对象第一次激活时调用（在 Awake 之后）
    void Start() {
        Debug.Log("Start: 游戏开始");
    }

    // 每帧调用（帧率依赖，不适用于物理计算）
    void Update() {
        // Time.deltaTime = 上一帧耗时（秒），用于帧率无关的计算
        float speed = 5f * Time.deltaTime;  // 5单位/秒，而非5单位/帧
    }

    // 固定时间间隔调用（默认 0.02s = 50Hz），适用于物理
    void FixedUpdate() {
        // 物理相关操作放这里
    }

    // 对象被销毁前调用
    void OnDestroy() {
        Debug.Log("OnDestroy: 对象销毁");
    }
}

// 修改位置和旋转
transform.position = new Vector3(10, 20, 0);      // 绝对位置（世界坐标）
transform.localPosition = new Vector3(5, 0, 0);   // 相对父对象的位置
transform.Translate(Vector3.right * Time.deltaTime);  // 每帧向右移动

// 缩放
transform.localScale = new Vector3(2, 2, 1);  // 2倍放大

// 查找子对象和父对象
Transform child = transform.Find("ChildName");
Transform parent = transform.parent;

using UnityEngine;

public class SpriteDemo : MonoBehaviour {
    public SpriteRenderer sr;  // 在 Inspector 中拖拽赋值

    void Start() {
        // 修改颜色（RGBA，0~1）
        sr.color = new Color(1, 0, 0, 0.5f);  // 半透明红色

        // 修改排序层级（越大越靠前）
        sr.sortingOrder = 10;

        // 动态加载精灵
        Sprite loadedSprite = Resources.Load<Sprite>("Textures/Circle");
        sr.sprite = loadedSprite;
    }

    void Update() {
        // 脉冲缩放效果
        float scale = 1 + Mathf.Sin(Time.time * 3) * 0.1f;
        transform.localScale = new Vector3(scale, scale, 1);
    }
}

using UnityEngine;

public class HitCircle : MonoBehaviour {
    public Sprite circleSprite;  // 在 Inspector 中赋值圆圈图片
    public Sprite approachSprite;  // 判定圈图片

    // 静态方法：工厂模式创建 osu! 风格点击圆圈
    public static HitCircle Create(Vector2 position, float approachTime) {
        GameObject obj = new GameObject("HitCircle");
        obj.transform.position = position;

        // 添加 SpriteRenderer 组件
        SpriteRenderer sr = obj.AddComponent<SpriteRenderer>();
        sr.sortingOrder = 5;

        // 添加自定义脚本
        HitCircle hc = obj.AddComponent<HitCircle>();
        hc.Initialize(approachTime);
        return hc;
    }

    void Initialize(float time) {
        // 初始化逻辑
    }
}

using UnityEngine;

public class InputDemo : MonoBehaviour {
    void Update() {
        // 键盘输入
        if (Input.GetKeyDown(KeyCode.Space)) {  // 按下瞬间（仅一帧）
            Debug.Log("空格按下！");
        }
        if (Input.GetKey(KeyCode.W)) {  // 持续按住
            transform.Translate(Vector3.up * Time.deltaTime);
        }

        // 鼠标输入
        if (Input.GetMouseButtonDown(0)) {  // 0=左键, 1=右键, 2=中键
            Vector3 mousePos = Input.mousePosition;  // 屏幕坐标（像素）
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(mousePos);
            worldPos.z = 0;
            Debug.Log($"点击世界坐标: {worldPos}");
        }

        // osu! 核心：判断鼠标是否在圆圈内
        if (Input.GetMouseButtonDown(0)) {
            Vector3 clickPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            float distance = Vector2.Distance(transform.position, clickPos);
            if (distance < 0.5f) {  // 假设圆圈半径为 0.5
                Debug.Log("击中！");
            }
        }
    }
}

using UnityEngine;

public class AudioManager : MonoBehaviour {
    public AudioSource bgmSource;      // 背景音乐播放器
    public AudioSource sfxSource;      // 音效播放器
    public AudioClip bgmClip;          // 背景音乐文件
    public AudioClip hitClip;          // 击中音效
    public AudioClip missClip;         // 失误音效

    void Start() {
        // 播放背景音乐
        bgmSource.clip = bgmClip;
        bgmSource.loop = true;
        bgmSource.volume = 0.7f;
        bgmSource.Play();
    }

    // 播放击中音效
    public void PlayHit() {
        sfxSource.PlayOneShot(hitClip, 1.0f);  // 不中断其他音效
    }

    // osu! 核心：获取当前播放进度（毫秒）
    public float GetCurrentTimeMs() {
        return bgmSource.time * 1000f;
    }

    // 从指定时间开始播放（用于测试和重开）
    public void SeekTo(float timeMs) {
        bgmSource.time = timeMs / 1000f;
    }
}

using UnityEngine;

public class BeatSync : MonoBehaviour {
    public AudioSource music;
    public float bpm = 120;  // 每分钟 120 拍

    private float beatInterval;  // 每拍间隔（秒）
    private float nextBeatTime;

    void Start() {
        beatInterval = 60f / bpm;  // 120 BPM = 0.5 秒/拍
        nextBeatTime = 0;
    }

    void Update() {
        float currentTime = music.time;

        // 检测是否到达下一拍
        if (currentTime >= nextBeatTime) {
            OnBeat();
            nextBeatTime += beatInterval;
        }
    }

    void OnBeat() {
        // 每拍触发的事件：生成音符、闪烁背景等
        Debug.Log("Beat!");
    }
}

using UnityEngine;
using TMPro;  // TextMeshPro 命名空间
using UnityEngine.UI;

public class UIManager : MonoBehaviour {
    public TextMeshProUGUI scoreText;   // 分数显示
    public TextMeshProUGUI comboText;   // 连击数显示
    public TextMeshProUGUI judgeText;   // 判定结果（Perfect/Great...）
    public Slider hpSlider;             // 生命值条
    public Image judgeImage;            // 判定结果背景图

    private int score = 0;
    private int combo = 0;

    // 更新分数和连击
    public void AddScore(int points, string judgement) {
        score += points;
        combo++;
        scoreText.text = $"Score: {score:D8}";  // 8位数字，前导补零
        comboText.text = $"{combo}x";

        // 显示判定结果
        judgeText.text = judgement;
        judgeText.color = GetJudgeColor(judgement);

        // 动画效果：判定文字放大后消失
        StopAllCoroutines();
        StartCoroutine(AnimateJudgeText());
    }

    private Color GetJudgeColor(string judge) {
        switch (judge) {
            case "Perfect":  return new Color(1, 0.8f, 0.2f);   // 金色
            case "Great":    return Color.green;
            case "Good":     return Color.yellow;
            case "Miss":     return Color.red;
            default:        return Color.white;
        }
    }

    // 协程：判定文字动画
    System.Collections.IEnumerator AnimateJudgeText() {
        judgeText.transform.localScale = Vector3.one * 1.5f;
        yield return new WaitForSeconds(0.1f);
        judgeText.transform.localScale = Vector3.one;
        yield return new WaitForSeconds(0.5f);
        judgeText.text = "";
    }

    // 更新生命值（0~1）
    public void SetHP(float hp) {
        hpSlider.value = Mathf.Clamp01(hp);
    }
}

using UnityEngine;

public class ApproachCircle : MonoBehaviour {
    public float approachTime = 1.0f;   // 判定圈收缩时间
    public float startScale = 3.0f;     // 起始大小（相对于目标）

    private float timer = 0;
    private Vector3 targetScale;

    void Start() {
        targetScale = transform.localScale;
        transform.localScale = targetScale * startScale;
    }

    void Update() {
        timer += Time.deltaTime;
        float t = timer / approachTime;

        // Lerp 线性插值：从 startScale 平滑过渡到 1.0
        float current = Mathf.Lerp(startScale, 1.0f, t);
        transform.localScale = targetScale * current;

        // 时间到后销毁
        if (t >= 1.0f) {
            OnMiss();
        }
    }

    void OnMiss() {
        Debug.Log("Miss!");
        Destroy(gameObject);
    }

    // osu! 核心：获取当前判定窗口（越接近1.0，判定越严格）
    public float GetAccuracy() {
        return Mathf.Abs(timer / approachTime - 1.0f);
    }
}

using UnityEngine;

public class HitEffect : MonoBehaviour {
    public ParticleSystem hitParticles;   // 在 Inspector 中赋值

    public void Play(Vector3 position, Color color) {
        // 移动到击中位置
        transform.position = position;

        // 修改粒子颜色
        var main = hitParticles.main;
        main.startColor = color;

        // 播放一次
        hitParticles.Play();

        // 2秒后销毁特效对象
        Destroy(gameObject, 2f);
    }
}

using UnityEngine;

public class CircleHitArea : MonoBehaviour {
    public float radius = 0.5f;
    public LayerMask hitLayer;  // 筛选可点击的层级

    // 方法1：直接距离计算（osu! 核心判定）
    public bool IsPointInside(Vector2 point) {
        return Vector2.Distance(transform.position, point) <= radius;
    }

    // 方法2：使用 Physics2D.OverlapCircle（适合复杂场景）
    public Collider2D[] GetOverlapping() {
        return Physics2D.OverlapCircleAll(transform.position, radius, hitLayer);
    }

    // 可视化判定区域（Scene 视图中可见）
    void OnDrawGizmos() {
        Gizmos.color = Color.cyan;
        Gizmos.DrawWireSphere(transform.position, radius);
    }
}

// 射线检测（从摄像机到鼠标位置）
public class RaycastInput : MonoBehaviour {
    void Update() {
        if (Input.GetMouseButtonDown(0)) {
            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(mousePos, Vector2.zero);
            if (hit.collider != null) {
                Debug.Log($"点击了: {hit.collider.name}");
            }
        }
    }
}

using UnityEngine;

public enum Judgement { Perfect, Great, Good, Miss }

public class HitJudge {
    // 判定窗口（毫秒）：点击时间与目标时间的差值
    public static readonly float PERFECT_WINDOW = 50f;
    public static readonly float GREAT_WINDOW = 100f;
    public static readonly float GOOD_WINDOW = 150f;

    public static Judgement Judge(float timeDiffMs) {
        float abs = Mathf.Abs(timeDiffMs);
        if (abs <= PERFECT_WINDOW) return Judgement.Perfect;
        if (abs <= GREAT_WINDOW)   return Judgement.Great;
        if (abs <= GOOD_WINDOW)    return Judgement.Good;
        return Judgement.Miss;
    }

    public static int GetScore(Judgement j, int combo) {
        switch (j) {
            case Judgement.Perfect: return 300 + combo * 10;
            case Judgement.Great:   return 100 + combo * 5;
            case Judgement.Good:    return 50;
            default:               return 0;
        }
    }
}

using UnityEngine;

public class PlayerData : MonoBehaviour {
    // 保存最高分
    public static void SaveHighScore(string songName, int score) {
        int current = PlayerPrefs.GetInt($"HighScore_{songName}", 0);
        if (score > current) {
            PlayerPrefs.SetInt($"HighScore_{songName}", score);
            PlayerPrefs.Save();  // 立即写入磁盘
        }
    }

    // 读取最高分
    public static int LoadHighScore(string songName) {
        return PlayerPrefs.GetInt($"HighScore_{songName}", 0);
    }
}

using UnityEngine;
using System.IO;

// 可序列化的分数记录
[System.Serializable]
public class ScoreRecord {
    public string songName;
    public int score;
    public float accuracy;
    public string rank;  // S/A/B/C/D
    public string date;
}

[System.Serializable]
public class ScoreDatabase {
    public ScoreRecord[] records;
}

public class JsonSaver : MonoBehaviour {
    private string SavePath => Path.Combine(Application.persistentDataPath, "scores.json");

    public void SaveScores(ScoreRecord[] records) {
        var db = new ScoreDatabase { records = records };
        string json = JsonUtility.ToJson(db, true);  // true = 格式化缩进
        File.WriteAllText(SavePath, json);
    }

    public ScoreRecord[] LoadScores() {
        if (!File.Exists(SavePath)) return new ScoreRecord[0];
        string json = File.ReadAllText(SavePath);
        var db = JsonUtility.FromJson<ScoreDatabase>(json);
        return db?.records ?? new ScoreRecord[0];
    }
}

using UnityEngine;
using System.Collections.Generic;

// 单个音符数据
[System.Serializable]
public class NoteData {
    public float time;      // 目标时间（毫秒，从歌曲开始）
    public float x, y;     // 屏幕坐标（0~1 归一化，映射到实际分辨率）
    public int type;        // 0=普通圆, 1=滑条, 2=转盘（本项目先实现 0）
}

// 完整谱面
[System.Serializable]
public class Beatmap {
    public string title;
    public string artist;
    public float bpm;
    public List<NoteData> notes = new List<NoteData>();
}

// 谱面加载器（从 JSON 文件加载）
public class BeatmapLoader : MonoBehaviour {
    public TextAsset beatmapJson;  // 在 Inspector 中拖拽 .json 文件

    public Beatmap Load() {
        return JsonUtility.FromJson<Beatmap>(beatmapJson.text);
    }

    // 创建测试谱面的辅助方法
    public static Beatmap CreateTestBeatmap() {
        var bm = new Beatmap {
            title = "Test Song",
            artist = "Test Artist",
            bpm = 120
        };
        // 生成 20 个均匀分布的音符
        for (int i = 0; i < 20; i++) {
            bm.notes.Add(new NoteData {
                time = 2000 + i * 500,   // 从 2 秒开始，每 0.5 秒一个
                x = Random.Range(0.1f, 0.9f),  // 归一化坐标
                y = Random.Range(0.1f, 0.9f),
                type = 0
            });
        }
        return bm;
    }
}

using UnityEngine;

public static class CoordinateMapper {
    // osu! 标准虚拟分辨率
    public const float OSU_WIDTH = 512f;
    public const float OSU_HEIGHT = 384f;

    // 将 osu! 坐标 (0~512, 0~384) 映射到世界坐标
    public static Vector2 ToWorldPosition(float osuX, float osuY) {
        // 假设摄像机正交尺寸和宽高比适配 osu! 比例
        Camera cam = Camera.main;
        float orthoHeight = cam.orthographicSize * 2;
        float orthoWidth = orthoHeight * cam.aspect;

        float worldX = (osuX / OSU_WIDTH - 0.5f) * orthoWidth;
        float worldY = (osuY / OSU_HEIGHT - 0.5f) * orthoHeight;
        return new Vector2(worldX, worldY);
    }
}

using UnityEngine;
using System;

public class HitCircle : MonoBehaviour {
    public NoteData data;              // 音符数据
    public float approachTime = 800f;  // 判定圈提前出现的时间（毫秒）
    public float circleRadius = 0.3f;  // 圆圈半径（世界单位）

    // 组件引用
    private SpriteRenderer circleRenderer;
    private SpriteRenderer approachRenderer;
    private SpriteRenderer overlayRenderer;

    // 状态
    private bool isHit = false;
    private bool isMissed = false;
    private float spawnTime;         // 实际生成时间（毫秒）

    // 事件：击中或错过时通知 GameManager
    public event Action<HitCircle, Judgement, float> OnJudged;

    public void Initialize(NoteData note, float currentTimeMs) {
        data = note;
        spawnTime = currentTimeMs;

        // 设置位置
        Vector2 pos = CoordinateMapper.ToWorldPosition(note.x, note.y);
        transform.position = pos;

        // 获取组件（假设子对象已配置好）
        circleRenderer = transform.Find("Circle").GetComponent<SpriteRenderer>();
        approachRenderer = transform.Find("ApproachCircle").GetComponent<SpriteRenderer>();
        overlayRenderer = transform.Find("Overlay")?.GetComponent<SpriteRenderer>();
    }

    void Update() {
        if (isHit || isMissed) return;

        float currentTime = AudioManager.Instance.GetCurrentTimeMs();
        float timeUntilHit = data.time - currentTime;

        // 判定圈收缩动画
        if (approachRenderer != null) {
            float progress = 1 - (timeUntilHit / approachTime);
            progress = Mathf.Clamp01(progress);
            float scale = Mathf.Lerp(4f, 1f, progress);
            approachRenderer.transform.localScale = Vector3.one * scale;
            approachRenderer.color = new Color(1, 1, 1, 1 - progress);
        }

        // 错过判定：超过 GOOD_WINDOW 仍未点击
        if (timeUntilHit < -HitJudge.GOOD_WINDOW) {
            Miss();
        }
    }

    // 外部调用：检测是否被点击
    public bool TryHit(Vector2 clickPos, float currentTimeMs) {
        if (isHit || isMissed) return false;

        // 距离判定
        float distance = Vector2.Distance(transform.position, clickPos);
        if (distance > circleRadius * 1.5f) return false;

        // 时间判定
        float timeDiff = currentTimeMs - data.time;
        Judgement judge = HitJudge.Judge(timeDiff);

        if (judge != Judgement.Miss) {
            Hit(judge, timeDiff);
            return true;
        }
        return false;
    }

    private void Hit(Judgement judge, float timeDiff) {
        isHit = true;
        OnJudged?.Invoke(this, judge, timeDiff);

        // 击中动画：缩放脉冲后消失
        StartCoroutine(HitAnimation());
    }

    private void Miss() {
        isMissed = true;
        OnJudged?.Invoke(this, Judgement.Miss, 0);
        Destroy(gameObject, 0.3f);
    }

    System.Collections.IEnumerator HitAnimation() {
        // 快速放大
        transform.localScale = Vector3.one * 1.3f;
        circleRenderer.color = Color.white;
        yield return new WaitForSeconds(0.05f);

        // 渐隐
        float elapsed = 0;
        while (elapsed < 0.2f) {
            elapsed += Time.deltaTime;
            float alpha = 1 - (elapsed / 0.2f);
            circleRenderer.color = new Color(1, 1, 1, alpha);
            yield return null;
        }
        Destroy(gameObject);
    }
}

using UnityEngine;
using System.Collections.Generic;

public class NoteSpawner : MonoBehaviour {
    public GameObject hitCirclePrefab;   // 在 Inspector 中赋值 Prefab
    public float approachTime = 800f;  // 判定圈提前出现的时间（毫秒）

    private Beatmap beatmap;
    private int nextNoteIndex = 0;
    private List<HitCircle> activeNotes = new List<HitCircle>();

    public void LoadBeatmap(Beatmap bm) {
        beatmap = bm;
        nextNoteIndex = 0;
        activeNotes.Clear();
    }

    void Update() {
        if (beatmap == null || nextNoteIndex >= beatmap.notes.Count) return;

        float currentTime = AudioManager.Instance.GetCurrentTimeMs();

        // 当音频时间到达 spawnTime 时生成音符
        // spawnTime = note.time - approachTime
        while (nextNoteIndex < beatmap.notes.Count) {
            NoteData note = beatmap.notes[nextNoteIndex];
            float spawnTime = note.time - approachTime;

            if (currentTime >= spawnTime) {
                SpawnNote(note);
                nextNoteIndex++;
            } else {
                break;
            }
        }
    }

    void SpawnNote(NoteData note) {
        GameObject obj = Instantiate(hitCirclePrefab, transform);
        HitCircle hc = obj.GetComponent<HitCircle>();
        hc.Initialize(note, AudioManager.Instance.GetCurrentTimeMs());
        hc.OnJudged += OnNoteJudged;
        activeNotes.Add(hc);
    }

    void OnNoteJudged(HitCircle note, Judgement judge, float diff) {
        activeNotes.Remove(note);
        ScoreManager.Instance.ProcessHit(judge);
        UIManager.Instance.ShowJudgement(judge);
    }

    // 将点击事件传递给所有活跃的音符
    public void ProcessClick(Vector2 worldPos) {
        float currentTime = AudioManager.Instance.GetCurrentTimeMs();

        // 优先判定最早出现的音符（避免后面的遮挡前面的）
        for (int i = 0; i < activeNotes.Count; i++) {
            if (activeNotes[i].TryHit(worldPos, currentTime)) {
                break;  // 一次点击只判定一个音符
            }
        }
    }
}

using UnityEngine;
using UnityEngine.SceneManagement;

public class GameManager : MonoBehaviour {
    public static GameManager Instance { get; private set; }

    public enum GameState { Menu, Playing, Paused, GameOver, Result }
    public GameState CurrentState { get; private set; } = GameState.Menu;

    // 引用
    public AudioManager audioManager;
    public NoteSpawner noteSpawner;
    public ScoreManager scoreManager;
    public UIManager uiManager;

    void Awake() {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);  // 切换场景时不销毁
    }

    public void StartGame(Beatmap beatmap) {
        CurrentState = GameState.Playing;
        scoreManager.Reset();
        noteSpawner.LoadBeatmap(beatmap);
        audioManager.Play(beatmap.title);
        uiManager.ShowGameUI();
    }

    public void PauseGame() {
        if (CurrentState == GameState.Playing) {
            CurrentState = GameState.Paused;
            audioManager.Pause();
            Time.timeScale = 0;  // 冻结游戏时间
            uiManager.ShowPauseMenu();
        }
    }

    public void ResumeGame() {
        CurrentState = GameState.Playing;
        audioManager.Resume();
        Time.timeScale = 1;
        uiManager.HidePauseMenu();
    }

    public void GameOver() {
        CurrentState = GameState.GameOver;
        audioManager.Stop();
        uiManager.ShowGameOver();
    }

    public void ShowResult() {
        CurrentState = GameState.Result;
        var result = scoreManager.GetFinalResult();
        uiManager.ShowResultScreen(result);
    }

    public void ReturnToMenu() {
        Time.timeScale = 1;
        SceneManager.LoadScene("MenuScene");
    }
}

using UnityEngine;

public class ScoreManager : MonoBehaviour {
    public static ScoreManager Instance { get; private set; }

    public int Score { get; private set; }
    public int Combo { get; private set; }
    public int MaxCombo { get; private set; }
    public float HP { get; private set; } = 1f;
    public int TotalNotes { get; set; }
    public int PerfectCount { get; private set; }
    public int GreatCount { get; private set; }
    public int GoodCount { get; private set; }
    public int MissCount { get; private set; }

    void Awake() { Instance = this; }

    public void Reset() {
        Score = 0; Combo = 0; MaxCombo = 0; HP = 1f;
        PerfectCount = GreatCount = GoodCount = MissCount = 0;
    }

    public void ProcessHit(Judgement judge) {
        int points = HitJudge.GetScore(judge, Combo);
        Score += points;

        switch (judge) {
            case Judgement.Perfect:
                Combo++; PerfectCount++;
                HP = Mathf.Min(1f, HP + 0.02f);
                break;
            case Judgement.Great:
                Combo++; GreatCount++;
                HP = Mathf.Min(1f, HP + 0.01f);
                break;
            case Judgement.Good:
                Combo = 0; GoodCount++;
                HP = Mathf.Max(0, HP - 0.05f);
                break;
            case Judgement.Miss:
                Combo = 0; MissCount++;
                HP = Mathf.Max(0, HP - 0.15f);
                break;
        }

        if (Combo > MaxCombo) MaxCombo = Combo;

        // 通知 UI 更新
        UIManager.Instance.UpdateScore(Score, Combo, HP);

        // 生命值归零
        if (HP <= 0) {
            GameManager.Instance.GameOver();
        }
    }

    // 计算最终评级
    public string GetRank() {
        float accuracy = GetAccuracy();
        if (accuracy >= 1.0f && MissCount == 0) return "SS";
        if (accuracy >= 0.95f) return "S";
        if (accuracy >= 0.90f) return "A";
        if (accuracy >= 0.80f) return "B";
        if (accuracy >= 0.60f) return "C";
        return "D";
    }

    public float GetAccuracy() {
        if (TotalNotes == 0) return 0;
        float weighted = PerfectCount * 1.0f + GreatCount * 0.5f + GoodCount * 0.25f;
        return weighted / TotalNotes;
    }

    public GameResult GetFinalResult() {
        return new GameResult {
            score = Score,
            maxCombo = MaxCombo,
            accuracy = GetAccuracy(),
            rank = GetRank(),
            perfect = PerfectCount,
            great = GreatCount,
            good = GoodCount,
            miss = MissCount
        };
    }
}

[System.Serializable]
public class GameResult {
    public int score;
    public int maxCombo;
    public float accuracy;
    public string rank;
    public int perfect, great, good, miss;
}

// ResultScreen.cs - 结算画面
using UnityEngine;
using TMPro;

public class ResultScreen : MonoBehaviour {
    public TextMeshProUGUI scoreText;
    public TextMeshProUGUI accuracyText;
    public TextMeshProUGUI comboText;
    public TextMeshProUGUI rankText;
    public TextMeshProUGUI detailText;

    public void Display(GameResult result) {
        scoreText.text = $"Score: {result.score:D8}";
        accuracyText.text = $"Accuracy: {result.accuracy:P2}";
        comboText.text = $"Max Combo: {result.maxCombo}x";
        rankText.text = result.rank;
        rankText.color = GetRankColor(result.rank);
        detailText.text = $"Perfect: {result.perfect}  Great: {result.great}  Good: {result.good}  Miss: {result.miss}";
    }

    Color GetRankColor(string rank) {
        switch (rank) {
            case "SS": return new Color(1, 0.84f, 0);     // 金色
            case "S":  return new Color(1, 0.65f, 0);     // 橙色
            case "A":  return Color.green;
            case "B":  return Color.cyan;
            case "C":  return Color.yellow;
            default:   return Color.red;
        }
    }
}

using UnityEngine;

public class InputHandler : MonoBehaviour {
    void Update() {
        // 鼠标点击
        if (Input.GetMouseButtonDown(0)) {
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            worldPos.z = 0;
            GameManager.Instance.noteSpawner.ProcessClick(worldPos);
        }

        // 键盘快捷键
        if (Input.GetKeyDown(KeyCode.Escape)) {
            if (GameManager.Instance.CurrentState == GameManager.GameState.Playing) {
                GameManager.Instance.PauseGame();
            } else if (GameManager.Instance.CurrentState == GameManager.GameState.Paused) {
                GameManager.Instance.ResumeGame();
            }
        }

        // 游戏结束后按空格返回菜单
        if (Input.GetKeyDown(KeyCode.Space)) {
            if (GameManager.Instance.CurrentState == GameManager.GameState.Result
             || GameManager.Instance.CurrentState == GameManager.GameState.GameOver) {
                GameManager.Instance.ReturnToMenu();
            }
        }
    }
}

using UnityEngine;

public class LowLatencyAudio : MonoBehaviour {
    void Awake() {
        // 获取当前 DSP 缓冲区大小
        int bufferSize, numBuffers;
        AudioSettings.GetDSPBufferSize(out bufferSize, out numBuffers);
        Debug.Log($"当前缓冲区: {bufferSize} 样本, {numBuffers} 缓冲");

        // 设置为最小配置（增加 CPU 负载但降低延迟）
        AudioSettings.SetDSPBufferSize(256, 2);  // 256 样本 / 2 缓冲
        // 采样率 48000Hz 时，256 样本 = 5.3ms 延迟
    }

    // 精确的音频时间查询（基于 DSP 时钟，非游戏帧）
    public static double GetAudioTime() {
        return AudioSettings.dspTime;  // 双精度，基于音频硬件时钟
    }
}

// 使用 DSP 时间的判定器
public class DspTimeJudge : MonoBehaviour {
    public AudioSource music;

    void Update() {
        // 错误方式：Time.time 与音频实际播放不同步
        // float badTime = Time.time; // 受帧率波动影响

        // 正确方式：使用音频驱动级的时间戳
        double preciseTime = AudioSettings.dspTime;
        double songTime = music.time;  // AudioSource 内部使用 DSP 时间

        // 更精确的方式：根据采样位置计算
        ulong samplePos = (ulong)(AudioSettings.dspTime * AudioSettings.outputSampleRate);
        double exactMs = samplePos * 1000.0 / AudioSettings.outputSampleRate;
    }
}

using UnityEngine;

// 输入预测与回溯判定
public class InputLatencyCompensator : MonoBehaviour {
    // 预设延迟补偿量（通过校准工具测得，单位毫秒）
    public float inputLatencyMs = 30f;
    public float audioLatencyMs = 20f;

    // 总偏移：判定时刻 = 点击时刻 - 输入延迟 + 音频延迟
    private float TotalOffsetMs => audioLatencyMs - inputLatencyMs;

    // 判定核心：将点击时间修正到音频时间轴
    public Judgement JudgeWithLatency(float noteTargetMs, float clickRealtimeMs) {
        float adjustedClick = clickRealtimeMs - TotalOffsetMs;
        float diff = adjustedClick - noteTargetMs;
        return HitJudge.Judge(diff);
    }
}

// 校准工具：让玩家跟随节拍点击，统计平均偏差
public class LatencyCalibrator : MonoBehaviour {
    private List<float> offsets = new List<float>();
    private AudioSource metronome;

    void OnMetronomeBeat() {
        // 记录玩家点击与音频节拍的差值
        float playerClickTime = Time.realtimeSinceStartup * 1000;
        float beatTime = metronome.time * 1000;
        offsets.Add(playerClickTime - beatTime);
    }

    public float GetAverageOffset() {
        if (offsets.Count == 0) return 0;
        float sum = 0;
        foreach (var o in offsets) sum += o;
        return sum / offsets.Count;
    }
}

using UnityEngine;

public class FrameSync : MonoBehaviour {
    void Start() {
        // 强制垂直同步：消除画面撕裂，但可能引入输入延迟
        QualitySettings.vSyncCount = 1;

        // 无垂直同步：最低输入延迟，但可能撕裂
        // QualitySettings.vSyncCount = 0;
        // Application.targetFrameRate = -1;

        // 节奏游戏推荐：固定刷新率匹配显示器
        // 若显示器 144Hz，目标 144fps
        Application.targetFrameRate = 144;

        // 确保 Update 在 FixedUpdate 之后（输入优先）
        // 或通过 Input System 的事件驱动模式绕过 Update
    }

    // 使用 OnRenderObject 或 LateUpdate 做最后的视觉修正
    // 将判定圈位置根据 DSP 时间做子帧插值
    void LateUpdate() {
        double dspNow = AudioSettings.dspTime;
        // 根据精确的音频时间微调视觉元素位置
    }
}

// 需通过 NuGet 安装 osu!framework：dotnet add package ppy.osu.Framework
using osu.Framework;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Screens;
using osuTK;

// 游戏入口
public class MyRhythmGame : Game {
    [BackgroundDependencyLoader]
    private void Load() {
        // 添加一个简单的圆圈精灵
        Add(new Circle {
            Size = new Vector2(100),
            Colour = Color4.Cyan,
            Position = new Vector2(200, 150)
        });
    }
}

// 屏幕管理：不同界面作为 Screen 切换
public class MainMenuScreen : Screen {
    private SpriteText title;

    [BackgroundDependencyLoader]
    private void Load() {
        InternalChildren = new Drawable[] {
            new Box {  // 背景
                RelativeSizeAxes = Axes.Both,
                Colour = new Color4(0.1f, 0.1f, 0.15f, 1)
            },
            title = new SpriteText {
                Text = "osu!framework Rhythm Game",
                Font = new FontUsage(size: 40),
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre
            }
        };
    }
}

// 程序启动器
public static class Program {
    public static void Main() {
        using (var host = Host.GetSuitableHost("MyGame")) {
            host.Run(new MyRhythmGame());
        }
    }
}

using osu.Framework.Audio.Track;
using osu.Framework.Graphics.Audio;

public class OsuAudioPlayer : Drawable {
    private TrackBass track;  // BASS 音频轨道

    [BackgroundDependencyLoader]
    private void Load(AudioManager audio) {
        // 异步加载音频
        track = audio.GetTrackStore().Get("song.mp3");
    }

    public void Play() {
        track?.Start();
    }

    public double GetCurrentTime() {
        // 精确的音频播放位置（毫秒级精度）
        return track?.CurrentTime ?? 0;
    }

    // 音频速率调整（不改变音高，类似 osu! 中的 DT/HT 模式）
    public void SetRate(double rate) {
        if (track != null) track.Tempo.Value = rate;
    }
}

// osu! 特有的通道聚合混音器
public class RhythmMixer : DrawableAudioWrapper {
    // 可以同时管理背景音乐、音效、语音通道
    // 各自独立控制音量、均衡器、效果器
}

// 通过 NuGet 引用 osu.Game 相关包
// 或直接克隆 https://github.com/ppy/osu 源码学习

using osu.Game.Beatmaps;
using osu.Game.Rulesets.Osu;
using osu.Game.Rulesets.Osu.Objects;

public class OsuBeatmapLoader {
    // 解析 .osu 谱面文件为强类型对象
    public Beatmap<OsuHitObject> Parse(string filePath) {
        var stream = File.OpenRead(filePath);
        var decoder = new LegacyBeatmapDecoder();
        var beatmap = decoder.Decode(stream);
        return beatmap;
    }

    // 获取所有音符并按时间排序
    public List<OsuHitObject> GetSortedHitObjects(Beatmap<OsuHitObject> beatmap) {
        var objects = new List<OsuHitObject>(beatmap.HitObjects);
        objects.Sort((a, b) => a.StartTime.CompareTo(b.StartTime));
        return objects;
    }
}

// OsuHitObject 的子类代表不同音符类型
// HitCircle：普通点击圆
// Slider：滑条（包含路径点和持续时间）
// Spinner：转盘（持续按住直到结束）