基于 Unity 2022 与 UXR SDK 开发轻量级 AR 消消乐游戏

这段脚本的核心意义在于，它将原本复杂的编辑器操作变成了一键式。在 AR 开发中，经常需要调整棋盘在空间中的相对位置。通过修改 mainCamera.transform.position 或者棋盘的 Z 轴偏移，可以瞬间改变游戏的深度感。

游戏状态管理 (GameManager)

GameManager 是游戏的大脑，它不关心宝石是怎么消掉的，只关心：现在多少分了？还剩几步？游戏结束了吗？

关键代码：GameManager.cs

using UnityEngine;
using UnityEngine.UI;

public class GameManager : MonoBehaviour {
    public Text scoreText;
    public Text movesText;
    private int score = 0;
    private int moves = 30;

    void Start() {
        UpdateUI();
    }

    public void AddScore(int points) {
        score += points;
        UpdateUI();
    }

    public void UseMove() {
        moves--;
        UpdateUI();
        if (moves <= 0) {
            GameOver();
        }
    }

    void UpdateUI() {
        if (scoreText != null) scoreText.text = "Score: " + score;
        if (movesText != null) movesText.text = "Moves: " + moves;
    }

    void GameOver() {
        Debug.Log("Game Over! Final Score: " + score);
    }

    public void RestartGame() {
        UnityEngine.SceneManagement.SceneManager.LoadScene(
            UnityEngine.SceneManagement.SceneManager.GetActiveScene().name);
    }
}

这里值得注意的一点是，在 UI 更新时进行了非空判断。在 AR 项目里，UI 的加载顺序有时会因为 SDK 的初始化而略有延迟，这种健壮性处理是必须的。

核心递归逻辑：棋盘生成与消除 (Board)

这是整个游戏最核心、也最复杂的部分。需要处理 8×8 的二维数组，并且要保证：

1. 初始化无解：开局不能直接有三连。
2. 交换检测：只有交换后能产生消除的操作才是合法的。
3. 连锁反应：一次消除后，宝石掉落，可能产生新的消除，这需要用到递归（Recursive）或者协程（Coroutine）。

关键代码：Board.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Board : MonoBehaviour {
    public int width = 8;
    public int height = 8;
    public float gemSpacing = 1f;
    public GameObject[] gemPrefabs; // 不同颜色的宝石预制体
    private Gem[,] gems;
    private bool isProcessing = false;
    private int movingGems = 0;
    private GameManager gameManager;

    void Start() {
        gameManager = FindObjectOfType<GameManager>();
        gems = new Gem[width, height];
        SetupBoard();
    }

    void SetupBoard() {
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                int randomGemType = Random.Range(0, gemPrefabs.Length);
                // 避免初始就有匹配
                while (HasMatchOnFill(x, y, randomGemType)) {
                    randomGemType = Random.Range(0, gemPrefabs.Length);
                }
                CreateGem(x, y, randomGemType);
            }
        }
        // 居中棋盘，方便在 AR 眼镜中观察
        transform.position = new Vector3(-width * gemSpacing / 2f + gemSpacing / 2f, -height * gemSpacing / 2f + gemSpacing / 2f, 0);
    }

    bool HasMatchOnFill(int column, int row, int gemType) {
        if (column > 1 && gems[column - 1, row]?.gemType == gemType && gems[column - 2, row]?.gemType == gemType) return true;
        if (row > 1 && gems[column, row - 1]?.gemType == gemType && gems[column, row - 2]?.gemType == gemType) return true;
        return false;
    }

    void CreateGem(int x, int y, int gemType) {
        Vector2 position = new Vector2(x * gemSpacing, y * gemSpacing);
        GameObject gem = Instantiate(gemPrefabs[gemType], position, Quaternion.identity);
        gem.transform.parent = transform;
        gem.SetActive(true);
        Gem gemScript = gem.GetComponent<Gem>();
        gemScript.SetPosition(x, y);
        gemScript.gemType = gemType;
        gems[x, y] = gemScript;
    }

    public void SwapGems(int col1, int row1, int col2, int row2) {
        if (isProcessing) return;
        if (col2 < 0 || col2 >= width || row2 < 0 || row2 >= height) return;
        Gem gem1 = gems[col1, row1];
        Gem gem2 = gems[col2, row2];
        if (gem1 != null && gem2 != null) StartCoroutine(SwapGemsCoroutine(gem1, gem2));
    }

    IEnumerator SwapGemsCoroutine(Gem gem1, Gem gem2) {
        isProcessing = true;
        int tempCol = gem1.column, tempRow = gem1.row;
        gem1.SetPosition(gem2.column, gem2.row);
        gem2.SetPosition(tempCol, tempRow);
        gems[gem1.column, gem1.row] = gem1;
        gems[gem2.column, gem2.row] = gem2;
        gem1.MoveTo(new Vector3(gem1.column * gemSpacing, gem1.row * gemSpacing, 0));
        gem2.MoveTo(new Vector3(gem2.column * gemSpacing, gem2.row * gemSpacing, 0));
        yield return new WaitForSeconds(0.3f);
        List<Gem> matches = FindAllMatches();
        if (matches.Count == 0) {
            // 回退逻辑
            gem1.SetPosition(gem2.column, gem2.row);
            gem2.SetPosition(tempCol, tempRow);
            gems[gem1.column, gem1.row] = gem1;
            gems[gem2.column, gem2.row] = gem2;
            gem1.MoveTo(new Vector3(gem1.column * gemSpacing, gem1.row * gemSpacing, 0));
            gem2.MoveTo(new Vector3(gem2.column * gemSpacing, gem2.row * gemSpacing, 0));
            yield return new WaitForSeconds(0.3f);
        } else {
            gameManager.UseMove();
            yield return StartCoroutine(ProcessMatches(matches));
        }
        isProcessing = false;
    }

    List<Gem> FindAllMatches() {
        List<Gem> matches = new List<Gem>();
        // 横向检测
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width - 2; x++) {
                if (gems[x,y] != null && gems[x+1,y] != null && gems[x+2,y] != null) {
                    if (gems[x,y].gemType == gems[x+1,y].gemType && gems[x,y].gemType == gems[x+2,y].gemType) {
                        if (!matches.Contains(gems[x,y])) matches.Add(gems[x,y]);
                        if (!matches.Contains(gems[x+1,y])) matches.Add(gems[x+1,y]);
                        if (!matches.Contains(gems[x+2,y])) matches.Add(gems[x+2,y]);
                    }
                }
            }
        }
        // 纵向检测类似逻辑...
        return matches;
    }

    IEnumerator ProcessMatches(List<Gem> matches) {
        gameManager.AddScore(matches.Count * 10);
        foreach (Gem gem in matches) {
            gems[gem.column, gem.row] = null;
            Destroy(gem.gameObject);
        }
        yield return new WaitForSeconds(0.3f);
        yield return StartCoroutine(DropGems());
        yield return StartCoroutine(FillBoard());
        List<Gem> newMatches = FindAllMatches();
        if (newMatches.Count > 0) yield return StartCoroutine(ProcessMatches(newMatches));
    }

    IEnumerator DropGems() {
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                if (gems[x, y] == null) {
                    for (int yAbove = y + 1; yAbove < height; yAbove++) {
                        if (gems[x, yAbove] != null) {
                            gems[x, y] = gems[x, yAbove];
                            gems[x, yAbove] = null;
                            gems[x, y].SetPosition(x, y);
                            gems[x, y].MoveTo(new Vector3(x * gemSpacing, y * gemSpacing, 0));
                            break;
                        }
                    }
                }
            }
        }
        yield return new WaitForSeconds(0.5f);
    }

    IEnumerator FillBoard() {
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                if (gems[x, y] == null) {
                    int randomGemType = Random.Range(0, gemPrefabs.Length);
                    Vector2 spawnPosition = new Vector2(x * gemSpacing, height * gemSpacing);
                    GameObject gem = Instantiate(gemPrefabs[randomGemType], spawnPosition, Quaternion.identity);
                    gem.transform.parent = transform;
                    Gem gemScript = gem.GetComponent<Gem>();
                    gemScript.SetPosition(x, y);
                    gemScript.gemType = randomGemType;
                    gemScript.MoveTo(new Vector3(x * gemSpacing, y * gemSpacing, 0));
                    gems[x, y] = gemScript;
                }
            }
        }
        yield return new WaitForSeconds(0.5f);
    }

    public void OnGemMoveComplete() {
        movingGems--;
    }
}

在 AR 开发中，IEnumerator（协程）是极其好用的工具。因为宝石的下落和移动必须是平滑的动画，如果直接改变位置，玩家会觉得画面闪烁。通过协程配合 WaitForSeconds，能给大脑一个处理空间变化的缓冲区。

宝石的微观交互 (Gem)

每一颗宝石都是一个独立的个体，它需要知道自己被摸到了，并且知道被拖向了哪个方向。

关键代码：Gem.cs

using UnityEngine;

public class Gem : MonoBehaviour {
    public int column;
    public int row;
    public int gemType;
    private Board board;
    private Vector2 firstTouchPosition;
    private Vector2 finalTouchPosition;
    private bool isMoving = false;
    private Vector3 targetPosition;
    public float moveSpeed = 10f;

    void Start() {
        board = FindObjectOfType<Board>();
    }

    void Update() {
        if (isMoving) {
            transform.position = Vector3.Lerp(transform.position, targetPosition, moveSpeed * Time.deltaTime);
            if (Vector3.Distance(transform.position, targetPosition) < 0.01f) {
                transform.position = targetPosition;
                isMoving = false;
                board.OnGemMoveComplete();
            }
        }
        // 这里的 MouseButton 输入在 Rokid UXR 下会被自动映射为射线点击
        if (Input.GetMouseButtonDown(0)) {
            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(mousePos, Vector2.zero);
            if (hit.collider != null && hit.collider.gameObject == gameObject) firstTouchPosition = mousePos;
        }
        if (Input.GetMouseButtonUp(0)) {
            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(firstTouchPosition, Vector2.zero);
            if (hit.collider != null && hit.collider.gameObject == gameObject) {
                finalTouchPosition = mousePos;
                CalculateAngle();
            }
        }
    }

    void CalculateAngle() {
        Vector2 direction = finalTouchPosition - firstTouchPosition;
        if (direction.magnitude < 0.5f) return;
        if (Mathf.Abs(direction.x) > Mathf.Abs(direction.y)) {
            if (direction.x > 0) board.SwapGems(column, row, column + 1, row);
            else board.SwapGems(column, row, column - 1, row);
        } else {
            if (direction.y > 0) board.SwapGems(column, row, column, row + 1);
            else board.SwapGems(column, row, column, row - 1);
        }
    }

    public void MoveTo(Vector3 newPosition) {
        targetPosition = newPosition;
        isMoving = true;
    }

    public void SetPosition(int col, int r) {
        column = col;
        row = r;
    }
}

这里有一个细节：在计算方向时，加入了 direction.magnitude < 0.5f 的判断。这是为了防止轻微抖动导致的误触。在 AR 环境下，由于是对着空气操作，射线的稳定性不如物理屏幕，这个缓冲区（Deadzone）非常重要。

运行时预制体生成 (GemPrefabCreator)

为了让项目包体尽可能小，没有使用精美的 3D 模型，而是通过代码在运行时绘制了一张 128x128 的带渐变的圆形贴图。这种纯程序化的资源生成方式，适合快速原型。

关键代码：GemPrefabCreator.cs

using UnityEngine;

public class GemPrefabCreator : MonoBehaviour {
    public static GameObject CreateGemPrefab(Color color, string name) {
        GameObject gem = new GameObject(name);
        SpriteRenderer sr = gem.AddComponent<SpriteRenderer>();
        Texture2D texture = new Texture2D(128, 128);
        Color[] pixels = new Color[128 * 128];
        Vector2 center = new Vector2(64, 64);
        float radius = 60;
        for (int y = 0; y < 128; y++) {
            for (int x = 0; x < 128; x++) {
                float distance = Vector2.Distance(new Vector2(x, y), center);
                if (distance < radius) pixels[y * 128 + x] = color * (1f - (distance / radius) * 0.3f);
                else pixels[y * 128 + x] = Color.clear;
            }
        }
        texture.SetPixels(pixels);
        texture.Apply();
        sr.sprite = Sprite.Create(texture, new Rect(0, 0, 128, 128), new Vector2(0.5f, 0.5f), 128);
        gem.AddComponent<CircleCollider2D>().radius = 0.45f;
        gem.AddComponent<Gem>();
        return gem;
    }
}

常见问题与解决方案

即便代码逻辑写对了，第一次运行项目时，大概率还是会遇到问题。这里总结了几个在调试时遇到的典型坑。

字体缺失问题

这是 Unity 新版本的已知槽点。在 Unity 2022 LTS 中，如果像以前一样直接引用内置的 Arial.ttf，会发现编译成 APK 后，眼镜里的文字全部变成了空白。控制台会疯狂报：ArgumentException: Arial.ttf is no longer a valid built in font。

避坑指南： 现在的内置字体名字改成了 LegacyRuntime.ttf。在代码中加载时一定要写对，或者最稳妥的方法是：自己导入一个开源的中文字体库。

只有 UI 没棋盘？三步排查法

很多时候运行起来，能看到 Score 和 Moves 在跳，但眼前一片漆黑，宝石棋盘没了。这时候不要慌，按以下顺序排查：

1. 棋盘坐标 (Z-depth)：AR 相机的剪裁平面（Clipping Planes）通常设置得比较窄。如果你的棋盘 Z 轴坐标设置成了 0，而相机在 -10 且正交尺寸不对，棋盘可能就在视线之外。
2. Layer 问题：检查生成的 Board 节点是否在默认层。如果误分到了不可见的 Layer，它就像隐身了一样。
3. Inspector 赋值检测：如果是通过编辑器拖入的预制体，检查 gemPrefabs 数组有没有漏填。哪怕空了一项，代码在实例化时就会中断，导致整个棋盘崩溃。

构建设置与分辨率

针对 Rokid AR Lite，务必确保：

• 色彩空间：尽量选择 Linear。
• 渲染管线：建议开启 URP，以获得更好的抗锯齿效果，否则宝石边缘会有严重的锯齿感。
• 多线程渲染：开启它可以显著降低眼镜的功耗和发热。

总结与展望

利用 Unity 2022 LTS + UXR 3.0 SDK，完成了一个从零到一的 AR 探索。这套组合的优点显而易见：生态成熟、开发门槛低、真机适配顺滑。

当然，目前这仅仅是一个基础版本。接下来，迭代的方向还有很多：

1. 音效与反馈：加入立体空间音频，让宝石爆破的声音从棋盘所在的方位传来。
2. 视觉特效：引入 URP 的粒子系统，让消除瞬间火花四溅。
3. 深度交互：接入手势追踪。想象一下，用食指和中指捏住宝石进行物理拖拽，那才是真正的空间计算体验。
4. 关卡设计：引入不同的障碍物（冰块、木板），将这套轻量级原型打造成完整的商业产品。

AR 开发不需要一上来就追求宏大的叙事，有时候，在现实世界里安安稳稳地玩上一局消消乐，就是空间计算带给我们的快乐。