Unity on 无铃怎么系铃

Unity中流场寻路的实现

Sat, 31 Jan 2026 21:36:24 +0800

引入

流场寻路是一种基于向量场寻路的群体寻路算法。通过在网格中计算向量场，单位根据脚下向量场的方向移动即可渐渐向目标移动。因为所有要移动的单位共享一个向量场，计算一次就可以给所以单位导航，实现了群体寻路的低开销。
可以想象一个高低不同的沙盘，往盘中到水产生了流动（向量场），沙盘上棋子自然会向底处（目标）流去。

构建数据结构

先使用二维数组构建一个网格数据结构。要包含以下数据：

表示该网格是否可以通行（该项目中只有障碍物情况）。
该网格到目标的最短路径代价，不可通行设置为MAX值。
该网格包含的向量，指向代价最小的邻接位置。

//使用ScriptableObject以在编辑器下预计算并保存障碍数据
public class FieldGridSO : ScriptableObject
{
   public Vector2Int GridSize = new Vector2Int(150, 100);
   public float CellSize = 1f;
   public Vector2 origin = Vector2.zero;//网格原点
   
   private bool[,] _obstacleField;
   private int[,] _costField;
   private Vector2[,] _flowField;

   //TODO
}

标记障碍数据

可以使用unity的Physics.CheckBox检测是否和场景中物体有碰撞。最直接的方式是逐个网格检查后在obstacleField中标记。但是这样在100x100网格下就要做1万次检测了，静态场景无所谓，但是当场景会变化，要更新障碍信息时会非常消耗时间。
可以采用类似四叉树检测的方式，先在整个网格区域进行检查，没有碰撞全部标记为无障碍完成计算，有碰撞就将网格四等分，然后在每个等分的网格递归上述步骤，直到最终划分的网格小于等于每个网格的尺寸CellSize。
以下为具体实现：

//......续之前代码

//使用栈数据结构防止栈溢出。
//存储参数数据。
struct BakeObstacleFieldArgs
{
    public Vector2 center;
    public Vector2 halfSize;

    public BakeObstacleFieldArgs(Vector2 center, Vector2 halfSize)
    {
        this.center = center;
        this.halfSize = halfSize;
    }
}
private void BakeObstacleField(Vector2 center, Vector2 halfSize, string obstacleMask)
{
    //用于记录时间。
    Stopwatch sw = new Stopwatch();
    sw.Start();

     if (_obstacleField == null)
      {
         _obstacleField = new bool[GridSize.x, GridSize.y];
      }
      else
      {
         Array.Clear(_obstacleField, 0, _obstacleField.Length);
      }

    Stack<BakeObstacleFieldArgs> _argsStack = new Stack<BakeObstacleFieldArgs>();
    BakeObstacleFieldArgs args = new BakeObstacleFieldArgs(center, halfSize);
    
    _argsStack.Push(args);

    while (_argsStack.Count > 0)
    {
        args = _argsStack.Pop();
        
        bool isHit = Physics.CheckBox(
        new Vector3(args.center.x, args.center.y, 0f),
        new Vector3(args.halfSize.x, args.halfSize.y, 1f),
        quaternion.identity,
        1 << LayerMask.NameToLayer(obstacleMask)
        );

        //没有碰撞情况下，退出
        if (!isHit)
        {
            continue;
        }
        
        //划分大小小于等于CellSize情况下，退出
        if (args.halfSize.x <= CellSize * 0.5f && args.halfSize.y <= CellSize * 0.5f)
        {
            //计算对应数组位置
            Vector2Int intPos = Vector2Int.zero;
            int x = (int)Math.Floor((args.center.x - origin.x) / CellSize);
            int y = (int)Math.Floor((args.center.y - origin.y) / CellSize);
            if (x >= 0 && x < GridSize.x && y >= 0 && y < GridSize.y)
            {
                intPos = new Vector2Int(x, y);
                _obstacleField[intPos.x, intPos.y] = true;
            }
            continue;
        }
        
        //划分空间
        Vector2 newHalfSize = new Vector2(0.5f * args.halfSize.x, 0.5f * args.halfSize.y);
        Vector2[] newCenters = {
        new Vector2(args.center.x - newHalfSize.x, args.center.y - newHalfSize.y),
        new Vector2(args.center.x + newHalfSize.x, args.center.y + newHalfSize.y),
        
        new Vector2(args.center.x - newHalfSize.x, args.center.y + newHalfSize.y),
        new Vector2(args.center.x + newHalfSize.x, args.center.y - newHalfSize.y),
        };

        foreach (var newCenter in newCenters)
        {
            //入栈
            BakeObstacleFieldArgs newArgs = new BakeObstacleFieldArgs(newCenter, newHalfSize);
            _argsStack.Push(newArgs);
        }
        
    }

    sw.Stop();
    Debug.Log(sw.ElapsedMilliseconds + "ms");
}

我又另外写了个直接逐网格检测的函数就行对比。

可以看到，在1000x1000网格下，直接检测花了351ms,而四叉树优化版本花了12ms。提升了将近96.6%。

计算代价图

接下来要计算每个网格到目标的代价。可以从目标点开始，使用BFS广度优先遍历张网格。目标点代价为0，接下来访问其邻接节点，代价为之前访问的节点代价加1，整个网格遍历完成后即完成代价图的计算。
以下是实现：

//......续之前代码

private void CalculateCostField(Vector2Int target)
{
    if (_costField == null)
    {
        _costField = new int[GridSize.x, GridSize.y];
    }
    
    bool[,] isVisited = new bool[GridSize.x, GridSize.y];

    Vector2Int[] dirs = {
        new Vector2Int(0, -1),  // up
        new Vector2Int(0, 1),   // down
        new Vector2Int(-1, 0),  // left
        new Vector2Int(1, 0),   // right
        new Vector2Int(1, 1),
        new Vector2Int(-1, 1),
        new Vector2Int(-1, -1),
        new Vector2Int(1, -1)
    };
    
    Queue<int[]> queue = new Queue<int[]>();
    queue.Enqueue(new[] { target.x, target.y , 0});
    isVisited[target.x, target.y] = true;
    while (queue.Count != 0)
    {
        Int32[] current = queue.Dequeue();
        
        int x = current[0];
        int y = current[1];
        int lCost = current[2];
        
        _costField[x, y] = lCost;

        foreach (var dir in dirs)
        {
        int x1 = x + dir.x;
        int y1 = y + dir.y;
        if (x1 < GridSize.x && x1 >= 0 && y1 < GridSize.y && y1 >= 0 &&
            isVisited[x1, y1] == false)
        {
            isVisited[x1, y1] = true;

            if (_obstacleField[x1, y1] == true)
            {
                queue.Enqueue(new[] { x1, y1, int.MaxValue});
            }
            else
            {
                queue.Enqueue(new[] { x1, y1, lCost + 1});
            }
        }
        }
    }
}

因为只是涉及数组访问和数值计算，速度还是挺快，这里先不考虑优化。

计算向量图

向量场的计算非常简单，只要遍历所有网格，找到网格周围代价最小的邻接网格，再计算指向它的单位向量即可。

//......续之前代码
private void CalculateFlowField()
   {
      Stopwatch ss = new Stopwatch();
      ss.Start();
      _flowField = new Vector2[GridSize.x, GridSize.y];
      
      Vector2Int[] dirs = {
         new Vector2Int(0, -1),//up
         new Vector2Int(0, 1),// down
         new Vector2Int(-1, 0),
         new Vector2Int(1, 0),
         new Vector2Int(1, 1),
         new Vector2Int(-1, 1),
         new Vector2Int(-1, -1),
         new Vector2Int(1, -1),
      };
      ss.Stop();
      Debug.Log(ss.ElapsedMilliseconds + "ms. 初始化数组");
      
      ss.Restart();
      for (int x = 0; x < GridSize.x; x++)
      {
         for (int y = 0; y < GridSize.y; y++)
         {
            int minCostMove = int.MaxValue;
            Vector2 minDir = new Vector2(x, y);
            foreach (var dir in dirs)
            {
               int ix = x + dir.x;
               int iy = y + dir.y;
               if (ix >= 0 && ix < GridSize.x && iy >= 0 && iy < GridSize.y && _obstacleField[ix, iy] == false)
               {
                  if (_costField[ix, iy] < minCostMove)
                  {
                     minCostMove = _costField[ix, iy];
                     minDir = dir;
                  }
               }
            }
            _flowField[x, y] = minDir.normalized;
         }
      }
      ss.Stop();
      Debug.Log(ss.ElapsedMilliseconds + "ms. 计算数据");
   }

管理器

接下来，简单编写一个unity组件，用于管理该数据。它应该存储一个向量图的引用，负责其初始化，设置向量图目标以开始计算。
先在FieldGridSO添加相关函数并暴露。

public void SetTarget(Vector2 target)
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    Vector2Int intTarget = Vector2Int.zero;
    int x = (int)Math.Floor((target.x - origin.x) / CellSize);
    int y = (int)Math.Floor((target.y - origin.y) / CellSize);
    if (x >= 0 && x < GridSize.x && y >= 0 && y < GridSize.y)
    {
        intTarget = new Vector2Int(x, y);
    }
    CalculateCostField(intTarget);
    CalculateFlowField();

    sw.Stop();
    Debug.Log(sw.ElapsedMilliseconds + " ms");
}

public Vector2 GetFlowFieldVector(Vector2 pos)
{
    if (_costField == null || _flowField == null)
    {
        return Vector2Int.zero;
    }
    
    Vector2Int intPos = Vector2Int.zero;
    int x = (int)Math.Floor((pos.x - origin.x) / CellSize);
    int y = (int)Math.Floor((pos.y - origin.y) / CellSize);
    if (x >= 0 && x < GridSize.x && y >= 0 && y < GridSize.y)
    {
        intPos = new Vector2Int(x, y);
        return _flowField[intPos.x, intPos.y];
    }
    else
    {
        Vector2Int flowdir = Vector2Int.zero;
        if (x < 0)
        {
        flowdir.x = 1;
        }
        else if (x > GridSize.x)
        {
        flowdir.x = -1;
        }

        if (y < 0)
        {
        flowdir.y = 1;
        }
        else if (y > GridSize.y)
        {
        flowdir.y = -1;
        }
        
        return flowdir;
    }
}

然后是管理器类。

public class MeshBaker : MonoBehaviour
{
    public Vector2Int GridSize = new Vector2Int(100, 100);
    public float CellSize = 0.5f;
    
    public bool TempMapGizmosEnable = true;
    public bool ObstacleFieldGizmosEnable = true;
    public bool GridGizmosEnable = true;

    public FieldGridSO _fieldGrid;

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Vector2 mousePos = Input.mousePosition;
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(mousePos);
            if (_fieldGrid != null)
            {
                _fieldGrid.SetTarget(worldPos);
            }
        }
    }

    public Vector2 FindDir(Vector2 pos)
    {
        return _fieldGrid.GetFlowFieldVector(pos);
    }

    //可以绘制相关信息的函数
    private void OnDrawGizmos()
    {
        if (_fieldGrid != null && TempMapGizmosEnable)
        {
            _fieldGrid.DrawTempMapGizmos(transform.position);
        }

        if (_fieldGrid != null && ObstacleFieldGizmosEnable)
        {
            _fieldGrid.DrawObstacleFieldGizmos(transform.position);
        }

        if (GridGizmosEnable && _fieldGrid != null)
        {
            _fieldGrid.DrawGridGizmos(transform.position);
        }
    }
}

代理器

创建代理器代理单位的寻路。

public class FieldGridAgent : MonoBehaviour
{
    public MeshBaker baker;
    private Rigidbody2D rb2d;

    private void Awake()
    {
        rb2d = GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        if (baker != null)
        {
            Vector2 dir = baker.FindDir(transform.position);
            rb2d.velocity = dir * 0.5f;
        }
    }
}

在Unity用LLM大模型+FSM有限状态机构建智能敌人AI

Tue, 20 Jan 2026 19:24:51 +0800

引入

从老师给出的题目中选出该课题后。首先便浮现以下几个问题：

要在什么类型游戏下使用LLM实现敌人的AI？
AI要全权接管敌人AI，还是介入部分，又要介入哪个部分呢？
因为LLM返回结果需要一定时间，且结果有不确定性，要怎么解决？

在第一个问题上，我最终选择2d俯视角射击游戏。他对于我们而言足够简单，特别是在有AI辅助编写代码下，可以快速完成原型开发。而在关键的敌人身上也只有移动和射击两个基本操作，但是却可以设计出足够复杂的行为来体现LLM的作用。
随后我采用有限状态机混合LLM的方式来驱动敌人的行动。现阶段LLM肯定不能时时刻刻调用来确定敌人的行动，应该像人体一样：感官收集信息，由大脑进行决策，又有小脑，脊髓和肌肉记忆负责简单动作和反射。设计感知模块，决策模块，执行模块，由LLM担任敌人AI的指挥官。
最后通过提示词设计，让LLMAPI返回Json格式结果，限定了其输出，一定程度上保证了结果的准确性。同时在客户端验证结果，设计非法回复处理。

开发环境搭建

由于小组里共有三人可以负责程序的开发，我决定引入开源项目来解决敌人寻路问题。先是了解到unity的packages中有ai.navigation包集成了A*的实现，可以简化敌人寻路AI开发。又发现navigation对于2d游戏的实现不佳。通过网络搜索和询问AI最后引入了navmeshplus来支持2d寻路。
所以最终初始环境为：

unity 2022.3.6f1c1
package unity.ai.navigation": “1.1.7”
“com.h8man.2d.navmeshplus”: “https://github.com/h8man/NavMeshPlus.git#master"

项目架构设计

2d俯视角游戏基本设置

PlayerController
基本玩家控制脚本，只有移动和射击两种操作。
SmoothFllowCamera
简单相机跟踪
HealthInteractor
即可以处理玩家又可以处理敌人的血量变化和交互的脚本。
Bullet
子弹预制体的MonoBehaviour脚本

LLM API调用

DeepSeekChatManager 调用DeepSeep大模型API的模块。

核心模块，敌人AI

参考人类思考和行动的方式，进行了分层设计，大致为感知，决策，执行层。

中间桥梁感知层EnvPerceiver
通过该脚本检测环境信息，包装为自然语言传递给下流决策层进行决策，和给执行层锁定追踪对象，寻找掩体。
顶层决策层LLMPlanner
接收感知层信息，调用LLMAPI调用模块，传达命令给执行层。
底层执行层，共两层
1. StrategyExecuter
  
  接收命令，发出状态切换的指令。
2. 低级执行层，预编写的各种状态
  1. IdleState待机状态
  2. RetreatState撤退状态
  3. ChaseState追击状态
  4. WanderState游荡状态

最终结果

实际开发中的难点

根据自己开发的部分和小组成员的反馈。在AI辅助开发情况下，难度不高。主要是未考虑其他条件和提供给AI的实际项目上下文不足导致的bug。如：

API调用没有使用异步或者协程导致阻塞主线程。
空引用不存在的模块。
API调用超时，非法输出处理。通过引入状态延续，默认状态机制解决。
实际最困难的部分，反而是状态机部分。撤退状态开始时涉及了掩体躲避和反击，但是用AI编写的代码不和预期，最终因为时间关系，只能改为单纯尝试远离玩家的设计。还有一些参数的设置问题，为了控制API调用频率，降低成本。我们引入了API调用频率控制的参数。太慢显得敌人呆呆，太快消耗token。最后引入根据环境是否高压，动态控制思考调用频率，即减少token消耗，又保留敌人的高智能。

总结

这次架构设计让我深刻理解了“确定性系统”与“非确定性 AI”的结合之道。通过将 LLM 限制在“策略层”，我们既获得了智能的战术决策，又保留了传统代码的稳定性。
但是还有一些未来可以改进优化的地方。
最开始是准备引入unityPackage的ML-Agent包，在底层执行使用强化学习让敌人行为更智能。考虑到DDL要到了，需要的python方面AI编码和训练时间，最终没有加入。
目前只有一个敌人，而且代码只考虑孤军作战的情况。放多几个敌人是没有相应的合作行为。未来或许可以加入指挥官系统，考虑多ai合作。
考虑给LLM更多的权限，比如更多状态，放开状态参数调整权限，让有限状态产生更多变化。

UnityWebRequest

Sat, 15 Nov 2025 16:49:10 +0800

引入

简介

UnityWebRequest 对象用于与 Web 服务器进行通信。 UnityWebRequest 处理 HTTP 与 Web 服务器进行通信的流程。其他对象 - 特别是 DownloadHandler 和 UploadHandler - 分别管理数据的下和上传。

–来自unity文档

基本用法示例

using system.Collections;
using UnityEngine;
using UnityEngine.Networking;

// 下载文本数据
//using 语法是为了确保这些对象在不再需要时能够及时释放资源。
Ienumertor DownloadText(string url)
{
    using(UnityWebRequest request = UnityWebRequest.Get(url))
    {
        yield return request.SendWebRequest();

        if(request.result == UnityWebRequest.Result.Success)
        {
            string text = request.downloadHandler.text;
            Debug.log("Download success: " + text);
        }
    }
}

// 下载文件并保存
IEnumerator DownloadFile(string url, string savePath)
{
    using(UnityWebRequest request = UnityWebRequest.Get(url))
    {
        request.downloadHandler = new DownloadHandlerFile(savePath);
        yield return request.SendWebRequest();
    }
}

// 上传表单数据
IEnumerator UploadData(string url, string data) 
{
    using(UnityWebRequest request = UnityWebRequest.Post(url, data)) 
    {
        byte[] jsonToSend = Encoding.UTF8.GetBytes(data);
        request.uploadHandler = new UploadHandlerRaw(jsonToSend);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        
        yield return request.SendWebRequest();
    }
}

常通过以下途径创建UnityWebRequest对象

//构造函数，method表示HTTP协议的GET, Post, PUT,不附加method和handler默认为GET method
public UnityWebRequest ();
public UnityWebRequest (string url);
public UnityWebRequest (string url, string method);
public UnityWebRequest (string url, string method, Networking.DownloadHandler downloadHandler, Networking.UploadHandler uploadHandler);

//通过静态函数返回
//这些函数可返回针对许多常见用例相应配置的 UnityWebRequest 对象。请参阅：Get、Post、Put、GetTexture。

public static Networking.UnityWebRequest Get (string uri);
//发送 HTTP HEAD 请求的 UnityWebRequest
public static Networking.UnityWebRequest Head (string uri);
//将原始数据上传到远程服务器的 UnityWebRequest
public static Networking.UnityWebRequest Post (string uri, string postData);
//向 uri 传输 bodyData的 UnityWebRequest
public static Networking.UnityWebRequest Put (string uri, byte[] bodyData);
public static Networking.UnityWebRequest Put (string uri, string bodyData);

可以发现UnityWebRequest包含一些重要变量，常用的是downloadHandler和uploadHandler类的引用,定义如何处理从远程服务器接收的 HTTP 响应体数据。
还有之后的request.SendWebRequest()向url发送请求的方法。这里一般用yield return等待请求完成，防止阻塞主线程。

AsyncProgrammingInUnity

Fri, 05 Sep 2025 23:04:59 +0800

引入

在编写如延时操作，UI和其他动画控制，加载资源（场景，模型和贴图等），等待网络请求等操作时，需要将处理操作分布多帧中或者为了不阻塞主线程需要异步编程。考虑现在可能只需要简单延时操作，UI动画控制，加载等操作，先从unity的协程coroutine和C#的Task类考虑。

unity协程

首先需要知道unity的大部分游戏逻辑，输入处理和渲染都是在主线程处理处理，是单线程的。大部分API只能在主线程调用，子线程尝试调用可能有异常和未定义错误。而unity协程本质上也是在主线程上运行的，协程函数任务被分配到不同帧中处理。

语法

协程方法通过C#的迭代器关键字IEnumerator，定义一个返回迭代器的函数实现；并在函数体通过yiled return YieldInstruction(waitForSeconds,waitForFixedUpdate等的基类)暂停协程函数和决定什么时候恢复执行；最后通过StartCoroutine(IEnumerator routine)开始协程函数。
示例代码如下：

using UnityEngine;

//协程是在MonoBehavour实现，只能在MonoBegaviour脚本中使用
public class TestExample : MonoBehaviour
{
    private IEnumerator Test()
    {
        for(int i = 0; i < 10; i++)
        {
            Debug.Log(i + " loop, in " + Time.frameCount + " frame.");
            yield return null;
        }
    }

    void Start()
    {
        StartCoroutine(Test());
    }
}

//最终输出：
//0 loop, in 1 frame
//1 loop, in 2 frame
//2 loop, in 3 frame
//...
//3 loop, in 10 frame

yield return null即暂停后在下一帧执行。还可以使用：

yield return new WaitForSeconds(1);//等待1秒，受到TimeScale影响。
yield return new WaitForSecondsRealTime(1);//等待1秒，不受到TimeScale影响。
yield return new WaitForFixedUpdate();//等待到下一次fixedUpdate执行。
yield return StartCoroutine(anoTher Coroutine);//等待另一个协程执行完成后。

局限

使用范围

协程只能在继承了MonoBehaviour的类在启动，依赖于组件类型脚本和场景中物体或者空物体。

生命周期问题

协程和挂载脚本的GamwObject绑定，对象销毁，协程停止而不会销毁。可能引发内存泄漏，空引用或者未知错误。

性能问题

yield return 时候频繁创建返回对象造成GC。
由于实际是在主线程上，过多协程还是会造成阻塞。
如果涉及到数据读取，yield return null不好把握一帧读取多少。因为单线程，一帧读取多会阻塞，少了浪费时间。

功能实现局限

协程函数无法返回值
协程函数不能使用try，catch进行错误捕获。

c# Task类

c# Task类是.Net框架下提供异步操作的核心类，基于Thread，ThreadPool的高度抽象。能够以直观，高效的方式编写异步，多线程代码，而不需要关心线程的生命周期，如创建，启动，暂停和恢复等。

基本用法

using System.Threading.Tasks;
private async Task<string> TestAsync()
{
    Debug.Log("async Task start!");
    await Task.Delay(3000);
    return "Task completed! return result";
}

private async void Start()
{
    string res = await TestAsync();
    Debug.log("res");
}

private void Update()
{
    Debug.log("Update!");
}


//预期输出：
//async Task start
//Update!
//Update:
//.....
//after 3s
//Task completed! return result

async关键字允许函数进行异步操作，即可以在函数中使用await关键字。当遇到需要等待另一个任务完成，使用await关键字会暂停函数将控制权返回到调用方，等待任务完成后再回到该异步函数。

Task常用函数

using System.Thread.Tasks;

Task.Run(Action action);//委托或者lambda函数表达式。
Task.Delay(Int time);//创建在time秒后结束的任务。
Task.WhenAll(Task[] tasks)//等待数组中所有任务完成。
Task.WhenAny(Task[] tasks)//等待数组中任一任务完成。

除此以外还有其他高级用法，现阶段可能还用不上，等有更高级的需求在补充。

Csharp中的委托，事件和Unity中的特殊事件类型

Sun, 17 Aug 2025 22:28:25 +0800

C#委托

介绍

在C#里委托是一种类型安全的函数指针，类似于C/C++中的函数指针，相当于C#的引用之于C/C++的指针一样，提供类似指针的操作，但是更加安全。
且委托允许指向多个函数，即多播。

语法

委托的声明。

//委托声明
public delegate 返回类型 委托名(参数列表);
//如下
public delegate int MathOperation(int x, int y);

在声明委托之后，通过new来实例化一个委托。之后就可以通过委托来调用其引用的函数。

//委托声明
public delegate int MathOperation(int x, int y);
public int add(int x, int y)
{
    return x + y;
}
//实例化时，构造参数不能为空。
MathOperation mo = new MathOperation(add);
int res = mo(3, 5);
//res = 8

相同类型的委托可以进行合并。让所有委托时调用多个函数。

//续之前代码
int a = 1;
public delegate void ChangeA(int b);
public void add(int b)
{
    a += b;
} 
public void multi(int b)
{
    a *= b
}
ChangeA ca;
ChangeA ca1 = new ChangeA(add);
ChangeA ca2 = new ChangeA(multi);
ca = ca1;
ca += ca2;
ca(5);
//a = 30;

委托还可以通过-=来移除引用的函数。

`1`	`ca -= multi;`

委托可以作为函数参数。

//如
public int testFunc(int a, MathOperation mo)
{
    return mo(a, a);
}

其他

C#提供了几种常见的泛型委托类型，可以使用这些直接实例化常见的委托。

//Action表示不返回值的函数，最多接收16个参数。
public Action<string, int> action = func;
//Action表示有返回值的函数，最多接收16个参数。
//只有一个泛型参数时，代表返回值类型。
//多个时最后一个为返回类型，其他为输入类型。
public Func<int, int, int> addFunc = func;
//Predicate表示返回bool值的函数，泛型参数为输入类型。
public Predicate<int, int> isTrue = func;

另外C#匿名函数的使用也会使用delegate关键字。或者类似C++11Lambda表达式那样更简洁的写法。

//在需要函数(即委托)作为参数时，可以直接使用匿名函数。
public void test(Func<int, int> func)
{
    console.writeLine(func(2));
}
//delegate关键字创建匿名函数。
test(delegate(int a){return a * a;});
test(delegate(int a){return a + 5;});
//lambda表达式创建匿名函数
test((int a) => {return a * a;});
test((int a) => a * a);
//输出:
//4
//7

但是因为匿名函数是没有名字的函数，所以如果在委托中添加一个匿名函数，是没办法减掉这个匿名函数的。
如果匿名函数中使用了外部函数的变量，可能导致该变量的生命周期延长，产生异常结果。可以使用static声明不捕获外部变量的匿名函数。

C#事件

介绍

知道了委托的用处，第一反应就是可以用于游戏中的事件处理。
但是同时会发现使用委托实现观察者模式(又名发布-订阅模式，我个人更喜欢这个名字)，特别是一个发布，多个订阅时，会发现委托不能直接添加函数，添加订阅时需要创建多个委托后进行合并，比较麻烦。其实C#已经提供了实现发布-订阅模式，且使用方便的事件类型。
C#事件就是对委托进行了封装，来实现发布-订阅模式的一个类型。

语法

//声明事件之前，需要声明该事件的委托类型(即该事件发生时调用什么样的函数)。
public delegate void testHandler(string args);
//再基于声明的委托定义事件。
public event testHandler Ontest;
//事件的触发,事件只能在定义事件类里面触发即事件由发布者发布。
//？用于检查事件中委托引用的函数是否为空，保证只要有订阅者才触发。
Ontest?.Invoke(s);
//事件的订阅和取消订阅。提供-=，+=
Ontest += funcName;
Ontest -= funcName;

完整的发布-订阅模式实现

//事件的委托类型经常命名为XXHandler
public delegate void testHandler(string args);
//发布者
public class Pulisher
{
    public event testHandler Ontest;
    public void OntestInvoke(string a)
    {
        Ontest?.Invoke(s);
    }

    //模拟事件的触发
    public void StartTest()
    {
        OntestInvoke("sss");
    }
}
//订阅者
public class subscriber
{
    public void subscribe(Pulisher pulisher)
    {
        pulisher.Ontest += react;
    }

    //订阅者对事件发生做出反应
    private void react(string s)
    {
        Console.WriteLine(s);
    }
}

static void main(sting[] args)
{
    Pulisher p = new Pulisher();
    subscriber s = new subscriber();
    s.subscribe(p);

    subscriber s1 = new subscriber();
    s1.subscribe(p);
    //多个订阅者

    //事件触发
    p.StartTest();
    //输出：
    //sss
    //sss
    //做出了反应。
}

unityEvent

发布-订阅模式是游戏中常用的设计模式，robloxstudio和godot都提供了在编辑器配置事件的方法，unity也有相关功能。
unityEvent是unity提供的对事件操作的api，unityevent允许在inspector直接添加或者删除订阅者函数，简化了代码的书写。

using UnityEngine.Events;
public class tester : MonoBehavior
{
    public UnityEvent unityEvent;

    //模拟事件触发
    public void Invoke()
    {
        unityEvent?.Invoke();
    }
}

这样就可以在inspector看见类似button的onclick的事件ui。

想要带有参数需要重载unityEvent<T0>,unityEvent<T0, T1> 抽象类。

using UnityEngine.Events;
[Serializable]
public class FloatEvent : UnityEvent<float>{};
public class tester : MonoBehavior
{
    public UnityEvent unityEvent;
    public FloatEvent floatEvent;

    //模拟事件触发
    public void Invoke()
    {
        unityEvent?.Invoke();
    }

    public void FloatInvoke()
    {
        FloatEvent?.Invoke(0.5f);
    }
}

也可以在代码中添加和删除监听

1
2

unityEvent.AddListener(funcName);
unityEvent.RemoveListener(funcName);

相关链接:
委托的菜鸟教程相关页面。
事件的菜鸟教程相关页面。
匿名函数和lambda菜鸟教程相关页面。
CSDN,匿名函数和lambda。
CSDNunity事件。
Unity官方，UnityEvent相关文档手册部分和脚本API部分。

Unity数据持久化存储

Sat, 16 Aug 2025 20:40:49 +0800

Json方案

简介

JSON: JavaScript Object Notation(JavaScript 对象表示法)
JSON是存储和交换文本信息的语法，类似 XML。JSON比 XML 更小、更快，更易解析。 JSON易于人阅读和编写。C、Python、C++、Java、PHP、Go 等编程语言都支持 JSON。

方法

文件读写

在unity进行json文件读写操作需要引入命名空间System.IO中的File类。使用其中相关静态函数。

using System.IO;
//写入
File.WriteAllText(string path, string text, json);
//读取
string json = File.ReadAllText(string path);

存储位置

Application.persistentDataPath
适用于保存需要长期保留的用户数据（如设置、进度、关卡数据等）。
在各平台上的实际路径不同，但都在应用可写的目录。

转为json字符串

将数据转换为Json字符串使用unity提供的类JsonUtility中的静态函数。

//转换为json。
string json = JsonUtility.ToJson(object obj, bool prettyPrint = false);
//转换为对象。
Data data = JsonUtility.FromJson<Data>(string json);

示例

using System.IO;
public static class JsonHelper
{
    public static void SaveJson(string path, object obj)
    {
        string finalPath = Application.persistentDataPath + "/" + path;
        //或者string finalPath = Path.Combine(Application.persistentDataPath, path);
        string jsonData = JsonUtility.ToJson(obj, true);
        //可以在write这里进行适当的错误处理
        File.WriteAllText(finalPath, jsonData, json);
    }

    public static T LoadJson<T>(string path)
    {
        string finalPath = Application.persistentDataPath + "/" + path;
        if(File.Exists(finalPath))
        {
            string jsonData = File.ReadAllText(path);
            //担心转换的对象有问题可以在这里进行适当的错误处理。
            return JsonUtility.FromJson<T>(jsonData);
        }
    }
}

注意

限制

JsonUtility.ToJson支持任何普通类和结构体，和派生自MonoBehaviour或scriptableOnject的类。且只支持其中unity受序列化器支持的字段。虽然可以将C#原始类型传入，但是只会在Json中生成空对象字段。
虽然ToJson方法支持派生自MonoBehaviour或scriptableOnject的类，但是JsonUtility.FromJson只支持创建普通类和结构；不支持派生自UnityEngine.Object的类（如MonoBehaviour或ScriptableObject）。
如果想从Json读取并创建或者覆写怕派生自UnityEngine.Object的类，可以额外创建一个只包含数据的普通类，再提供这个数据类进行对象的创建或者覆写。
或者想对更多数据类型的支持，如字典，列表等，可以使用其他的api如Newtonsoft.Json（Json.NET）— 适合更复杂的结构。
优点：支持字典、列表、嵌套对象等，序列化选项灵活。