Environment.CurrentDirectory // C:\WINDOWS\system32
Environment.ProcessPath // 项目所在路径\ImageUpdateTool\bin\Debug\net7.0-windows10.0.19041.0\win10-x64\AppX\ImageUpdateTool.exe
Environment.SystemDirectory // C:\WINDOWS\system32
Environment.GetFolderPath(SpecialFolder folder, SpecialFolderOption option)
// 根据SpecialFolder这个枚举，可以获取文档、桌面、ProgramFiles等特殊文件夹的路径

string gitKey = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1";
Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(gitKey);

if (key == null) // 未安装Git

string path = Environment.GetEnvironmentVariable("Path");
if (!path.Contains("Git\\cmd")) // 未安装Git

/// <summary>
/// 设置体素(i, j, k) 的状态为 state
/// </summary>
/// <param name="state">true -> 标记体素被占用，false -> 标记体素取消占用</param>
private void SetVoxelState(int x, int y, int z, bool state)
{
int originalIndex = x * _voxelYNum * _voxelZNum + y * _voxelZNum + z;
int compressedIndex = originalIndex >> 5; // 对应上文中的index
int offset = originalIndex - (compressedIndex << 5); // 对应上文中的bit

if (state)
{
_voxels[compressedIndex] |= (uint)(1 << offset);
}
else
{
_voxels[compressedIndex] &= ~(uint)(1 << offset);
}
}

// go -> 场景中的一个gameObject
var mf = go.GetComponent<MeshFilter>();
var mesh = mf.mesh;
int[] triangles = mesh.triangles;
Vector3[] vertices = mesh.vertices;

// local -> world
// go -> 场景中的一个gameObject
... // 获取go的mesh、vertices、triangles
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = go.transform.TransformPoint(vertices[i]);
}

// local -> world 使用矩阵运算
// Unity 提供了 Matrix4x4 
// goTrans -> go.transform
Matrix4x4 transMatrix = new Matrix4x4();
transMatrix.SetTRS(goTrans.position, goTrans.rotation, goTrans.localScale);
for (int i = 0; i < vertices.Length; i++)
{
var vertex = vertices[i];
vertex = transMatrix.MultiplyPoint(vertex);
vertices[i] = vertex;
}

// 获取场景内所有的gameObject，逐个判断是否在VoxelizationBox范围内。
foreach (var go in Object.FindObjectsOfType<GameObject>())
{
if (go.transform == _startPoint || go.transform == _destPoint)
continue;

var mf = go.GetComponent<MeshFilter>();
if (mf == null) continue;
var mesh = mf.mesh;
var bounds = go.GetComponent<MeshRenderer>().bounds;

if (!_voxelBox.Intersects(bounds)) continue;

// 物体和VoxelizationBox有交叉
// 获取物体Mesh的全部三角面，逐个光栅化（标记其占用的体素）
int[] triangles = mesh.triangles;
Vector3[] vertices = mesh.vertices;
var goTrans = go.transform;

// local -> worldPosition
Matrix4x4 transMatrix = new Matrix4x4();
transMatrix.SetTRS(goTrans.position, goTrans.rotation, goTrans.localScale);
for (int i = 0; i < vertices.Length; i++)
{
var vertex = vertices[i];
vertex = transMatrix.MultiplyPoint(vertex);
vertices[i] = vertex;
}

// 对每个三角面进行体素化
for (int i = 0; i < triangles.Length; i += 3)
{
int j = i + 1, k = i + 2;
RasterizeTriangle(vertices[triangles[i]], 
vertices[triangles[j]], 
vertices[triangles[k]]);
}
}

/// <summary>
/// 将三角面abc光栅化(体素化)
/// </summary>
private void RasterizeTriangle(Vector3 a, Vector3 b, Vector3 c)
{
// Debug.Log($"Triangle: a = {a}, b = {b}, c = {c}");

// 求出当前三角面abc的AABB盒
Bounds triBound = new Bounds();
triBound.max = a.ComponentMax(b).ComponentMax(c);
triBound.min = a.ComponentMin(b).ComponentMin(c);

// 如果当前三角面不在体素化范围内，就返回，不处理了。
if (!_voxelBox.Intersects(triBound))
return;

// 求三角面abc在z方向上占用的体素的坐标范围
var z0 = Mathf.Clamp(
Mathf.FloorToInt((triBound.min.z - _voxelBox.min.z) / _cellSize),
0,
_voxelZNum - 1
);

var z1 = Mathf.Clamp(
Mathf.CeilToInt((triBound.max.z - _voxelBox.min.z) / _cellSize),
0,
_voxelZNum - 1
);

// 一个三角形被正方形切割得到的图形最多有七个顶点
List<Vector3> NextRow = new List<Vector3>(7);
List<Vector3> CurrentRow = new List<Vector3>(7);
List<Vector3> NextGrid = new List<Vector3>(7);
List<Vector3> CurrentGrid = new List<Vector3>(7);

NextRow.Add(a);
NextRow.Add(b);
NextRow.Add(c);

// Debug.Log($"RasterizeTriangle: z0 = {z0}, z1 = {z1}");

for (int z = z0; z <= z1; z++)
{
// 分割线
float zSecant = _voxelBox.min.z + (z + 1) * _cellSize;

DividePolygon(NextRow, CurrentRow, zSecant, true);
if (CurrentRow.Count < 3)
continue;

// 求经过z分割线分割后，下方多边形的AABB盒
float minX = CurrentRow[0].x, maxX = CurrentRow[0].x;
for (int i = 1; i < CurrentRow.Count; i++)
{
minX = Mathf.Min(minX, CurrentRow[i].x);
maxX = Mathf.Max(maxX, CurrentRow[i].x);
}

// 求多边形在x方向上占用体素x坐标范围
var x0 = Mathf.Clamp(
Mathf.FloorToInt((minX - _voxelBox.min.x) / _cellSize),
0,
_voxelXNum - 1
);

var x1 = Mathf.Clamp(
Mathf.CeilToInt((maxX - _voxelBox.min.x) / _cellSize),
0,
_voxelXNum - 1
);

// Debug.Log($"RasterizeTriangle: x0 = {x0}, x1 = {x1}");

for (int x = x0; x <= x1; x++)
{
float xSecant = _voxelBox.min.x + (x + 1) * _cellSize;

DividePolygon(CurrentRow, CurrentGrid, xSecant, false);
if (CurrentGrid.Count < 3)
continue;

// 求经过x分割后，左方多边形的AABB盒
float minY = CurrentGrid[0].y, maxY = CurrentGrid[0].y;
for (int i = 0; i < CurrentGrid.Count; i++)
{
minY = Mathf.Min(minY, CurrentGrid[i].y);
maxY = Mathf.Max(maxY, CurrentGrid[i].y);
}

if (maxY <= _voxelBox.min.y || minY >= _voxelBox.max.y)
continue;

// 求多边形在y方向上占用体素y坐标范围
var y0 = Mathf.Clamp(
Mathf.FloorToInt((minY - _voxelBox.min.y) / _cellHeight),
0,
_voxelYNum - 1
);

var y1 = Mathf.Clamp(
Mathf.CeilToInt((maxY - _voxelBox.min.y) / _cellHeight),
y0 + 1, 
_voxelYNum - 1
);

// Debug.Log($"RasterizeTriangle: y0 = {y0}, y1 = {y1}");
for (int y = y0; y < y1; y++)
{
SetVoxelState(x, y, z, true);
}
}
}
}

/// <summary>
/// 沿着 secant 将 divided 描述的多边形进行切分
/// </summary>
/// <remarks>
/// 在方法执行完毕后，位于 secant 上侧或右侧的多边形会被存储在 divided 中,
/// 位于 secant 下侧或左侧的多边形会被存储在 result 中 
/// </remarks>
/// <param name="zAxis">为true说明 z = secant, 为false说明是 x = secant </param>
private void DividePolygon(List<Vector3> divided, List<Vector3> result, float secant, bool zAxis)
{
List<Vector3> nextPart = new List<Vector3>(7);
result.Clear();

for (int i = 1; i <= divided.Count; i++)
{
Vector3 a = divided[i - 1], b = divided[i % divided.Count];

// true -> nextPart, false -> result
bool aBelongs = false, bBelongs = false;
aBelongs = zAxis ? (a.z >= secant) : (a.x >= secant);
bBelongs = zAxis ? (b.z >= secant) : (b.x >= secant);

// Debug.Log($"DividePolygon: aBelongs = {aBelongs}, bBelongs = {bBelongs}");

if (i == 1)
{
if (aBelongs) nextPart.Add(a);
else result.Add(a);
}

if (aBelongs ^ bBelongs)
{
float proportion, intersectX, intersectY, intersectZ;

if (zAxis)
{
proportion = (secant - a.z) / (b.z - a.z);
intersectX = a.x + (b.x - a.x) * proportion;
intersectZ = secant;
}
else
{
proportion = (secant - a.x) / (b.x - a.x);
intersectX = secant;
intersectZ = a.z + (b.z - a.z) * proportion;
}

intersectY = a.y + (b.y - a.y) * proportion;

var intersect = new Vector3(intersectX, intersectY, intersectZ);
nextPart.Add(intersect);
result.Add(intersect);
}

if (i != divided.Count)
{
if (bBelongs) nextPart.Add(b);
else result.Add(b);
}
}

divided.Clear();
divided.AddRange(nextPart);
}

/// <summary>
/// 设置体素(x, y, z) 的状态为 state/>
/// </summary>
/// <param name="state">true -> 标记体素被占用，false -> 标记体素取消占用</param>
private void SetVoxelState(int x, int y, int z, bool state)
{
// Debug.Log($"Set Voxel ({x}, {y}, {z}) occupied!");
int originalIndex = x * _voxelYNum * _voxelZNum + y * _voxelZNum + z;
int compressedIndex = originalIndex >> 5;
int offset = originalIndex - (compressedIndex << 5);

if (state)
{
_voxels[compressedIndex] |= (uint)(1 << offset);
}
else
{
_voxels[compressedIndex] &= ~(uint)(1 << offset);
}
}

private List<Vector3Int> PathFinding(Vector3Int startVoxel, Vector3Int destVoxel)
{
Dictionary<Vector3Int, Vector3Int> precursorDict = new Dictionary<Vector3Int, Vector3Int>();
List<Vector3Int> path = new List<Vector3Int>();

Queue<Vector3Int> bfsQ = new Queue<Vector3Int>();
bfsQ.Enqueue(startVoxel);

while (bfsQ.Count > 0)
{
Vector3Int current = bfsQ.Dequeue();
if (current == destVoxel)
{
// Debug.Log("Find Path!!!!");
path.Add(destVoxel);
var prev = precursorDict[current];
do
{
path.Add(prev);
prev = precursorDict[prev];
} while (prev != startVoxel);

break;
}

for (int i = 0; i < 6; i++)
{
int dx = _dirX[i], dy = _dirY[i], dz = _dirZ[i];
Vector3Int nextVoxel = current + new Vector3Int(dx, dy, dz);
if (IsVoxelInside(nextVoxel) 
&& IsStayableVoxel(nextVoxel) 
&& !precursorDict.ContainsKey(nextVoxel))
{
bfsQ.Enqueue(nextVoxel);
precursorDict.Add(nextVoxel, current);
}
}
}
return path;
}

/// <summary>
/// 传入voxel坐标，判断这个位置是否可以停留
/// </summary>
/// <remarks>
/// 一个可以停留的voxel用以下三点判断：<br/>
/// 1. 本身不是障碍物 <br/>
/// 2. 下方是障碍物 （站在地面上） <br/>
/// 3. 四周是障碍物 （爬墙） <br/>
/// 4. 四周正下方一格是障碍物（进入向下爬墙状态） <br/>
/// 其中 1 必须满足，2、3、4满足其一即可
/// </remarks>
/// <returns><see langword="true"/>-> 可以停留，<see langword="false"/>-> 不可停留</returns>
private bool IsStayableVoxel(Vector3Int voxel)
{

return IsVoxelInside(voxel) && !IsVoxelOccupied(voxel.x, voxel.y, voxel.z) // 1.
&& (IsVoxelOccupied(voxel.x - 1, voxel.y, voxel.z)                 // 3.
|| IsVoxelOccupied(voxel.x + 1, voxel.y, voxel.z)              // 3.
|| IsVoxelOccupied(voxel.x, voxel.y - 1, voxel.z)              // 2.
|| IsVoxelOccupied(voxel.x, voxel.y, voxel.z + 1)              // 3.
|| IsVoxelOccupied(voxel.x, voxel.y, voxel.z - 1)              // 3.
|| IsVoxelOccupied(voxel.x - 1, voxel.y - 1, voxel.z)          // 4.
|| IsVoxelOccupied(voxel.x + 1, voxel.y - 1, voxel.z)          // 4.
|| IsVoxelOccupied(voxel.x, voxel.y - 1, voxel.z - 1)          // 4.
|| IsVoxelOccupied(voxel.x, voxel.y - 1, voxel.z + 1)          // 4.
);
}

private bool IsVoxelInside(Vector3Int voxel)
{
return voxel.x >= 0 && voxel.x < _voxelXNum
&& voxel.y >= 0 && voxel.y < _voxelYNum
&& voxel.z >= 0 && voxel.z < _voxelZNum;
}

private bool IsVoxelInside(int x, int y, int z)
{
return x >= 0 && x < _voxelXNum
&& y >= 0 && y < _voxelYNum
&& z >= 0 && z < _voxelZNum;
}

/// <summary>
/// 判断点c与向量ab的位置关系
/// </summary>
/// <returns>c在ab左侧，返回1；c在ab右侧，返回-1；c与ab共线，返回0。</returns>
private static int AreaSign(Vector2 a, Vector2 b, Vector2 c)
{
Vector2 ab = b - a;
Vector2 ac = c - a;

float area = ab.Cross(ac);

if (area > EPS) return 1; // c 在 ab 左侧
else if (area < -EPS) return -1; // c 在 ab 右侧
else return 0; //a, b, c共线
}

/// <summary>
/// 叉积
/// </summary>
/// <returns>二维向量叉积的模</returns>
public static float Cross(this Vector2 a, Vector2 b)
{
return a.x * b.y - a.y * b.x;
}

/// <summary>
/// 用于判断点<paramref name="c"/> 是否位于向量ab的左侧。
/// </summary>
/// <returns><paramref name="c"/>位于向量ab左侧为true，否则为false</returns>
public static bool Left(Vector2 a, Vector2 b, Vector2 c)
{
return AreaSign(a, b, c) > 0;
}

/// <summary>
/// 用于判断点<paramref name="c"/> 是否位于向量ab的左侧或在ab上。
/// </summary>
/// <returns><paramref name="c"/>位于向量ab左侧或在ab上为true，否则为false</returns>
public static bool LeftOn(Vector2 a, Vector2 b, Vector2 c)
{
return AreaSign(a, b, c) >= 0;
}

/// <summary>
/// 判断点<paramref name="a"/>, <paramref name="b"/>, <paramref name="c"/>是否共线
/// </summary>
/// <returns>三点共线则返回true，否则false</returns>
public static bool Collinear(Vector2 a, Vector2 b, Vector2 c)
{
return AreaSign(a, b, c) == 0;
}

/// <summary>
/// 对角线ab是否在∠A内部
/// </summary>
/// <returns>ab在∠A内部返回true，否则false</returns>
public static bool InCone(Vertex a, Vertex b)
{
Vertex a0 = a.Prev, a1 = a.Next;

// 若∠A为劣角(<180°)
if (LeftOn(a0.Position, a.Position, a1.Position))
{
return Left(a.Position, b.Position, a0.Position)
&& Left(b.Position, a.Position, a1.Position);
}

return !(LeftOn(a.Position, b.Position, a1.Position)
&& LeftOn(b.Position, a.Position, a0.Position));
}

public class Vertex
{
public Vector2 Position;
public Vertex Prev;
public Vertex Next;
}

/// <summary>
/// 线段ab与线段cd严格相交
/// </summary>
/// <remarks>严格相交: 不包含三点共线的情况，例如 T 形</remarks>
/// <returns>ab与cd相交，返回true，否则false</returns>
public static bool IntersectStrictly(Vector2 a, Vector2 b, Vector2 c, Vector2 d)
{
if (Collinear(a, b, c) || Collinear(a, b, d)
|| Collinear(c, d, a) || Collinear(c, d, b))
return false;

return (Left(a, b, c) ^ Left(a, b, d))
&& (Left(c, d, a) ^ Left(c, d, b));
}

/// <summary>
/// 线段ab与线段cd相交
/// </summary>
/// <returns>ab与cd相交则返回true，否则false</returns>
public static bool Intersect(Vector2 a, Vector2 b, Vector2 c, Vector2 d)
{
if (IntersectStrictly(a, b, c, d))
return true;

if (Between(a, b, c) || Between(a, b, d)
|| Between(c, d, a) || Between(c, d, b))
return true;

return false;
}

/// <summary>
/// 判断在abc共线时，<paramref name="c"/> 是否在 <paramref name="a"/>, <paramref name="b"/> 中间
/// </summary>
/// <returns><paramref name="c"/>在<paramref name="a"/>, <paramref name="b"/>中间则返回true，否则返回false，abc不共线直接返回false</returns>
public static bool Between(Vector2 a, Vector2 b, Vector2 c)
{
if (!Collinear(a, b, c)) return false;

if (a.x == b.x)
return (a.y <= c.y && c.y <= b.y)
|| (b.y <= c.y && c.y <= a.y);
else
return (a.x <= c.x && c.x <= b.x)
|| (b.x <= c.x && c.x <= a.x);
}

/// <summary>
/// 对角线ab是否与非点 <paramref name="a"/>, <paramref name="b"/> 相邻的边相交
/// </summary>
/// <returns>有相交返回true，否则false</returns>
public static bool DiagonalWithoutIntersect(Vertex a, Vertex b)
{
Vertex current = a.Next;
while (current.Next != a)
{
Vertex next = current.Next;

if (current != a && current != b
&& next != a && next != b
&& Intersect(current.Position, next.Position, a.Position, b.Position))
return false;

current = next;
}

return true;
}

/// <summary>
/// 对角线ab是否为内部对角线
/// </summary>
/// <remarks>内部对角线: 指对角线完全在多边形的内部</remarks>
/// <returns>ab为内部对角线返回true，否则false</returns>
public static bool Diagonal(Vertex a, Vertex b)
{
return InCone(a, b) && InCone(b, a) && DiagonalWithoutIntersect(a, b);
}

public class Polygon
{
public Vertex StartVertex => _startVertex;

private Vertex _startVertex;

#region Methods...
}

/// <summary>
/// 将Polygon分割成若干凸多边形，使用 divide-and-conquer 方法；
/// 该方法基于 Arkin, Ronald C.的论文
/// "Path planning for a vision-based autonomous robot".
/// </summary>
/// <returns>凸多边形数组，即此多边形的分割结果。</returns>
public List<Convex> Split()
{
List<Convex> convexList = new List<Convex>();

// 寻找一个凹的顶点 concave 对应上图的C点
Vertex concave = FindConcaveVertex();

if (concave == null)
{
// 没找到凹的顶点，说明this本身就是凸多边形
convexList.Add(new Convex(this));
return convexList;
}
else
{
// 找一个poly上的点，和concave组一个内部对角线，将poly分割成两部分
Vertex splitVertex = null;
Vertex current = _startVertex;
do
{
if (BasicOperations.Diagonal(current, concave))
{
splitVertex = current;
break;
}
current = current.Next;
} while (current != _startVertex);

// 这种情况理论上不会发生 //TODO: 报个Warning
if (splitVertex == null) { return null; }
// splitVertex对应上图中的A点

// 将此多边形拆分成两个子多边形
Vertex splitVertexNext = splitVertex.Next; // 对应上图B点
Vertex concavePrev = concave.Prev; // 对应上图B点

// 将AC连接起来
splitVertex.Next = concave;
concave.Prev = splitVertex;

// A点的补充点 A'
Vertex suppliedSplitVertex = new Vertex(splitVertex.Position);
// C点的补充点 C'
Vertex suppliedConcave = new Vertex(concave.Position);

// 将A'C'连接起来
suppliedSplitVertex.Prev = suppliedConcave;
suppliedConcave.Next = suppliedSplitVertex;

// 将A'和B连接起来，C'和B连接起来
suppliedSplitVertex.Next = splitVertexNext;
splitVertexNext.Prev = suppliedSplitVertex;
suppliedConcave.Prev = concavePrev;
concavePrev.Next = suppliedConcave;

// 生成P1，P2
Polygon childPolygon1 = new Polygon(concave);
Polygon childPolygon2 = new Polygon(suppliedConcave);

// 递归求解
convexList.AddRange(childPolygon1.Split());
convexList.AddRange(childPolygon2.Split());
}

return convexList;
}

public class Convex
{
public Vertex StartVertex => _startVertex;

private Vertex _startVertex;
}

/// <summary>
/// 处理中间包含孔的多边形
/// </summary>
public void MergeHole(Polygon hole)
{
if (!HasInnerPolygon(hole)) // hole必须在多边形内部才有必要去合并
return; 

bool hasFound = false;
Vertex linkVertPoly = null, linkVertHole = null;
Vertex holeVertex = hole.StartVertex;

// 在P和hole上找到两个点，用其连线合并P和hole 
do
{
Vertex vert = StartVertex;
do
{
// vert - holeVertex 线段，不与P或者hole上的任何一个非相邻边相交
if (BasicOperations.DiagonalWithoutIntersect(vert, holeVertex)
&& BasicOperations.DiagonalWithoutIntersect(holeVertex, vert))
{
linkVertPoly = vert; // 对应上图中的点A
linkVertHole = holeVertex; // 对应上图中的点F
hasFound = true;
break;
}
vert = vert.Next;
} while (vert != StartVertex);

if (hasFound) break;
holeVertex = holeVertex.Next;
} while (holeVertex != hole.StartVertex);

// 将P与hole融合
if (hasFound)
{
// 将A和F连接起来
Vertex linkVertPolyNext = linkVertPoly.Next; // 对应上图点B
linkVertPoly.Next = linkVertHole;
Vertex linkVertHolePrev = linkVertHole.Prev; // 对应上图点I
linkVertHole.Prev = linkVertPoly;

// 反转链表
// 在上图中可以看到F->I->H->G变成了F->G->H->I
// 但是在实现的时候，并不会更换顶点，而是将Next指针和Prev指针做个交换
Vertex prev = linkVertHole, current = linkVertHolePrev;
while (current != linkVertHole)
{
Vertex currentPrev = current.Prev;
prev.Next = current;
current.Prev = prev;

prev = current;
current = currentPrev;
}

// 补充linkVertHole重合节点， 对应上图的点F'
var suppliedLinkVertHole = new Vertex();
suppliedLinkVertHole.Position = linkVertHole.Position;
// 连接I和F'
suppliedLinkVertHole.Prev = prev;
prev.Next = suppliedLinkVertHole; 

// 补充linkVertPoly重合节点， 对应上图的点A'
var suppliedLinkVertPoly = new Vertex();
suppliedLinkVertPoly.Position = linkVertPoly.Position;
// 连接A'F'
suppliedLinkVertPoly.Prev = suppliedLinkVertHole;
suppliedLinkVertHole.Next = suppliedLinkVertPoly;
// 连接A'B
suppliedLinkVertPoly.Next = linkVertPolyNext;
linkVertPolyNext.Prev = suppliedLinkVertPoly;
}
}

if (!HasInnerPolygon(hole)) // hole必须在多边形内部才有必要去合并
return; 

/// <summary>
/// 从 <paramref name="raySource"/>发出的水平向右的射线，是否与线段ab相交
/// </summary>
/// <returns>相交则返回true，否则返回false</returns>
public static bool HorizontalRayIntersectSegment(Vector2 raySource, Vector2 a, Vector2 b)
{
if (a.y == b.y) return false;                               // 线段与射线平行、重合
if (a.y > raySource.y && b.y > raySource.y) return false;   // 线段在射线上方
if (a.y < raySource.y && b.y < raySource.y) return false;   // 线段在射线下方
if ((b.y < a.y && b.y == raySource.y)
|| (a.y < b.y && a.y == raySource.y)) return false;     // 射线与下方端点相交
if (a.x < raySource.x && b.x < raySource.x) return false;   // 线段在射线左边

var x = b.x - (b.x - a.x) * (b.y - raySource.y) / (b.y - a.y); // 求交点x坐标
return x >= raySource.x;
}

/*
_start      -> 线段起点 
_end        -> 线段终点
_pointCount -> 采样点数目
*/
for (int i = 0; i < _pointCount; i++)
{
    Vector2 pos = new Vector2();
    pos.x = start.x + (_end.x - start.x) * i / (_pointCount - 1);
    pos.y = start.y + (_end.y - start.y) * i / (_pointCount - 1);
    
    // 用于在界面上显示，提前初始化了若干个gameObject，
    // 用到的时候就直接设置其位置，并显示出来
    var point = _pointList[i];
    point.transform.position = pos;
    point.SetActive(true);
}

/*
_curEnd   -> 线段终点
_curStart -> 线段起点
*/

// 求方向向量，如果大小小于1明显是起点终点都在一个格子内，不用管的
// 注：“方向向量”应该是单位向量，但是我们这里只需要其值的正负，所以省去Normalized过程
Vector2 dirVec = _curEnd - _curStart;
if (dirVec.sqrMagnitude < 1) return;

// 根据方向向量，计算出我们的八个方向的向量
Vector2Int dir = new Vector2Int();
dir.x = dirVec.x > 0 ? 1 : dirVec.x < 0 ? -1 : 0;
dir.y = dirVec.y > 0 ? 1 : dirVec.y < 0 ? -1 : 0;

// Debug.Log("dir: " + dir.x + " " + dir.y);

Queue<(int, int)> gridQ = new Queue<(int, int)>();

// 为起点染色
int startX = Mathf.FloorToInt(_curStart.x);
int startY = Mathf.FloorToInt(_curStart.y);
(int startGridX, int startGridY) = WorldPointToGrid(startX, startY); // 将世界坐标转为格子gameObject数组下标
ColorAGrid(startGridX, startGridY);
gridQ.Enqueue((startX, startY));

(int, int) endGrid = (Mathf.FloorToInt(_curEnd.x), Mathf.FloorToInt(_curEnd.y)); // 终点格子坐标

int layer = 0;
while (true)
{
    layer++;
    if (layer > 200) break; // 总感觉写个while(true)会有死循环卡死程序的风险所以加了个魔法数

    (int x, int y) = gridQ.Dequeue();

    // 当扫描到终点后就可以退出循环了
    if (x == endGrid.Item1 && y == endGrid.Item2)
    {
        (int gridX, int gridY) = WorldPointToGrid(x, y);
        ColorAGrid(gridX, gridY);
        break;
    }

    // 预处理出当前要被检查的格子坐标
    int[,] worldPoints = new int[,]
    {
        {x + dir.x, y},
        {x + dir.x, y + dir.y},
        {x, y + dir.y}
    };

    for (int i = 0; i < 3; i++)
    {
        int worldPointX = worldPoints[i, 0], worldPointY = worldPoints[i, 1];
        if (IsLineThroughGrid(worldPointX, worldPointY)) // 判断线段是否经过该格子
        {
            (int gridX, int gridY) = WorldPointToGrid(worldPointX, worldPointY);

            // 超出地图范围了，不用处理，
            if (gridX < 0 || gridX >= Row || gridY < 0 || gridY >= Column)
                continue;

            // 已被染色的，不再处理
            if (_grids[gridX, gridY].color != Color.gray)
            {
                ColorAGrid(gridX, gridY);
                gridQ.Enqueue((worldPointX, worldPointY));
            }
        }
    }
}

/*
careVertex -> 是否关心顶点，为true则线段经过格子顶点也算穿过格子
*/
private bool IsLineThroughGrid(int nextGridX, int nextGridY, bool careVertex = false)
{
    // Ax + by + c = 0; 直线的一般表达式
    // A = y2 - y1, B = x1 - x2, C = x2y1 - x1y2
    float A = _curEnd.y - _curStart.y;
    float B = _curStart.x - _curEnd.x;
    float C = _curEnd.x * _curStart.y - _curStart.x * _curEnd.y;

    // 格子的四个顶点
    int[,] vertexes = new int[,]
    {
        {nextGridX, nextGridY},
        {nextGridX + 1, nextGridY},
        {nextGridX, nextGridY + 1},
        {nextGridX + 1, nextGridY + 1}
    };

    // 将四个顶点代入方程
    float[] values = new float[4];
    for (int i = 0; i < 4; i++)
    {
        values[i] = A * vertexes[i, 0] + B * vertexes[i, 1] + C;
    }

    bool through;
    if (careVertex)
    {
        through = !((values[0] > 0 && values[1] > 0 && values[2] > 0 && values[3] > 0)
                    || (values[0] < 0 && values[1] < 0 && values[2] < 0 && values[3] < 0));
    }
    else
    {
        through = !((values[0] >= 0 && values[1] >= 0 && values[2] >= 0 && values[3] >= 0)
                    || (values[0] <= 0 && values[1] <= 0 && values[2] <= 0 && values[3] <= 0));
    }

    return through;
}

private void Update()
{
    GatherInput(); // 获取输入
    RunCollisionChecks(); // 碰撞检测

    CalculateWalk(); // 水平移动（计算水平速度）

    // 下坠/重力（计算垂直速度）
    CalculateJumpApex();  
    CalculateGravity(); 
    
    CalculateJump(); // 跳跃（设置垂直速度）

    MoveCharacter(); // 移动角色
}

public struct FrameInput
{
    public float X; // 水平方向的输入值
    public float Y; // 垂直方向的输入值
    public bool JumpDown; // 跳跃键按下为true
    public bool JumpUp; // 跳跃键抬起为true
}

private void GatherInput()
{
    Input = new FrameInput
    {
        JumpDown = UnityEngine.Input.GetButtonDown("Jump"),
        JumpUp = UnityEngine.Input.GetButtonUp("Jump"),
        X = UnityEngine.Input.GetAxisRaw("Horizontal")
    };

    // 这里记录了松开跳跃键的时间，
    // 目的是实现容错机制中的第三条，还没完全落地时，即可再次跳跃，
    if (Input.JumpDown)
    {
        _lastJumpPressed = Time.time;
    }
}

[Header("COLLISION")]

[SerializeField, Tooltip("角色的碰撞检测盒")]
private Bounds _characterBounds;

[SerializeField, Tooltip("射线检测的Layer")]
private LayerMask _groundLayer;

[SerializeField, Tooltip("每个方向发射的射线数量")]
private int _detectorCount = 3;

[SerializeField, Tooltip("射线检测距离")]
private float _detectionRayLength = 0.1f;

[SerializeField, Tooltip("发射线区域与边缘的缓冲区大小")]
[Range(0.1f, 0.3f)]
private float _rayBuffer = 0.1f; //增大数值可以尽量避免侧向的射线碰撞到地板

private RayRange _raysUp, _raysRight, _raysDown, _raysLeft; // 四个方向的RayRange参数
private bool _colUp, _colRight, _colDown, _colLeft; // 分别表示四个方向是否发生碰撞

private float _timeLeftGrounded; // 记录离开地面时的时间

/// <summary>
/// 通过在四个方向上发射若干射线，进行四个方向上的碰撞检测
/// </summary>
private void RunCollisionChecks()
{
    // 初始化四个方向上的RagRange参数
    CalculateRayRanged();

    // Ground
    LandingThisFrame = false;
    var groundedCheck = RunDetection(_raysDown);
    if (_colDown && !groundedCheck) _timeLeftGrounded = Time.time; // 对应情况1 
    else if (!_colDown && groundedCheck)
    {
        _coyoteUsable = true; // 这个参数后面再讲 

        // 对应情况2
        LandingThisFrame = true;
    }

    _colDown = groundedCheck;

    _colUp = RunDetection(_raysUp);
    _colLeft = RunDetection(_raysLeft);
    _colRight = RunDetection(_raysRight);

    bool RunDetection(RayRange range)
    {
        return EvaluateRayPositions(range).Any(point => Physics2D.Raycast(point, range.Dir, _detectionRayLength, _groundLayer));
    }
}

/// <summary>
/// 计算四个方向上发射射线的范围；
/// 即确定射线的起点线，终点线，方向。
/// 影响参数：_raysUp, _raysRight, _raysDown, _raysLeft
/// </summary>
private void CalculateRayRanged()
{
    // 根据当前位置和参数中设定的检测盒大小，生成一个检测盒，以检测盒四个边界为准，修改RayRange
    var b = new Bounds(transform.position, _characterBounds.size);

    _raysDown = new RayRange(b.min.x + _rayBuffer, b.min.y, b.max.x - _rayBuffer, b.min.y, Vector2.down);
    _raysUp = new RayRange(b.min.x + _rayBuffer, b.max.y, b.max.x - _rayBuffer, b.max.y, Vector2.up);
    _raysLeft = new RayRange(b.min.x, b.min.y + _rayBuffer, b.min.x, b.max.y - _rayBuffer, Vector2.left);
    _raysRight = new RayRange(b.max.x, b.min.y + _rayBuffer, b.max.x, b.max.y - _rayBuffer, Vector2.right);
}


private IEnumerable<Vector2> EvaluateRayPositions(RayRange range)
{
    for (var i = 0; i < _detectorCount; i++)
    {
        var t = (float)i / (_detectorCount - 1);
        yield return Vector2.Lerp(range.Start, range.End, t);
    }
}

[Header("WALKING")]

[SerializeField, Tooltip("加速度")]
private float _acceleration = 90;

[SerializeField, Tooltip("最大移动速度")]
private float _moveClamp = 13;

[SerializeField, Tooltip("减速度")]
private float _deAcceleration = 60f;

[SerializeField, Tooltip("在跳跃中对移速的加成系数")]
private float _apexBonus = 2;

/// <summary>
/// 根据按键和碰撞情况，修改Player水平速度，实现左右移动
/// 影响参数：_currentHorizontalSpeed
/// </summary>
private void CalculateWalk()
{
    // 有“Horizontal”按键按下
    if (Input.X != 0)
    {
        // 设置水平速度，根据加速度加速
        _currentHorizontalSpeed += Input.X * _acceleration * Time.deltaTime;

        // 将速度限制在最大移动速度范围内
        _currentHorizontalSpeed = Mathf.Clamp(_currentHorizontalSpeed, -_moveClamp, _moveClamp);

        // 根据跳跃高度对速度给予加成
        var apexBonus = Mathf.Sign(Input.X) * _apexBonus * _apexPoint;
        _currentHorizontalSpeed += apexBonus * Time.deltaTime;
    }
    else
    {
        // 松开按键后，逐渐减速
        _currentHorizontalSpeed = Mathf.MoveTowards(_currentHorizontalSpeed, 0, _deAcceleration * Time.deltaTime);
    }

    // 如果左右两侧撞到墙壁，则将速度强制设成 0，不允许穿墙
    if (_currentHorizontalSpeed > 0 && _colRight || _currentHorizontalSpeed < 0 && _colLeft)
    {
        _currentHorizontalSpeed = 0;
    }
}

[Header("GRAVITY")]

[SerializeField, Tooltip("最大下落速度")]
private float _fallClamp = -40f;

[SerializeField, Tooltip("最小下落加速度")]
private float _minFallSpeed = 80f;

[SerializeField, Tooltip("最大下落加速度")]
private float _maxFallSpeed = 120f;

private float _fallSpeed; // 当前下落加速度

/// <summary>
/// 实现重力
/// </summary>
private void CalculateGravity()
{
    if (_colDown) // 说明落地了
    {
        // 落地后将垂直速度归零
        if (_currentVerticalSpeed < 0) _currentVerticalSpeed = 0;
    }
    else
    {
        // 当松开跳跃键并且此时还在上升，调大下落加速度使Player快速减速到下落状态
        float fallSpeed = _endedJumpEarly && _currentVerticalSpeed > 0 ? _fallSpeed * _jumpEndEarlyGravityModifier : _fallSpeed;

        // 依据当前下落加速度，修改当前垂直速度
        _currentVerticalSpeed -= fallSpeed * Time.deltaTime;

        // 因为有最大下落速度的限制，向下时不能快过最大下落速度
        if (_currentVerticalSpeed < _fallClamp) _currentVerticalSpeed = _fallClamp;
    }
}

[Header("JUMPING")]

[SerializeField, Tooltip("跳跃初速度")]
private float _jumpHeight = 30;

[SerializeField, Tooltip("当上升时速度小于该值时认为接近跳跃最高点了")]
private float _jumpApexThreshold = 10f;

[SerializeField, Tooltip("离开平台边缘仍可起跳的时间")]
private float _coyoteTimeThreshold = 0.1f;

[SerializeField, Tooltip("在离落地前多少时间内就可以响应跳跃按键")]
private float _jumpBuffer = 0.1f;

[SerializeField, Tooltip("中断跳跃时附加的乡下加速度倍数")]
private float _jumpEndEarlyGravityModifier = 3;

private bool _coyoteUsable; // 并没在跳跃中
private bool _endedJumpEarly = true; // 是否中断了跳跃
private float _apexPoint; // 起跳时为0，跳到最高点时为
private float _lastJumpPressed; // 上次按下跳跃键的时间

// 是否脱离平台边缘并且可以跳起
private bool CanUseCoyote => _coyoteUsable && !_colDown && _timeLeftGrounded + _coyoteTimeThreshold > Time.time;

// 是否在落地后自动跳起
private bool HasBufferedJump => _colDown && _lastJumpPressed + _jumpBuffer > Time.time;

/// <summary>
/// 根据跳跃的程度，调整向下的加速度
/// 越接近跳跃的最高点（即Velocity.y -> 0）时，_apexPoint -> 1
/// 向下的加速度也受_apexPoint影响，_apexPoint -> 1，_fallSpeed -> max
/// </summary>
private void CalculateJumpApex()
{
    if (!_colDown)
    {
        // 越接近跳跃最高点（即垂直速度接近0）时，向下加速度越大
        _apexPoint = Mathf.InverseLerp(_jumpApexThreshold, 0, Mathf.Abs(Velocity.y));
        _fallSpeed = Mathf.Lerp(_minFallSpeed, _maxFallSpeed, _apexPoint);
    }
    else
    {
        _apexPoint = 0;
    }
}

/// <summary>
/// 处理跳跃
/// </summary>
private void CalculateJump()
{
    // 如果 按下跳跃键且处于CanUseCoyote时，或者 处于HasBufferedJump时，跳跃
    if ((Input.JumpDown && CanUseCoyote) || HasBufferedJump)
    {
        _currentVerticalSpeed = _jumpHeight; // 设置初始速度
        _endedJumpEarly = false;             // 并未中断跳跃
        _coyoteUsable = false;               // 已经在跳跃中，使CanUseCoyote一定为false
        _timeLeftGrounded = float.MinValue;  // -3.40282347E+38，使CanUseCoyote一定为false
        JumpingThisFrame = true;             // 在当前帧跳跃了
    }
    else
    {
        JumpingThisFrame = false; // 在当前帧没有跳跃
    }

    // 如果当前帧松开了跳跃键，并且此时Player还在上升，则说明是中断跳跃
    if (!_colDown && Input.JumpUp && !_endedJumpEarly && Velocity.y > 0)
    {
        // 这里可以粗暴的将垂直速度设为0，但是这样手感不好，我们不这样做
        // _currentVerticalSpeed = 0;
        _endedJumpEarly = true;
    }

    // 如果向上撞到了障碍物，得强制速度为零，
    if (_colUp)
    {
        if (_currentVerticalSpeed > 0) _currentVerticalSpeed = 0;
    }
}

[Header("MOVE")]

[SerializeField, Tooltip("碰撞检测精度")]
private int _freeColliderIterations = 10;

/// <summary>
/// 移动角色
/// </summary>
private void MoveCharacter()
{
    Vector3 pos = transform.position;

    // 根据Player当前帧的水平、垂直移动速度计算出下一帧应处于的位置
    RawMovement = new Vector3(_currentHorizontalSpeed, _currentVerticalSpeed);
    Vector3 move = RawMovement * Time.deltaTime;
    Vector3 furthestPoint = pos + move;

    // 如果没有发生碰撞，则可以直接移动Player
    var hit = Physics2D.OverlapBox(furthestPoint, _characterBounds.size, 0, _groundLayer);
    if (!hit)
    {
        transform.position += move;
        return;
    }

    // 否则我们要根据_freeColliderIterations，将原本一帧的移动拆分成若干更小的几步，逐步移动。
    Vector3 positionToMoveTo = transform.position;
    for (int i = 1; i < _freeColliderIterations; i++)
    {
        // 由近到远，一步一步试探
        float t = (float)i / _freeColliderIterations;
        Vector2 posToTry = Vector2.Lerp(pos, furthestPoint, t);

        if (Physics2D.OverlapBox(posToTry, _characterBounds.size, 0, _groundLayer))
        {
            transform.position = positionToMoveTo;

            // 这说明我们差一点就跳上一个平台，可以轻推一下Player，让其可以跳上平台
            // 或者起跳时头顶碰到了平台的角，可以轻轻让Player再靠外一点，不会被平台挡住跳跃
            if (i == 1)
            {
                if (_currentVerticalSpeed < 0) _currentVerticalSpeed = 0;
                Vector3 dir = transform.position - hit.transform.position;
                transform.position += dir.normalized * move.magnitude;
            }

            return;
        }

        positionToMoveTo = posToTry;
    }
}