taiko_web/Unity迁移指南.md

# Taiko Web 到 Unity 迁移完整指南

## 📋 目录
1. [项目概述](#项目概述)
2. [准备工作](#准备工作)
3. [第一阶段：Unity基础学习](#第一阶段unity基础学习)
4. [第二阶段：项目架构设计](#第二阶段项目架构设计)
5. [第三阶段：核心功能实现](#第三阶段核心功能实现)
6. [第四阶段：资源迁移](#第四阶段资源迁移)
7. [第五阶段：完善与优化](#第五阶段完善与优化)

---

## 项目概述

### 当前项目分析
你的 Taiko Web 项目包含以下核心组件：

1. **游戏核心类**：
   - `Game.js` - 主游戏逻辑
   - `Controller.js` - 游戏控制器
   - `GameRules.js` - 游戏规则和评分
   - `GameInput.js` - 输入处理
   - `Circle.js` - 音符对象

2. **谱面系统**：
   - `.tja` 文件格式
   - `parsetja.js` - 谱面解析器

3. **音频系统**：
   - 音乐播放
   - 音效管理

4. **UI系统**：
   - HTML/CSS界面
   - Canvas绘图

5. **其他功能**：
   - 分数管理
   - 插件系统
   - 多人游戏

### 迁移目标
将上述功能全部用Unity重新实现，最终产品可以作为PC/移动平台的独立游戏或WebGL游戏。

---

## 准备工作

### 1. 安装必要软件

**Unity编辑器**：
- 下载地址：https://unity.com/download
- 推荐版本：Unity 2022.3 LTS (长期支持版本)
- 选择安装模块：
  - ✅ Unity Editor
  - ✅ Visual Studio Community (代码编辑器)
  - ✅ WebGL Build Support (如果要发布网页版)
  - ✅ Android Build Support (如果要发布安卓版)

**Visual Studio Code** (可选，如果你更喜欢轻量编辑器)：
- 下载地址：https://code.visualstudio.com/

### 2. 学习资源准备

**必看教程**：
1. Unity官方教程：https://learn.unity.com/
2. 推荐课程：
   - "Unity入门" - 学习基础操作（2-3小时）
   - "2D游戏开发" - 学习2D游戏制作（5-8小时）
   - "C#编程基础" - 如果没有编程经验（10小时）

**参考文档**：
- Unity脚本API：https://docs.unity3d.com/ScriptReference/
- C#基础教程：https://learn.microsoft.com/zh-cn/dotnet/csharp/

### 3. 创建项目规划表

建议时间线（根据你的学习速度调整）：
- 第一阶段（1-2周）：Unity基础学习
- 第二阶段（3-5天）：项目架构设计
- 第三阶段（3-4周）：核心功能实现
- 第四阶段（1-2周）：资源迁移
- 第五阶段（1-2周）：完善与优化

**总计：约8-12周**

---

## 第一阶段：Unity基础学习

### 第1步：安装和熟悉Unity界面（1天）

1. **安装Unity Hub和Unity Editor**
   - 下载并安装Unity Hub
   - 通过Hub安装Unity 2022.3 LTS
   - 创建Unity账号并激活个人版许可证（免费）

2. **创建第一个项目**
   ```
   1. 打开Unity Hub
   2. 点击"新建项目"
   3. 选择"2D Core"模板
   4. 命名为"TaikoUnityTest"
   5. 选择保存位置
   6. 点击"创建项目"
   ```

3. **熟悉Unity界面**
   - **Scene视图**：场景编辑窗口
   - **Game视图**：游戏运行预览窗口
   - **Hierarchy面板**：场景对象层级
   - **Inspector面板**：属性查看/编辑
   - **Project面板**：资源文件管理
   - **Console面板**：日志和错误信息

### 第2步：学习GameObject和Component（2-3天）

**核心概念**：
- GameObject（游戏对象）：场景中的所有东西都是GameObject
- Component（组件）：附加到GameObject上的功能模块

**实践练习**：

1. **创建一个简单的2D精灵**：
   ```
   1. 右键Hierarchy → 2D Object → Sprite
   2. 在Inspector中看到Transform和Sprite Renderer组件
   3. 尝试修改Position、Rotation、Scale
   4. 尝试改变Sprite和Color
   ```

2. **添加脚本组件**：
   ```csharp
   // 在Project面板右键 → Create → C# Script
   // 命名为"TestMovement"
   
   using UnityEngine;
   
   public class TestMovement : MonoBehaviour
   {
       public float speed = 5f;
       
       void Update()
       {
           // 使用箭头键移动对象
           float horizontal = Input.GetAxis("Horizontal");
           float vertical = Input.GetAxis("Vertical");
           
           transform.position += new Vector3(horizontal, vertical, 0) * speed * Time.deltaTime;
       }
   }
   ```
   
3. **将脚本拖到GameObject上，点击Play测试**

### 第3步：学习C#基础（3-5天）

如果你已经懂JavaScript，C#会比较容易上手。主要区别：

| JavaScript | C# |
|------------|-----|
| `var x = 10` | `int x = 10;` (需要类型声明) |
| `class Game{` | `public class Game {` |
| `this.score = 0` | `private int score = 0;` |
| `function update(){}` | `void Update(){}` |

**重点学习**：
- 变量类型（int, float, string, bool）
- 类和对象
- 函数/方法
- 条件语句（if/else/switch）
- 循环（for/while）
- 数组和List<T>
- 访问修饰符（public/private/protected）

**简单练习**：
```csharp
// 创建一个分数管理器脚本
using UnityEngine;

public class ScoreManager : MonoBehaviour
{
    public int score = 0;
    public int combo = 0;
    
    public void AddScore(int points)
    {
        score += points;
        Debug.Log("当前分数: " + score);
    }
    
    public void IncreaseCombo()
    {
        combo++;
        Debug.Log("连击数: " + combo);
    }
    
    public void ResetCombo()
    {
        combo = 0;
    }
    
    void Start()
    {
        // 游戏开始时调用
        Debug.Log("游戏开始！");
    }
    
    void Update()
    {
        // 每帧调用
        if (Input.GetKeyDown(KeyCode.Space))
        {
            AddScore(100);
            IncreaseCombo();
        }
    }
}
```

### 第4步：学习Unity 2D基础（2-3天）

**必学内容**：

1. **Sprite和Sprite Renderer**
   - 导入图片资源
   - 设置Sprite的Pixels Per Unit
   - Sprite Renderer排序层级（Sorting Layer/Order）

2. **Canvas和UI系统**
   - 创建Canvas
   - UI元素：Text, Image, Button
   - Canvas Scaler设置
   - Anchors和Pivot

3. **音频系统**
   - Audio Source组件
   - Audio Clip资源
   - 播放/暂停/停止音频
   
   ```csharp
   // 播放音频示例
   public AudioClip hitSound;
   private AudioSource audioSource;
   
   void Start()
   {
       audioSource = GetComponent<AudioSource>();
   }
   
   void PlayHitSound()
   {
       audioSource.PlayOneShot(hitSound);
   }
   ```

4. **Prefab（预制体）**
   - 将GameObject拖到Project面板创建Prefab
   - 使用Prefab实例化音符
   
   ```csharp
   public GameObject notePrefab;
   
   void CreateNote()
   {
       GameObject note = Instantiate(notePrefab);
       note.transform.position = new Vector3(10, 0, 0);
   }
   ```

### 第5步：简单游戏Demo（3-4天）

**目标**：制作一个简化版的太鼓节奏游戏Demo

**功能列表**：
- ✅ 音符从右向左移动
- ✅ 按空格键判定
- ✅ 显示分数
- ✅ 播放背景音乐

**实现步骤**：

1. **创建音符脚本**：
```csharp
using UnityEngine;

public class Note : MonoBehaviour
{
    public float speed = 5f;
    
    void Update()
    {
        // 向左移动
        transform.position += Vector3.left * speed * Time.deltaTime;
        
        // 超出屏幕销毁
        if (transform.position.x < -10f)
        {
            Destroy(gameObject);
        }
    }
}
```

2. **创建判定脚本**：
```csharp
using UnityEngine;
using UnityEngine.UI;

public class GameController : MonoBehaviour
{
    public Text scoreText;
    public GameObject notePrefab;
    public Transform judgePosition; // 判定位置
    
    private int score = 0;
    private float nextNoteTime = 0f;
    
    void Update()
    {
        // 自动生成音符
        if (Time.time > nextNoteTime)
        {
            SpawnNote();
            nextNoteTime = Time.time + 2f; // 每2秒一个音符
        }
        
        // 检测输入
        if (Input.GetKeyDown(KeyCode.Space))
        {
            CheckHit();
        }
    }
    
    void SpawnNote()
    {
        GameObject note = Instantiate(notePrefab);
        note.transform.position = new Vector3(10f, 0f, 0f);
    }
    
    void CheckHit()
    {
        // 查找所有音符
        GameObject[] notes = GameObject.FindGameObjectsWithTag("Note");
        
        foreach (GameObject note in notes)
        {
            float distance = Mathf.Abs(note.transform.position.x - judgePosition.position.x);
            
            if (distance < 0.5f) // 判定范围
            {
                score += 100;
                scoreText.text = "Score: " + score;
                Destroy(note);
                Debug.Log("Perfect!");
                return;
            }
        }
        
        Debug.Log("Miss!");
    }
}
```

3. **场景设置**：
   - 创建空对象"GameController"，添加GameController脚本
   - 创建Canvas，添加Text显示分数
   - 创建Sprite作为音符，保存为Prefab
   - 创建Sprite作为判定线
   - 给音符Prefab添加"Note" Tag

---

## 第二阶段：项目架构设计

### 第1步：分析现有代码结构（1天）

**你的Web项目架构**：
```
Game (主游戏类)
├── Controller (控制器)
├── GameRules (规则)
├── GameInput (输入)
├── View (视图)
├── SongData (歌曲数据)
└── Circles (音符数组)
```

**对应的Unity架构**：
```
GameManager (主管理器)
├── NoteManager (音符管理)
├── ScoreManager (分数管理)
├── InputManager (输入管理)
├── AudioManager (音频管理)
├── UIManager (UI管理)
└── ChartLoader (谱面加载)
```

### 第2步：创建正式项目（1天）

1. **创建新项目**：
   - 项目名：`TaikoUnity`
   - 模板：2D Core
   - 位置：`C:\Users\Vanillaaaa\Documents\TaikoUnity`

2. **创建文件夹结构**：
```
Assets/
├── Scripts/
│   ├── Core/           (核心系统)
│   ├── Gameplay/       (游戏逻辑)
│   ├── UI/             (界面)
│   ├── Audio/          (音频)
│   ├── Input/          (输入)
│   └── Utils/          (工具类)
├── Prefabs/
│   ├── Notes/          (音符预制体)
│   └── UI/             (UI预制体)
├── Sprites/
│   ├── Notes/          (音符图片)
│   ├── UI/             (UI图片)
│   └── Backgrounds/    (背景)
├── Audio/
│   ├── Music/          (音乐)
│   └── SFX/            (音效)
├── Charts/             (谱面文件)
└── Scenes/
    ├── MainMenu        (主菜单)
    ├── SongSelect      (选歌)
    └── Game            (游戏)
```

3. **设置项目配置**：
   - File → Build Settings
   - 设置目标平台（PC/WebGL）
   - Player Settings → Resolution：1280x720

### 第3步：创建核心脚本框架（2天）

创建以下基础脚本（架子，先不实现具体功能）：

**1. GameManager.cs**：
```csharp
using UnityEngine;
using UnityEngine.SceneManagement;

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }
    
    public SongData currentSong;
    public float gameTime;
    public bool isPlaying;
    
    void Awake()
    {
        // 单例模式
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
    
    public void StartGame(SongData song)
    {
        currentSong = song;
        SceneManager.LoadScene("Game");
    }
    
    public void PauseGame()
    {
        isPlaying = false;
        Time.timeScale = 0f;
    }
    
    public void ResumeGame()
    {
        isPlaying = true;
        Time.timeScale = 1f;
    }
    
    public void EndGame()
    {
        // 显示结果界面
    }
}
```

**2. NoteManager.cs**：
```csharp
using UnityEngine;
using System.Collections.Generic;

public class NoteManager : MonoBehaviour
{
    public GameObject donNotePrefab;      // 红色音符
    public GameObject kaNotePrefab;       // 蓝色音符
    public GameObject drumrollPrefab;     // 连打
    
    private List<Note> activeNotes = new List<Note>();
    private ChartData currentChart;
    
    public void LoadChart(ChartData chart)
    {
        currentChart = chart;
    }
    
    public void SpawnNote(NoteData noteData)
    {
        GameObject prefab = GetNotePrefab(noteData.type);
        GameObject noteObj = Instantiate(prefab);
        
        Note note = noteObj.GetComponent<Note>();
        note.Initialize(noteData);
        
        activeNotes.Add(note);
    }
    
    private GameObject GetNotePrefab(NoteType type)
    {
        switch(type)
        {
            case NoteType.Don:
                return donNotePrefab;
            case NoteType.Ka:
                return kaNotePrefab;
            default:
                return donNotePrefab;
        }
    }
    
    void Update()
    {
        // 根据歌曲时间生成音符
        SpawnNotesAtTime(GameManager.Instance.gameTime);
    }
    
    void SpawnNotesAtTime(float time)
    {
        // TODO: 实现音符生成逻辑
    }
}
```

**3. ScoreManager.cs**：
```csharp
using UnityEngine;

public enum JudgeResult
{
    Perfect,
    Good,
    Bad,
    Miss
}

public class ScoreManager : MonoBehaviour
{
    public int totalScore;
    public int combo;
    public int maxCombo;
    
    public int perfectCount;
    public int goodCount;
    public int badCount;
    public int missCount;
    
    public void AddJudgement(JudgeResult result)
    {
        switch(result)
        {
            case JudgeResult.Perfect:
                perfectCount++;
                combo++;
                totalScore += 100;
                break;
            case JudgeResult.Good:
                goodCount++;
                combo++;
                totalScore += 50;
                break;
            case JudgeResult.Bad:
                badCount++;
                combo = 0;
                totalScore += 10;
                break;
            case JudgeResult.Miss:
                missCount++;
                combo = 0;
                break;
        }
        
        if(combo > maxCombo)
            maxCombo = combo;
        
        UIManager.Instance?.UpdateScore(totalScore, combo);
    }
    
    public void ResetScore()
    {
        totalScore = 0;
        combo = 0;
        maxCombo = 0;
        perfectCount = goodCount = badCount = missCount = 0;
    }
}
```

**4. 数据类定义（在Scripts/Utils/中创建GameData.cs）**：
```csharp
using System;
using System.Collections.Generic;

[Serializable]
public class SongData
{
    public string title;
    public string subtitle;
    public float bpm;
    public string audioFile;
}

[Serializable]
public enum NoteType
{
    Don,        // 咚（红色）
    Ka,         // 咔（蓝色）
    DaiDon,     // 大咚
    DaiKa,      // 大咔
    Drumroll,   // 连打
    Balloon     // 气球
}

[Serializable]
public class NoteData
{
    public NoteType type;
    public float time;      // 出现时间（秒）
    public float endTime;   // 结束时间（连打用）
    public int hitCount;    // 需要打击次数（气球用）
}

[Serializable]
public class ChartData
{
    public SongData song;
    public List<NoteData> notes = new List<NoteData>();
}
```

---

## 第三阶段：核心功能实现

### 第1步：音符系统（4-5天）

**实现音符基类**：

```csharp
// Note.cs
using UnityEngine;

public class Note : MonoBehaviour
{
    public NoteData data;
    public float speed = 5f;
    public bool isHit = false;
    
    protected SpriteRenderer spriteRenderer;
    protected Transform judgeLineTransform;
    
    public virtual void Initialize(NoteData noteData)
    {
        data = noteData;
        spriteRenderer = GetComponent<SpriteRenderer>();
        judgeLineTransform = GameObject.FindGameObjectWithTag("JudgeLine")?.transform;
    }
    
    protected virtual void Update()
    {
        if(!isHit)
        {
            Move();
            CheckMiss();
        }
    }
    
    protected virtual void Move()
    {
        // 从右向左移动
        transform.position += Vector3.left * speed * Time.deltaTime;
    }
    
    protected virtual void CheckMiss()
    {
        // 如果音符已经过了判定线很远
        if(judgeLineTransform != null)
        {
            float distance = transform.position.x - judgeLineTransform.position.x;
            if(distance < -2f) // Miss判定
            {
                OnMiss();
            }
        }
    }
    
    public virtual JudgeResult Judge()
    {
        if(judgeLineTransform == null)
            return JudgeResult.Miss;
        
        float distance = Mathf.Abs(transform.position.x - judgeLineTransform.position.x);
        
        // 判定窗口（根据你原项目的规则调整）
        if(distance < 0.075f)
            return JudgeResult.Perfect;
        else if(distance < 0.125f)
            return JudgeResult.Good;
        else if(distance < 0.2f)
            return JudgeResult.Bad;
        else
            return JudgeResult.Miss;
    }
    
    public virtual void OnHit(JudgeResult result)
    {
        isHit = true;
        
        // 播放音效
        AudioManager.Instance?.PlayHitSound(data.type);
        
        // 显示特效
        EffectManager.Instance?.ShowJudgeEffect(transform.position, result);
        
        // 销毁音符
        Destroy(gameObject);
    }
    
    protected virtual void OnMiss()
    {
        isHit = true;
        ScoreManager scoreManager = FindObjectOfType<ScoreManager>();
        scoreManager?.AddJudgement(JudgeResult.Miss);
        Destroy(gameObject);
    }
}
```

**创建具体音符类**：

```csharp
// DonNote.cs (红色音符)
public class DonNote : Note
{
    public override void Initialize(NoteData noteData)
    {
        base.Initialize(noteData);
        spriteRenderer.color = new Color(1f, 0.3f, 0.3f); // 红色
    }
}

// KaNote.cs (蓝色音符)
public class KaNote : Note
{
    public override void Initialize(NoteData noteData)
    {
        base.Initialize(noteData);
        spriteRenderer.color = new Color(0.3f, 0.5f, 1f); // 蓝色
    }
}
```

### 第2步：输入系统（2-3天）

```csharp
// InputManager.cs
using UnityEngine;

public class InputManager : MonoBehaviour
{
    public KeyCode donLeft = KeyCode.F;      // 左咚
    public KeyCode donRight = KeyCode.J;     // 右咚
    public KeyCode kaLeft = KeyCode.D;       // 左咔
    public KeyCode kaRight = KeyCode.K;      // 右咔
    
    private NoteManager noteManager;
    private ScoreManager scoreManager;
    
    void Start()
    {
        noteManager = FindObjectOfType<NoteManager>();
        scoreManager = FindObjectOfType<ScoreManager>();
    }
    
    void Update()
    {
        // 检测咚（红色）输入
        if(Input.GetKeyDown(donLeft) || Input.GetKeyDown(donRight))
        {
            ProcessHit(NoteType.Don);
        }
        
        // 检测咔（蓝色）输入
        if(Input.GetKeyDown(kaLeft) || Input.GetKeyDown(kaRight))
        {
            ProcessHit(NoteType.Ka);
        }
    }
    
    void ProcessHit(NoteType hitType)
    {
        // 查找最接近判定线的音符
        Note closestNote = FindClosestNote(hitType);
        
        if(closestNote != null)
        {
            JudgeResult result = closestNote.Judge();
            
            if(result != JudgeResult.Miss)
            {
                closestNote.OnHit(result);
                scoreManager.AddJudgement(result);
            }
        }
    }
    
    Note FindClosestNote(NoteType hitType)
    {
        GameObject[] noteObjects = GameObject.FindGameObjectsWithTag("Note");
        Note closestNote = null;
        float minDistance = float.MaxValue;
        Transform judgeLine = GameObject.FindGameObjectWithTag("JudgeLine")?.transform;
        
        if(judgeLine == null)
            return null;
        
        foreach(GameObject obj in noteObjects)
        {
            Note note = obj.GetComponent<Note>();
            
            if(note == null || note.isHit)
                continue;
            
            // 检查音符类型是否匹配
            if(!IsNoteTypeMatch(note.data.type, hitType))
                continue;
            
            float distance = Mathf.Abs(note.transform.position.x - judgeLine.position.x);
            
            if(distance < minDistance && distance < 0.3f) // 判定范围
            {
                minDistance = distance;
                closestNote = note;
            }
        }
        
        return closestNote;
    }
    
    bool IsNoteTypeMatch(NoteType noteType, NoteType hitType)
    {
        // Don可以打Don和DaiDon
        if(hitType == NoteType.Don)
        {
            return noteType == NoteType.Don || noteType == NoteType.DaiDon;
        }
        // Ka可以打Ka和DaiKa
        else if(hitType == NoteType.Ka)
        {
            return noteType == NoteType.Ka || noteType == NoteType.DaiKa;
        }
        
        return false;
    }
}
```

### 第3步：谱面加载系统（3-4天）

**TJA解析器**（这是核心部分，需要移植你的parsetja.js逻辑）：

```csharp
// TJAParser.cs
using System;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class TJAParser
{
    public ChartData Parse(string filePath)
    {
        ChartData chart = new ChartData();
        chart.song = new SongData();
        chart.notes = new List<NoteData>();
        
        string[] lines = File.ReadAllLines(filePath);
        
        bool inNoteData = false;
        float currentTime = 0f;
        float bpm = 120f;
        int measureIndex = 0;
        
        foreach(string line in lines)
        {
            string trimmed = line.Trim();
            
            // 跳过空行和注释
            if(string.IsNullOrEmpty(trimmed) || trimmed.StartsWith("//"))
                continue;
            
            // 解析元数据
            if(trimmed.Contains(":") && !inNoteData)
            {
                ParseMetadata(trimmed, chart.song, ref bpm);
            }
            // 开始音符数据
            else if(trimmed == "#START")
            {
                inNoteData = true;
                currentTime = 0f;
            }
            // 结束音符数据
            else if(trimmed == "#END")
            {
                break;
            }
            // 解析音符数据
            else if(inNoteData)
            {
                if(trimmed.StartsWith("#"))
                {
                    // 处理命令（如#BPMCHANGE）
                    ProcessCommand(trimmed, ref bpm);
                }
                else if(trimmed.EndsWith(","))
                {
                    // 解析小节
                    ParseMeasure(trimmed, chart.notes, ref currentTime, bpm);
                    measureIndex++;
                }
            }
        }
        
        return chart;
    }
    
    void ParseMetadata(string line, SongData song, ref float bpm)
    {
        string[] parts = line.Split(new char[]{':'}, 2);
        if(parts.Length != 2)
            return;
        
        string key = parts[0].Trim();
        string value = parts[1].Trim();
        
        switch(key)
        {
            case "TITLE":
                song.title = value;
                break;
            case "SUBTITLE":
                song.subtitle = value;
                break;
            case "BPM":
                float.TryParse(value, out bpm);
                song.bpm = bpm;
                break;
            case "WAVE":
                song.audioFile = value;
                break;
        }
    }
    
    void ProcessCommand(string command, ref float bpm)
    {
        if(command.StartsWith("#BPMCHANGE"))
        {
            string value = command.Replace("#BPMCHANGE", "").Trim();
            float.TryParse(value, out bpm);
        }
    }
    
    void ParseMeasure(string measure, List<NoteData> notes, ref float currentTime, float bpm)
    {
        // 移除逗号
        measure = measure.TrimEnd(',');
        
        // 计算每个音符的时间间隔
        float beatDuration = 60f / bpm; // 一拍的时间
        float noteDuration = (beatDuration * 4f) / measure.Length; // 一个音符的时间
        
        for(int i = 0; i < measure.Length; i++)
        {
            char noteChar = measure[i];
            
            if(noteChar != '0') // 0表示没有音符
            {
                NoteData note = new NoteData();
                note.time = currentTime + (i * noteDuration);
                
                // 根据字符确定音符类型
                switch(noteChar)
                {
                    case '1':
                        note.type = NoteType.Don;
                        break;
                    case '2':
                        note.type = NoteType.Ka;
                        break;
                    case '3':
                        note.type = NoteType.DaiDon;
                        break;
                    case '4':
                        note.type = NoteType.DaiKa;
                        break;
                    case '5':
                    case '6':
                        note.type = NoteType.Drumroll;
                        // TODO: 处理连打的结束时间
                        break;
                    case '7':
                        note.type = NoteType.Balloon;
                        break;
                }
                
                notes.Add(note);
            }
        }
        
        // 更新当前时间（一个小节 = 4拍）
        currentTime += beatDuration * 4f;
    }
}
```

**谱面加载器**：

```csharp
// ChartLoader.cs
using UnityEngine;

public class ChartLoader : MonoBehaviour
{
    public void LoadChart(string chartPath)
    {
        TJAParser parser = new TJAParser();
        ChartData chart = parser.Parse(chartPath);
        
        // 加载音乐
        AudioManager.Instance?.LoadMusic(chart.song.audioFile);
        
        // 传递给NoteManager
        NoteManager noteManager = FindObjectOfType<NoteManager>();
        noteManager?.LoadChart(chart);
        
        Debug.Log($"加载谱面: {chart.song.title}");
        Debug.Log($"音符数量: {chart.notes.Count}");
    }
}
```

### 第4步：音频系统（2-3天）

```csharp
// AudioManager.cs
using UnityEngine;
using System.Collections;

public class AudioManager : MonoBehaviour
{
    public static AudioManager Instance { get; private set; }
    
    public AudioSource musicSource;
    public AudioSource sfxSource;
    
    public AudioClip donHitSound;
    public AudioClip kaHitSound;
    public AudioClip drumrollSound;
    
    void Awake()
    {
        if(Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
        
        // 创建AudioSource组件
        if(musicSource == null)
        {
            musicSource = gameObject.AddComponent<AudioSource>();
            musicSource.loop = false;
            musicSource.playOnAwake = false;
        }
        
        if(sfxSource == null)
        {
            sfxSource = gameObject.AddComponent<AudioSource>();
            sfxSource.playOnAwake = false;
        }
    }
    
    public void LoadMusic(string fileName)
    {
        // 从Resources文件夹加载音乐
        AudioClip clip = Resources.Load<AudioClip>("Music/" + Path.GetFileNameWithoutExtension(fileName));
        
        if(clip != null)
        {
            musicSource.clip = clip;
        }
        else
        {
            Debug.LogError($"找不到音乐文件: {fileName}");
        }
    }
    
    public void PlayMusic()
    {
        if(musicSource.clip != null)
        {
            musicSource.Play();
        }
    }
    
    public void StopMusic()
    {
        musicSource.Stop();
    }
    
    public void PlayHitSound(NoteType type)
    {
        AudioClip clip = null;
        
        switch(type)
        {
            case NoteType.Don:
            case NoteType.DaiDon:
                clip = donHitSound;
                break;
            case NoteType.Ka:
            case NoteType.DaiKa:
                clip = kaHitSound;
                break;
        }
        
        if(clip != null)
        {
            sfxSource.PlayOneShot(clip);
        }
    }
    
    public float GetMusicTime()
    {
        return musicSource.time;
    }
}
```

### 第5步：UI系统（2-3天）

```csharp
// UIManager.cs
using UnityEngine;
using UnityEngine.UI;

public class UIManager : MonoBehaviour
{
    public static UIManager Instance { get; private set; }
    
    [Header("Game UI")]
    public Text scoreText;
    public Text comboText;
    public Image comboBackground;
    
    [Header("判定显示")]
    public Text judgeText;
    public GameObject perfectEffect;
    public GameObject goodEffect;
    public GameObject badEffect;
    
    void Awake()
    {
        if(Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }
    
    public void UpdateScore(int score, int combo)
    {
        if(scoreText != null)
        {
            scoreText.text = score.ToString("D8"); // 8位数字，前面补0
        }
        
        if(combo > 0)
        {
            if(comboText != null)
            {
                comboText.text = combo.ToString();
                comboText.gameObject.SetActive(true);
            }
            
            if(comboBackground != null)
            {
                comboBackground.gameObject.SetActive(true);
            }
        }
        else
        {
            if(comboText != null)
            {
                comboText.gameObject.SetActive(false);
            }
            
            if(comboBackground != null)
            {
                comboBackground.gameObject.SetActive(false);
            }
        }
    }
    
    public void ShowJudgeResult(JudgeResult result)
    {
        if(judgeText == null)
            return;
        
        switch(result)
        {
            case JudgeResult.Perfect:
                judgeText.text = "良";
                judgeText.color = Color.yellow;
                break;
            case JudgeResult.Good:
                judgeText.text = "可";
                judgeText.color = Color.white;
                break;
            case JudgeResult.Bad:
                judgeText.text = "不可";
                judgeText.color = Color.gray;
                break;
        }
        
        // 显示后淡出
        StopAllCoroutines();
        StartCoroutine(FadeOutJudgeText());
    }
    
    System.Collections.IEnumerator FadeOutJudgeText()
    {
        judgeText.gameObject.SetActive(true);
        
        yield return new WaitForSeconds(0.5f);
        
        float fadeTime = 0.3f;
        float elapsed = 0f;
        Color originalColor = judgeText.color;
        
        while(elapsed < fadeTime)
        {
            elapsed += Time.deltaTime;
            float alpha = 1f - (elapsed / fadeTime);
            judgeText.color = new Color(originalColor.r, originalColor.g, originalColor.b, alpha);
            yield return null;
        }
        
        judgeText.gameObject.SetActive(false);
        judgeText.color = originalColor;
    }
}
```

---

## 第四阶段：资源迁移

### 第1步：图片资源（2-3天）

**需要准备的图片**：
1. 音符图片（Don, Ka, DaiDon, DaiKa）
2. 判定线
3. 背景图片
4. UI元素（按钮、框架等）
5. 特效Sprite

**导入步骤**：
1. 将图片复制到`Assets/Sprites/`对应文件夹
2. 选中图片，在Inspector中：
   - Texture Type: Sprite (2D and UI)
   - Pixels Per Unit: 100（根据图片大小调整）
   - Filter Mode: Bilinear
   - Compression: 根据需要选择

**创建音符Prefab**：
```
1. 创建空GameObject，命名为"DonNote"
2. 添加Sprite Renderer，设置Sprite
3. 添加Note.cs或DonNote.cs脚本
4. 添加Tag "Note"
5. 拖到Prefabs/Notes/文件夹，创建Prefab
6. 删除Hierarchy中的对象
```

### 第2步：音频资源（1-2天）

**处理音频文件**：

你的项目使用.ogg格式，Unity完全支持。

**导入步骤**：
1. 在`Assets/`创建`Resources/Music/`文件夹
2. 复制.ogg音乐文件到这个文件夹
3. 选中音频文件，设置：
   - Load Type: Streaming（大文件）或 Compressed In Memory（小文件）
   - Compression Format: Vorbis
   - Quality: 70-100%

**音效文件**：
1. 创建`Assets/Resources/SFX/`文件夹
2. 导入打击音效
3. 设置：
   - Load Type: Decompress On Load
   - Compression Format: PCM

### 第3步：谱面文件迁移（1天）

**迁移.tja文件**：

1. 在`Assets/`创建`Resources/Charts/`文件夹
2. 复制所有.tja文件
3. 由于Unity不能直接读取Resources文件夹中的文本，需要使用StreamingAssets：

```
Assets/StreamingAssets/Charts/
├── 1/
│   └── main.tja
├── 3/
│   └── main.tja
...
```

4. 修改ChartLoader加载方式：

```csharp
public void LoadChart(string songId)
{
    string path = Path.Combine(Application.streamingAssetsPath, "Charts", songId, "main.tja");
    
    if(File.Exists(path))
    {
        TJAParser parser = new TJAParser();
        ChartData chart = parser.Parse(path);
        // ... 继续处理
    }
}
```

---

## 第五阶段：完善与优化

### 第1步：完善游戏流程（3-4天）

**创建场景切换**：

1. **主菜单场景**（MainMenu.scene）：
```csharp
// MainMenuController.cs
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class MainMenuController : MonoBehaviour
{
    public Button playButton;
    public Button settingsButton;
    public Button exitButton;
    
    void Start()
    {
        playButton.onClick.AddListener(OnPlayClicked);
        settingsButton.onClick.AddListener(OnSettingsClicked);
        exitButton.onClick.AddListener(OnExitClicked);
    }
    
    void OnPlayClicked()
    {
        SceneManager.LoadScene("SongSelect");
    }
    
    void OnSettingsClicked()
    {
        // 打开设置界面
    }
    
    void OnExitClicked()
    {
        Application.Quit();
    }
}
```

2. **选歌场景**（SongSelect.scene）：
```csharp
// SongSelectController.cs
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using System.Collections.Generic;

public class SongSelectController : MonoBehaviour
{
    public Transform songListParent;
    public GameObject songItemPrefab;
    
    private List<string> songIds = new List<string>{"1", "3", "4", "5"...};
    
    void Start()
    {
        LoadSongList();
    }
    
    void LoadSongList()
    {
        foreach(string songId in songIds)
        {
            GameObject item = Instantiate(songItemPrefab, songListParent);
            SongItem songItem = item.GetComponent<SongItem>();
            songItem.Setup(songId, OnSongSelected);
        }
    }
    
    void OnSongSelected(string songId)
    {
        // 保存选择的歌曲ID
        PlayerPrefs.SetString("SelectedSong", songId);
        
        // 加载游戏场景
        SceneManager.LoadScene("Game");
    }
}
```

3. **游戏场景控制器**：
```csharp
// GameSceneController.cs
using UnityEngine;
using UnityEngine.SceneManagement;

public class GameSceneController : MonoBehaviour
{
    public ChartLoader chartLoader;
    public NoteManager noteManager;
    public ScoreManager scoreManager;
    public AudioManager audioManager;
    
    private float countdownTime = 3f;
    private bool gameStarted = false;
    
    void Start()
    {
        // 获取选择的歌曲
        string songId = PlayerPrefs.GetString("SelectedSong", "1");
        
        // 加载谱面
        chartLoader.LoadChart(songId);
        
        // 重置分数
        scoreManager.ResetScore();
        
        // 开始倒计时
        StartCoroutine(StartCountdown());
    }
    
    System.Collections.IEnumerator StartCountdown()
    {
        // 显示3, 2, 1...
        for(int i = 3; i > 0; i--)
        {
            UIManager.Instance?.ShowCountdown(i);
            yield return new WaitForSeconds(1f);
        }
        
        // 开始游戏
        gameStarted = true;
        GameManager.Instance.isPlaying = true;
        audioManager.PlayMusic();
    }
    
    void Update()
    {
        if(gameStarted)
        {
            GameManager.Instance.gameTime = audioManager.GetMusicTime();
        }
        
        // 检测暂停
        if(Input.GetKeyDown(KeyCode.Escape))
        {
            PauseGame();
        }
    }
    
    void PauseGame()
    {
        // 显示暂停菜单
    }
    
    public void ReturnToMenu()
    {
        SceneManager.LoadScene("MainMenu");
    }
}
```

### 第2步：添加特效和动画（2-3天）

**打击特效**：
```csharp
// EffectManager.cs
using UnityEngine;

public class EffectManager : MonoBehaviour
{
    public static EffectManager Instance { get; private set; }
    
    public GameObject perfectEffectPrefab;
    public GameObject goodEffectPrefab;
    public GameObject badEffectPrefab;
    
    void Awake()
    {
        if(Instance == null)
            Instance = this;
    }
    
    public void ShowJudgeEffect(Vector3 position, JudgeResult result)
    {
        GameObject prefab = null;
        
        switch(result)
        {
            case JudgeResult.Perfect:
                prefab = perfectEffectPrefab;
                break;
            case JudgeResult.Good:
                prefab = goodEffectPrefab;
                break;
            case JudgeResult.Bad:
                prefab = badEffectPrefab;
                break;
        }
        
        if(prefab != null)
        {
            GameObject effect = Instantiate(prefab, position, Quaternion.identity);
            Destroy(effect, 1f); // 1秒后销毁
        }
        
        // 显示判定文字
        UIManager.Instance?.ShowJudgeResult(result);
    }
}
```

**连击数动画**：
```csharp
// ComboAnimator.cs
using UnityEngine;
using UnityEngine.UI;

public class ComboAnimator : MonoBehaviour
{
    public Text comboText;
    private Animator animator;
    
    void Start()
    {
        animator = GetComponent<Animator>();
    }
    
    public void PlayAnimation()
    {
        if(animator != null)
        {
            animator.SetTrigger("Pop");
        }
    }
}
```

### 第3步：优化和调试（2-3天）

**性能优化**：

1. **对象池**（避免频繁Instantiate和Destroy）：
```csharp
// ObjectPool.cs
using System.Collections.Generic;
using UnityEngine;

public class ObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int initialSize = 50;
    
    private Queue<GameObject> pool = new Queue<GameObject>();
    
    void Start()
    {
        for(int i = 0; i < initialSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            pool.Enqueue(obj);
        }
    }
    
    public GameObject Get()
    {
        if(pool.Count > 0)
        {
            GameObject obj = pool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            return Instantiate(prefab);
        }
    }
    
    public void Return(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}
```

2. **音符生成优化**：
```csharp
// 在NoteManager中使用对象池
private ObjectPool notePool;

void SpawnNote(NoteData noteData)
{
    GameObject noteObj = notePool.Get();
    // ... 设置音符
}

// 音符销毁时
public void ReturnNote(GameObject note)
{
    notePool.Return(note);
}
```

**调试工具**：
```csharp
// DebugManager.cs
using UnityEngine;

public class DebugManager : MonoBehaviour
{
    public bool showDebugInfo = true;
    public KeyCode toggleKey = KeyCode.F1;
    
    void Update()
    {
        if(Input.GetKeyDown(toggleKey))
        {
            showDebugInfo = !showDebugInfo;
        }
    }
    
    void OnGUI()
    {
        if(!showDebugInfo)
            return;
        
        GUILayout.BeginArea(new Rect(10, 10, 300, 200));
        GUILayout.Box("Debug Info");
        
        GUILayout.Label($"FPS: {(int)(1f / Time.deltaTime)}");
        GUILayout.Label($"Game Time: {GameManager.Instance.gameTime:F2}");
        GUILayout.Label($"Active Notes: {GameObject.FindGameObjectsWithTag("Note").Length}");
        
        if(GUILayout.Button("Restart"))
        {
            UnityEngine.SceneManagement.SceneManager.LoadScene(
                UnityEngine.SceneManagement.SceneManager.GetActiveScene().name
            );
        }
        
        GUILayout.EndArea();
    }
}
```

### 第4步：构建和发布（1天）

**构建设置**：

1. **PC版本**：
   ```
   File → Build Settings
   - Platform: Windows/Mac/Linux
   - Architecture: x86_64
   - Target Platform: Windows/macOS/Linux
   点击"Build"
   ```

2. **WebGL版本**：
   ```
   File → Build Settings
   - Platform: WebGL
   - Compression Format: Gzip
   - Memory Size: 256MB+（根据需要）
   点击"Build"
   
   发布到网站：
   将生成的Build文件夹上传到服务器
   访问index.html
   ```

---

## 📚 额外学习资源

### Unity官方资源
- Learn Unity: https://learn.unity.com/
- 官方文档: https://docs.unity3d.com/
- 官方论坛: https://forum.unity.com/

### 视频教程
- Brackeys（YouTube）: 最受欢迎的Unity教程频道
- sykoo（YouTube）: 节奏游戏制作教程
- GameDev.tv: Udemy上的优质课程

### 参考项目
- OpenTaiko: Unity太鼓达人开源项目
- Taiko no Tatsujin PC: 参考游戏机制

### 社区
- Unity中文社区: https://unity.cn/
- r/Unity2D (Reddit): 2D游戏开发讨论
- Discord服务器: Unity Game Dev Community

---

## ⚠️ 常见问题和解决方案

### Q1: Unity太慢/卡顿？
**A**: 
- 检查是否开启了"Auto Refresh"（可以关闭）
- 使用Fast Enter Play Mode
- 关闭不必要的Editor窗口

### Q2: 音频延迟问题？
**A**:
```csharp
// 在Project Settings → Audio中
// DSP Buffer Size: Best Latency
// 在代码中添加音频延迟补偿
public float audioLatency = 0.1f;
```

### Q3: 谱面时间不同步？
**A**:
- 检查BPM解析是否正确
- 添加Offset调整
- 使用`Time.time`而不是`Time.deltaTime`累加

### Q4: 打包后找不到文件？
**A**:
- 使用`Application.streamingAssetsPath`
- 检查文件是否在StreamingAssets文件夹
- WebGL需要使用UnityWebRequest异步加载

---

## ✅ 完成检查清单

### 学习阶段
- [ ] Unity界面熟悉
- [ ] C#基础语法掌握
- [ ] 2D游戏基础了解
- [ ] 简单Demo完成

### 开发阶段
- [ ] 项目结构搭建
- [ ] 音符系统实现
- [ ] 输入系统实现
- [ ] 谱面解析器完成
- [ ] 音频系统完成
- [ ] UI系统完成
- [ ] 分数系统完成

### 完善阶段
- [ ] 场景切换完成
- [ ] 特效和动画添加
- [ ] 性能优化
- [ ] 调试工具添加

### 发布阶段
- [ ] PC版本测试
- [ ] WebGL版本测试
- [ ] 所有功能测试通过

---

## 🎯 下一步行动

1. **立即开始**：
   - 今天安装Unity
   - 创建第一个测试项目
   - 完成第一个脚本

2. **本周目标**：
   - 完成Unity基础学习
   - 制作简单Demo

3. **本月目标**：
   - 完成核心功能实现
   - 能够加载和播放一首歌

4. **长期目标**：
   - 完整游戏发布
   - 添加更多功能（多人模式、自定义皮肤等）

---

## 💡 最后的建议

1. **循序渐进**：不要急于实现所有功能，先做一个最简单的版本能跑起来
2. **多实践**：看教程的同时一定要动手做
3. **善用搜索**：遇到问题先Google/百度，大部分问题都有解决方案
4. **保存进度**：经常commit代码到Git
5. **不要放弃**：遇到困难很正常，坚持学习就能完成

祝你迁移顺利！有任何问题随时问我。🎮✨