My project 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;
        }
    }
}

C++简单光线追踪软渲染

Sat, 24 Jan 2026 23:13:48 +0800

引入

记录以下相关学习和代码。相关代码和思路是从《计算机图形学入门:3d渲染指南》学习的
开发环境为：

window10 x64
visual studio 2022
c++17
SDL3
glm

基本框架

构建基本的渲染循环，之后就可以专注于光线追踪相关代码实现。

//Main.cpp

#include <SDL3/SDL.h>
#include <SDL3/SDL_pixels.h>
#include <iostream>

#include "softRenderBase.hpp"


int main()
{
    //初始化SDL环境
	SDL_Init(SDL_INIT_VIDEO);
	SDL_Window* window = SDL_CreateWindow("soft-renderer", WINDOW_WIDTH, WINDOW_HEIGHT, 0);
	
	SDL_Renderer* renderer = SDL_CreateRenderer(window, NULL);
	if (!renderer)
	{
		std::cerr << "渲染器创建失败" << SDL_GetError() << std::endl;
		SDL_DestroyWindow(window);
		SDL_Quit();
		return -1;
	}

	SDL_Texture* texture = SDL_CreateTexture(
		renderer,
		SDL_PIXELFORMAT_ARGB8888,
		SDL_TEXTUREACCESS_STREAMING,
		WINDOW_WIDTH,
		WINDOW_HEIGHT
	);
	if (!texture)
	{
		std::cerr << "texture创建失败" << SDL_GetError() << std::endl;
		SDL_DestroyRenderer(renderer);
		SDL_DestroyWindow(window);
		SDL_Quit();
		return -1;
	}

    //创建缓冲区存储图像数据
	SDL_PixelFormatDetails* format;
	Uint32* pixelBuffer = new Uint32[WINDOW_WIDTH * WINDOW_WIDTH];
	clearBuffer(pixelBuffer, colorFromRGBA(255, 255, 255, 255));

	bool quit = false;
	SDL_Event event;

    //更新缓冲区
    //考虑到使用的cpu进行软渲染，而且我暂时不会进行相关优化。
    //只更新一次缓冲区
	draw(pixelBuffer);

    //主循环
	while (!quit)
	{
		while (SDL_PollEvent(&event))
		{
			if (event.type == SDL_EVENT_QUIT)
			{
				quit = true;
			}
		}

        //更新texture上传到窗口表面
		SDL_UpdateTexture(texture, NULL, pixelBuffer, WINDOW_WIDTH * sizeof(Uint32));
		SDL_RenderClear(renderer);
		SDL_RenderTexture(renderer, texture, NULL, NULL);
		SDL_RenderPresent(renderer);
	}

	delete[] pixelBuffer;
	SDL_DestroyTexture(texture);
	SDL_DestroyRenderer(renderer);
	SDL_DestroyWindow(window);
	SDL_Quit();

	return 0;
}

编写绘制单个像素的函数和将RGBA值转换为uint32_t的值的函数。

void setPixel(Uint32* buffer, int x, int y, Uint32 color)
{
	if (x < 0 || x > WINDOW_WIDTH || y < 0 || y > WINDOW_HEIGHT)
	{
		return;
	}

	buffer[y * WINDOW_WIDTH + x] = color;
}

Uint32 colorFromRGBA(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
	return (static_cast<Uint32>(a) << 24) | (static_cast<Uint32>(r) << 16) | (static_cast<Uint32>(g) << 8) | (static_cast<Uint32>(b));
}

Uint32 colorFromRGBA(glm::vec4 rgba)
{
	return colorFromRGBA(rgba.r, rgba.g, rgba.b, rgba.a);
}

核心代码

基本结构体的定义

视口相当于设备窗口中虚拟三维世界中的对应，长宽比一般和设备窗口对应。

struct Viewport
{
	float width;
	float height;
	float distance;
	Viewport(float w, float h, float d)
	{
		width = w;
		height = h;
		distance = d;
	}
};

struct Sphere
{
	glm::vec3 position;
	float radius;
	glm::vec3 color;
    Sphere(glm::vec3 p, float radius)
    {
        position = p;
        this->radius = radius;
        color = glm::vec3(255, 255, 255);
    }
}

std::vector<Sphere> sceneObj = {
	Sphere(glm::vec3(0, 0, 7), 1, glm::vec3(0, 128, 0))
};

draw函数

void draw(Uint32* buffer)
{
    //遍历像素
    for (int pixelX = 0; pixelX < WINDOW_WIDTH; pixelX++)
    {
        for (int pixelY = 0; pixelY < WINDOW_HEIGHT; pixelY++)
        {
            float x = (float)pixelX * viewport.width / (float)WINDOW_WIDTH - viewport.width / 2;
            float y = (float)pixelY * viewport.height / (float)WINDOW_HEIGHT - viewport.height / 2;
            y = -y;
            float z = viewport.distance;
            //窗口像素转换为三维空间中viewport对应坐标。
            //...TODO
        }
    }
}

射线碰撞检测实现

要实现在屏幕上渲染场景中的球体，最符合直觉也最简单实现的方式是从眼睛所在位置向视口在屏幕像素对应位置发射射线，碰到哪个球就显示什么颜色。实际上我认为从这一步开始学习是最好，很快就能看到屏幕上显示的球，学校教图形是反而从光栅化，插值开始。
那么首先就应该判断射线和球是否相交。
射线需要确定起点和方向。 $S$ 表示射线起点。
$\vec{D}$ 表示射线方向。要表示射线上任意一点$P$为：
$P = S + t\vec{D}$
球是最为熟悉的，任意点$P$在球上满足：
$(P - O)^2 = R^2$
$O$为球心，$R$为半径。
联立是一元二次方程，根据有无解了判断相交，可求得 $t$ 计算$P$点。
但是要注意的是，射线的t应该是大于零的，对于小于零解要舍弃。和零比较考虑误差用较小值代替。

struct Ray
{
	glm::vec3 startPoint;
	glm::vec3 direction;

	Ray(glm::vec3 p, glm::vec3 dir)
	{
		startPoint = p;
		direction = dir;
	}
};

//optional是c++17引入的用来表示一些函数不存在结果情况（std::nullopt）的类型
std::optional<float> isRayBallIntersect(Ray ray, Sphere ball)
{
	auto ro = ray.startPoint - ball.position;

	float b = 2.0f * glm::dot(ro, ray.direction);
	float a = glm::dot(ray.direction, ray.direction);
	float c = glm::dot(ro, ro) - ball.radius * ball.radius;

	float result = 0.0f;

	float delta = b * b - 4.0f * a * c;

	if (delta >= 1e-6f)
	{
		float t1 = (-b + sqrt(delta)) / (2.0f * a);
		float t2 = (-b - sqrt(delta)) / (2.0f * a);

		//选取大于零且较小的解
		if (t2 > 1e-6f)
		{
			return t2;
		}
		if (t1 > 1e-6f)
		{
			return t1;
		}
	}
	//无解
	return std::nullopt;
}

添加一个新的函数std::optionalglm::vec3 caculateColor(Ray ray)在draw函数中用于计算颜色。并在其中进行碰撞检测。

std::optional<glm::vec3> caculateColor(Ray ray)
{
	for (auto& sphere : sceneObj)
	{
		auto t = isRayBallIntersect(ray, sphere);
		if (t.has_value())
		{
			if (t >= 0)
			{
				if (!tmin.has_value() || t.value() < tmin.value())
				{
					tmin = t.value();
					frontSphere = &sphere;
				}
			}
		}
	}

	if (tmin.has_value() && tmin.value() >= 1e-4f && frontSphere != nullptr)
	{
		//...TODO
		//可以直接返回颜色试试看结果。
		//return frontSphere->color;
	}

	return std::nullopt;

}

Phong光照模型

在这里我只使用考虑光源与物体表面直接光照，即局部光照模型——phong模型。它是不考虑物体间光线相互反射，能量守恒的简化大概符合经验的光照模型。
其中包括了漫反射，环境光和镜面反射。
以下为符号约定：
$K_a, K_b, K_s$为环境光，漫反射和镜面反射对应的材质系数，决定物体对这些类型的反射强弱；
$I$光源光强;
$\vec{N}$为法线；
$\vec{L}$为光源方向，点到光源；
$\vec{V}$为视线方向，视点到点；
$\vec{R}$为光线相对法线的反射。

环境光
假设环境光为一个常量，$K_a$材质环境光系数。物体返回的环境光强度为：
$i_a = k_a * I_a$
漫反射光
强度和夹角余弦相关，物体返回的漫反射光强度为：
$i_d = k_d * I * max(0, \vec{N}\cdot\vec{L})$，max用于防止负值。
镜面反射光
$i_s = k_s * I * max(0, \vec{R}\cdot\vec{V})^s$,$s$为镜面反射或者高光指数，用于控制高光范围。

最终返回的光强$I$为 $I = i_a + i_d + i_s$。

为Sphere添加相关参数。添加calculateLight并修改caculateColor函数为：

// 注意，我这里代码忽略了对应的材质系数。
void calculateLight(glm::vec3& p, Sphere* frontSphere, Ray& ray, float& intensity)
{
	for (auto& light : sceneLight)
	{
		auto n = glm::normalize(p - frontSphere->position);
		auto l = glm::normalize(light.position - p);
		auto r = glm::normalize(ray.direction);

		if (light.type == AMBIENT)
		{
			//环境光
			intensity += light.intensity;
		}
		else if (light.type == POINT)
		{
			//漫反射光
			intensity += light.intensity * std::max(0.0f, glm::dot(n, l));
			//镜面反射
			if (frontSphere->specular != -1)
			{
				auto reflectLight = 2.0f * n * glm::dot(n, l) - l;
				intensity += light.intensity * std::powf(glm::dot(r, reflectLight), frontSphere->specular);
			}
		}
	}
}

std::optional<glm::vec3> caculateColor(Ray ray)
{
	······
	if (tmin.has_value() && tmin.value() >= 1e-4f && frontSphere != nullptr)
	{
		color = frontSphere->color;
		glm::vec3 p = ray.startPoint + tmin.value() * ray.direction;
		float intensity = 0.0f;

		calculateLight(p, frontSphere, ray, intensity);

		color *= intensity;
		color = glm::clamp(color, glm::vec3(0), glm::vec3(255));
		//可以直接返回颜色试试看结果。
		//return color;
	}
	
	return std::nullopt;
}

关于镜像——Whitted—style Ray tracing

镜像已经是属于间接光照了，一个简单的想法是，根据光路可逆，计算视线相对法线反射光线。再以这反射光线为视角，计算它“看到了什么颜色”，用这个颜色参与最终颜色的计算。
这里可以使用递归实现，先为Sphere添加reflect参数。再添加一个全局常量const int MAX_TRACE_DEPTH设置最大递归深度。

std::optional<glm::vec3> caculateColor(Ray ray)
{
	static int depth = 0;
	······
	//计算为颜色后，根据是否有镜像属性决定是否开始递归。
	color *= intensity;
	color = glm::clamp(color, glm::vec3(0), glm::vec3(255));
	if (frontSphere->reflect > 0 && frontSphere->reflect < 1 && depth < MAX_TRACE_DEPTH)
	{
		auto n = glm::normalize(p - frontSphere->position);
		auto l = glm::normalize(-ray.direction);

		//视线相对法线反射光线
		auto reflectDir = 2.0f * n * glm::dot(n, l) - l;

		depth++;
		auto flectColor = caculateColor(Ray(p + 1e-6f * n, reflectDir));
		if (flectColor.has_value())
		{
			return glm::mix(color, flectColor.value(), frontSphere->reflect);
		}
		else
		{
			return color;
		}
	}
}

在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更多的权限，比如更多状态，放开状态参数调整权限，让有限状态产生更多变化。