By

Introduction

游戏开发过程中，特别是战斗中避免不了要判定各种攻击和技能是否击中，而这些判定都得通过碰撞系统来实现正确的判定。本篇文章正是为了学习了解战斗系统中攻击技能判定是如何实现的而编写的。

后续大部分理论知识和小部分文字以及截图来源:

【Unity】图形相交检测

感谢该博主的无私分享

所有的代码后续会传到Github上，想查看可视化绘制的完整代码可在Github上下到。

碰撞检测

What

碰撞检测 – 碰撞检测指判定物体(不论是3D还是2D物体)之间的相交。比如物理系统里碰撞检测指的是物体之间的实体碰撞以及物理效果。战斗系统里碰撞检测指的是技能和攻击的命中判定。

Why

那么为什么需要碰撞检测了？

  1. 物理游戏里要模拟真实的物理效果，碰撞检测是必不可少的。
  2. 战斗系统里，攻击和技能的命中判定都离不开碰撞检测。
  3. 纯数学级别的碰撞检测模拟比Unity自带的Collider准确且高效。

Note:

  1. 虽然我们可以通过Unity现成的Collider去做碰撞检测，但Collider的碰撞判定顺序是不可控的，并且Collider组件会带来很大的性能开销，所以无论是出于准确性还是性能考虑，战斗力的技能和攻击判定我们都不能直接用Collider(特别是涉及网络同步的时候)。

How

功能需求

  1. 支持3D一些简单形状(点,AABB,OBB,球形)的碰撞检测判定
  2. 支持2D一些简单形状(点,矩形，圆形，扇形，胶囊体，OBB)的碰撞检测判定

理论知识

碰撞检测从原理上来说就是数学运算，就是图形相交检测。

所以要实现一套自己的碰撞检测系统，我们要先学习图形相交检测相关的数学知识。

这里我们以2D的碰撞检测为例来学习实现碰撞检测系统。复杂的3D碰撞检测很多时候可以简化到2D来实现相同的效果并且得到更高效的判定结果。后续只会实现一部分简单的3D形状的碰撞判定。

2D形状

点

点在2D里我们通过X，Y坐标来定义，所以点的定义如下:

1
public Vector2 Point;
圆形

圆形是由圆心+半径来定义，圆形的定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/// <summary>
/// 2D圆形定义
/// </summary>
public struct Circle2D
{
    /// <summary>
    /// 中心点位置
    /// </summary>
    public Vector2 Center;

    /// <summary>
    /// 半径
    /// </summary>
    public float Radius;

    public Circle2D(Vector2 center, float radius)
    {
        Center = center;
        Radius = radius;
    }
}
矩形(轴对齐包围盒-AABB)

矩形(轴对齐包围盒-AABB)是由中心点+长宽来定义，长宽边分别与X/Y轴平行的矩形，矩形(轴对齐包围盒-AABB)定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/// <summary>
/// 2D AABB定义
/// </summary>
public struct AABB2D
{
    /// <summary>
    /// 中心点位置
    /// </summary>
    public Vector2 Center;

    /// <summary>
    /// 宽和高
    /// </summary>
    public Vector2 Extents;

    public AABB2D(Vector2 center, Vector2 extents)
    {
        Center = center;
        Extents = extents;
    }
}

Note:

  1. 矩形(轴对齐包围盒-AABB)的长宽平行于X和Y轴
有向包围盒(OBB)

有向包围盒(OBB)可以理解成一个带旋转角度的矩形(轴对齐包围盒-AABB)，正因为矩形(轴对齐包围盒-AABB)无法表达长宽不平行与X和Y轴的形状，所以才有了有向包围盒(OBB)。

让我们通过下图来形象的理解圆形，矩形(轴对齐包围盒-AABB)和有向包围盒(OBB)的区别:

CIRCLE_AABB_OBB_DES

向包围盒(OBB)由中心点+长宽+旋转角度来定义，定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <summary>
/// 2D OBB定义
/// </summary>
public struct OBB2D
{
    /// <summary>
    /// 中心点位置
    /// </summary>
    public Vector2 Center;

    /// <summary>
    /// 宽和高
    /// </summary>
    public Vector2 Extents;

    /// <summary>
    /// 旋转角度
    /// </summary>
    public float Angle;

    public OBB2D(Vector2 center, Vector2 extents, float angle)
    {
        Center = center;
        Extents = extents;
        Angle = angle;
    }
}
胶囊体

胶囊体是由起点+线段u+胶囊体半径d定义。胶囊体实际上是与线段u的最短距离d的点的集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <summary>
/// 2D胶囊体定义
/// </summary>
public struct Capsule2D
{
    /// <summary>
    /// 起点
    /// </summary>
    public Vector2 StartPoint;

    /// <summary>
    /// 起点线段
    /// </summary>
    public Vector2 PointLine;

    /// <summary>
    /// 胶囊体半径
    /// </summary>
    public float Radius;

    public Capsule2D(Vector2 startpoint, Vector2 pointline, float radius)
    {
        StartPoint = startpoint;
        PointLine = pointline;
        Radius = radius;
    }
}

SphereDefinition

从上面引申出了点与线段的最短距离算法:

1
2
3
4
5
6
7
8
9
10
11
12
/// <summary>
/// 点与线段的最短距离
/// </summary>
/// <param name="startpoint">线段起点</param>
/// <param name="line">线段向量</param>
/// <param name="targetpoint">求解点</param>
/// <returns></returns>
public static float SqrDistanceBetweenSegmentAndPoint(Vector2 startpoint, Vector2 line, Vector2 targetpoint)
{
    float t = Vector2.Dot(targetpoint - startpoint, line) / line.sqrMagnitude;
    return (targetpoint - (startpoint + Mathf.Clamp01(t) * line)).sqrMagnitude;
}

要理解上面的公式，需要知道向量里的一些基本概念，参考:

向量学习

上面的计算公式理解如下：

float t = Vector2.Dot(targetpoint - startpoint, line) / line.sqrMagnitude; // 计算求解点映射到线段line上的比例。

(startpoint + Mathf.Clamp01(t) * line) // 计算的是映射点P点的坐标

(targetpoint - (startpoint + Mathf.Clamp01(t) * line) ) // 表达的是目标点到线段的那条向量d

(targetpoint - (startpoint + Mathf.Clamp01(t) * line) ) .sqrMagnitude; // 得到目标点到线段的向量的距离平方(后续用平方比代替开方比，因为平方比在计算机上比开方比更快)

后续计算形状相交很多都会转化成点与线的距离来比较实现碰撞检测

Note:

  1. 判定一个点处于胶囊体内部，就是判断点与线段的距离
  2. 计算机开方计算比平方计算慢，所以我们采用平方比较来代替开方值比较
扇形

扇形是由起点+扇形半径+扇形朝向+扇形角度定义，扇形定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 2D扇形定义
/// </summary>
public struct Sector2D
{
    /// <summary>
    /// 扇形起点
    /// </summary>
    public Vector2 StartPoint;

    /// <summary>
    /// 扇形半径
    /// </summary>
    public float Radius;

    /// <summary>
    /// 扇形朝向
    /// </summary>
    public Vector2 Direction;

    /// <summary>
    /// 扇形角度
    /// </summary>
    public float Angle;

    public Sector2D(Vector2 startpoint, float radius, Vector2 direction, float angle)
    {
        StartPoint = startpoint;
        Radius = radius;
        Direction = direction;
        Angle = angle;
    }
}
凸多边形

多边形的定义是否多个顶点位置定义的，多边形定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
 * Description:             Polygon2D.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/20
 */

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

namespace TH.Module.Collision2D
{
    /// <summary>
    /// Polygon2D.cs
    /// 多边形定义
    /// </summary>
    public struct Polygon2D
    {
        /// <summary>
        /// 多边形顶点(注意保持统一顺时针或者逆时针定义)
        /// </summary>
        public Vector2[] Vertexes;

        public Polygon2D(Vector2[] vertexes)
        {
            Vertexes = vertexes;
        }

        /// <summary>
        /// 是否是有效多边形
        /// </summary>
        /// <returns></returns>
        public bool IsValide()
        {
            if (Vertexes == null || Vertexes.Length < 3))
            {
                Debug.LogError("多边形顶点数不应该小于3个!");
                return false;
            }
            return true;
        }
    }
}

Note:

  1. 上述定义并不能保证一定是凸多边形

分离轴定理

了解了各种形状的定义后，在了解真正的碰撞检测判定前，为了更好的理解后面的碰撞检测计算，我们先来了解一个概念分离轴定理

分离轴定理（separating axis theorem, SAT）分离轴定理是指，两个不相交的凸集必然存在一个分离轴，使两个凸集在该轴上的投影是分离的。

判断两个形状是否相交，实际上是判断分离轴是否能把两个形状分离。若存在分离轴能使两个图形分离，则这两个图形是分离的。

基于以上理论，寻找分离轴是我们要做的工作，重新考虑两个圆形的相交检测，实际上我们做的是把圆心连线的方向作为分离轴：

SAT

通过分离轴定理的定义可以看出，通过找到两个凸集形状的分离轴，我们可以实现两个形状相交的判定，这个会成为我们后面判定碰撞检测的重要理论知识

接下来让我们真正进入碰撞检测实战。

形状碰撞检测

点与圆形

点与圆形的相交判定实际上就是判定点与圆心的距离是否大于半径。

这里理论很简单，就不上效果图了，直接看代码:

1
2
3
4
5
6
7
8
9
10
/// <summary>
/// 判断圆形与点之间的交叉检测
/// </summary>
/// <param name="circle1"></param>
/// <param name="point"></param>
/// <returns></returns>
public static bool CircleAndPointIntersection2D(Circle2D circle1, Vector2 point)
{
    return (circle1.Center - point).sqrMagnitude < circle1.Radius * circle1.Radius;
}

点与矩形(AABB)

点与矩形的判定也比较容易，利用AABB的轴和XZ平行，我们可以直接比较点的X和Z是否在AABB的最大最小范围内即可(也可以理解成点与AABB中心的距离是否小于等于AABB的宽/2和长/2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
/// 点是否在矩形(AABB)内
/// </summary>
/// <param name="aabb"></param>
/// <param name="point"></param>
/// <returns></returns>
public static bool PointInAABB2D(AABB2D aabb, Vector2 point)
{
    // 点和AABB原点的位置偏移(等价于将点移动到AABB坐标系)
    Vector2 offset = aabb.Center - point;
    offset = Vector2.Max(offset, -offset);
    // 判定偏移是否小于AABB宽/2和AABB长/2
    return offset.x <= aabb.Extents.x / 2 && offset.y <= aabb.Extents.y / 2;
}

PointIntersectionWithAABB2D

代码比较简单就不详细解释了。

点与多边形

判定一个点是否在多边形内，本文使用的是角度和和**叉积(点线)**判定法，更多的解题思路参考:

详谈判断点在多边形内的七种方法（最全面）

上文中提到射线法比较优，但考虑到理解难易度，还是角度和和**叉积(点线)**法更易理解，本文主要以这两种解法为例。

角度和法

学过平面几何的同学都知道，如果一个点在凸多边形内，那么这个点和凸多边形各顶点连线构成的夹角和应该为360度。

角度和法正是利用了这一个定义来实现一个点是否在凸多边形内的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/// <summary>
/// 点是否在多边形内(内角和法)
/// </summary>
/// <param name="polygon">多边形</param>
/// <param name="point">点</param>
/// <returns></returns>
public static bool PointInPolygon2D(Polygon2D polygon, Vector2 point)
{
    if(!polygon.IsValide())
    {
        return false;
    }
    Vector2[] polygonVertexes = polygon.Vertexes;
    int polygonVertexsNumber = polygonVertexes.Length;
	// 点与所有多边形顶点的连线向量
    Vector2[] pointLines = new Vector2[polygonVertexsNumber];
    for(int i = 0, length = polygonVertexsNumber; i < length; i++)
    {
        pointLines[i] = polygonVertexes[i] - point;
    }
    // 计算所有多边形顶点连线之间的夹角总和
    float totalAngle = Vector2.SignedAngle(pointLines[polygonVertexsNumber - 1], pointLines[0]);
    for(int i = 0, length = polygonVertexsNumber - 1; i < length; i++)
    {
        totalAngle += Vector2.SignedAngle(pointLines[i], pointLines[i + 1]);
    }
    if (Mathf.Abs(Mathf.Abs(totalAngle) - 360f) < 0.1f)
    {
        return true;
    }
    return false;
}

PolygonVertexesInfo

PointOutOfPolygon

PointInPolygon

从上面可以看到我们通过累加点到多边形所有顶点构成的线段的夹角总和判定除了点是否在多边形内。但上面的方法new了大量的Vector3数组以及用到了Vector2.SignedAngle()等反三角函数，所以速度和效率上并不是不太优，接下来我们会讲到针对点是否在凸多边形内的更优解法(叉乘(点线)法)。

Note:

  1. 此方法适用于凸多边形和凹多边形
叉积(点线)法

叉积(点线)法的核心思想是判定点到多边形所有顶点构成的边是否都在相邻多边形边的一侧(顺时针的话需要都在左侧，逆时针的话需要都在右侧)

这里我们利用叉乘(叉乘结果>0还是<0能区分)来实现两个向量的左右关系判定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/// <summary>
/// 点是否在凸边形内(叉积(点线)法)
/// Note:
/// 1. 确保是凸多边形
/// 2. 确保凸多边形顶点是顺时针
/// </summary>
/// <param name="polygon">凸多边形</param>
/// <param name="point">点</param>
/// <returns></returns>
public static bool PointInConvexPolygon2D(Polygon2D polygon, Vector2 point)
{
    if (!polygon.IsValide())
    {
        return false;
    }
    Vector2[] polygonVertexes = polygon.Vertexes;
    int polygonVertexsNumber = polygonVertexes.Length;
    Vector3 pointLine;
    Vector3 polygonEdge;
    int index;
    // 这里采用顶点顺时针判定
    for (int i = 0, length = polygonVertexsNumber; i < length; i++)
    {
        pointLine = new Vector3(point.x - polygonVertexes[i].x, 0, point.y - polygonVertexes[i].y);
        index = (i + 1) % polygonVertexsNumber;
        polygonEdge = new Vector3(polygonVertexes[index].x - polygonVertexes[i].x, 0, polygonVertexes[index].y - polygonVertexes[i].y);
        // 计算多边形顶点的连线向量和边的左右关系
        // Vector3.Cross(A, B).y > 0 表示A在B的左侧
        // Vector3.Cross(A, B).y < 0 表示A在B的右侧
        // Vector3.Cross(A, B).y == 0 表示A和B平行
        if (Vector3.Cross(pointLine, polygonEdge).y >= 0)
        {
            return false;
        }
    }
    return true;
}

PolygonVertexesInfo2

PointOutOfPolygon2

PointInPolygon2

从上面的效果图可以看出我们通过叉积法也成功判定出了点是否在凸多边形内。

但上面的方式需要创建大量的Vector3来构建边以及叉乘判定，虽然Vector3是结构体类型不会造成GC问题，但核心只是为了实现两个向量的方向判定，依然有优化的空间。

我们可以把2D的向量方向当做就在XZ平面的3D向量来计算(即把Y轴值当做0)，通过叉乘最原始的公式直接计算叉乘后Y轴值的大小来判定两个向量的方向关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/// <summary>
/// 点是否在凸边形内(叉积(点线)法--不构建Vector3纯数学运算)
/// Note:
/// 1. 确保是凸多边形
/// 2. 确保凸多边形顶点是顺时针
/// </summary>
/// <param name="polygon">凸多边形</param>
/// <param name="point">点</param>
/// <returns></returns>
public static bool BetterPointInConvexPolygon2D(Polygon2D polygon, Vector2 point)
{
    if (!polygon.IsValide())
    {
        return false;
    }
    Vector2[] polygonVertexes = polygon.Vertexes;
    int polygonVertexsNumber = polygonVertexes.Length;
    int index;
    float lineX;
    float lineZ;
    float edgeX;
    float edgeZ;
    // 把2D向量当做XZ平面的3D向量来处理
    // 不构建Vector3的边，直接利用叉乘公式计算叉乘后的Y值
    // 然后通过Y值来判定两个2D向量的方向
    // 这里采用顶点顺时针判定
    for (int i = 0, length = polygonVertexsNumber; i < length; i++)
    {
        lineX = point.x - polygonVertexes[i].x;
        lineZ = point.y - polygonVertexes[i].y;
        index = (i + 1) % polygonVertexsNumber;
        edgeX = polygonVertexes[index].x - polygonVertexes[i].x;
        edgeZ = polygonVertexes[index].y - polygonVertexes[i].y;
        // 利用叉乘原始公式进行计算判定两个向量的方向
        // Vector3.Cross(A, B).y > 0 表示A在B的左侧
        // Vector3.Cross(A, B).y < 0 表示A在B的右侧
        // Vector3.Cross(A, B).y == 0 表示A和B平行
        if((lineZ * edgeX - lineX * edgeZ) > 0)
        {
            return false;
        }
    }
    return true;
}

PolygonVertexesInfo3

PointOutOfPolygon3

PointInPolygon3

可以看到不通过构建Vector3，我们直接利用叉乘的公式把2D当3D计算出叉乘的Y值，依然可以有效的判定出点是否在凸多边形内。

在3D维度两个向量不再是在单纯的XZ平面而是在任意平面，这里不再能直接使用叉乘的y值进行判定，除非两个向量在XZ平面。

Note:

  1. 此方法适用于凸多边形
  2. 注意叉积判定对于多边形顶点的顺序要求
  3. 2维向量叉乘AXB = (0, 0, x1 * y2 - x2 * y1)，x1 * y2 - x2 * y1大于0表示A在B的右侧，小于0表示A在B的左侧，等于0表示A和B平行(大前提是左手坐标系，右手坐标系左右侧是反过来的)
  4. 叉乘y大于0表示A在B的左侧还是小于0表示A在B的左侧主要看我们用的左手坐标系还是右手坐标系，因为Unity是左手坐标系，所欲叉乘y大于0表示A在B的左侧
  5. 利用叉乘结果y大于0还是y小于0区分方向的同时，我们还能用于推断向量A在向量B的左侧还是右侧(大前提是两个向量在XZ平面)

圆形与圆形

圆形和圆形相交判定起始就是2个圆心的距离是否大于两个圆的半径之和。

1
2
3
4
5
6
7
8
9
10
/// <summary>
/// 判断圆形与圆形之间的交叉检测
/// </summary>
/// <param name="circle1"></param>
/// <param name="circle2"></param>
/// <returns></returns>
public static bool CircleAndCircleIntersection2D(Circle2D circle1, Circle2D circle2)
{
    return (circle1.Center - circle2.Center).sqrMagnitude < (circle1.Radius + circle2.Radius) * (circle1.Radius + circle2.Radius);
}

这个比较简单没什么好说的。

圆形与胶囊体

结合前面分离轴定理，我们要想判定圆形和胶囊体是否相交，首先找到分离轴，而圆形和胶囊体的分离轴是胶囊体线段上距离圆形最近的点P与圆心所在的方向。

所以判定圆心到胶囊体线段的距离是否大于胶囊体半径+圆形半径即可。

1
2
3
4
5
6
7
8
9
10
11
/// <summary>
/// 判断圆形与胶囊体相交
/// </summary>
/// <param name="circle"></param>
/// <param name="capsule"></param>
/// <returns></returns>
public static bool CircleAndCapsuleIntersection2D(Circle2D circle, Capsule2D capsule)
{
    float sqrdistance = SqrDistanceBetweenSegmentAndPoint(capsule.StartPoint, capsule.PointLine, circle.Center);
    return sqrdistance < (circle.Radius + capsule.Radius) * (circle.Radius + capsule.Radius);
}

Circle2DIntersectionWithCapsule2D

Capsule

Circle2DIntersectionWithRotateCapsule2D

Capsule2

圆形与矩形(AABB)

利用AABB的对称性，我们以AABB中心为原点，两边为坐标轴的坐标系。通过将圆形移动AABB的大小，然后看圆形所在位置与中心点距离是否还大于圆形半径来判定圆形和AABB是否相交。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/// <summary>
/// 判断圆形与AABB相交
/// </summary>
/// <param name="circle"></param>
/// <param name="aabb"></param>
/// <returns></returns>
public static bool CircleAndAABBIntersection2D(Circle2D circle, AABB2D aabb)
{
    // 以AABB中心为圆心
    Vector2 v = Vector2.Max(circle.Center - aabb.Center, -(circle.Center - aabb.Center));
    // 把圆心坐标偏移AABB大小
    Vector2 u = Vector2.Max(v - aabb.Extents / 2, Vector2.zero);
    // 判定圆心距离是否还大于圆形半径判定相交
    return u.sqrMagnitude < circle.Radius * circle.Radius;
}

Circle2DIntersectionWithAABB

AABB2DInfo

圆形与有向包围盒(OBB)

结合前面OBB的定义:

有向包围盒(OBB)可以理解成一个带旋转角度的矩形(轴对齐包围盒-AABB)

可以看出OBB和AABB的主要区别是支持了选择的AABB，那么我们判定OBB和圆形的相交检测也就等价于把圆形旋转到OBB所在坐标系后，然后当做圆形和AABB相交判定即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/// <summary>
/// Vector3临时变量(用于优化new Vector3)
/// </summary>
private static Vector3 Vector3Temp;

/// <summary>
/// 判定圆形和OBB相交检测
/// </summary>
/// <param name="circle"></param>
/// <param name="obb"></param>
/// <returns></returns>
public static bool CircleAndOBBIntersection2D(Circle2D circle, OBB2D obb)
{
    // 以OBB中心为坐标原点
    Vector2 point = circle.Center - obb.Center;
    Vector3Temp.x = point.x;
    Vector3Temp.y = 0;
    Vector3Temp.z = point.y;
    // 将圆心通过反向旋转转到OBB坐标系
    Vector3 point2 = Quaternion.AngleAxis(-obb.Angle, Vector3.up) * Vector3Temp;
    point.x = point2.x;
    point.y = point2.z;
    // 将旋转后的圆心位置和OBB做AABB方式的相交判定
    Vector2 v = Vector2.Max(point, -point);
    // 把圆心坐标偏移OBB大小
    Vector2 u = Vector2.Max(v - obb.Extents / 2, Vector2.zero);
    // 判定圆心距离是否还大于圆形半径判定相交
    return u.sqrMagnitude < circle.Radius * circle.Radius;
}

Circle2DIntersectionWithOBB2D

OBB2DInfo

Note:

  1. Quaternion.AngleAxis()如果绕Y轴旋转直接乘以Vector2会得到错误的结果，所以我们需要当做Vector3来计算，最后再转换回Vector2
  2. 虽然Vector3是结构体不会造成GC，但不想每次判定都创建Vector3所以定义了一个临时Vector3用于计算重用

圆形与凸多边形

圆形与凸多边形相交判定只需要在点和凸多边形相交判定上增加圆心不在凸多边形内时，判定圆心到多边形每条边的距离是否有小于圆形半径即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 判断圆形与多边形相交
/// </summary>
/// <param name="circle"></param>
/// <param name="polygon"></param>
/// <returns></returns>
public static bool CircleAndPolygonIntersection2D(Circle2D circle, Polygon2D polygon)
{
    // 判定圆心是否在多边形内
    if(BetterPointInConvexPolygon2D(polygon, circle.Center))
    {
        return true;
    }
    // 圆心不在多边形内，则判定圆心与每条边的距离是否小于半径
    Vector2 circleCenter = circle.Center;
    float sqrR = circle.Radius * circle.Radius;
    var vertexes = polygon.Vertexes;
    int polygonVertexsNumber = polygon.Vertexes.Length;
    Vector2 edge;
    int index;
    for (int i = 0, length = polygonVertexsNumber; i < length; i++)
    {
        index = (i + 1) % polygonVertexsNumber;
        edge.x = vertexes[index].x - vertexes[i].x;
        edge.y = vertexes[index].y - vertexes[i].y;
        // 判定圆心到单条边的距离是否小于半径
        if(SqrDistanceBetweenSegmentAndPoint(vertexes[i], edge, circleCenter) < sqrR)
        {
            return true;
        }
    }
    return false;
}

Circle2DIntersectionPolygon2D

注释写的很详细了，就不详细解释说明了。

圆形与扇形

当扇形角度大于180度时，就不再是凸多边形了，不能适用于分离轴理论。

我们把相交判定分成两个部分判定:

  1. 圆形在扇形角度内，直接判定扇形原点和圆心距离是否大于扇形半径+圆形半径
  2. 圆形在扇形角度外，利用扇形对称性，将原因映射到扇形一侧，通过映射后的原因与扇形一条边的距离是否小于圆形半径判定相交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/// <summary>
/// 判断圆形与扇形相交
/// </summary>
/// <param name="circle"></param>
/// <param name="sector"></param>
/// <returns></returns>
public static bool CircleAndSectorIntersection2D(Circle2D circle, Sector2D sector)
{
    Vector2 tempDistance = circle.Center - sector.StartPoint;
    float halfAngle = Mathf.Deg2Rad * sector.Angle / 2;
    // 判定扇形起点和圆心距离是否小于扇形半径+圆形半径
    if (tempDistance.sqrMagnitude < (sector.Radius + circle.Radius) * (sector.Radius + circle.Radius))
    {
        // 判定圆形是否在扇形角度内
        if (Vector3.Angle(tempDistance, sector.Direction) < sector.Angle / 2)
        {
            return true;
        }
        else
        {
            // 利用扇形的对称性，将圆心位置映射到一侧
            Vector2 targetInsectorAxis = new Vector2(Vector2.Dot(tempDistance, sector.Direction), Mathf.Abs(Vector2.Dot(tempDistance, new Vector2(-sector.Direction.y, sector.Direction.x))));
            // 扇形的一条边
            Vector2 directionInSectorAxis = sector.Radius * new Vector2(Mathf.Cos(halfAngle), Mathf.Sin(halfAngle));
            // 通过判定映射后的原因与扇形一条边的距离是否小于圆形半径判定相交
            return SqrDistanceBetweenSegmentAndPoint(Vector2.zero, directionInSectorAxis, targetInsectorAxis) <= circle.Radius * circle.Radius;
        }
    }
    return false;
}

Circle2DIntersectionWithSector2D

Sector2DInfo

Note:

  1. 当扇形角度大于180度时，就不再是凸多边形了，不能适用于分离轴理论。

矩形(AABB)与矩形(AABB)

AABB与AABB的相交判定，考虑到AABB的轴都相同且都为矩形的特殊性，相交判定只需要判定两个AABB原点的距离是否有任何一个小于宽/2之和或长/2之和即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
/// 判定AABB和AABB相交检测
/// </summary>
/// <param name="aabb1"></param>
/// <param name="aabb2"></param>
/// <returns></returns>
public static bool AABBAndAABBIntersection2D(AABB2D aabb1, AABB2D aabb2)
{
    // 两个AABB原点的位置偏移
    Vector2 offset = aabb2.Center - aabb1.Center;
    offset = Vector2.Max(offset, -offset);
    // 判定偏移是否小于两者宽/2之和和两者长/2之和
    return offset.x <= (aabb1.Extents.x / 2 + aabb2.Extents.x / 2) && offset.y <= (aabb1.Extents.y / 2 + aabb2.Extents.y / 2);
}

AABB2DIntersectionWithAABB2D

AABB2DInfo1

AABB2DInfo2

AABB和AABB的判定比较简单，就不详细解释了。

进阶学习

关于OBB等凸多边形相关的交叉判定，我们需要用到分离轴定理，这里暂时不深入实现了(TODO)，详情参考:

UNITY实战进阶-OBB包围盒详解-6

关于3D的相交检测，这里我们用Unity Bounds提供的关于OBB的实现类。

更多的3D相交检测自定义实现，可以参考二维的实现扩展到3维，这里暂时不做进一步的学习记录。(大部分时候我们可以简化相交检测，比如讲3D简化到2D，扇形椭圆简化到圆形或点来实现相交碰撞检测)

线段相交

线段相交理论知识参考:

Unity3D C#数学系列之判断两条线段是否相交并求交点

LineIntersectionPoint

相交大前提:

  1. AB和CD必须共面。

如何判定AB和CD共面了?

通过计算ACD平面法线是否与AB垂直即可(2D向量可以省去这一步)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/// <summary>
/// 4个点是否共面
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="c"></param>
/// <param name="d"></param>
/// <returns></returns>
public static bool IsCoplanarVector(Vector3 a, Vector3 b, Vector3 c, Vector3 d)
{
    // 通过叉乘计算CA和CD的法线向量
    var ab = b - a;
    var ca = a - c;
    var cd = d - c;
    var normal = Vector3.Cross(ca, cd);
    // 通过ab向量和CA和CD法线向量的点乘是否为0来判定是否垂直
    // a,b,c,d从而判定出是否共面
    if(Mathf.Approximately(Vector3.Dot(normal, ab), Mathf.Epsilon))
    {
        return true;
    }
    return false;
}

如何判定相交:

  1. 快速排斥和跨立实现判定是否相交

这里我采用跨立法来判定，跨立法是指两个线段相交必须满足两个线段的两个点分别在另一个线段的两侧。

这里我们利用叉乘来判定两个向量的方向从而判定是否线段在另一个线段两侧。

2D向量:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/// <summary>
/// 2D向量叉乘
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static float Cross(Vector2 a, Vector2 b)
{
    return a.x * b.y - b.x * a.y;
}

/// <summary>
/// 4个点是否ab和cd线段是否相交
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="c"></param>
/// <param name="d"></param>
/// <returns></returns>
public static bool IsCross(Vector2 a, Vector2 b, Vector2 c, Vector2 d)
{
    // 通过叉乘计算CA和CD的法线向量
    var ab = b - a;
    var ac = c - a;
    var ad = d - a;
    // 叉乘判定两个向量的方向
    // 判定ab是否在cd两侧
    // 以ab为基准，如果ab叉乘ac或ad大于0表示逆时针反之顺时针,0表示两者方向相同
    // 那么c和d要在ab同一侧，则ab叉乘ac的结果和ab叉乘ad的结果相乘需要>0
    if (Vector2Utilities.Cross(ab, ac) * Vector2Utilities.Cross(ab, ad) >= 0)
    {
        return false;
    }
    // 同理以cd为基准，如果ca和cb叉乘结果相乘>0则表示a和b在cd同一侧
    var ca = a - c;
    var cb = b - c;
    var cd = d - c;
    if (Vector2Utilities.Cross(cd, ca) * Vector2Utilities.Cross(cd, cb) >= 0)
    {
        return false;
    }
    return true;
}

3D向量:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/// <summary>
/// 4个点是否ab和cd线段是否相交
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="c"></param>
/// <param name="d"></param>
/// <returns></returns>
public static bool IsCross(Vector3 a, Vector3 b, Vector3 c, Vector3 d)
{
    // 通过叉乘计算CA和CD的法线向量
    var ab = b - a;
    var ac = c - a;
    var ad = d - a;
    // 叉乘判定两个向量的方向
    // 判定ab是否在cd两侧
    // 以ab为基准，如果ac和ad叉乘结果再点乘>0则表示c和d在ab同一侧
    // 3D向量叉乘是向量，通过计算两个叉乘向量的点乘判定是否同方向从而判定是否在一侧
    if (Vector3.Dot(Vector3.Cross(ab, ac), Vector3.Cross(ab, ad)) >= 0)
    {
        return false;
    }
    // 同理以cb为基准，如果ca和cb叉乘结果再点乘>0表示a和b在cd同一侧
    var ca = a - c;
    var cb = b - c;
    var cd = d - c;
    if (Vector3.Dot(Vector3.Cross(cd, ca), Vector3.Cross(cd, cb)) >= 0)
    {
        return false;
    }
    return true;
}

如何计算交点:

  1. 几何法分析出交点

让我们直接看下结论:

LineIntersectionFormula

这个结论主要是通过2D平面几何的相似三角形以及向量叉乘在的集合解释是平行四边形面积(两个三角形面积之和)推到而来的。

LineIntersectionPicture

详情推到参考:

Unity3D C#数学系列之判断两条线段是否相交并求交点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/// <summary>
/// 计算AB与CD两条线段的交点.
/// </summary>
/// <param name="a">A点</param>
/// <param name="b">B点</param>
/// <param name="c">C点</param>
/// <param name="d">D点</param>
/// <param name="intersectPos">AB与CD的交点</param>
/// <returns>是否相交 true:相交 false:未相交</returns>
public static bool GetIntersectPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 d, out Vector2 intersectPos)
{
    intersectPos = Vector2.zero;
    // Note:
    // 1. 2D向量不需要判定共面
    if (!IsCross(a, b, c, d))
    {
        return false;
    }
    // 根据推到结论
    // AO / AB = Cross(CA, CD) / Cross(CD, AB)
    // O = A + Cross(CA, CD) / Cross(CD, AB) * AB
    var ab = b - a;
    var ca = a - c;
    var cd = d - c;
    Vector3 v1 = Vector3.Cross(ca, cd);
    Vector3 v2 = Vector3.Cross(cd, ab);
    float ratio = Vector3.Dot(v1, v2) / v2.sqrMagnitude;
    intersectPos = a + ab * ratio;
    return true;
}

LineIntersectionPointCapture

可以看到我们成功可视化算出了两条线段相交的点。

那么如果我们不考虑两条线段相交，单纯想求得两个线段(包含延长线)上的交点时，应该怎么计算了？

实际上相似三角形的推论即使两个线段不相交也是成立的，所以我们唯一要确保的就是两个线段不平行，只有两个线段不平行才有交点。所以我们不需要判定线段两个点是否在两侧只需判定两个线段是否平行，剩下的步骤和之前一致即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/// <summary>
/// 4个点是否ab和cd线段是否平行
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="c"></param>
/// <param name="d"></param>
/// <returns></returns>
public static bool IsParallel(Vector2 a, Vector2 b, Vector2 c, Vector2 d)
{
    // 通过叉乘计算AB和CD是否为0判定是否平行
    var ab = b - a;
    var cd = d - c;
    return Mathf.Approximately(Vector2Utilities.Cross(ab, cd), Mathf.Epsilon);
}

/// <summary>
/// 计算AB与CD两条线段的交点(包含衍生直线)
/// </summary>
/// <param name="a">A点</param>
/// <param name="b">B点</param>
/// <param name="c">C点</param>
/// <param name="d">D点</param>
/// <param name="intersectPos">AB与CD的交点</param>
/// <returns>是否相交 true:相交 false:未相交</returns>
public static bool GetLineIntersectPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 d, out Vector2 intersectPos)
{
    intersectPos = Vector2.zero;
    // Note:
    // 1. 2D向量不需要判定共面
    if (IsParallel(a, b, c, d))
    {
        return false;
    }
    // 根据推到结论
    // AO / AB = Cross(CA, CD) / Cross(CD, AB)
    // O = A + Cross(CA, CD) / Cross(CD, AB) * AB
    var ab = b - a;
    var ca = a - c;
    var cd = d - c;
    Vector3 v1 = Vector3.Cross(ca, cd);
    Vector3 v2 = Vector3.Cross(cd, ab);
    float ratio = Vector3.Dot(v1, v2) / v2.sqrMagnitude;
    intersectPos = a + ab * ratio;
    return true;
}

LineIntersectionPoint2Capture

可以看到我们通过不判定线段点是否在两侧，只判定平时依然计算出了两个线段在延长线上的交点。

实战

待添加……

注意事项

  • 复杂的3D碰撞检测我们可以映射到2D来简化运算量实现相同的效果

  • 能够用简单的形状实现效果尽量用简单的形状来实现避免过于复杂的碰撞检测判定

  • 在坐标平移旋转转换时注意先旋转后平移，不然先平移后旋转会导致坐标转换错误，因为先旋转后平移!=先平移后旋转

Github

CollisionDetectionStudy

学习总结

  1. 2D图形相交检测更多的是平面几何知识，通过将图形转换成纯数学定义来求解
  2. 向量里的点乘叉乘对于求解向量的角度和旋转方向以及两个向量的相对位置很有用

Reference

【Unity】图形相交检测

3D 碰撞检测

Unity3D-游戏中的技能碰撞检测

[包围盒]球，AABB，OBB

UNITY实战进阶-OBB包围盒详解-6

unity3d：两条线段相交并求交点坐标

Unity3D C#数学系列之判断两条线段是否相交并求交点

By

前言

本章节博客是在项目需求设计支持Lua AI系统的前提下，驱动深入学习行为树设计实现。关于AI的相关基础概念学习可以参考:Programming Game AI by Example。而本章节的重点就是行为树，最终目的是实现一份Unity里能够支持项目级使用的支持Lua测使用AI的行为树框架设计。源代码考虑到公司正在使用所以暂时不放源码，大家可以参考设计思路自行实现。

行为树

行为树介绍

行为树首先要知道的一点，是一颗树形结构，树里包含控制决策走向的控制节点和负责展示表现的叶子结点。

行为树抽象一个角色的简单AI角色逻辑如下：
BehaviorTreeHierachy

优点：

  1. 可视化决策逻辑
  2. 可复用控制节点
  3. 逻辑和实现低耦合(叶子结点才是与上层逻辑挂钩的)

节点分类

从设计上来说节点功能划分为两类：

  1. 决策节点(决定行为树走向的非叶子节点)
  2. 行为节点(叶子节点决定最后的行为表现)

决策节点分类：

  1. 组合节点(序列节点(相当于and)、选择节点(相当于or)、并行节点(相当于for循环)等)
  2. 装饰节点(可以作为某种节点的一种额外的附加条件，如允许次数限制，时间限制，错误处理等。Note:装饰节点只有一个子节点)

行为节点分类：

  1. 条件节点(控制节点结果)
  2. 动作节点(实际的行为表现)

节点状态

所有的节点都有三种状态：

  1. 运行中(Running)
  2. 运行完毕(Success / Failed)
  3. 无效(Invalide)

正是通过上面的三种状态来实现行为树的行为决策的(所有节点都有返回状态)

节点选择

决策控制选择节点时需要有依据，这里的依据可以看做是选择某个节点的一个前提条件(Precondition)，前提可以让我们快速判定分支避免不必要的子节点判定。控制节点相当于默认返回True，叶子节点可以作为选择节点的依据。

关于节点选择更多的优化(e.g. 1. 带优先级的选择 2. 带权值的选择……)参考：

行为树（Behavior Tree）实践（2）– 进一步的讨论

Note:
这里考虑到前置条件等价于组合节点的第一个节点设置条件节点，所以最终实战实现里没有实现前置条件(Precondition)

行为树更新

行为树更新方案：
2. 每次从上次运行的节点运行(打断时从根节点重新运行)

行为树中断

前面我们已经选择了方案2，这里就要考虑一下如何实现行为打断了。

从前面可以看出行为树节点是有Running状态的，也就是说只要满足子节点的层层条件后，可以持续执行一段时间(比如寻找目标地点寻路过去这段时间都是Running)。

试想一下游戏过程中所有的条件数据都是在实时变化的，执行寻找目标地点的条件可以在任何时候出现条件不满足的情况，那么我们如何打断正在执行的Running节点，让行为树判定执行一条符合条件的行为分支了？

通过了解，BehaviorDesigner里存在4中类型的中断：

  1. None
  2. Self
  3. Lower Priority
  4. Both

详情参考:行为树 中断的理解

核心都是通过标识决策节点的打断类型以及配合设置相应条件节点来实现额外的条件判定，从而实现其他子节点运行时也可以动态判定其他节点条件来实现打断运行节点。

BehaviorDesigner节点有抽象出节点优先级概念(大概就是树形结构的层级顺序优先级)。

这里只是为了实现一个简易版的行为树，所以就不实现那么复杂的打断机制了。

方案：
行为树运行时记录运行时跑过的需要重新评估的节点的运行结果状态(现阶段主要是指条件节点)，每一次从根节点运行时都判定需要重新评估的节点运行状态是否有变化，有变化表示条件有变行为树需要打断执行。

为什么使用行为树

从Programming Game AI by Example的介绍里可以看到相比状态机(FSM)行为树有以下几个好处:

  1. 使用行为树解决了状态机(FSM)过于复杂后维护成本高不利于扩展的问题。
  2. 行为树决策节点重用性高
  3. 行为树可视化编辑器能高效的查看行为树执行情况

行为树实战

目标：

  1. 实现一套可用于项目级别使用的支持Lua版编写AI的Unity行为树(深入理解行为树的原理和实现)

设计：

  1. 使用黑板模式作为单颗行为树的数据中心解决方案
  2. 使用Unity原生API实现行为树节点编辑器，支持高效方便的行为树编辑导出调试工具
  3. 使用Json(至于性能问题未来可选择高效的Json库，这里主要看中Json的可读性)作为行为树数据序列化反序列化方案
  4. 使用C#开发一套兼容CS和Lua的行为树框架(方便未来直接用于作为CS测的行为树解决方案)，兼容Lua的核心思想是参数由string序列化，行为树节点反序列化构建时自行解析。
  5. 支持暂停，打断以及加载不同行为树Json的行为树框架
  6. 支持条件节点状态变化级别的行为树打断设计

数据管理

黑板模式

可以简单的理解成一个共享数据的地方，核心设计是一个K-V结构的Map容器(结合泛型的设计支持不同类型的数据访问)，通过统一的数据访问方式实现行为树统一的数据访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 /// <summary>
   /// 黑板模式，数据共享中心
   /// </summary>
   public class Blackboard
   {
       /// <summary>
       /// 黑板数据集合中心
       /// </summary>
       protected Dictionary<string, IBlackboardData> mBlackboardDataMap;

       public Blackboard()
       {
           mBlackboardDataMap = new Dictionary<string, IBlackboardData>();
       }

       /// <summary>
       /// 添加黑板数据
       /// </summary>
       /// <param name="key"></param>
       /// <param name="data"></param>
       /// <returns></returns>
       public bool AddData(string key, IBlackboardData data)
       {
           IBlackboardData value;
           if(!mBlackboardDataMap.TryGetValue(key, out value))
           {
               mBlackboardDataMap.Add(key, data);
               return true;
           }
           else
           {
               Debug.LogError(string.Format("黑板数据里已存在Key:{0}的数据，添加数据失败!", key));
               return false;
           }
       }

       /// <summary>
       /// 移除黑板数据
       /// </summary>
       /// <param name="key"></param>
       /// <returns></returns>
       public bool RemoveData(string key)
       {
           return mBlackboardDataMap.Remove(key);
       }

       /// <summary>
       /// 获取指定黑板数据
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="key"></param>
       /// <returns></returns>
       public T GetData<T>(string key)
       {
           var value = GetBlackboardData(key);
           if (value != null)
           {
               return (value as BlackboardData<T>).Data;
           }
           else
           {
               Debug.LogError("返回默认值!");
               return default(T);
           }
       }

       /// <summary>
       /// 更新黑板数据
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="key"></param>
       /// <param name="data"></param>
       /// <returns></returns>
       public bool UpdateData<T>(string key, T data)
       {
           var value = GetBlackboardData(key);
           if(value != null)
           {
               (value as BlackboardData<T>).Data = data;
               return true;
           }
           else
           {
               Debug.LogError(string.Format("更新Key:{0}的数据失败!", key));
               return false;
           }
       }

       /// <summary>
       /// 清除黑板数据
       /// </summary>
       public void ClearData()
       {
           mBlackboardDataMap.Clear();
       }

       /// <summary>
       /// 获取黑板指定数据
       /// </summary>
       /// <param name="key"></param>
       /// <returns></returns>
       private IBlackboardData GetBlackboardData(string key)
       {
           IBlackboardData value;
           if (!mBlackboardDataMap.TryGetValue(key, out value))
           {
               Debug.LogError(string.Format("找不到Key:{0}的黑板数据!", key));
           }
           return value;
       }
   }

   /// <summary>
   /// 黑板数据接口抽象
   /// </summary>
   public interface IBlackboardData
   {

   }

   /// <summary>
   /// 黑板数据泛型基类
   /// </summary>
   public class BlackboardData<T> : IBlackboardData
   {
       /// <summary>
       /// 数据
       /// </summary>
       public T Data
       {
           get;
           set;
       }

       public BlackboardData(T data)
       {
           Data = data;
       }
   }

   #region 黑板数据常用数据类型定义
   /// <summary>
   /// 黑板数据整形数据
   /// </summary>
   public class IntBlackboardData : BlackboardData<int>
   {
       public IntBlackboardData(int data) : base(data)
       {
       }
   }

......
   #endregion

这里具体的黑板数据类型支持通过集成BlackboardData即可，这里就不放全部代码了。

黑板模式这里用于实现自定义变量并支持修改和读取判定，用于实现自定义变量控制AI逻辑。
黑板模式实现效果如下:
自定义变量节点
自定义变量参数面板
所有自定义变量展示面板

节点编辑器

关于节点编辑器，核心要了解Unity以下几个API:

  1. Event – UnityGUI事件响应编写接口类
    节点编辑器操作响应
  2. GUILayout.BeginArea() GUILayout.Toolbar() GUILayout.EndArea() EditorGUILayout.*** – GUI自定义面板UI显示接口
    节点编辑器操作面板
  3. GenericMenu – Unity编写自定义菜单的类
    行为树编辑器菜单
  4. BeginWindows() GUI.Window() EndWindows() GUI.DragWindow() – Unity编写节点窗口的类(支持拖拽的节点)
    行为树节点窗口
  5. Handles.DrawBezier() – 绘制节点曲线(Bezier曲线)连接线的接口
    行为树节点连线
  6. JsonUtility.ToJson() JsonUtility.FromJson() – Unity Json数据序列化反序列化存储
    行为树序列化反序列化存储

结合上面几个核心类，最终实现行为树节点编辑器效果图如下:
行为树节点编辑器效果展示

行为树框架

这里考虑项目正在使用，所以不方便放出源码，通过给出行为树的UML类图设计，大家可以参考思路自行实现(因为UML比较大所以分了两张图):
行为树UML类图1
行为树UML类图2

行为树打断

这里单独谈谈行为树的打断实现，在BehaviourDesigner里行为树的打断设计相对比较复杂，详情可以参考:
Unity3D Behavior Designer 行为树4 打断机制的实现

而这里实现的行为树打断是一种较为简单打断方式，就是在每棵行为树重新从根节点开始执行时，记录执行过的节点以及需要重新判定的节点以及状态，在下一次从根节点运行时执行需要重新判定的节点是否有状态变化来判定是否需要打断行为树Running等执行状态。而需要打断的节点是从上一次记录的执行过的节点里执行结果为Running的才需要打断，其他状态不用打断。

行为树驱动执行代码大致如下:
BTGraph.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 /// <summary>
/// 更新
/// </summary>
public void OnUpdate()
{
    if (RootNode != null)
    {
        // 根节点处于非成功和失败状态(一般来说是Running)
        if (!RootNode.IsTerminated)
        {
            // 节点处于非运行时需要清除上一次运行数据
            if(!RootNode.IsRunning)
            {
                // 清除上一次运行数据(比如执行过的节点和需要重新评估的节点数据)
                ClearRunningDatas();
            }
            // 重新评估需要重新判定的节点，看状态是否有变化
            if (ReevaluatedExecutedNodes())
            {
                // 重新判定节点运行结果有变化需要重置运行节点重新判定
                DoAbortBehaviourTree();
            }
            RootNode.OnUpdate();
        }
        // 根节点处于成功或失败状态
        else
        {
            // 清除上一次运行数据(比如执行过的节点和需要重新评估的节点数据)
            ClearRunningDatas();
            // 重新评估需要重新判定的节点，看状态是否有变化
            if (ReevaluatedExecutedNodes())
            {
                // 重新判定节点运行结果有变化需要重置运行节点重新判定
                DoAbortBehaviourTree();
            }
            // 判定行为树单次执行完后是否需要自动重启下一次执行
            if (OwnerBT.RestartWhenComplete)
            {
                RootNode.OnUpdate();
            }
        }
    }
}

/// <summary>
/// 执行终止行为树
/// </summary>
public void DoAbortBehaviourTree()
{
    Debug.Log("DoAbortBehaviourTree()");
    foreach (var executingnode in ExecutingNodesMap)
    {
        // 只有执行中的节点需要打断(避免执行完成的节点二次打断)
        if(executingnode.Value.IsRunning)
        {
            executingnode.Value.OnConditionalAbort();
        }
    }
    ClearRunningDatas();
}

而动态打断机制是通过指定特定节点(比如当前博主只支持条件节点)是否支持参与重新打断判定实现的。
BTBaseConditionNode.cs

1
2
3
4
5
6
7
8
/// <summary>
/// 是否可被重新评估
/// </summary>
/// <returns></returns>
protected override bool CanReevaluate()
{
    return AbortType == EAbortType.Self;
}

公司项目没有继续做了，项目开源了:

BehaviourTreeForLua

Reference

行为树（Behavior Tree）实践（1）– 基本概念
行为树（Behavior Tree）实践（2）– 进一步的讨论
用800行代码做个行为树（Behavior Tree）的库（1）
用800行代码做个行为树（Behavior Tree）的库（2）
AI 行为树设计与实现-理论篇
行为树及其实现
unity 行为树 简单实现
基于Unity行为树设计与实现的尝试
游戏设计模式——黑板模式
Unity3D Behavior Designer 行为树4 打断机制的实现

By

前言

多年使用Unity经验的朋友对于列表单元肯定很熟悉，每个公司也都有着自己的一套单元格设计。本章节博客着重学习Unity里列表单元格框架的设计和实现，深入学习不同单元格框架的设计优劣。

列表

什么是列表了？
可以滚动，支持创建多个基于特定模板显示的单元格容器。

列表的功能需求(**(√)**表示本人已经实现的部分)？

  1. 滚动显示(支持滚动到指定位置)(√)
  2. 动态添加(支持任何位置添加元素)(√)
  3. 循环列表(支持从头滚到尾再接着滚动到头的循环方式)
  4. 不同大小单元格显示(支持自适应大小或者自定义传单元格大小)(√)
  5. 多种列表类型显示(e.g. 横向,竖向，横向网格，竖向网格等)(√)
  6. 单元格构造自定义传参**(√)**
  7. 自定义滚动动画**(√)**
  8. 不同单元格朝向(e.g. 从左往右或从右往左。从上往下或者从下往上。)(√)
  9. 单元格矫正(最终单元格会滚动到某个最近的单元格位置)(√)
  10. 单元格对象池(e.g. 单元格逻辑对象(Object)对象池。单元格实体对象(GameObject)对象池。)(√)
  11. 单元格嵌套滚动(e.g. 嵌套不同方向的单元格容器滚动支持)(√)
  12. 本地单元格模拟创建查看效果(e.g. Inspector支持快速模拟查看排版等)(√)

单元格容器

这里关于单元格容器，这里主要实现了两套:

  1. 支持不同滚动方向不同初始化朝向支持不同大小(手动传Size或者自动计算Size)嵌套滚动单元格的一套通用单元格容器。
  2. 支持两侧深度滚动显示的单元格容器(这一套实现的效果比较特别所以单独实现的)
    其中本人主要以第一套(以前在公司学习到的一套实现方案，后来在此基础上扩展支持了很多功能)为重点来学习实战。

单元格实现分析

这里通过学习了解市面上常见的单元格实现来了解常见的单元格实现方案：

LoopScrollRect

LoopScrollRect
这一套是钱康来大佬编写分享的一套支持循环列表的实现方案。
通过查看源码，可以了解到，这一套实现核心是基于ContentSizeFitter，LayoutGroup和LayoutElement相关组件来实现动态计算单元格位置显示循环滚动以及不同大小等效果的。
亮点分析:

  1. 使用了原生Scroller，但并不依赖原生ScrolRect那套来计算滚动，这样为支持循环列表打下了基础。
  2. 单元格位置数据与单元格逻辑对象分离，可以做到动态计算单元格显示时只有需要显示的才有逻辑单元格对象(避免New大量的单元格)。

缺点分析:

  1. 虽然基于LayoutGroup和LayoutElement，但并非正向通过他们的排版功能得到不同单元格大小显示，而是反向设置LayoutElement来通过LayoutUtility.GetPreferredHeight()等接口方法来实现正确的计算滚动排版。这儿也就意味着做不到自动计算单元格大小的功能。
  2. 单元格显示是通过SendMessage的形式触发，感觉这种方式效率可能不如直接调用接口方法来的快(个人感觉)。
    核心获取单元格大小的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
protected override float GetSize(RectTransform item)
{
    float size = contentSpacing;
    if (m_GridLayout != null)
    {
        size += m_GridLayout.cellSize.y;
    }
    else
    {
        size += LayoutUtility.GetPreferredHeight(item);
    }
    return size;
}

单元格初始化显示触发代码:

1
2
3
4
public override void ProvideData(Transform transform, int idx)
{
    transform.SendMessage("ScrollCellIndex", idx);
}

FancyScrollView

FancyScrollView
FancyScrollViewExhibition
这一套是在UWA上看到的，貌似是日本开发者开发的。
通过上面的效果图可以看到，这一套实现了很强大的结合自定义动画或者Shader的单元格容器框架。
通过查看源代码可以发现，这一套非常强大的一点是通过自定义实现Scroller强大的滚动单元格容器需要的滚动相关的计算和回调支持。
上次代码只需要通过ScrollView和Scroller接口设置显示数据以及单元格模板等就能做到很好的单元格容器滚动效果。
亮点分析:

  1. 没有依赖原生Scroller，自定义实现了Scroller，可以更加容易的支持循环列表。
  2. 动态计算显示与否是通过当前滚动到的位置来判定，而单元格位置信息并没有耦合到单元格对象里，这样可以做到逻辑对象数量等于最大可显示的数量。
  3. 更新显示回调(UpdatePosition)里有传入位置数据，可以基于位置数据做动画(Animator)或者Shader相关的表现展示。
  4. 不依赖于Scroller，LayoutGroup等组件，开销更低

缺点分析:

  1. 单元格不支持不同大小，都是按预制件统一大小来计算

super-scrollview

ugui-super-scrollview-example
这一套是Unity Asset Store里出售的一套滚动单元格插件。
让我们先来一张效果图展示：
SuperScrollViewExhibition
从上面可以看到，SuperScrollView可以做到很多效果(e.g. 翻页，动态加载，动态大小变化，滚动到指定位置，动态增删单元格，不同朝向单元格容器显示……)
基本上能想到的单元格容器效果，这个插件都支持。
接下来让我们结合源码和实例来分析下这一套单元格容器的好坏:
亮点分析:

  1. 单元格位置数据与逻辑对象分离，可以有效的减少逻辑单元格对象数量。
  2. 自定义的单元格大小抽象，可以方便的自定义传入不同大小的单元格并显示。
  3. 支持不同朝向的单元格容器显示(核心是反向初始化和计算单元格位置显示)

缺点分析:

  1. 使用了ScrollRect部分功能(特别是容器滚动部分)，这一点导致要做循环列表就很困难

后续本人的单元格容器很大程度上跟SuperScrollView更相近(指功能设计上而非代码设计)。

实战单元格容器

通过学习了解市面上的单元格容器实现，可以看到有几个比较重要的点：

  1. 不依赖于ScrollRect滚动，自定义分离单元格位置数据和单元格逻辑对象，是实现循环列表和减少逻辑单元格对象数量的关键。
  2. 大部分都不支持自动计算大小，需要手动计算传递单元格大小，相对来说没那么方便，但开销会小。

接下来让我们看看博主实战最终实现的效果(主要讲解第一套单元格):
LeftToRightScene

TopToBottomScene

HorizontalGalleryDemoScene

ChatMessageListScene

ChangeItemSizeScene

ClickAndLoadMoreScene

GridViewScene

PageViewScene

SpinDatePickerScene

SelectAndDeleteOrMoveScene

上面展示了我支持的各类单元格容器，比如横向单元格容器，竖向单元格容器，横向网格单元格容器，竖向网格单元格容器，动态大小等各种用法。
DepthScrollExhibition
第三章图主要展示的是另一套单元格容器，支持左右两侧指定深度滚动的单元格容器。

Note:

基于ContentSizeFitter和LayoutGroup的自动计算大小测试性能开销比较大最后决定不予支持了。

深入讲解

让我们通过横向单元格的面板来大致了解下单元格都支持哪些功能：
!(HorizontalContainerInspector)(/img/Unity/CellContainer/HorizontalContainerInspector.png)
从面板上可以看出，博主的单元格容器主要支持了以下几个功能：

  1. 单元格滚动自动矫正以及相关速度设置(最终确保滚动到单元格正中心位置)
  2. 支持不同朝向的单元格创建显示
  3. 支持嵌套单元格容器(不同朝向的单元格容器可以嵌套滚动)
  4. 支持单元格的间距和初始位置排版设置
  5. 支持设置多预制件用于绑定不同逻辑单元格对象显示在同一个单元格容器下
  6. 支持编辑器下快速模拟创建单元格查看排版

单元格容器核心实现原理：

  1. 通过手动传单元格大小或者自动计算单元格大小来得到每个单元格的大小数据
  2. 通过累加计算出总的可滚动Content大小，同时计算出单元格的抽象单元格位置
  3. 结合IBeginDragHandler, IDragHandler, IEndDragHandler接口来判定拖拽状态(比如是否开始或结束拖拽，拖拽方向等)，以及实现嵌套单元格的拖拽事件判定以及分发
  4. Content结合ScrollRect来实现滚动回调(OnValueChanged)触发滚动计算判定，结合单元格的抽象位置来判定每个单元格的显隐状态。同时判定是否满足单元格矫正条件
  5. 通过IEndDragHandler响应结束拖拽时判定是否需要执行单元格矫正
  6. 向上层暴露OnShow,OnVisibleScroll,MoveTOIndex,OnHide等接口来实现单元格逻辑流程显示回收(BaseScrollContainer:bindContainerCallBack()接口传递)

结合UML类图来理解下单元格容器的设计:
CellContainerUML

首先先放一段完整的创建单元格显示的事例代码，后续会一一讲解具体实现细节流程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
RightToLeftContainer.bindContainerCallBack(onCellShow);
  RightToLeftContainer.setCellDatasByCellCount(20);

  /// <summary>
  /// 单元格显示回调
  /// </summary>
  /// <param name="cellindex"></param>
  /// <param name="cellinstance"></param>
  private void onCellShow(int cellindex, GameObject cellinstance)
  {
      var toptobottomcell = cellinstance.GetComponent<ShowCellIndexCell>();
      if (toptobottomcell == null)
      {
          toptobottomcell = cellinstance.AddComponent<ShowCellIndexCell>();
      }
      toptobottomcell.init(cellindex);
  }

接下来让我们看看单元格容器的细节实现：
CellData.cs（单元格相关抽象）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
public class CellData : IRecycle
{
    /// <summary>
    /// 当前Cell索引
    /// </summary>
    public int CellIndex
    {
        get;
        set;
    }

    /// <summary>
    /// 拥有者单元格
    /// </summary>
    protected BaseScrollContainer mOwnerContainer;

    /// <summary>
    /// Cell实例对象
    /// </summary>
    public GameObject CellGO
    {
        get;
        protected set;
    }

    /// <summary>
    /// Cell实例对象的RectTransform
    /// </summary>
    public RectTransform CellGORectTransform
    {
        get;
        protected set;
    }

    /// <summary>
    /// 单元格大小(宽和高)
    /// </summary>
    private Vector2 mCellSize;

    /// <summary>
    /// 单元格预制件索引
    /// </summary>
    public int CellPrefabIndex
    {
        get;
        private set;
    }


    ......

        public void onCreate()
    {
        //Debug.Log("NewCellData:onCreate()");
    }


    public void onDispose()
    {
        //Debug.Log("NewCellData:onDispose()");
        CellIndex = -1;
        mOwnerContainer = null;
        CellGO = null;
        CellGORectTransform = null;
        CellPrefabIndex = -1;
        mCellSize = Vector2.zero;
        mRectPos = Vector2.zero;
        mRectAbsPos = Vector2.zero;
        CellRect.Set(0.0f, 0.0f, 0.0f, 0.0f);
    }

    public CellData()
    {
        CellIndex = -1;
        mOwnerContainer = null;
        CellGO = null;
        CellGORectTransform = null;
        CellPrefabIndex = -1;
        mCellSize = Vector2.zero;
        mRectPos = Vector2.zero;
        mRectAbsPos = Vector2.zero;
        CellRect.Set(0.0f, 0.0f, 0.0f, 0.0f);
    }

    /// <summary>
    /// 初始化单元格实例对象
    /// </summary>
    /// <param name="cellinstance"></param>
    public void init(GameObject cellinstance)
    {
        if(cellinstance != null)
        {
            CellGO = cellinstance;
            // 不同单元格容器公用同一个模板对象可能会出现锚点不一致问题，所以每次强制设置
            CellGORectTransform = CellGO.transform as RectTransform;
            CellGORectTransform.anchorMax = AnchorMax;
            CellGORectTransform.anchorMin = AnchorMin;
            CellGORectTransform.pivot = Pivot;
            updateCellSizeAndPosition();
            if (!CellGO.activeSelf)
            {
                CellGO.SetActive(true);
            }
        }
        else
        {
            CellGO = null;
            CellGORectTransform = null;
        }
    }

    /// <summary>
    /// Cell数据清除
    /// </summary>
    public void clear()
    {
        mOwnerContainer = null;
        CellGO = null;
        CellGORectTransform = null;
        mCellSize = Vector2.zero;
        mRectPos = Vector2.zero;
        CellRect = Rect.zero;
        ObjectPool.Singleton.push<CellData>(this);
    }

    ......
}

上面列举了单元格参与容器显示判定计算比较重要的成员变量以及生命周期函数，可以看出单元格的大小和位置以及显示区域信息会用作单元格容器滚动时的判定数据，从而判定是否需要显示特定单元格。

从前面的事例代码可以看到单元格的创建可以手动指定单元格大小，不传会用默认预制件大小

设定单元格容器回调后触发setCellDatasByCellCount()等设置容器数量相关接口后，触发单元格以及单元格容器相关数据的初始化和判定以及滚动判定监听:
BaseScrollContainer.cs(单元格容器基类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// Use this for initialization
public virtual void Start()
{
    ScrollRect.onValueChanged.AddListener(onScrollChanged);
    TryCorrectData();
}

/// <summary>
/// 滚动回调刷新Cell显示
/// </summary>
/// <param name="scrollpos"></param>
protected override void onScrollChanged(Vector2 scrollpos)
{
    if (mCellDatas != null)
    {
        updateScrollValue();
        mMaskRect.x = mAvalibleScrollDistance * ScrollRect.horizontalNormalizedPosition;
        for (int i = 0; i < mCellDatas.Count; i++)
        {
            onCellDisplay(i);
        }
        checkCellPostionCorrect(mCurrentScrollDir);
    }
}

/// <summary>
/// Set container celldatas by pass data
/// 设置Container的cell数据通过列表数据
/// </summary>
/// <param name="prefabindexlist">预制件索引列表</param>
/// <param width="cellsizelist">单元格大小列表(为空表示采用预制件默认大小)</param>
/// <param name="scrollnormalizedposition">单元格初始滚动位置</param>
public void setCellDatasByDataList(List<int> prefabindexlist, List<Vector2> cellsizelist = null, Vector2? scrollnormalizedposition = null)
{
    var celldatalist = createNormalCellDataList(prefabindexlist, cellsizelist);
    setCellDatas(celldatalist, scrollnormalizedposition);
}

/// <summary>
/// Set container celldatas by pass cell count
/// 设置Container的cell数据通过单元格数量
/// </summary>
/// <param name="prefabindexlist">预制件索引列表</param>
/// <param width="cellsizelist">单元格大小列表(为空表示采用预制件默认大小)</param>
/// <param name="scrollnormalizedposition">单元格初始滚动位置</param>
public void setCellDatasByCellCount(int cellcount, Vector2? scrollnormalizedposition = null)
{
    var celldatalist = createNormalCellDataListWithCount(cellcount);
    setCellDatas(celldatalist, scrollnormalizedposition);
}

/// <summary>
/// Set container celldatas by pass celldata list
/// 设置Container的cell数据
/// </summary>
/// <param name="celldatas">所有的Cell数据</param>
/// <param name="scrollnormalizedposition">单元格初始滚动位置</param>
public void setCellDatas(List<CellData> celldatas, Vector2? scrollnormalizedposition = null)
{
    ......
}

/// <summary>
/// Update container relative datas
/// 更新容器数据
/// </summary>
/// <param name="scrollnormalizaedposition">单元格初始滚动位置</param>
/// <param name="keeprectcontentpos">是否保持rect content的相对位置(优先于scrollnormalizaedposition)</param>
protected abstract void updateContainerData(Vector2? scrollnormalizaedposition = null, bool keeprectcontentpos = false);

......

因为单元格的流程和细节还是比较多，这里讲解的不太全面，很多地方没有说到，但考虑到项目还在用这两套单元格滚动，所以展示不打算放出源码，等未来实际成熟再分享源码。

亮点分析:

  1. 支持嵌套单元格滚动(通过判定滚动方向手动向上传递滚动事件实现)
  2. 支持手动传Size
  3. 支持不同单元格模板以及不同单元格逻辑对象的显示

缺点分析:

  1. 滚动单元格依赖于ScrollRect的滚动机制需要一开始就计算出总的单元格大小之和，导致很难支持循环列表。
  2. 滚动列表要一开始就知道单元格的大小，导致一开始如果有过多的动态大小会导致单元格初始化前的计算开销过大。

未来优化

  1. 设计成支持纯虚拟的滚动列表，可以在滚动时再请求单元格大小信息做到动态更新ScrollRect滚动容器大小，动态单元格大小在初始化时的开销过大。
  2. 设计成不基于ScrollRect的滚动机制，为实现循环列表做准备

—————————-2021/4/20更新开始——————————-

开始着手分离单元格位置和单元格逻辑对象优化单元格逻辑对象过多问题，确保只需创建可见的单元格逻辑对象，减少不必要的逻辑对象创建开销。(已设计成回调似方式来优化逻辑对象问题)

—————————-2021/4/20更新结束——————————-

Note:

  1. 源代码里默认带了一套组件绑定(结合代码生成)的方案，感兴趣的朋友可以自己了解下
  2. 源代码里也默认带了ObjectPool和GameObjectPool两种对象池的实现，感兴趣的朋友可以自己了解下

Github地址

ScrollContainer

Reference

LoopScrollRect
FancyScrollView
ugui-super-scrollview-example
Unity3D研究院之ContentSizeFitter同步立即响应回调

By

前言

游戏开发过程中我们经常会需要访问一些指定节点，组件和脚本。

常规方式会通过编写GetChild(?)和GetComponent()代码的方式去获取节点和组件，但这样对于开发来说并不高效同时运行时的GetChild(?)和GetComponent()也是有运行开销的。

为了寻求更高效，高性能和便捷的方式，这里引出组件绑定的工具方案。

实现一套通用的组件绑定方案，为未来游戏快速开发打下基础。

组件绑定原理

  1. 通过Object数组实现通用类型的组件绑定存储
  2. 通过自定义Inspector实现绑定对象，绑定对象组件绑定选择以及模板类型选择，代码生成等UI操作界面
  3. 通过模板+代码生成实现组件绑定的自定义快速代码生成(通过生成partial代码不入侵原始逻辑代码)
  4. 结合自定义ScriptableObject自定义不同模板类型的不同代码输出目录实现自定义代码目录输出设置

功能实现

  1. 支持通节点不同组件的绑定
  2. 支持节点自定义变量名和注释定义
  3. 支持自定义代码模板的选择生成
  4. 支持组件绑定代码不入侵功能代码(利用partial class)功能生成代码
  5. 支持不同模板类型代码生成输出目录设置

实战实现

组件绑定脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/// <summary>
/// 节点绑定类
/// </summary>
[DisallowMultipleComponent]
public class ComponentBinder : MonoBehaviour
{
    /// <summary>
    /// 绑定类型索引值
    /// </summary>
    public int BindCodeTypeIndex;

    /// <summary>
    /// UI节点数据
    /// </summary>
    public List<ComponentBindData> NodeDatas = new List<ComponentBindData>();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/// <summary>
/// 组件绑定节点信息
/// </summary>
[Serializable]
public class ComponentBindData
{
    /// <summary>
    /// 节点对象
    /// </summary>
    [SerializeField]
    public UnityEngine.Object NodeTarget;

    /// <summary>
    /// 变量别名(用于生成代码)
    /// </summary>
    [SerializeField]
    public string VariableAlias;

    /// <summary>
    /// 节点描述
    /// </summary>
    [SerializeField]
    public string NodeDes;
    
    public ComponentBindData(UnityEngine.Object target)
    {
        NodeTarget = target;
        NodeDes = string.Empty;
    }
}

从上面的可以看出节点组件和脚本的数据绑定核心是通过脚本序列化Object[]数组以及相关数据的方式实现绑定节点数据存储的。

组件绑定自定义面板

1
2
3
4
5
6
7
8
9
/// <summary>
/// 组件绑定自定义Editor
/// </summary>
[CustomEditor(typeof(ComponentBinder))]
[CanEditMultipleObjects]
public class ComponentBinderEditor : Editor
{
    ******
}

这部分代码主要是实现ComponentBinder的Inspector自定义GUI显示，从而实现我们想要的自定义UI操作。

组件绑定模板代码生成

1
2
3
4
5
6
7
/// <summary>
/// CompoenntBinder代码生成工具
/// </summary>
public static class ComponentBinderCodeGenerator
{
	******
}
1
2
3
4
5
6
7
/// <summary>
/// 模板数据处理类
/// </summary>
public class TTemplate
{
    ******
}

此文件主要是通过自定义选择的模板文件***.txt结合TTemplate工具类实现模板文件txt里的内容自定义生成输出我们想要的代码。

窗口模板文件示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/*
 * Description:             #FileName#.cs
 * Author:                  #Author#
 * Create Date:             #CreatedDate#
 */

using UnityEngine;
using UnityEngine.UI;
using TH.Modules.UI;

namespace Game.Modules.UI
{	
	/// <summary>
	/// #ClassName#窗口
	/// </summary>
    public class #ClassName# : BaseWindow
    {
		public #ClassName#()
		{

		}

		/// <summary>
		/// 添加监听
		/// </summary>
		protected override void addListeners()
		{
			base.addListeners();
		}

		/// <summary>
		/// 窗口显示
		/// </summary>
		protected override void onShow()
		{
			base.onShow();
		}
		
		/// <summary>
		/// 移除监听
		/// </summary>
		protected override void removeListeners()
		{
			base.removeListeners();
		}
		
		/// <summary>
		/// 窗口销毁
		/// </summary>
		protected override void onDestroy()
		{
			base.onDestroy();
		}
    }
}

窗口组件绑定模板示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
 * Description:             #FileName#.cs
 * Author:                  #Author#
 * Create Date:             #CreatedDate#
 */

using UnityEngine;
using UnityEngine.UI;
using TH.Modules.UI;

namespace Game.Modules.UI
{
	/// <summary>
	/// #ClassName#窗口的组件绑定
	/// </summary>
    public partial class #ClassName#
    {
		 #MEMBER_DEFINITION_LOOP#
        /// <summary> #NodeDes# /// </summary>
        private #NodeType# #NodeName#;#MEMBER_DEFINITION_LOOP#
		   
		/// <summary>
		/// 缓存组件
		/// </summary>
		protected override void cacheComponents()
		{
			base.cacheComponents();
            #MEMBER_INIT_LOOP#
            #NodeName# = #NodeMemberName#.NodeDatas[#NodeIndex#].NodeTarget as #NodeType#;#MEMBER_INIT_LOOP#
        }

		/// <summary>
		/// 释放组件
		/// </summary>
		protected override void disposeComponents()
		{
			base.disposeComponents();
			#MEMBER_DISPOSE_LOOP#
            #NodeName# = null;#MEMBER_DISPOSE_LOOP#
		}
    }
}

其他模板生成参考文件:

CellUIBinder.txt，CellUITemplate.txt，GameObjectUIBinder.txt

组件绑定设置

1
2
3
4
5
6
7
8
9
/// <summary>
/// ComponentBindSetting.cs
/// 组件绑定设置数据
/// </summary>
[CreateAssetMenu(fileName = "ComponentBinderSetting", menuName = "ScriptableObjects/ComponentBinderSetting", order = 1)]
public class ComponentBinderSetting : ScriptableObject
{
    ******
}
1
2
3
4
5
6
7
8
9
10
/// <summary>
/// ComponentBinderSettingEditor.cs
/// 组件绑定自定义Editor
/// </summary>
[CustomEditor(typeof(ComponentBinderSetting))]
[DisallowMultipleComponent]
public class ComponentBinderSettingEditor : Editor
{
    ******
}

实战使用

  • 组件绑定设置

    ComponentBinderSettingUI

    通过自定义模板类型的代码输出路径设置实现自定义代码输出设置

  • 组件绑定选择

    ComponentBindChosenUI

    1. 支持通节点不同组件的绑定
    2. 支持节点自定义变量名和注释定义

  • 自定义绑定节点代码注释

    CustomScriptNotation

  • 窗口模板组件绑定设置以及代码生成

    WindowTemplateBindUsing

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    /*
     * Description:             WindowBindPrefab.cs
     * Author:                  TONYTANG
     * Create Date:             2022//05/29
     */

    using UnityEngine;
    using UnityEngine.UI;
    using TH.Modules.UI;

    namespace Game.Modules.UI
    {	
        /// <summary>
        /// WindowBindPrefab窗口
        /// </summary>
        public class WindowBindPrefab : BaseWindow
        {
            public WindowBindPrefab()
            {

            }

            /// <summary>
            /// 添加监听
            /// </summary>
            protected override void addListeners()
            {
                base.addListeners();
            }

            /// <summary>
            /// 窗口显示
            /// </summary>
            protected override void onShow()
            {
                base.onShow();
            }

            /// <summary>
            /// 移除监听
            /// </summary>
            protected override void removeListeners()
            {
                base.removeListeners();
            }

            /// <summary>
            /// 窗口销毁
            /// </summary>
            protected override void onDestroy()
            {
                base.onDestroy();
            }
        }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    /*
     * Description:             WindowBindPrefabBinder.cs
     * Author:                  TONYTANG
     * Create Date:             2022//05/29
     */

    using UnityEngine;
    using UnityEngine.UI;
    using TH.Modules.UI;

    namespace Game.Modules.UI
    {
    	/// <summary>
    	/// WindowBindPrefab窗口的组件绑定
    	/// </summary>
        public partial class WindowBindPrefab
        {
    		 
            /// <summary> 根GameObject /// </summary>
            private GameObject _rootGo;
            /// <summary> 根RectTransform /// </summary>
            private RectTransform _rootRect;
            /// <summary> 背景图 /// </summary>
            private Image imgBg;
            /// <summary> 左侧按钮 /// </summary>
            private Button btnLeftSwitch;
            /// <summary> 右侧按钮 /// </summary>
            private Button btnRightSwitch;
    		   
    		/// <summary>
    		/// 缓存组件
    		/// </summary>
    		protected override void cacheComponents()
    		{
    			base.cacheComponents();
                
                _rootGo = mComponentBinder.NodeDatas[0].NodeTarget as GameObject;
                _rootRect = mComponentBinder.NodeDatas[1].NodeTarget as RectTransform;
                imgBg = mComponentBinder.NodeDatas[2].NodeTarget as Image;
                btnLeftSwitch = mComponentBinder.NodeDatas[3].NodeTarget as Button;
                btnRightSwitch = mComponentBinder.NodeDatas[4].NodeTarget as Button;
            }

    		/// <summary>
    		/// 释放组件
    		/// </summary>
    		protected override void disposeComponents()
    		{
    			base.disposeComponents();
    			
                _rootGo = null;
                _rootRect = null;
                imgBg = null;
                btnLeftSwitch = null;
                btnRightSwitch = null;
    		}
        }
    }

    更多的代码生成示例，参考Github源代码工程。

    GameObjectBinderUI

    CellBinderUI

重点知识

  1. 利用自定义UI结合Object[]实现自定义组件绑定数据序列化
  2. 利用代码生成使用partial实现组件绑定代码无缝插入工程代码实现快速替换和访问

Github

ComponentBinder

By

前言

本章节博客是在使用一段时间Dotween后，对于Dotween是如何实现各种不同的缓动类型效果比较好奇。从本片博客会了解线性方程与线性代数之间的关系，以及数学(线性方程)在缓动中的实际应用和数学公式是如何输出显示的。本博客着重于学习数学在插值动画上的运用学习，博客末尾会给出实战的Git地址。

数学

在开始之前，让我们先来了解下如何编写网页版数学公式，然后用于我们的MarkDown中显示。

紧接着我们来回顾和学习了解，线性方程和线性代数各自的概念以及他们之间的关系。

数学公式

考虑到MarkDown或者网页显示数学公式都要有额外的插件支持，所以这里采用独立第三方制作公式显示，然后截图使用图片的形式来显示到MarkDown和网页上。

公式制作

通过搜索了解到LaTeX，是一种基于TeX的排版系统

LateX表达数学公式支持两种方式：

  1. inline mode(is used to write formulas that are part of a text)

    inline mode采用以下分隔符:

    \( \), $ $or\begin{math} \end{math}

  2. display mode(is used to write expressions that are not part of a text or paragraph, and are therefore put on separate lines.)

由于LateX规则过于庞大，所以这里只是简单的用到什么查什么。

更多更详细的学习参考:

Latex数学公式编写介绍

接下来只是以简单的二元一次方程组为示例，来学习LateX的数学表达结构:

先来看看最终要的效果：

XianXingFangCheng

实战：

这简单的二元一次方程，涉及到如下几个概念：

直接上最终LateX代码：

1
2
3
4
5
6
\usepackage{amsmath}

\begin{align*}
& \left( 2x - y = 0 \right) \\
& \left( -x + 2y = 3 \right)
\end{align*}

输出效果:

LateXXianXingFangCheng

上面没有找到如何输出{符号，忘知道的朋友告知。

上面这种表达方式，我们可以理解成方程组的行表达形式

在线编写LateX网址

上面那个LateX网址是收费的，其次是完全自己写LateX语法符号来编写数学公式。后来发现了更加可视化容易编写数学公式的在线免费网站，有兴趣的可以了解下：

mathcha

只需要按照规则输入符号就能打出想要的数学公式效果。

公式可视化

解决了函数编写输出，那么肯定希望更直观的看到函数的二维坐标系绘图，这里我找到一个在线绘制数学函数的网站：

WolframAlpha

MathmaticVisualization

线性方程

线性方程，这个应该是初中学习的知识，参考前面的示例来回顾一下：

LateXXianXingFangCheng

方程组又称联立方程，是两个或两个以上含有多个[未知数]联立得到的[集]。未知数的值称为方程组的**[根]，求方程组根的过程称为解方程组**。

这里就不深入探讨了，总之就是解方程组。这里我们更关注的是方程组是如何和线性代数关联上的。

线性代数

线性代数是关于向量空间的一个数学分支。它包括对线、面和子空间的研究，同时也涉及到所有的向量空间的一般性质。

前面的二元一次方程示例用不同的角度来思考和表达。

以列表达形式如下：

1
2
3
\begin{equation}
x \binom{2}{1} + y \binom{-1}{-2} = \binom{0}{3}
\end{equation}

效果：

XianXingFangChengMatrixStyle

结合二维坐标系：

ColumePictureXianXingFangCheng

图中是以向量的概念来绘制方程组图像，可以看到矩阵的概念已经呼之欲出了。

以矩阵的概念来表达如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
\qquad \qquad \qquad \qquad \qquad \quad
$\begin{bmatrix}
2 & -1 \\
-1 & 2
\end{bmatrix}$
$\begin{bmatrix}
x \\
y
\end{bmatrix}$
=
$\begin{bmatrix}
0 \\
3
\end{bmatrix}$

效果：

XianXingFangChengRealMatrixStyle

以下截图来源：

JianHuaMatrix

可以看出落实到矩阵的概念上，就是对于向量的矩阵变换问题了。向量X通过矩阵A的变换变换到b。

矩阵变换正是线性代数中的一部分。

矩阵可以帮助我们对于复杂的多维函数方程更方便的构造和求解。

更多在线学习参考:

方程组的几何解释

插值

相比前面的数学基础概念，总算进入更有趣的实战环节了。

插值缓动效果是指游戏里一些需要缓慢变化的动画效果(e.g. 移动位置插值，透明度变化插值，颜色变化插值等)。

一般来说在Unity里要实现插值，我们会直接通过类似Update(e.g. Update或Coroutine)的形式去累加时间，然后通过Unity提供的插值函数来获取当前插值的进度值，最终使用这个进度值参与插值运算得出最终插值效果。

所以我们会看到类似以下的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
using System.Collections;
using UnityEngine;

/// <summary>
/// Lerp挂载基类
/// </summary>
public class LerpBaseMono : MonoBehaviour {

    /// <summary>
    /// Lerp时长
    /// </summary>
    public float LerpDurationTime = 2.0f;

    /// <summary>
    /// 当前Lerp类型
    /// </summary>
    protected ELerpType mLerpType = ELerpType.None;

    // Use this for initialization
    void Start () {
        DoLerpPrepation();
        StartCoroutine(LerpCoroutine());
    }

    /// <summary>
    /// 执行Lerp准备工作
    /// </summary>
    protected virtual void DoLerpPrepation()
    {

    }

    /// <summary>
    /// Lerp携程
    /// </summary>
    /// <returns></returns>
    protected IEnumerator LerpCoroutine()
    {
        var starttime = Time.time;
        var endtime = starttime + LerpDurationTime;
        while(Time.time < endtime)
        {
            DoLerp(starttime, endtime, Time.time);
            yield return null;
        }
        DoLerp(starttime, endtime, Time.time);
    }

    /// <summary>
    /// 执行Lerp
    /// </summary>
    /// <param name="starttime"></param>
    /// <param name="endtime"></param>
    /// <param name="currenttime"></param>
    protected virtual void DoLerp(float starttime, float endtime, float currenttime)
    {
        var t = Mathf.InverseLerp(starttime, endtime, currenttime);
        Debug.Log($"开始时间:{starttime}结束时间:{endtime}当前时间:{currenttime}当前缓动值:{t}");
        DoRealLerp(t);
    }

    /// <summary>
    /// 执行真实Lerp效果
    /// </summary>
    /// <param name="t">缓动进度(0-1)</param>
    protected virtual void DoRealLerp(float t)
    {

    }
}

输出如下:

UnityLerpOutput

接下来有了缓动的插值t,我们就可以做不同的缓动动画效果了。

上面的代码已经为挂载不同的缓动效果做了设计准备，接下来让我们实现三个简单的缓动效果:

  1. 位移缓动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/// <summary>
/// PositionLerpMono.cs
/// 位置Lerp组件
/// </summary>
public class PositionLerpMono : LerpBaseMono
{
    /// <summary>
    /// 结束位置
    /// </summary>
    public Vector3 EndPos = Vector3.zero;

    /// <summary>
    /// 开始位置
    /// </summary>
    protected Vector3 mStartPos;

    /// <summary>
    /// 执行Lerp准备工作
    /// </summary>
    protected override void DoLerpPrepation()
    {
        base.DoLerpPrepation();
        mLerpType = ELerpType.LerpPosition;
        mStartPos = transform.localPosition;
    }

    /// <summary>
    /// 执行真实Lerp效果
    /// </summary>
    /// <param name="t">缓动进度(0-1)</param>
    protected override void DoRealLerp(float t)
    {
        transform.localPosition = Vector3.LerpUnclamped(mStartPos, EndPos, t);
    }
}
  1. 缩放缓动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/// <summary>
/// ScaleLerpMono.cs
/// 缩放缓动组件
/// </summary>
public class ScaleLerpMono : LerpBaseMono
{
    /// <summary>
    /// 结束缩放值
    /// </summary>
    public Vector3 EndScale = Vector3.one;

    /// <summary>
    /// 开始缩放值
    /// </summary>
    protected Vector3 mStartScale;

    /// <summary>
    /// 执行Lerp准备工作
    /// </summary>
    protected override void DoLerpPrepation()
    {
        base.DoLerpPrepation();
        mLerpType = ELerpType.LerpScale;
        mStartScale = transform.localScale;
    }

    /// <summary>
    /// 执行真实Lerp效果
    /// </summary>
    /// <param name="t">缓动进度(0-1)</param>
    protected override void DoRealLerp(float t)
    {
        transform.localScale = Vector3.LerpUnclamped(mStartScale, EndScale, t);
    }
}
  1. 透明度缓动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/// <summary>
/// AlphaLerpMono.cs
/// 透明度缓动组件
/// </summary>
[RequireComponent(typeof(Graphic))]
public class AlphaLerpMono : LerpBaseMono
{
    /// <summary>
    /// 结束透明度
    /// </summary>
    public float EndAlpha = 0.0f;

    /// <summary>
    /// Graphic组件
    /// </summary>
    protected Graphic mGraphicComponent;

    /// <summary>
    /// 开始透明度
    /// </summary>
    protected float mStartAlpha;

    /// <summary>
    /// 执行Lerp准备工作
    /// </summary>
    protected override void DoLerpPrepation()
    {
        base.DoLerpPrepation();
        mGraphicComponent = GetComponent<Graphic>();
        mStartAlpha = mGraphicComponent.color.a;
    }

    /// <summary>
    /// 执行真实Lerp效果
    /// </summary>
    /// <param name="t">缓动进度(0-1)</param>
    protected override void DoRealLerp(float t)
    {
        var oldcolor = mGraphicComponent.color;
        oldcolor.a = Mathf.Lerp(mStartAlpha, this.EndAlpha, t);
        mGraphicComponent.color = oldcolor;
    }
}

效果如下:

LerpScreenShort

通过上面可以看到我们已经实现了一个简陋版的不同Lerp效果的插值动画。

插值线性方程

接下来就要引入之前提到的线性方程了，从上面可以看出DoRealLerp里的参数t决定了缓动效果的最终进度值，现阶段t的值是通过世间累加然后Lerp插值到0-1的，也就是说是线性的速度。

1
var t = Mathf.InverseLerp(starttime, endtime, currenttime);

这里的线性速度换成线性方程的话，可以理解成y=x

y=x函数图

也就是说如果我们把t的变化速度函数修改成其他的线性方程，那就能达到同样的Lerp效果以不同的插值函数来表现。

让我们先通过easings.net来预览下插值函数大概长什么样:

EaseLerpFunction

这里核心思想是想替换t的插值计算方式，这里关于插值函数的代码就直接采用Github上现成的了:

EasingFunctions.cs

修改基类代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/// <summary>
/// Lerp挂载基类
/// </summary>
public class LerpBaseMono : MonoBehaviour {

    /// <summary>
    /// Lerp时长
    /// </summary>
    public float LerpDurationTime = 2.0f;

    /// <summary>
    /// 缓动类型
    /// </summary>
    public EasingFunction.Ease EaseType = EasingFunction.Ease.Linear;

    // Use this for initialization
    void Start () {
        StartCoroutine(LerpCoroutine());
    }

    /// <summary>
    /// 执行Lerp准备工作
    /// </summary>
    protected virtual void DoLerpPrepation()
    {

    }

    /// <summary>
    /// Lerp携程
    /// </summary>
    /// <returns></returns>
    protected IEnumerator LerpCoroutine()
    {
        DoLerpPrepation();
        var starttime = Time.time;
        var endtime = starttime + LerpDurationTime;
        while(Time.time < endtime)
        {
            DoLerp(starttime, endtime, Time.time);
            yield return null;
        }
        DoLerp(starttime, endtime, Time.time);
    }

    /// <summary>
    /// 执行Lerp
    /// </summary>
    /// <param name="starttime"></param>
    /// <param name="endtime"></param>
    /// <param name="currenttime"></param>
    protected virtual void DoLerp(float starttime, float endtime, float currenttime)
    {
        var t = Mathf.InverseLerp(starttime, endtime, currenttime);
        var easefunc = EasingFunction.GetEasingFunction(EaseType);
        t = easefunc(0, 1, t);
        //Debug.Log($"缓动类型:{this.EaseType}开始时间:{starttime}结束时间:{endtime}当前时间:{currenttime}当前缓动值:{t}");
        DoRealLerp(t);
    }

    /// <summary>
    /// 执行真实Lerp效果
    /// </summary>
    /// <param name="t">缓动进度(0-1)</param>
    protected virtual void DoRealLerp(float t)
    {

    }
}

这样一来我们就成功的替换了缓动的线性方程，且限定了缓动值t在0-1范围内，实现了不同缓动速度的t。

让我们来看看最终效果:

EasingFuncLerpPos

正如我们预期的那样，同样的终点和持续时间，三个不同缓动类型(线性方程)的移动插值，表现出了不一样的速度变化。

插值组件

上面我们的缓动组件已经雏形已经有了，接下来就是重新好好设计重构以下我们的缓动组件来达到通过挂在缓动组件能快速得到类似Dotween一样的代码效果。

用过Dotween都知道Dotween通过扩展方法的形式和泛型的形式，方便的支持了快速调用动画接口，接下来来看看Dotween几个大的概念设计：

Tweener是单个动画对象的抽象。

Sequence是多个动画Tweener的组合管理抽象。

所以借助于Tweener和Sequence再加上内部插值缓动的Ease的支持，能快速的触发各种缓动方程的动画组合拼接。

这里就不详细讲解Dotween的学习使用了，这里放一张官网Sequence的代码示例来感受一下，Dotween是如何快捷高效的支持多种缓动方程多个动画效果的编写的:

DotweenSequenceUsing

接下来参考Dotween的设计，我将动画组件UML设计如下:

TAnimationUML

编辑器面板扩展模拟播放:

InspectorSimulation

可以把上面的设计理解成组件版的简陋Dotween:

  • TBaseAnimation.cs

    所有插值动画的基类(抽象网络插值动画的流程以及基础支持),支持是否Awake时自动播放，插值类型，延迟时间，持续时间，循环类型设置等基础设置

  • TBaseAnimationEditor.cs

    插值动画自定义面板，核心扩展支持了Editor快速模拟播放，暂停，继续，停止按钮功能。

  • TSequenceAnimation.cs

    序列动画抽象,负责像Dotween的Sequence一样管理一系列TBaseAnimation的整体播放效果(比如线性播放和并发播放，目前仅支持单次或无限循环播放两种方式)

  • TSequenceAnimationEditor.cs

    序列动画的自定义面板，核心是通过SerializeObject和SerializeProperty编写支持Undo的自定义序列动画面板，同时支持了Editor快速模拟播放，暂停，继续，停止按钮功能。

  • EasingFunctions.cs

    Git上找的关于不同插值动画类型的核心函数方程定义,把时间插值比列通过不同的函数方程计算出不同的插值系数，从而实现不同的插值方程式的插值动画效果

  • TPositionAnimation.cs, TScaleAnimation.cs, TAlphaAnimation.cs ……

    落实到具体的插值动画类型的实现类

总结

  1. 通过起始时间，结束时间，当前时间我们可以计算出当前的插值比例。然后通过数学方程将插值比例使用不同的数学方程转换成我们不同插值类型的插值比例从而得到我们想要的不同函数插值效果。
  2. 组件式的插值动画相比之下没有纯代码(e.g. Dotween)那么高效和可控，但重用性高，方便快速制作简单的程序化动画。
  3. SerializeObject和SerializeProperty的使用就好比对象和反射属性之间的概念和关系，使用SerializeObject和SerilizeProperty能方便的使用Unity的Undo系统。

Git地址

Ease Component

Reference

Animation & Easing functions in Unity (Tween)

Easing functions

EasingFunctions GitHub

Dotween

DOTween 动画引擎仿写

线性代数

方程组的几何解释

线性代数与方程的关系（笔记）

LATEX

在线编写LateX网址

Latex数学公式编写介绍

WolframAlpha

By

前言

本篇文章是为了记录学习Unity官方最新推出的嵌套预制件工作流的相关知识，深入理解新版嵌套预制件的设计思路与使用工作流。

达到以下几个目标：

  1. 理解新版嵌套预制件带来的好处
  2. 如何避免Unity版本升级过程中预制件相关操作工具不兼容等问题。
  3. 设计新的预制件相关工具时考虑新老版本预制件工作流问题。

Prefab

首先我们先来了解下什么是预制件(Prefab)？
**Unity’s Prefab system allows you to create, configure, and store a GameObject complete with all its components, property values, and child GameObjects
as a reusable Asset. The Prefab Asset acts as a template from which you can create new Prefab instances in the SceneA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary.

根据官网的介绍我们可以得知，在Unity中Prefab和纹理，材质，音效一样都是一种资源格式，预制件(Prefab)其实是一个资源载体(e.g. GameObject包含层级以及多种Component脚本做成的重用实体对象)，为了方便重复使用做好的资源模版。

老版本预制件系统问题：

  1. 不支持嵌套预制件
  2. 不支持变体预制件(后续会介绍)

新版本预制件很好的解决了上面说到的两个问题。

新版预制件在Unity 2018.3推出
新版预制件主要由以下三个部分组成：

  1. 嵌套预制件
  2. 预制件变体
  3. 预制件模式

接下来挨个学习上面三个部分。

Note：
新版Prefab是一种Asset，但打开处理的时候更多的是一种对Content的封装的概念，打开Prefab Mode是指打开Prefab浏览编辑Prefab Content

嵌套预制件

嵌套预制件顾名思义是指预制件之间是允许引用使用的关系而不是完全独立复制使用的概念。
老版本预制件系统就是采用复制实体引用的方式。
而新版嵌套预制件是采用真实预制件引用的方式。

嵌套预制件举例说明：
预制件A里用到了预制件B，如果我们修改预制件B，那么预制件A应该是自动更新变化。

嵌套预制件实战：
如下所示，我们制作了三个预制件，分别是Prefab_Cube_A,Prefab_Sphere_B以及Prefab_A_And_B,其中前两者是独立的预制件，最后一个是使用前两个预制件拼接而成的新的预制件。
NestedPrefabExample

可以看到嵌套的预制件在新的预制件下是蓝色的(意味着是关联了特定预制件的意思)，为了验证嵌套预制件，我简单的修改Prefab_Cube_A颜色来达到实现我们预期的嵌套预制件是引用关系的验证：
NestedPrefabChangeMat
可以看到我们只修改了预制件Prefab_Cube_A的材质，但嵌套使用该预制件的Prefab_A_And_B里的Prefab_A也跟着变化了，这就是前面所提到的嵌套预制件的概念(嵌套引用关系而非实例化新个体)

预制件变体

预制件变体的概念类似于编程里继承的概念，继承属性的同时，父预制件的修改也会影响到子预制件变体。

预制件变体不仅继承了父预制件的状态数据，还跟父预制件是强制关联的。
举例说明：
通过预制件A创建预制件变体A2，当我们改变A时，A2继承的相同属性会跟着变化
NestedPrefabPrefabVariant
NestedPrefabChangeVariantParent

适用情况：

  1. 需要在个别Prefab基础上做少许做成预制件使用，同时需要同步父预制件修改的情况下。

Note:

  1. 预制件变体可以理解成封装了一层Prefab的Prefab Asset
  2. 预制件变体的Content根节点时Prefab而Prefab的Content根节点时GameObject

新版预制件工作流

Prefab有两种状态：

  1. Prefab Asset(Prefab资源)
  2. Prefab Instance(Prefab实例对象–场景里是蓝色的)
    Prefab Instance和Prefab Asset之间是关联着的，跟老版预制件里的概念是一致的。我们可以通过修改Prefab Instance然后把改变Apply到Prefab Asset上。新版预制件有区别的是支持Component级别的Apply和Revert。
    NestedPrefabComponentApply

还有一种独立于预制件的状态：实例对象
UnpackPrefabInstance
于预制件无关的实体对象是黑色的而非蓝色:
NestedPrefabUnpackPrefabColor
这里的Unpack相当于解除了Prefab Asset关联直接访问预制件的Content(Prefab Content后续会说到，在新版预制件里很重要的一个概念)

新版预制件有一个新的概念叫做预制件模式，修改并Apply修改到Prefab Asset上有两种方式：

  1. 直接打开Prefab Mode编辑
  2. 修改Prefab Instance后Apply到Prefab Asset上

这里重点讲解学习Prefab Mode：
Prefab Mode类似单独打开了一个修改预制件的场景，进入新的预制件场景才能看到预制件里的内容，这一点概念很重要
NestedPrefabOpenPrefabMode
NestedPrefabMode
在Prefab Mode下的修改可以通过保存和Undo操作来实现保存到Prefab Asset和撤销操作的效果。

了解了新版Prefab的Prefab Mode概念后，让我们结合相关API来制作一些新版Prefab的处理操作工具来深入理解：
需求：
检查指定Prefab里是否有无效的脚本挂在(Missing Script)并清除所有无效挂在脚本后保存Prefab Asset
NestedPrefabMissingScriptMono

相关API：

  1. AssetDatabase(处理Asset的工具类接口)
  2. Selection(处理Asset资源选中工具类接口)

步骤：

  1. 选中Prefab Asset
  2. 判定是否是选中Prefab Asset
  3. 打开Prefab Mode
  4. 查找并删除所有Missing Script
  5. 保存Prefab Asset并退出Prefab Mode
    实现：
    RemovePrefabMissingScriptTool.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// 删除预制件无效脚本引用工具
/// </summary>
public class RemovePrefabMissingScriptTool
{
    [MenuItem("Tools/Assets/移除Missing脚本 #&s", false)]
    public static void RemoveAllMissingScripts()
    {
        // 1. 选中Prefab Asset
        var selections = Selection.GetFiltered(typeof(Object), SelectionMode.Assets | SelectionMode.DeepAssets);
        Debug.Log($"选中有效数量:{selections.Length}");
        foreach (var selection in selections)
        {
            if(IsPrefabAsset(selection))
            {
                RemovePrefabAllMissingScripts(selection as GameObject);
            }
            else
            {
                Debug.LogError($"不符合预制件要求的Asset:{selection.name}");
            }
        }
        AssetDatabase.SaveAssets();
    }

    /// <summary>
    /// 是否是预制件资源
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    private static bool IsPrefabAsset(Object obj)
    {
        if(obj is GameObject)
        {
            var assetpath = AssetDatabase.GetAssetPath(obj);
            return !string.IsNullOrEmpty(assetpath);
        }
        else
        {
            return false;
        }
    }

    /// <summary>
    /// 移除预制件Asset所有无效的脚本
    /// </summary>
    private static void RemovePrefabAllMissingScripts(GameObject go)
    {
        // 3. 打开Prefab Mode
        // 4. 查找并删除所有Missing Script
        // 5. 保存Prefab Asset并推出Prefab Mode)
        var assetpath = AssetDatabase.GetAssetPath(go);
        var contentsRoot = PrefabUtility.LoadPrefabContents(assetpath);
        RemoveAllMissingScripts(contentsRoot);
        PrefabUtility.SaveAsPrefabAsset(contentsRoot, assetpath);
        PrefabUtility.UnloadPrefabContents(contentsRoot);
    }

    /// <summary>
    /// 移除无效的脚本
    /// </summary>
    private static void RemoveAllMissingScripts(GameObject go)
    {
        Component[] components = go.GetComponents<Component>();
        var r = 0;
        var serializedObject = new SerializedObject(go);
        var prop = serializedObject.FindProperty("m_Component");
        for (int i = 0; i < components.Length; i++)
        {
            if (components[i] == null)
            {
                string s = go.name;
                Transform t = go.transform;
                while (t.parent != null) 
                {
                    s = t.parent.name +"/"+s;
                    t = t.parent;
                }
                Debug.Log (s + " has an empty script attached in position: " + i, go);

                prop.DeleteArrayElementAtIndex(i - r);
                r++;
            }
        }
        serializedObject.ApplyModifiedProperties();
        foreach (Transform childT in go.transform)
        {
            RemoveAllMissingScripts(childT.gameObject);
        }
    }
}

核心思想是因为Missing Component本来就为Null无法向常规Component那样DestroyImmediate，需要通过SerializedObject去获取Component的方式删除指定位置的Component。

此脚本只针对单个预制件内容进行修改，嵌套预制件需要通过批量多选的方式实现各自移除各自身上的Missing Script来实现移除所有Missing脚本。

了解了Prefab Mode的存在，那么如何监听Prefab Mode的打开关闭生命周期了？
这里我们需要用到PrefabStage API(新版Prefab Mode下打开保存相关生命周期工具类接口)
这里只是简单的做个API实验，看看PrefabStage是否起作用。
PrefabStageListener.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using System.Collections;
using System.Collections.Generic;
using UnityEditor.Experimental.SceneManagement;
using UnityEngine;

/// <summary>
/// 新版预制件生命周期监听
/// </summary>
[ExecuteInEditMode]
public class PrefabStageListener : MonoBehaviour
{
    private void Start()
    {
        PrefabStage.prefabSaved += OnPrefabSaved;
        PrefabStage.prefabSaving += OnPrefabSaving;
        PrefabStage.prefabStageOpened += OnPrefabOpened;
        PrefabStage.prefabStageClosing += OnPrefabClosing;
    }

    private void OnDestroy()
    {
        PrefabStage.prefabSaved -= OnPrefabSaved;
        PrefabStage.prefabSaving -= OnPrefabSaving;
        PrefabStage.prefabStageOpened -= OnPrefabOpened;
        PrefabStage.prefabStageClosing -= OnPrefabClosing;
    }

    /// <summary>
    /// 响应预制件内容保存完毕
    /// </summary>
    /// <param name="go"></param>
    private void OnPrefabSaved(GameObject go)
    {
        Debug.Log("预制件内容保存完毕!");
    }

    /// <summary>
    /// 响应预制件内容保存
    /// </summary>
    /// <param name="go"></param>
    private void OnPrefabSaving(GameObject go)
    {
        Debug.Log("预制件内容保存!");
    }

    /// <summary>
    /// 响应预制件内容打开
    /// </summary>
    /// <param name="prefabstage"></param>
    private void OnPrefabOpened(PrefabStage prefabstage)
    {
        Debug.Log("打开预制件内容!");
        Debug.Log($"预制件:{prefabstage.prefabAssetPath} 内容阶段:{prefabstage.stageHandle}");
    }
    
    /// <summary>
    /// 响应预制件内容关闭
    /// </summary>
    /// <param name="prefabstage"></param>
    private void OnPrefabClosing(PrefabStage prefabstage)
    {
        Debug.Log("关闭预制件内容!");
        Debug.Log($"预制件:{prefabstage.prefabAssetPath} 内容阶段:{prefabstage.stageHandle}");
    }
}

结果:
PrefabStageListener
PrefabStage.prefabStageOpened全局监听不起作用(原因未知，忘知道的朋友告知)。PrefabStage.prefabStageClosing能正确工作。

Note:
Prefab Mode模式下修改叫做Save而非Apply，因为已经处于Prefab Content模式下了

进阶

PrefabUtility(操作处理Prefab的工具类接口)

更多学习，待续……

结论

  1. 支持嵌套预制件，能更高效的利用预制件，节约预制件的资源大小
  2. 支持预制件变体，能更高效的制作只有细微变化且有关联的相关预制件，增加开发效率
  3. 新版预制件最大区别就是提出了Prefab Mode的概念，让预制件在一个独立的环境进行编辑，进入Prefab Mode编辑的是Prefab Content而非Prefab本身。

引用

Prefabs Manual
详解新版Unity中可嵌套的Prefab系统
Introducing the new prefab workflow - Unity at GDC 2019
Unite LA 2018 - Introducing the New Prefab Workflow

By

前言

本篇文章是为了记录学习Unity官方一些好的第三方插件，作为基础的学习了解，为未来遇到问题思考解决方案时拓宽思路。

Sprite Atlas

依然从What，Why，How三个角度了学习了解Sprite Atlas。

What

Sprite Atlas是官方Sprite Packer的升级版本，是为了更好的解决图集打包加载问题而开发的，而图集是为了解决Draw Call问题。

Why

老版Unity的时候，图集打包功能(SpritePacker,打Tag的方式)并不完善，更多的是采用第三方好比TexturePacker打包图集在放到Unity项目里的工作流。

Sprite Atlas主要提供了以下三个功能:
1.创建、编辑图集以及设定图集参数
2.添加图集Variant（变种）
3.运行时访问图集

新版Sprite Atals已经很完善了，考虑到以下几个原因，决定学习官方的打包图集工具跟着官方走:

  1. TexturePacker是付费的,Sprite Atlas免费
  2. Sprite Atlas是官方的，跟官方走一般来说不会错
  3. Spritre Atlas已经成熟可以商用的级别

How

使用Sprite Atlas之前，我们需要打开Sprite Atlas功能开关：
Edit -> Project Setting -> Editor -> Sprite Packer -> Mode(Always Enable)
EnableSpriteAtlas

创建、编辑图集以及设定图集参数

在Sprite Atlas里Sprite Atlas是作为一种资源(Asset)存在。
创建Sprite Atlas：
右键 -> Sprite Atlas

选中创建的Sprite Atlas我们能看到相关设置:
SpriteAtlasSetting
这里的设置基本都和图集打包相关，这里就不一一详解了。
详情参见官网:
Sprite Atlas

点击Sprite Atlas -> Pack Preview即可查看打包后的结果:
PackPreview

这里关于Include in Build这个参数要详细说明一下，这个参数会决定一下几方面:

  1. 影响使用SpriteAtlas图集资源的资源是如何关联SpriteAtlas的(会决定使用该SpriteAtlas资源加载时加载哪一个图集资源–这里指的是有图集Variant的情况)
  2. 影响SpriteAtlas是否需要采用Later Bind(触不触发SpriteAtlasManager.atlasRequested接口,通过这个接口结合图集Variant我们可以做到例如不同平台加载不同图集的适配)。反之勾选Include in Build在依赖使用时会自动加载依赖的Sprite Atlas。
    这里貌似有些Unity版本有个Bug，勾选Include in Build会导致资源打包冗余
    IncludeInBuildCauseRedundancySpriteAtlasTexture

针对第一条详情参考:
Resolving different Sprite Atlas scenarios

Note:

  1. Sprite Atlas支持Objects for Packing设置文件夹
  2. 参与打包的图片必须设置成Sprite(2D and UI)格式
  3. Include in Build会影响SpriteAtlas的选择(比如是否要使用Later Bind等)

添加图集Variant（变种）

什么是图集Variant?
A Variant Sprite Atlas is a type of Sprite Atlas that does not contain its own list of selected Textures as it has no Objects for Packing list in its properties. Instead, it receives a copy of the content from the Sprite Atlas set as its Master Atlas.
图集Variant是指不能指定打包内容的图集，图集Variant内容来源于复制指定的Master图集。

图集Variant的适用场景?
图集Variant的主要目的是为了用于不同分辨率设备适配不同图集来实现，内存和效果的可控。

图集Variant设置适用：
SpriteAtlasVariants
可以看到我们创建一个SpriteAtlas把Type设置成Variant后，然后指定Master Atlas，最后通过调节Scale为0.5我们得到了比playerpreview图集小一倍大小的图集效果。

结论:

图集变体是类似Mipmap的东西，通过多打包多个不同大小的图集到游戏里，Unity自动帮我们选择合适的图集来加载，从而做到高分辨率机型加载高分辨率的，低分辨率机型加载低分辨率的，典型的空间换时间做法。

Note:

  1. 要想只打包使用图集Variant，需要把图集Variant的Include in Build打开，把图集Master的Include in Build关闭

运行时访问图集

Sprite Atlas作为一种资源开放给用户，支持在脚本中直接访问，还可以通过名字获取图集中的精灵。

这里我们采用设置不勾选Include in Build的设置打包SpriteAtlas

接下来我们通过SpriteAtlas接口访问打包AB后的Sprite Atlas里的图片资源试试：
首先让我们看看SpriteAtlas打包AB后的的资源数据：
SpriteAtlasAssetBundlePreview
可以看到SpriteAtlas作为资源参与AB打包，里面包含了SpriteAtlas，图集Texture2D以及Sprite数据。

这里我们看看UI预制件引用SpriteAtlas看看依赖打包的情况：
UIPrefabReferenceNotIncludeBuildSpriteAtlas
从上面可以看出UI窗口预制件包含了依赖的Sprite(这里和以前不一样，以前是不会包含依赖的Sprite的，会直接通过依赖关系加载依赖AB实现自动还原)，个人猜测这个和后续讲到的SpriteAtlas的Later Bind有关。

加载UI窗口预制件后发现Sprite Missing了:
UIPrefabSpriteMissing
通过查看依赖文件我发现依赖信息是没有对SpriteAtlas的依赖信息的。不知道这算不算是一个Bug还是设计如此，因为没有依赖信息对资源加载管理会造成问题，忘知道的朋友告知。
UIPrefabDepencency

问题:

  1. 加载使用SpriteAtlas的UI Prefab，SpriteAtlas会自动加载进内存且没有依赖信息。但如果此时主动加载了Sprite Atlas并主动强制卸载该Sprite Atlas的AB会导致UI Prefab使用的Sprite Atlas也跟随被清除。从这里看出UI Prefab对Sprite Atlas的依赖信息是有必要的，不然没法正确的管理资源加载。

这里引申出了SpriteAtlas一个很重要的功能，Later Bind

Note:

  1. 图集的被动(依赖)加载管理会有使用该图集的资源所决定(比如UI Prefab使用了SpriteAtlas，两个分别打包AB，这时加载UI Prefab后SpriteAtlas会自动加载进内存，而UI Prefab卸载以后，SpriteAtlas没有其他主动加载该SpriteAtlas的会自动卸载。)
Later Bind

SpritePacker时代“图集”我们是看不到的，因为设计者的初衷是想让开发者完全不用考虑图集的事。但是，这跟游戏开发时的动态加载图集时矛盾的！我们要动态加载就必须要知道atlas名字和sprite名，这样才能在 运行时动态的找到一张sprite！所以U3D程序员必须要清楚的知道你当前界面用的是哪atlas的哪个sprite。但是按照SpritePacker的做法他的初衷应该是想把图集干掉（干掉的意思让开发者不用关心），只需要考虑sprite即可，但是这是行不通的！
**SpriteAtlas其实就是为了解决上面说的问题而发布的功能。通过它我们可以将atlas和UIprefab“解耦”。同时，在Unity编辑器状态下我们仍然可以利用未打成SpriteAtlas的Sprite进行开发。等开发完成我们再发布成SpriteAtlas。**Unity提供了所谓“延迟绑定”（late bind）的技术来让我们实现这个功能。

AtlasManager.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class AtlasManager : SingletonTemplate<AtlasManager>
{
    public AtlasManager()
    {
        DIYLog.Log("添加SpriteAtals图集延时绑定回调!");
        SpriteAtlasManager.atlasRequested += onAtlasRequested;
    }

    /// <summary>
    /// 响应SpriteAtlas图集加载回调
    /// </summary>
    /// <param name="atlasname"></param>
    /// <param name="callback"></param>
    private void onAtlasRequested(string atlasname, Action<SpriteAtlas> callback)
    {
        DIYLog.Log($"加载SpriteAtlas:{atlasname}");
        // Later Bind -- 依赖使用SpriteAtlas的加载都会触发这里
        ResourceModuleManager.Singleton.requstResource(
        atlasname,
        (abi) =>
        {
            DIYLog.Log($"Later Bind加载SpriteAtlas:{atlasname}");
            var sa = abi.loadAsset<SpriteAtlas>(atlasname);
            callback(sa);
        });
    }

    ******
}

在加载使用SpriteAtlas(仅当设置成不勾选Include in Build)的相关资源时(比如UI Prefab)上诉回调会被触发完成对SpriteAtlas的加载，确保引用的Sprite能正确显示。同时这一机制就允许我们做到不同平台的不同图集资源加载适配这样的功能。

疑问:

  1. Later Bind只是加载SpriteAtlas提供的一个回调接口(无论是主动还是被动(依赖)加载)，回调接口内只知道加载了指定的SpriteAtlas却不知道具体的详细用法，这样一来基于对象绑定和索引计数的资源管理系统就无法正确的加载管理了(因为被动(依赖)加载得不到SpriteAtlas的依赖信息)。

个人方案：

  1. 当前这套基于对象绑定和索引计数的方案暂时没想到好的方案，可能需要对SpriteAtals的资源管理单独做一套管理策略来支持Later Bind的用法。有更好方案的朋友，望告知。
注意事项
  1. 开启Sprite Packer的设置Sprite Packer -> Mode(Always Enable)只决定图集合成时机(比如是运行时还是打包时还是编辑器时)。
  2. Sprite Atlas支持Objects for Packing设置文件夹
  3. 参与打包的图片必须设置成Sprite(2D and UI)格式
  4. Include in Build会影响SpriteAtlas图集资源的资源是如何关联SpriteAtlas(比如影响是否需要使用Later Bind,不勾选需要使用Later Bind否则会报警告)
相关概念
  1. Sprite Atlas把图集打包的概念延迟到特定时刻(比如打包或者打包AB)而编辑模式依然可以使用原始Sprite工作，总的来说就是延时自动化打包图集时机+允许使用原始Sprite的概念。
  2. Include in Build设置主要是看有没有动态适配加载图集需求，有的话就建议不勾选，然后结合Later Bind来做动态图集加载适配。反之勾选Include in Build在依赖使用时会自动加载依赖使用的Sprite Atals。
  3. Include in Build其次还会影响Sprite Atlas变体使用的选择。
  4. SpriteAtlas到了Unity 2018 LTS版本感觉才稳定些，建议使用稳定版本的SpriteAtlas
  5. Later Bind不会区分主动加载还是被动(依赖)加载SpriteAtlas,都会统一回调，要使用Later Bind机制的需要取消勾选Include in Build并解决SpriteAtlas的资源加载管理问题(在沿用原来的对象绑定和索引计数的资源管理方案基础上本人暂时没有好的方案)
  6. Sprite Atlas无论够不够选Include in Build打包AB都得不到Sprite Atlas的依赖信息，感觉这是一个bug
Bug记录
  1. 勾选Include in Build会导致资源打包冗余(部分Unity版本比如Unity2018.4.1f1)，建议升级到LTS版本
结论

SpriteAtlas虽然解决了Atlas和UIPrefab的解耦，同时提供了图集变体的概念来解决适配图集适配方案，但也带来了一些新的问题要解决(e.g. 要解决没有依赖信息的SpriteAtals基础上做到正确的资源加载管理)。

——————————–2021/20/12更新开始————————————–

正确使用姿势参考：

【Unity游戏开发】SpriteAtlas与AssetBundle最佳食用方案

简单来说:

  1. SpriteAtlas 勾选Include in build
  2. SpriteAtlas不设置AB打包
  3. 直接当做单Sprite一样加载

——————————–2021/20/12更新结束————————————–

Timeline

Timeline to create cinematic content, game-play sequences, audio sequences, and complex particle effects.

官方介绍Timeline可以用于制作类似电影过场表现的工具。

Timeline分为两个部分：

  1. Timeline Asset(数据)
  2. Timeline instance(数据关联实体对象)

Timeline Asset

介绍

Timeline Asset: Stores the tracks, clips, and recorded animations without links to the specific GameObjects being animated.

通过介绍可以看出Timeline Asset是类似于Animation Clip一样的资源文件可以用于录制动画但不需要关联到特定的物体上

Timeline Asset记录的动画数据是以子节点资源的形式挂载在Timeline Asset下的：

TimelineAssetHierachy

Note:
前面说的不需要关联到特定的物体上是指不需要像AnimationClip那样动画是针对指定物体制作的(挂给其他物体用不了该动画)，Timeline可以通过PlayableDirector动态关联动画对象。

分类

Timeline Asset是以Track为最小单位。

主要支持以下几种Track:

  1. Track Group(仅分层管理用)
  2. Activation Track(激活物体Track)
  3. Animation Track(动画Track)
  4. Audio Track(音频Track)
  5. Control Track(时间相关的控制)
  6. Playable Track(自定义Track)

TimelineComponent

这里我们着重学习Playable Track,自定义的一些表现行为都是通过Playable Track来做的。其他几个就不一一讲解了。

Playable Track

自定义Playable Track需要知道两个东西：

  1. PlayableAsset(用于支持Timeline创建和显示自定义PlayableAsset数据定义)
  2. PlayableBehaviour(用于Playable实际的生命周期等逻辑实现)

示例:

1
2
3
4
5
// 枚举事件定义
public enum EEventId
{
    DefaultEvent = 1,				// 默认事件
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/// <summary>
/// 事件分发器Asset
/// </summary>
[System.Serializable]
public class EventDispatcherAsset : PlayableAsset
{
    /// <summary>
    /// 事件
    /// </summary>
    public EEventId EventId = EEventId.DefaultEvent;

    // Factory method that generates a playable based on this asset
    public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
    {
        var playable = ScriptPlayable<EventDispatcherPlayable>.Create(graph);
        playable.GetBehaviour().EventId = EventId;
        return playable;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/// <summary>
/// 事件分发器Playable
/// </summary>
public class EventDispatcherPlayable : PlayableBehaviour
{
    /// <summary>
    /// 事件
    /// </summary>
    [Header("事件")]
    public EEventId EventId = EEventId.DefaultEvent;

    // Called when the owning graph starts playing
    // Playable开始执行时
    public override void OnGraphStart(Playable playable)
    {

    }

    // Called when the owning graph stops playing
    // Playable停止执行时
    public override void OnGraphStop(Playable playable)
    {

    }

    // Called when the state of the playable is set to Play
    // 触发Playable执行时
    public override void OnBehaviourPlay(Playable playable, FrameData info)
    {
        Debug.Log(string.Format("OnBehaviourPlay() 分发事件 : {0}", EventId));
    }

    // Called when the state of the playable is set to Paused
    // Playable暂停执行时
    public override void OnBehaviourPause(Playable playable, FrameData info)
    {

    }

    // Called each frame while the state is set to Play
    // Playable更新执行时
    public override void PrepareFrame(Playable playable, FrameData info)
    {

    }
}

TimelineCustomPlayable

代码不复杂就不详细介绍了。通过上面的代码，我们支持了一个创建自定义分发事件的Playable Track，而这个自定义的事件分发就可以用作我们Timeline和游戏逻辑之间的一个桥梁，帮助我们在Timeline播放的过程中自定义响应做一些表现。

Timeline instance

介绍

Timeline instance: Stores links to the specific GameObjects being animated or affected by the Timeline Asset. These links, referred to as bindings, are saved to the Scene.

要想关联场景物体和Timeline Asset让我们制作的电影过场动起来，我们需要创建Timeline instance(这里指的Playable Director组件)。

TimelinePlayableDirectorInspector

可以看到我们通过Timeline Asset录制的动画是通过Playable Director的Bindings动态关联到了场景物体上。

Note:
因为Timeline Asset是纯数据，Timeline instance决定了数据关联的对象，所以我们可以重用Timeline Asset对不同的物体做动画表现。

Timeline类设计

Playable

The Playables API provides a way to create tools, effects or other gameplay mechanisms by organizing and evaluating data sources in a tree-like structure known as the PlayableGraph. The PlayableGraph allows you to mix, blend, and modify multiple data sources, and play them through a single output.

从介绍个人的理解，Playable是一套可自定义数据处理流程成树状结构的工具。而自定义出来的树状结构数据就叫做PlayableGraph(后续会讲到)。而Timeline的核心正是Playable。

使用Playables API的好处:

  • The Playables API allows for dynamic animation blending. This means that objects in the scenes
    could provide their own animations. For example, animations for weapons, chests, and traps could be dynamically added to the PlayableGraph and used for a certain duration.
  • The Playables API allows you to easily play a single animation without the overhead involved in creating and managing an AnimatorController asset.
  • The Playables API allows users to dynamically create blending graphs and control the blending weights directly frame by frame.
  • A PlayableGraph can be created at runtime, adding playable node as needed, based on conditions. Instead of having a huge “one-size-fit-all” graph where nodes are enabled and disabled, the PlayableGraph can be tailored to fit the requirements of the current situation.

官网上介绍了Playable的不少好处，从介绍可以看出最大的好处就是运行时自定义组装数据处理流程，避免离线构建一套过于臃肿的数据定义(比如AnimatorController)

Note:

  1. Playable是Struct而非Class，为了避免内存分配导致GC
  2. Playable和PlayableOutput没有提供太多方法，而是通过PlayableExtension和PlayableOutputExtension用扩展方法的方式来提供的方法

PlayableGraph

The PlayableGraph defines a set of playable outputs that are bound to a GameObject or component. The PlayableGraph also defines a set of playables and their relationships. Figure 1 provides an example.

The PlayableGraph is responsible for the life cycle of its playables and their outputs. Use the PlayableGraph to create, connect, and destroy playables.

从上面的介绍，个人理解，PlayableGraph是一个自定义数据处理流程的完整单位，负责自定义数据处理流程里的节点定义，关联，以及生命周期。PlayableGraph是由Plyable(e.g.Playable,MixPlayable)+PlayableOuput组成。

PlayableAsset

A base class for assets that can be used to instantiate a Playable at runtime.

PlayableAsset是自定义Playable时定义数据Asset的基类。

PlayableBehaviour

PlayableBehaviour is the base class from which every custom playable script derives.

PlayableBehaviour是自定义Playable时定义行为实现的脚本基类。

PlayableOutput

个人理解是定义Playable里面的输出节点。所有的输入节点最后连接成树状结构后连到输出节点上，执行出自定义行为的输出表现。

参考下图:

PlayableOutputPreview

PlayableBinding

Struct that holds information regarding an output of a PlayableAsset. PlayableAssets specify the type of outputs it supports using PlayableBindings.

看介绍PlayableBinding是用于定义并持有PlayableAsset的数据输出信息。

ExposedReference

Creates a type whos value is resolvable at runtime. ExposedReference is a generic type that can be used to create references to Scene objects and resolve their actual values at runtime and by using a context object. This can be used by assets, such as a ScriptableObject or PlayableAsset to create references to Scene objects.

从介绍可以看出，ExposedReference是用于创建一个类型(其值在运行时处理绑定的)。用于解决PlayableAsset引用场景对象组件数据等问题。

辅助工具(GraphVisualizer)

The PlayableGraph Visualizer is a tool that displays the PlayableGraphs in the scene. It can be used in both Play and Edit mode and will always reflect the current state of the graph.

因为Playable的设计很庞大，里面有很多类和概念，为了方便理解Playable设计和使用可视化的查看构建出来的PlayableGraph显得额外有用，而PlayableGraph Visualizer正是这么一款工具。

接下来我们结合GraphVisualizer动态通过代码创建模拟用Playable API实现动画Animator Controller里的动画状态机类似的效果，从而深入学习理解Playable里各个类的设计和使用。

单AnimationClip单AniamtionOuput的动画播放
1
2
3
4
5
6
7
8
9
10
// 创建动画播放PlayableGraph
mCustomGraph = PlayableGraph.Create("DIYAnimationPlayableGraph");
// 创建动画播放PlyableGraph的PlayableOutput
var animoutput = AnimationPlayableOutput.Create(mCustomGraph, "AnimationOutput", CustomAnimator1);
// 创建动画播放PlyableGraph的动画Playable
var animationclipplayable = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip1);
// 设置动画播放PlayableOutput的关联Playable
animoutput.SetSourcePlayable(animationclipplayable);
// 播放创建的PlayableGraph
mCustomGraph.Play();

通过上面的代码我们动态创建了1个PlayableGraph，1个动画Plyable，1个动画PlayableOutput作为动画播放输出，并设置他们之间的关联，运行代码打开PlayableGraphVisualizer就可以查看到生成的单动画Clip播放PlayableGraph图了。

PlayableGraphVisualizerPreview

多AnimationClip混合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 创建动画播放PlayableGraph
mCustomGraph = PlayableGraph.Create("DIYAnimationPlayableGraph");
// 创建动画播放PlyableGraph的PlayableOutput
var animationOutput = AnimationPlayableOutput.Create(mCustomGraph, "AnimationOutput", CustomAnimator1);
// 创建动画播放混合Playable(设置两个输入Playable)
mAnimationMixerPlayable = AnimationMixerPlayable.Create(mCustomGraph, 2);
// 关联动画混合Playable到PlaybleOutput作为唯一输入
animationOutput.SetSourcePlayable(mAnimationMixerPlayable);
// 创建动画播放PlyableGraph的动画播放Playable1和Playable2
var animationClipPlayable1 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip1);
var animationClipPlayable2 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip2);
// 关联动画播放Playable1和Playable2作为动画混合Playable的输入连接(分别连接输入0和输入1接口)
mCustomGraph.Connect(animationClipPlayable1, 0, mAnimationMixerPlayable, 0);
mCustomGraph.Connect(animationClipPlayable2, 0, mAnimationMixerPlayable, 1);
// 播放创建的PlayableGraph
mCustomGraph.Play();

通过上面的代码我们动态创建了一个PlayableGraph，2个动画Plyable作为基础输入，1个动画混合Playable作为混合节点，1个动画PlayableOutput作为动画播放输出，并设置他们之间的关联，运行代码打开PlayableGraphVisualizer就可以查看到生成的动画混合播放PlayableGraph图了。

AnimationClipMixPreview

多AnimationClip多AnimationOuput

一个PlayableGraph是可以拥有多个PlayableOutput输出的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 创建动画播放PlayableGraph
mCustomGraph = PlayableGraph.Create("DIYAnimationPlayableGraph");
// 创建动画播放PlyableGraph的PlayableOutput1和PlayableOutput2
var animationOutput1 = AnimationPlayableOutput.Create(mCustomGraph, "AnimationOutput1", CustomAnimator1);
var animationOutput2 = AnimationPlayableOutput.Create(mCustomGraph, "AnimationOutput2", CustomAnimator2);
// 创建动画播放PlyableGraph的动画播放Playable1和Playable2
var animationClipPlayable1 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip1);
var animationClipPlayable2 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip2);
// 关联动画播放Playable1到动画播放PlaybleOutput1
// 关联动画播放Playable2到动画播放PlaybleOutput2
animationOutput1.SetSourcePlayable(animationClipPlayable1);
animationOutput2.SetSourcePlayable(animationClipPlayable2);
// 播放创建的PlayableGraph
mCustomGraph.Play();

通过上面的代码我们动态创建了一个PlayableGraph，2个动画Plyable对应2个动画PlayableOutput动画播放输出的输入，并设置他们之间的关联，运行代码打开PlayableGraphVisualizer就可以查看到生成的动画混合播放PlayableGraph图了。

MultipleAnimationInputAndOutputPreview

多AnimationClip混合并控制权重加播放状态

不同的Playable是可以设置混合权重加播放状态的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 创建动画播放PlayableGraph
mCustomGraph = PlayableGraph.Create("DIYAnimationPlayableGraph");
// 创建动画播放PlyableGraph的PlayableOutput
var animationOutput = AnimationPlayableOutput.Create(mCustomGraph, "AnimationOutput1", CustomAnimator1);
// 创建动画混合Playable
mAnimationMixerPlayable = AnimationMixerPlayable.Create(mCustomGraph, 2);
// 设置动画混合Playalbe作为动画播放输出Playable
animationOutput.SetSourcePlayable(mAnimationMixerPlayable);
// 创建动画播放PlyableGraph的动画播放Playable1和Playable2
var animationClipPlayable1 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip1);
var animationClipPlayable2 = AnimationClipPlayable.Create(mCustomGraph, CustomAnimationClip2);
// 设置动画混合输入和权重
mCustomGraph.Connect(animationClipPlayable1, 0, mAnimationMixerPlayable, 0);
mCustomGraph.Connect(animationClipPlayable2, 0, mAnimationMixerPlayable, 1);
mAnimationMixerPlayable.SetInputWeight(0, 1.0f);
mAnimationMixerPlayable.SetInputWeight(1, 1.0f);
// 暂停动画播放Playable1
animationClipPlayable1.Pause();
// 播放创建的PlayableGraph
mCustomGraph.Play();

通过上面的代码我们动态创建了一个PlayableGraph，2个动画Plyable作为动画混合Playable的输入,1个动画混合Playable作为动画播放输出的输入,1个PlayableOutput作为动画播放输出，并设置他们之间的关联和权重，并把其中一个动画播放Playable设置成暂停状态，运行代码打开PlayableGraphVisualizer就可以查看到生成的动画混合播放PlayableGraph图了。

MultipleAnimationBlendAndSetPlayableState

Note:

  1. 父Playable的播放状态设置会影响所有子节点Playable播放状态

Timeline实战

通过上面有了基础的知识后，接下来我们以实战的方式深入学习Timeline。

  • 目标
  1. 人物模型移动(Timeline自带)+人物模型动画播放(Timeline自带)+镜头移动(Cinemachine+Timeline)+2D对话+3D气泡对话的剧情表现+特效播放(Timeline自带)+音乐播放控制(扩展自定义Track，方便走自己的音效播放接口)
  2. 支持Timeline Editor拖拽预览+运行时播放预览
  • 功能开发
  1. 音乐播放控制(扩展自定义Track，方便走自己的音效播放接口)
  2. Timeline模型移动控制Track(TimeLine支持)
  3. 学习Cinemachine扩展Timeline的Track使用控制镜头移动表现
  4. 实现2D气泡对话+3D对话功能
  5. 扩展Timneline实现2D气泡对话Track+3D对话Track
  6. 动态创建实体对象的自定义Track绑定控制(如何实现?)
  • 准备工作
  1. Package Manager里安装Cinemachine模块
  2. 下载导入模型特效音效等相关资源

安装好Cinemachine后，打开Timeline里面就会看到多了Cinemachine的Track，从而就可以在Timeline里使用Cinemachine相关的扩展功能了:

TimelineCinemachineTrack

首先我们先放一下我们自定义制作的Timeline的预制件结构:

CustomTimelinePrefabHierachyPreview

音乐播放控制Track

CustomAduioTrack.cs(自定义音乐播放Track)

1
2
3
4
5
6
7
8
9
/// <summary>
/// CustomAudioTrack.cs
/// 自定义音效Track
/// </summary>
[TrackClipType(typeof(CustomAudioAsset))]
public class CustomAudioTrack : PlayableTrack
{

}

CustomAudioAsset.cs(自定义音乐播放Asset数据结构)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/// <summary>
/// CustomAudioAsset.cs
/// 自定义音效播放Asset
/// </summary>
public class CustomAudioAsset : BaseGameAsset, ITimelineClipAsset
{
    /// <summary>
    /// 音效类型
    /// </summary>
    public enum AudioType
    {
        Bgm = 1,            // 背景音乐
        Sound = 2,          // 音效
    }

    /// <summary>
    /// 音效播放组件
    /// </summary>
    public ExposedReference<AudioSource> SourceAudio;

    /// <summary>
    /// 播放的音效类型
    /// </summary>
    public AudioType PlayedAudioType = AudioType.Bgm;

    /// <summary>
    /// 音效资源路径
    /// </summary>
    public string AudioPath;
    
    /// <summary>
    /// 不支持重叠
    /// </summary>
    public ClipCaps clipCaps
    {
        get { return ClipCaps.None; }
    }

    public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
    {
        var playable = ScriptPlayable<CustomAudioBehaviour>.Create(graph);
        var audiobehaviour = playable.GetBehaviour();
        audiobehaviour.Name = Name;
        audiobehaviour.SourceAudio = SourceAudio.Resolve(graph.GetResolver());
        audiobehaviour.PlayedAudioType = PlayedAudioType;
        audiobehaviour.AudioPath = AudioPath;
        return playable;
    }
}

CustomAudioBehaviour.cs(自定义音乐播放行为)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/// <summary>
/// CustomAudioBehaviour.cs
/// 自定义音效播放Behaviour
/// </summary>
public class CustomAudioBehaviour : BaseGameBehaviour
{
    /// <summary>
    /// 音效播放组件
    /// </summary>
    public AudioSource SourceAudio;

    /// <summary>
    /// 播放的音效类型
    /// </summary>
    public CustomAudioAsset.AudioType PlayedAudioType;

    /// <summary>
    /// 音效资源路径
    /// </summary>
    public string AudioPath;

    /// <summary>
    /// 是否正在播放音乐
    /// </summary>
    private bool mIsPlayingAudio;
    
    public override void OnBehaviourPlay(Playable playable, FrameData info)
    {
        Debug.Log($"AudioBehaviour:OnBehaviourPlay() 执行指令:{Name}");
    }

    // Called each frame while the state is set to Play
    // Playable更新执行时
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
		TryPlayAudio();
    }

    // Called when the state of the playable is set to Paused
    // Playable暂停执行时
    public override void OnBehaviourPause(Playable playable, FrameData info)
    {
        Debug.Log($"AudioBehaviour:OnBehaviourPause() 执行指令:{Name}");
        if(SourceAudio != null && SourceAudio.clip != null)
        {
            SourceAudio.clip = null;
        }
        mIsPlayingAudio = false;
    }
    
    /// <summary>
    /// 尝试执行音乐播放
    /// </summary>
    private void TryPlayAudio()
    {
        if(mIsPlayingAudio == false && SourceAudio != null)
        {
            if (PlayedAudioType == CustomAudioAsset.AudioType.Bgm)
            {
                // TODO: 走背景音乐播放接口
                SourceAudio.clip = Resources.Load<AudioClip>(AudioPath);
                SourceAudio.Play();
            }
            else if (PlayedAudioType == CustomAudioAsset.AudioType.Sound)
            {
                // TODO: 走音效播放接口
                SourceAudio.clip = Resources.Load<AudioClip>(AudioPath);
                SourceAudio.Play();
            }
            mIsPlayingAudio = true;
        }
    }
}

接下来看下我们自定义的音效播放Track和音乐Asset的使用面板效果:

CustomAudioTrackPreview

CustomAudioAssetBGMInspector

CustomAudioAssetSoundInspector

从上面可以看到，我们通过ExposedReference的方式，挂载绑定了场景里的AudioSource作为背景音乐和音效播放组件。

接下来为了避免每一个CustomAudioAsset都自己去指定AudioSource绑定组件，我们可以通过在CustomAudioTrack来支持在Track统一指定AudioSource。

CustomAudioTrack.cs

1
2
3
4
5
6
7
8
9
10
/// <summary>
/// CustomAudioTrack.cs
/// 自定义音效Track
/// </summary>
[TrackClipType(typeof(CustomAudioAsset))]
[TrackBindingType(typeof(AudioSource))]
public class CustomAudioTrack : PlayableTrack
{

}

CustomAudioBehaviour.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/// <summary>
/// CustomAudioBehaviour.cs
/// 自定义音效播放Behaviour
/// </summary>
public class CustomAudioBehaviour : BaseGameBehaviour
{
    ******
        
    /// <summary>
    /// 音效播放组件
    /// </summary>
    private AudioSource mSourceAudio;

    // Called each frame while the state is set to Play
    // Playable更新执行时
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        if(mSourceAudio == null)
        {
            mSourceAudio = playerData as AudioSource;
        }
        TryPlayAudio();
    }
    
	******
}

CustomAudioTrack通过声明TrackBindingType(typeof(AudioSource))指定Track可以绑定AudioSource组件。

CustomAudioBehaviour通过在运行时ProcessFrame里动态使用Track上指定的AudioSource组件作为音乐播放组件来实现CustomAudioBehaviour采用Track统一绑定组件的的效果。

CustomAudioTrackWithAudioSourceBindingPreview

进阶

Unity使用Cinemachine和Timeline入门
Cinemachine and Timeline

Cinemachine

Timeline可以看做是自定义展示效果的工具，而Cinemachine可以看做是多摄像机的一套完整控制表现的工具。

更多的Cinemachine学习见后面

Cinemachine

Powering cameras for films and games

根据官网的简单介绍可以看出，Cinemachine是官方出的一款摄像机强大的控制系统，通过该系统，我们可以轻松的做到电影或者游戏级别的摄像机功能以及表现。

博主这里考虑学习使用Cinemachine的一个重大原因是，做赛车游戏，希望有一个稳定(不抖动)跟随的摄像机。(自己写的效果有抖动问题)

Cinemachine里有两个重要的组件和概念:

  1. Cinemachine Brain
  2. Virtual Cameras

Cinemachine Brain

The Cinemachine Brain is a component in the Unity Camera itself. Cinemachine Brain monitors all active Virtual Cameras in the Scene. To specify the next live Virtual Camera, you activate or deactivate the desired Virtual Camera’s game object.

从上面的介绍可以看出，Cinemachine Brain组件式挂载在摄像机对象上的一个组件，负责管理所有Virual Camera，同一时间只有一个Virtual Camera起作用用于主摄像机，优先选择Priority高的已激活Virutal Camera作为当前起作用的摄像机，优先级相同的情况下看哪个Virtual Camera后激活优先。

CinemachineBrain

关于Cinemachine Brain的详细参数介绍，这里就不深入探讨了，感兴趣的朋友参考文档去自行了解。

Note:

  1. Timeline重写了Cinemachine Brain的Priority系统可以更好的控制摄像机达到更精准的摄像机控制。

Virtual Cameras

Cinemachine does not create new cameras. Instead, it directs a single Unity camera for multiple shots. You compose these shots with Virtual Cameras. Virtual Cameras move and rotate the Unity camera and control its settings.

从上面的介绍可以知道，Cinemachine里的Virtual Cameras并非真正的Camera组件，而是一个抽象概念，而这个抽象的Virtuel Cameras会去负责控制真正的摄像机达到预定的效果。

每一个Virtual Cameras都会对应一个GameObject和一个CinemachineVirtualCamera组件脚本:

CinemachineVirtualCamera

Virtual Camera States

Virtual Camera有三种状态:

  1. Live:The virtual camera is actively controlling the Unity Camera. The virtual camera is tracking its targets and being updated every frame.
  2. Standby: The virtual camera is tracking its targets and being updated every frame, but no Unity Camera is actively being controlled by it. This is the state of a virtual camera that is enabled in the scene but perhaps at a lower priority than the Live virtual camera.
  3. Disabled: The virtual camera is present but disabled in the scene. It is not actively tracking its targets and so consumes no processing power. However, the virtual camera can be made live from the Timeline.

从介绍可以看到Live是指当前Virtual Camera优先级最高起作用的那个。而Standby是优先级低于当前起作用的Virtual Camera但没有Disable的Virtual Camera，这些摄像机逻辑上依然会更新跟随自己设定的对象，但不会影响真实摄像机运作。最后Disabled是即低于当前最高优先级Virtual Camera也没有激活的Virtual Camera，这类摄像机不会有任何运行开销，逻辑层面也不会在继续跟随自己的目标对象。

Virtual Camera Params

关于Virtual Camera的细节参数学习，接下来学习几个重要的参数，更多的细节参考:

Cinemachine overview

Priority正如前面提到的，决定了Virtual Camera在Cinemachine Brain里的选择优先级。

Follow和Look At两个参数分别决定了摄像机的跟随对象和对焦对象，这两个参数是常规游戏类型里都需要的概念，好比博主当前要做的赛车游戏，Follow和Look At对象都是赛车就能做到跟随和聚焦赛车的效果。

Body属性提供了Virtual Camera对于摄像机移动的算法选择，从而达到适配各种游戏类型的摄像机镜头移动要求。

CinemachineBodyProperties

这里博主的赛车游戏默认选择Transposer来达到平滑跟随效果。

Aim属性提供了Virtual Camera对于佘香即旋转的算法选择，从而达到适配各种游戏类型的摄像机镜头选择要求。

CinemachineAimProperties

Body和Aim通过细节的参数调整能实现各种角度以及各种游戏类型需求的摄像机跟随聚焦效果，这里博主暂时就不深入学习讨论了，有兴趣的可以参考文档去了解细节。

那么Virtual Camera的聚焦效果是如何实现的了？

了解聚焦效果之前有几个重钙的概念需要了解:

  1. Dead zone: The area of the frame that Cinemachine keeps the target in.

  2. Soft zone: If the target enters this region of the frame, the camera will re-orient to put it back in the dead zone. It will do this slowly or quickly, according to the time specified in the Damping settings.

  3. Screen: The screen position of the center of the dead zone. 0.5 is the center of the screen.

  4. Damping: Simulates the lag that a real camera operator introduces while operating a heavy physical camera. Damping specifies quickly or slowly the camera reacts when the target enters the soft zone while the camera tracks the target. Use small numbers to simulate a more responsive camera, rapidly moving or aiming the camera to keep the target in the dead zone. Larger numbers simulate heavier cameras, The larger the value, the more Cinemachine allows the target to enter the soft zone.

CinemachineZone

Dead Zone, Soft Zone, Screen参数在Body和Aim的属性面板上有体现，他们决定了摄像机是如何应对Look At对象走出指定区域时响应变化以及如何确保Look At对象在指定区域内的。

Cinemachine Camera Types

Unity Cinemachine自带了很多种摄像机用于不同的游戏种类:

CinemachineCameraTypes

不同的摄像机种类适用于不同的游戏类型。

Virtual Camera

Virtual Camera在前面的介绍已经提过了，这里就不再重复了，后续的摄像机类型大部分也是基于Virtual Camera的，只是在Virtual Camera的基础上实现了一套各自摄像机管理方式从而达到不同的摄像机类型效果。

FreeLook Camera

此类摄像机没有基于Virtual Camera而是单独挂载了一个Cinemachine Free Look的脚本实现的。

A Cinemachine Camera geared towards a 3rd person camera experience. The camera orbits around its subject with three separate camera rigs defining rings around the target. Each rig has its own radius, height offset, composer, and lens settings. Depending on the camera’s position along the spline connecting these three rigs, these settings are interpolated to give the final camera position and state.

从介绍可以看出，FreeLook Camera是用于第三人称围绕目标对象旋转控制的一套摄像机类型(比如第三人称RPG等游戏，有围绕主角相关的摄像机旋转控制等)。

State-Driven Camera

这里的State指的是Animator里的State，通过State-Drive Camera我们可以轻易的实现Animator State和Virtual Camera选择的绑定。这样就能轻易实现Walk状态用什么Virtual Camera，Idle状态使用什么Virtual Camera的效果。

更多的摄像机类型参考:

About Cinemachine

这里还值得一提的是摄像机限定移动范围和摄像机被障碍物主档导致目标对象不可见时Cinemachine提供的一种解决方案：

Collision Avoidance and Shot Evaluation

CinemachineCollider

An add-on module for Cinemachine Virtual Camera that post-processes the final position of the virtual camera. Based on the supplied settings, the Collider will attempt to preserve the line of sight with the LookAt target of the virtual camera by moving away from objects that will obstruct the view.

简单来说CinemachineCollider是通过相关设置，通过射线检测评估出当前摄像机最优的位置，从而避免被障碍物遮挡视线等问题。

Note:

  1. The collider uses Physics Raycasts to do these things, hence obstacles in the scene must have collider volumes in order to be visible to the CinemachineCollider.

CinemachineConfiner

An add-on module for Cinemachine Virtual Camera that post-processes the final position of the virtual camera. It will confine the virtual camera’s position to the volume specified in the Bounding Volume field.

从介绍可以看出CinemachineConfiner相比CinemachineCollider，这是一个单纯限制摄像机运动范围的组件，更加轻量，没有过多多射线检测评估等过程，用于简单的限制摄像机运动范围，此组件更佳。

Note:

  1. This is less resource-intensive than CinemachineCollider, but it does not perform shot evaluation.

实战

实战前，先让我们明确下个人的摄像机需求，需求明确了才能更加正确的使用Cinemachine达到效果。

摄像机需求:

  1. 支持相机单独控制操作
  2. 支持相机限定移动范围操作
  3. 支持相机锁定目标操作
  4. 支持相机锁定目标和自由操作自由切换操作
  5. 支持相机锁定目标操作回调上层逻辑(用于配合逻辑层做事情)
  6. 场景摄像机支持多个摄像机同时控制(比如:MainCamera和3D UI Camera)

待续……

TextMeshPro

What

TextMesh Pro is the ultimate text solution for Unity. It’s the perfect replacement for Unity’s UI Text and the legacy Text Mesh.

TextMeshPro原本是第三方个人编写的一款更优的Unity文本替代方案，后被Unity官方收购。

Why

使用TextMeshPro替代原生文本的原因有很多：

  1. TMP使用了SDF(Signed Distance Field)技术达到不失真的放大缩小渲染
  2. TMP自带实现了图文混排(通过富文本打Tag的形式)以及很多文本所需的功能(e.g. 字间距，自定义字体大小，段落格式，对齐方式等)
  3. TMP使用Shader去实现更好的文本表现效果(类似PS的一些效果)满足文本需求

缺点:

  1. 不支持动态字体(看网上说是TMP1.4支持动态字体(Generating Settings)，但我在Unity2018.4.1.f1上导入的TMP没有找到动态字体设置的入口，望知道的朋友告知一声在哪里设置)，需要生成对应的字体纹理库(对于文字多的比如中文来说有很大的内存压力)

SDF(Signed Distance Field)介绍:
一个空间区域的SDF函数定义为，从空间中任意给定的一点到该区域边界的距离，SDF函数值的符号取决于该点在区域的内部还是外部，外部为正，内部为负。

这里可以简单的理解成TMP通过函数式的定义方式(类似矢量图的定义方式)来解决像素图放大模糊的问题来渲染出可动态放大缩小不模糊的图像。深入理解参考下面的链接：函数式编程与 Signed Distance Field

How

TMP需要通过TMP提供的字体库制作工具制作所需的对应字体文件：
FontAssetCreatePanel
如果想要使用图文混排还需要自己制作SpriteAsset:
SpriteAssetCreatePanel
制作好后创建TextMeshPro组件后指定需要使用的Font Asset和Sprite Asset即可:
TextMeshProAssignFontAssetAndSpriteAsset

最终效果：
TextMeshProUsing
TextMeshPro同一个Font Asset需要制作不同的渲染效果需要通过制作不同的Material来实现：
CreateFontAssetMaterial

然后在针对新创建的Material Asset调整Shader和具体效果即可，创建完成后就可以在Font Asset的材质下拉列表里选择需要使用的效果：
FontAssetMaterialChosen

关于TextMeshPro的默认相关设置(e.g. 默认创建的Font Asset，默认Fallback到的Font Asset等)是通过TMP Settings文件里的设置来完成的:
TMPSettings

Note:

  1. TMP的Fallback的使用是在原始设定的Font Asset里找不到对应文字时的一种回退安全机制，官方的建议是真正使用的Font Asset采用高分率图集，Fallback的Font Asset采用低分辨率图集。

引用

Sprite Atlas

Sprite Atlas
Master and Variant Sprite Atlases
Variant Sprite Atlas
Sprite Atlas workflow
Preparing Sprite Atlases for distribution
Sprite Packer Modes
Unity2017新功能之Sprite Atlas详解
UGUI的图集处理方式-SpriteAtlas的前世今生

Timeline

Unity–Timeline自定义PlayableTrack
Unity2017中Timeline的简单使用方法
Unity使用Cinemachine和Timeline入门

graph-visualizer

Timeline

xtending Timeline: A Practical Guide

Creative Scripting for Timeline

Playable API：定制你的动画系统

Playables API

The PlayableGraph

ScriptPlayable and PlayableBehaviour

Playables Examples

TextMesh Pro

TextMesh Pro
函数式编程与 Signed Distance Field
Unity游戏开发——TextMeshPro的使用
在Unity 2018中充分使用TextMesh Pro
Making the most of TextMesh Pro in Unity 2018

Cinemachine

Cinemachine overview

Cinemachine Learn

By

数据库

数据存储对于游戏开发来说是必不可少的，在常规的游戏开发中，后端服务器会采用MySQL(关系型数据库),**MongoDB(非关系型数据库)**等作为数据库存储。

关于关系型和菲关系型数据库的学习理解参考:

网络通信和服务器学习

本章节是在没有后端但又有玩家数据存储需求的前提下诞生的，通过调研**SQLite(关系型数据库)**正是定位本地高效数据库而非CS结构的数据库，所以本章节通过深入学习SQLite，弄懂如何正确高效的把本地玩家数据存储到本地数据库。

SQLite

What

首先来看看SQLite官网的一个介绍:
SQLite is not directly comparable to client/server SQL database engines such as MySQL, Oracle, PostgreSQL, or SQL Server since SQLite is trying to solve a different problem.
Client/server SQL database engines strive to implement a shared repository of enterprise data. They emphasize scalability, concurrency, centralization, and control. SQLite strives to provide local data storage for individual applications and devices. SQLite emphasizes economy, efficiency, reliability, independence, and simplicity.
SQLite does not compete with client/server databases. SQLite competes with fopen().
从上面的介绍可以看出，SQLite(C语言编写的库)虽然也是关系型数据库，但他的定位和MySQL不一样，定位的是本地高效数据库而非CS结构的数据库。

Why

那么什么时候适用于SQLite?什么时候适用于MySQL(CS)了？
SQLite官网也给出了明确的介绍，详情参见官网SQLite
这里只列举下官网介绍的什么时候适用于MYSQL:

  1. Client/Server Applications(CS结构的程序–需要大量客户端服务器通信存储)
  2. High-volume Websites(高吞吐量的网站)
  3. Very large datasets(数据存储量大–数据大)
  4. High Concurrency(高并发–很多人同时写入)

How

这里本人明确了暂时是打算用于单机版游戏的本地数据库，所以倾向于用SQLite来做。
接下来会接触以下几个知识点：

  1. Unity(游戏开发引擎)
  2. SQLite4Unity3d(第三方给Unity封装好的SQLite库–支持Window，Android(ARM64貌似也支持了)和IOS)
  3. Navicat(可视化数据库工具)
  4. SQL(数据库查询语言)

目标:

  1. 编写一个数据库操作UI界面，支持数据库的增删改查操作(方便学习使用SQLite4Unity3d提供的接口访问SQLite数据库)
  2. 利用Navicat查看Window本地存储的数据库数据(学会Navicat的基本使用和数据库SQL相关操作)
  3. 打包编译Window和Android版本到真机上查看效果(确保多平台的兼容性)

SQLite4Unity3d实战

环境准备:
Unity版本：2018.4.8f1
SQLite4Unity3d: SQLite4Unity3d
Navivat: Navicat Premium
SQL:SQL学习1 or SQL学习2

Note:

  1. SQLite4Unity3d uses only the synchronous part of sqlite-net, so all the calls to the database are synchronous.(SQLite4Unity3d有这么一句官方提示，可以看出所有的数据库操作都是同步的。这里考虑到都是单机本地存储同时数据量也不会很大，所以同步异步不是很重要，所以并不影响个人使用。)

PC实战

接下来结合SQLite4Unity3d来实战学习数据库的增删改查等操作。
第1步
创建空的Unity工程，制作简单的交互UI
SQLiteUserInterface

第2步
拷贝SQLite相关库文件：
SQLitePlugin
还要拷贝SQLite.cs(SQLite4Unity3d作者封装的访问SQLite的相关接口)
通过查看SQLite.cs的源代码可以看出,作者封装的这一层通过CS层多抽象了一层数据库访问(增删改查)和表格数据结构，然后结合反射(反射查找对应类的数据库)和Linq(实现快速的数据库查询)来实现通用的数据访问。

第3步
定义数据库表结构:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/// <summary>
/// 玩家信息
/// </summary>
public class Player
{
    [PrimaryKey]
    public int UID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return $"[Player: UId={UID}, FirstName={FirstName},  LastName={LastName}, Age={Age}]";
    }
}

第4步
建立SQLite数据库连接(不存在的话会根据Flag决定是否自动创建):

1
2
3
DatabaseFolderPath = $"{Application.persistentDataPath}/";
// 建立数据库连接
mSQLiteConnect = new SQLiteConnection($"{DatabaseFolderPath}/{DatabaseName}", SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create);

可以看到本来StreamingAssets目录下没有数据库文件的这一下就创建成功了。
CreateDatabase

第5步
数据库里创建玩家表:

1
mSQLiteConnect.CreateTable<Player>();

CreatePlayerTable
因为还没有数据所以看不到数据打印，通过Navicat打开数据库，我们可以看到已经成功创建了Player表:
PlayerTableView

第6步
玩家表插入玩家数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
mSQLiteConnect.Insert(new Player
        {
            UID = 1,
            FirstName = "Huan",
            LastName = "Tang",
            Age = 29,
        });
        mSQLiteConnect.Insert(new Player
        {
            UID = 3,
            FirstName = "XiaoYun",
            LastName = "Zhou",
            Age = 28,
        });
        mSQLiteConnect.Insert(new Player
        {
            UID = 2,
            FirstName = "Jiang",
            LastName = "Fan",
            Age = 28,
        });
        mSQLiteConnect.Insert(new Player
        {
            UID = 5,
            FirstName = "ZhenLiang",
            LastName = "Li",
            Age = 29,
        });
        mSQLiteConnect.Insert(new Player
        {
            UID = 4,
            FirstName = "XiaoLin",
            LastName = "Kuang",
            Age = 28,
        });

InsertPlayerTableData

第7步
玩家表删除指定玩家ID数据：

1
mSQLiteConnect.Delete<Player>(deleteuid);

DeletePlayerTableData

第7步
玩家表修改指定玩家Age数据：

1
2
valideplayer.Age = newage;
mSQLiteConnect.Update(valideplayer);

ModifyPlayerTableAgeData

第8步
删除玩家表所有数据：

1
var rownumber = mSQLiteConnect.DeleteAll<Player>();

DeleteAllPlayerTableData
可以看到我们成功删除了玩家表里的所有数据，接下来用Navicat验证下数据库里的情况：
DatabaseAfterDeleteAllPlayerTableData

第9步
删除数据库里的玩家表：

1
var rownumberaffected = mSQLiteConnect.DropTable<Player>();

DeletePlayerTable
删除玩家表后通过Navicat查看数据库:
DatabaseViewAfterDeletePlayerTable
通过查看源码，我们可以看到，DraopTable底层实际是通过调用SQL的Drop语句来实现删除表的:

1
2
3
4
5
6
7
8
9
10
11
/// <summary>
/// Executes a "drop table" on the database.  This is non-recoverable.
/// </summary>
public int DropTable<T>()
{
    var map = GetMapping (typeof (T));

    var query = string.Format("drop table if exists \"{0}\"", map.TableName);

    return Execute (query);
}

关于SQL更多学习参考:
SQL 教程
SQL Tutorial
可以看到通过使用SQLite4Unity3d的SQLite.cs相关的接口，成功的实现了对于数据库的创建，以及数据库表的创建，增删改查等操作。

第10步
关闭数据库连接:

1
mSQLiteConnect.Close();

Android实战

为了验证SQLite4Unity3d的跨平台能力，接下来打包验证真机:
Android真机数据库操作:
AndroidSQLiteUsing

Android真机数据库文件查看(本人使用的ES文件浏览器)：
![DatabaseViewAfterOperation]/img/Database/DatabaseViewAfterOperation.png)

Android真机数据库详细信息PC查看:
AndroidDatabaseView

可以看到Android真机上数据库的一些基础操作都成功了的。IOS这里就暂时不验证了，根据Github上的介绍理论上是支持的。

Note:

  1. 真机可读取目录修改为Application.persistentDataPath,因为Application.streamingAssetsPath在真机上是只读目录。
  2. 真机使用ES文件浏览器来查看程序目录下的数据库文件

SQLite4Unity3d进阶

学习了SQLite4Unity3d的基础使用，接下来要考虑的是实战使用时，如何封装一层数据库管理，方便游戏里的所有数据库数据都成功的加载读取修改保存。

这里主要是对于SQLite.cs的简单封装，用于支持多数据库创建，以及数据库创建路径管理，以及自定义数据库表的封装访问。

上代码之前，先简单看下封装的代码设计:

  • DatabaseManager.cs(对多数据库创建访问以及路径规划进行封装支持)
  • BaseDatabase.cs(数据库基类抽象–实现对数据库操作进行封装)
  • BaseTableData.cs(数据库表数据基类抽象–实现对数据库表操作进行封装)
  • BaseIntTableData.cs(int做主键的表数据抽象–实现对int主键表的操作封装)
  • BaseStringTableData.cs(string做主键的表数据抽象–实现对string主键表的操作封装)

DatabaseManager.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
namespace TH.Modules.Data
{
    /// <summary>
    /// 数据库管理类
    /// 主要功能如下:
    /// 1. 数据库路径处理(数据库存储管理)
    /// 2. 多数据库支持
    /// 3. 数据库连接，关闭，CUID操作等操作依然使用SQLite的封装
    /// </summary>
    public class DatabaseManager : SingletonTemplate<DatabaseManager>
    {
        /// <summary>
        /// 数据库文件夹地址
        /// </summary>
        private readonly static string DatabaseFolderPath = Application.persistentDataPath + "/Database/";

        /// <summary>
        /// 已连接的数据库映射Map
        /// Key为数据库名，Value为对应的数据库连接
        /// </summary>
        private Dictionary<string, SQLiteConnection> ConnectedDatabaseMap;

        public DatabaseManager()
        {
            //检查数据库文件目录是否存在
            if(!Directory.Exists(DatabaseFolderPath))
            {
                Directory.CreateDirectory(DatabaseFolderPath);
            }
            ConnectedDatabaseMap = new Dictionary<string, SQLiteConnection>();
        }

        /// <summary>
        /// 打开数据库连接
        /// </summary>
        /// <param name="databasename"></param>
        /// <param name="openflags"></param>
        /// <param name="storeDateTimeAsTicks"></param>
        public void openDatabase(string databasename, SQLiteOpenFlags openflags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create, bool storeDateTimeAsTicks = false)
        {
            if(!isDatabaseConnected(databasename))
            {
                var databasepath = DatabaseFolderPath + databasename;
                var connection = new SQLiteConnection(databasepath, openflags, storeDateTimeAsTicks);
                ConnectedDatabaseMap.Add(databasename, connection);
                Debug.Log($"连接数据库:{databasename}");
            }
            else
            {
                Debug.Log($"数据库:{databasename}已连接,请勿重复连接!");
            }
        }

        /// <summary>
        /// 获取指定数据库连接
        /// </summary>
        /// <param name="databasename"></param>
        /// <returns></returns>
        public SQLiteConnection getDatabaseConnection(string databasename)
        {
            SQLiteConnection connection;
            if (ConnectedDatabaseMap.TryGetValue(databasename, out connection))
            {
                return connection;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 关闭数据库连接
        /// </summary>
        /// <param name="databasename"></param>
        public void closeDatabase(string databasename)
        {
            SQLiteConnection connection;
            if(ConnectedDatabaseMap.TryGetValue(databasename, out connection))
            {
                connection.Close();
                ConnectedDatabaseMap.Remove(databasename);
                Debug.Log($"关闭数据库:{databasename}");
            }
            else
            {
                Debug.LogError($"未连接数据库:{databasename},关闭失败!");
            }
        }

        /// <summary>
        /// 关闭所有已连接的数据库
        /// </summary>
        public void closeAllDatabase()
        {
            foreach (var databasename in ConnectedDatabaseMap.Keys)
            {
                closeDatabase(databasename);
            }
        }

        /// <summary>
        /// 清除
        /// </summary>
        public void clear()
        {
            closeAllDatabase();
        }
        
        /// <summary>
        /// 指定数据库是否已连接
        /// </summary>
        /// <param name="databasename"></param>
        /// <returns></returns>
        private bool isDatabaseConnected(string databasename)
        {
            return ConnectedDatabaseMap.ContainsKey(databasename);
        }

        #region 辅助方法
        /// <summary>
        /// 获取指定数据库表的所有数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="databasename">数据库名</param>
        /// <returns></returns>
        public string getTableAllDatasInOneString<T>(string databasename) where T : new()
        {
            SQLiteConnection sqliteconnection = getDatabaseConnection(databasename);
            if (sqliteconnection != null)
            {
                var querytable = sqliteconnection.Table<T>();
                if (querytable != null)
                {
                    var result = string.Empty;
                    foreach (var data in querytable)
                    {
                        result += data.ToString();
                        result += "\n";
                    }
                    return result;
                }
                else
                {
                    return string.Empty;
                }
            }
            else
            {
                return string.Empty;
            }
        }
        #endregion
    }
}

TODO:

  1. 现阶段是默认存在包外的persistentDataPath，对于数据库如何做好加密管理避免被轻易修改，这个问题还有待学习思考。
  2. 数据库表是否存在还没找到方式判定(暂时是从流程上确保表存在的)

BaseDatabase.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
namespace TH.Modules.Data
{
    /// <summary>
    /// BaseDatabase.cs
    /// 数据库基类抽象
    /// Note:
    /// 子类自行实现单例模式方便访问
    /// </summary>
    public abstract class BaseDatabase
    {
        /// <summary>
        /// 数据库连接
        /// </summary>
        protected SQLiteConnection mSQLiteConnect;

        /// <summary>
        /// 数据库名
        /// </summary>
        public virtual string DatabaseName
        {
            get
            {
                return $"{GetType().Name}.db";
            }
        }

        protected BaseDatabase()
        {

        }

        /// <summary>
        /// 加载数据库
        /// </summary>
        public void LoadDatabase()
        {
            mSQLiteConnect = DatabaseManager.Singleton.openDatabase(DatabaseName);
        }

        /// <summary>
        /// 数据库是否已连接
        /// </summary>
        /// <returns></returns>
        public bool IsConnected()
        {
            return mSQLiteConnect != null;
        }

        ///// <summary>
        ///// 指定表是否存在
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <returns></returns>
        //public bool IsTableExist<T>() where T : BaseTableData, new()
        //{
        //    if (!IsConnected())
        //    {
        //        Debug.LogError($"数据库:{DatabaseName}未连接，访问类名:{typeof(T).Name}表是否存在失败!");
        //        return false;
        //    }
        //    // TODO: 找到方法判定是否存在
        //    return false;
        //}

        /// <summary>
        /// 创建指定数据库表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool CreateTable<T>() where T : BaseTableData, new()
        {
            if(!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，创建类名:{typeof(T).Name}表失败!");
                return false;
            }
            //if(!IsTableExist<T>())
            //{
            //    Debug.LogError($"数据库:{DatabaseName}，类名:{typeof(T).Name}表已存在，请勿重复创建!");
            //    return false;
            //}
            mSQLiteConnect.CreateTable<T>();
            return true;
        }

        /// <summary>
        /// 插入指定int主键的表数据(如果表不存在则创建表)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool InsertDataI<T>(T data) where T : BaseIntTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            mSQLiteConnect.Insert(data);
            return true;
        }

        /// <summary>
        /// 插入指定int主键的表数据(如果表不存在则创建表,如果主键存在则覆盖更新)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool InsertOrReplaceDataI<T>(T data) where T : BaseIntTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            mSQLiteConnect.InsertOrReplace(data);
            return true;
        }

        /// <summary>
        /// 插入指定int主键的表数据(如果表不存在则创建表)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool InsertDataS<T>(T data) where T : BaseStringTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            mSQLiteConnect.Insert(data);
            return true;
        }

        /// <summary>
        /// 插入指定string主键的表数据(如果表不存在则创建表,如果主键存在则覆盖更新)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool InsertOrReplaceDataS<T>(T data) where T : BaseStringTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            mSQLiteConnect.InsertOrReplace(data);
            return true;
        }

        /// <summary>
        /// 删除指定UID的表数据(整形主键)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool DeleteDataByUIDI<T>(int uid) where T : BaseIntTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，删除类名:{typeof(T).Name}表UID:{uid}数据失败!");
                return false;
            }
            var deletedNumber = mSQLiteConnect.Delete<T>(uid);
            Debug.Log($"数据库:{DatabaseName}，删除类名:{typeof(T).Name}表UID:{uid}数量:{deletedNumber}");
            return deletedNumber > 0;
        }

        /// <summary>
        /// 删除指定UID的表数据(字符串主键)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool DeleteDataByUIDS<T>(string uid) where T : BaseStringTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，删除类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            var deletedNumber = mSQLiteConnect.Delete<T>(uid);
            Debug.Log($"数据库:{DatabaseName}，删除类名:{typeof(T).Name}表UID:{uid}数量:{deletedNumber}");
            return deletedNumber > 0;
        }

        /// <summary>
        /// 更新指定int主键的表数据(如果表不存在则创建表)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool UpdateDataI<T>(T data) where T : BaseIntTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            var updatedNumber = mSQLiteConnect.Update(data);
            Debug.Log($"数据库:{DatabaseName}，更新类名:{typeof(T).Name}表UID:{data.UID}数量:{updatedNumber}");
            return updatedNumber > 0;
        }

        /// <summary>
        /// 更新指定string主键的表数据(如果表不存在则创建表)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool UpdateDataS<T>(T data) where T : BaseStringTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，插入类名:{typeof(T).Name}表数据失败!");
                return false;
            }
            //if (!IsTableExist<T>())
            //{
            //    CreateTable<T>();
            //}
            var updatedNumber = mSQLiteConnect.Update(data);
            Debug.Log($"数据库:{DatabaseName}，更新类名:{typeof(T).Name}表UID:{data.UID}数量:{updatedNumber}");
            return updatedNumber > 0;
        }

        /// <summary>
        /// 获取指定UID的表数据(整形主键)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T GetDataByUIDI<T>(int uid) where T : BaseIntTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，获取类名:{typeof(T).Name}表数据失败!");
                return null;
            }
            var data = mSQLiteConnect.Find<T>((databaseTable) => databaseTable.UID == uid);
            if (data == null)
            {
                Debug.LogError($"数据库:{DatabaseName}，获取类名:{typeof(T).Name}的UID:{uid}表数据不存在!");
                return null;
            }
            return data;
        }

        /// <summary>
        /// 获取指定UID的表数据(字符串主键)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T GetDataByUIDS<T>(string uid) where T : BaseStringTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，获取类名:{typeof(T).Name}表数据失败!");
                return null;
            }
            var data = mSQLiteConnect.Find<T>((databaseTable) => databaseTable.UID == uid);
            if (data == null)
            {
                Debug.LogError($"数据库:{DatabaseName}，获取类名:{typeof(T).Name}的UID:{uid}表数据不存在!");
                return null;
            }
            return data;
        }


        /// <summary>
        /// 获取指定表所有数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public TableQuery<T> GetAllData<T>() where T : BaseTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，获取类名:{typeof(T).Name}表数据失败!");
                return null;
            }
            var tbData = mSQLiteConnect.Table<T>();
            if (tbData == null)
            {
                Debug.LogError($"数据库:{DatabaseName}，获取类名:{typeof(T).Name}表所有数据不存在!");
                return null;
            }
            return tbData;
        }

        /// <summary>
        /// 删除指定表所有数据
        /// </summary>
        /// <returns></returns>
        public int DeleteTableAll<T>() where T : BaseTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，删除类名:{typeof(T).Name}表所有数据失败!");
                return 0;
            }
            //if (!IsTableExist<T>())
            //{
            //    Debug.LogError($"数据库:{DatabaseName}，删除类名:{typeof(T).Name}表不存在,删除所有数据失败!");
            //    return 0;
            //}
            var deletedNumber = mSQLiteConnect.DeleteAll<T>();
            Debug.Log($"数据库:{DatabaseName}，删除类名:{typeof(T).Name}表所有数据数量:{deletedNumber}");
            return deletedNumber;
        }

        /// <summary>
        /// 删除指定表
        /// </summary>
        /// <returns></returns>
        public int DeleteTable<T>() where T : BaseTableData, new()
        {
            if (!IsConnected())
            {
                Debug.LogError($"数据库:{DatabaseName}未连接，删除类名:{typeof(T).Name}表失败!");
                return 0;
            }
            var deletedNumber = mSQLiteConnect.DropTable<T>();
            Debug.Log($"数据库:{DatabaseName}，删除类名:{typeof(T).Name}表数量:{deletedNumber}");
            return deletedNumber;
        }

        /// <summary>
        /// 关闭数据库
        /// </summary>
        public void CloseDatabase()
        {
            DatabaseManager.Singleton.closeDatabase(DatabaseName);
            mSQLiteConnect = null;
        }
    }
}

BaseTableData.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
namespace TH.Modules.Data
{
    /// <summary>
    /// BaseTableData.cs
    /// 数据库表数据基类抽象
    /// </summary>
    public abstract class BaseTableData
    {
        /// <summary>
        /// 表名
        /// </summary>
        public string TableName
        {
            get
            {
                return GetType().Name;
            }
        }

        public BaseTableData()
        {

        }

        /// <summary>
        /// 打印数据
        /// </summary>
        public override string ToString()
        {
            return $"[TableName:{TableName}]";
        }
    }
}

BaseIntTableData.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
namespace TH.Modules.Data
{
    /// <summary>
    /// BaseIntTableData.cs
    /// Int做主键的表数据抽象
    /// </summary>
    public abstract class BaseIntTableData : BaseTableData
    {
        /// <summary>
        /// 主键UID
        /// </summary>
        [PrimaryKey]
        public int UID
        {
            get;
            set;
        }

        public BaseIntTableData() : base()
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="uid"></param>
        public BaseIntTableData(int uid) : base()
        {
            UID = uid;
        }

        /// <summary>
        /// 打印所有表数据
        /// </summary>
        public override string ToString()
        {
            return $"[TableName:{TableName} UID:{UID}]";
        }
    }
}

BaseStringTableData.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
namespace TH.Modules.Data
{
    /// <summary>
    /// BaseStringTableData.cs
    /// string做主键的表数据抽象
    /// </summary>
    public abstract class BaseStringTableData : BaseTableData
    {
        [PrimaryKey]
        public string UID
        {
            get;
            set;
        }

        public BaseStringTableData() : base()
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="uid"></param>
        public BaseStringTableData(string uid) : base()
        {
            UID = uid;
        }

        /// <summary>
        /// 打印数据
        /// </summary>
        public override string ToString()
        {
            return $"[TableName:{TableName} UID:{UID}]";
        }
    }
}

GameDatabase.cs(自定义游戏数据库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/// <summary>
/// GameDatabase.cs
/// 游戏数据库
/// </summary>
public class GameDatabase : BaseDatabase
{
    /// <summary>
    /// 单例对象
    /// </summary>
    public static GameDatabase Singleton
    {
        get
        {
            if(mSingleton != null)
            {
                return mSingleton;
            }
            mSingleton = new GameDatabase();
            return mSingleton;
        }
    }
    private static GameDatabase mSingleton;

    public GameDatabase() : base()
    {

    }
}

Player.cs(自定义玩家数据表结构)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/// <summary>
/// 玩家信息表成员结构
/// </summary>
public class Player : BaseIntTableData
{
    /// <summary>
    /// 名
    /// </summary>
    public string FirstName
    {
        get;
        set;
    }

    /// <summary>
    /// 姓
    /// </summary>
    public string LastName
    {
        get;
        set;
    }

    /// <summary>
    /// 年龄
    /// </summary>
    [Indexed]
    public int Age
    {
        get;
        set;
    }

    public Player() : base()
    {

    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="firstName"></param>
    /// <param name="lastName"></param>
    /// <param name="age"></param>
    public Player(int uid, string firstName, string lastName, int age) : base(uid)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    /// <summary>
    /// 打印数据
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return $"[Player: UID={UID}, FirstName={FirstName},  LastName={LastName}, Age={Age}]";
    }
}

进阶版的实战代码见Github源码:

SQLiteStudy

结论

  1. SQLite适用于非CS结构，存储数据量不大，不会多人并发操作数据库的情况(好比单机游戏的数据库)。
  2. 数据量大或者多人操作频繁或者需要CS架构支持，更适合MySQL+Redis
  3. SQLite4Unity3d通过反射和Linq对SQLite的封装实现了对于SQL无感和ORM(Object Relational Mapping)数据库访问方式。
  4. SQLite4Unity3d支持多平台，适合单机游戏数据存储

Reference

SQLite4Unity3d

Github地址

SQLiteStudy

By

前言

本章节是为了记录学习游戏开发过程中的服务器搭建以及前后端网络通信相关的知识点，游戏开发中联网是必不可少的，无论是从游戏热更新(服务器通知版本以及热更相关信息)，还是游戏社交(微信分享，联机组队)，还是防破解(服务器校验)都离不开网络通信和服务器。

本人是前端程序，对后端服务器开发几乎一窍不通，本篇文章也算是为了开阔自己的眼界，同时也是为了未来自己的游戏有网络这一块的支持需要对服务器搭建以及网络通信要有所了解。本文着重点不在于高效和优美的框架设计，着眼于基础的网络通信和服务器搭建，而这正是此篇博客的初衷。

  • 目标
  1. 理解游戏服务器工作原理
  2. 理解不同服务器框架的优劣，选择合适的服务器框架
  3. 学会搭建基础的游戏服务器，具备基础的数据存储功能(本文重点)
  4. 掌握网络通信知识，搭建前后端通信框架，支持前后端通信(本文重点)

服务器

那么什么是服务器了？

个人简单的理解，可以把服务器理解成运行在远程电脑上，通过网络对客户端提供服务(数据处理，数据存储读取，消息转发等)的机器或者软件。

了解服务器架构：

游戏服务器架构的演进简史

从上面可以看出服务器有以下几个基础功能：

  1. 对于游戏数据和玩家数据的存储(数据存储)
  2. 对玩家数据进行数据广播和同步(消息通信)
  3. 把一部分游戏逻辑在服务器上运算，做好验证，防止外挂(服务器验证)
  4. 服务器架构设计(容灾，性能，扩容等)

第三点涉及到前后端框架设计(帧同步 or 状态同步等)，第四点更与服务器端密切相关，本文着眼点是前两点，第三点和第四点作为未来学习的一个知识点，。

数据存储

关系型数据库

关系数据库（英语：Relational database），是创建在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。现实世界中的各种实体以及实体之间的各种联系均用关系模型来表示。

个人简单的理解，关系数据库大概就是以前学SQL的时候，数据库里通过表来抽象实体数据，表之间通过ID映射关联起来的概念(e.g. 比如数据库里有两张表，一张员工表，一张员工数据表。员工表用于抽象员工ID，员工名字，员工薪资等信息。而员工数据用于存储员工ID，员工入职日期等信息。然后两张表示通过员工ID来映射关联起来。)。

典型的关系型数据库:
MySQL

典型的关系型数据查询语言:
SQL

这里还值得一提的一个本地数据库：
SQLite

详细的MYSQL和SQLite对比参考:
SQLite和MySQL数据库的区别与应用

SQLite

SQLite学习详情参考

非关系型数据库

NoSQL是对不同于传统的关系数据库的数据库管理系统的统称。两者存在许多显著的不同点，其中最重要的是NoSQL不使用SQL作为查询语言。其数据存储可以不需要固定的表格模式，也经常会避免使用SQL的JOIN操作，一般有水平可扩展性的特征。

看了上面Wiki的介绍，本人其实还是一知半解，等待后续深入学习理解非关系型数据库。

有了关系型数据库为什么还需要非关系型数据库了？
当代典型的关系数据库在一些数据敏感的应用中表现了糟糕的性能，例如为巨量文档创建索引、高流量网站的网页服务，以及发送流式媒体。关系型数据库的典型实现主要被调整用于执行规模小而读写频繁，或者大批量极少写访问的事务。NoSQL的结构通常提供弱一致性的保证，如最终一致性，或交易仅限于单个的数据项。不过，有些系统，提供完整的ACID保证在某些情况​​下，增加了补充中间件层（例如：CloudTPS）

典型的菲关系型数据库:
MongoDB，Redis

数据库选择

关系数据库还是NoSQL数据库
数据库选择历程
游戏服务器存储系统设计
本人对数据库的经验还停留在学校学习SQL的时候，也可以理解成使用过一点关系型数据库。
这里是想深入理解关系和非关系之间的区别，同时为选择游戏开发时使用的数据库类型做知识储备。以下理解的不对的地方，忘指出。

结合上面两篇文章的学习理解，个人理解关系型数据库(e.g. MySQL)适用于读写不频繁(面向表级别的锁定)，需要强大的查询(SQL)功能。
而非关系型数据库(e.g. Redis)适用于频繁读写(性能要求高 – Redis是Ke-Vlaue结构，且面向内存的存储模型(使用RDB和AOF做持久化))，需要高扩展性。

结合网上的学习理解，使用Redis(做内存Cache)+MySQL(做稳定的数据库存储查询)利用各自优势使用在不同模块来实现高性能的服务器存储设计是比较高效合理的。

这里本人出于学习目的，暂定以关系型数据库(MySQL)作为服务器数据库存储介质，暂时不考虑Redis。

出于单机游戏数据库存储学习，暂时以关系型数据库(SQLite)作为本地数据库存储介质。

后期Redis进阶学习:
Redis 教程

消息通信

消息通信是本篇文章的重点，首先让我们理一理实现消息通信前我们需要做些什么？

  1. 联网方式(选择通信协议，比如: TCP || UPD)
  2. 数据格式定义(会影响数据编码和解析，比如: Protobuf)
  3. 数据收发(涉及到网络通信监听，比如: Socket编程)
  4. 数据解析(涉及到二进制数据写入和读取，一般来说都不会明文传输)

一般来说消息通信的流程如下：

  1. 服务器启动了网络监听(比如通过Socket监听固定端口等待客户端连接)
  2. 客户端通过Socket连接服务器端口
  3. 指定前后端消息协议(Protobuf)，基于协议封装消息数据
  4. 客户端通过封装二进制消息数据通过Socket传递给服务器
  5. 服务器接受到二进制数据通过对应方式解析消息后返回客户端消息
  6. 客户端做出对应表现

联网方式

了解联网方式之前，我们需要知道一些相关的网络知识。

以前学计算机网络课程时，印象最深的就是网络的OSI七层分类：

OSI模型

这里我们主要关注的是以下两层：

  1. 会话层

    负责在数据传输中设置和维护计算机网络中两台计算机之间的通信连接。这一层是负责网络连接的，比如我们通过Socket启动端口监听

  2. 传输层

    把传输表头（TH）加至数据以形成数据包。传输表头包含了所使用的协议等发送信息。例如:传输控制协议（TCP）等。这一层负责添加网络协议相关信息，比如根据不同网络协议(TCP or UDP)用不同的方式处理丢包问题

更详细的网络相关知识介绍参考:

TCP和UDP的区别

这里我们只要知道TCP(Transmission Control Protocol，传输控制协议)协议是面向连接的可靠传输协议，有三次握手过程。而UDP(User Data Protocol，用户数据报协议)协议是无连接不可靠协议。

传输协议选择？
TCP
理由：

  1. 游戏对网络数据准确性要求较高

数据格式定义

这里的数据格式指的是网络消息数据格式定义。

在完成了客户端和服务器基础网络数据传输能力(TPC)后，我们必须定义一个统一的消息定义(即数据格式)和消息处理的方式，这样客户端和服务器端才能正常的解析网络数据。

数据格式需求：

  1. 知道数据大小
  2. 知道数据类型
  3. 知道如何序列化和反序列化数据

基础的数据格式定义如下:

  1. 数据长度(short - 2字节) – 用于存储消息数据长度
  2. 消息ID(short - 2字节) – 用于区分消息类型
  3. 二进制数据(Protobuf) – 用于序列化和反序列化数据

数据收发

有了TCP网络数据传输的能力后，我们还需要网络通信的能力。
网路通信方式选择？
Socket

数据解析

数据的解析就是前面提到的数据序列化和反序列化的能力。

数据解析协议选择？
Protobuf
理由：

  1. 强大的生态圈，多语言支持，数据前后兼容性，强大序列化反序列化能力等

服务器验证

为什么需要验证？

单机游戏不联网很容易有外挂的一个原因就是本地数据(本地存储或者只存在内存中)很容易被串改且无法验证正确性，比如通过修改内存数据(e.g. 数值挂)，修改游戏运行速度(e.g. 加速挂)

解决这一问题的关键正式服务器验证，把所有的数据都存储在服务器上，所有的数据修改都必须通过服务器校验才能通过，这样一来客户端伪造数据就能被识别出来从而防止部分外挂。

服务器验证的应用场景？

服务器验证有一点很重要的应用就是服务器运行战斗逻辑，确保所有客户端结果一致性。

这一点涉及到前后端同步框架相关的知识，详情参考:

两种同步模式：状态同步和帧同步

这里直接借用博客里的一些定义来加深基础理解：

什么是同步？

所谓同步，就是要多个客户端表现效果是一致，数据是一致。

什么是状态同步？

状态同步下，客户端更像是一个服务端数据的表现层。以服务器通知为准。

什么是帧同步？

帧同步下，通信就比较简单了，服务端只转发操作，不做任何逻辑处理。

FrameSync

状态同步和帧同步的区别？

最大的区别就是战斗核心逻辑写在哪，状态同步的战斗逻辑在服务端，帧同步的战斗逻辑在客户端。

这里只是简单的引用上面博主的部分说明来加深理解，更深入学习请参考前面给出的博客链接。

服务器从零开发

前面是对于服务器相关理论知识的一些基础知识的学习实战。接下来为了真正做到开发一个可用的服务器，接下来打算从零开发搭建一个可用的服务器用于个人独立游戏(最重要的目的是从中学习到服务器相关的知识以及用到自己的游戏中来)。

服务器语言选择

作为一个服务器知识几乎为零的前端小白(用到过的语言为C#,C++,Lua,Python,Java–其中C#和Lua是现在用的最多的)，打算入门服务器开发(主要用于个人游戏开发)，所以在语言选择上主要是希望易上手，性能也还行。在高并发方面要求不高。

对于相对熟悉C#和Lua的博主来说能使用**C#**开发服务器的是比较合适的。

未来的语言学习要针对开发的游戏类型对服务器的性能要求等来分析再做具体选型。

结合网上的资料，了解到:

11种服务器编程语言对比（附游戏服务器框架） 2020.06

服务器开源框架

选择一个好的开源框架作为服务器开发入门来说是必不可少的，这里了解基于C#的服务器框架比较少，有一个ET的服务器框架比较出名，但ET看起来过于庞大，入门起来可能比较难，所以这里暂时没有考虑。

未来的学习方向可能不限语言，不一定是ET也可能是别的语言的服务器框架。

现阶段打算先从0开始打通服务器和客户端的流程，所以打断用C#自己写一套简易版的服务器来熟悉整个服务器开发。

网络通信

网络通信是指通过网络进行数据传输处理的能力。为了实现网络通信，我们需要借助于TCP( or UDP or **)协议进行数据传输，借助Socket进行端口监听，从而实现网络通信的能力。

联网方式选择？
TCP协议 + Socket
理由：

  1. 游戏开发对网络稳定性要求较高，所以选择以TCP作为网络传输协议。

数据格式定义选择？
Protobuf
理由：

  1. 强大的生态圈，多语言支持，数据前后兼容性，强大序列化反序列化能力等

前后端通信模式选择？
帧同步
理由：

  1. 现阶段只是为了实现前后端的通信能力，只是希望后端提供消息处理和数据存储的功能，暂时不考虑反外挂，服务器验证等问题，所以选择更适合以后端转发通知的CS模式的帧同步。

联网通信实现

二进制抽象类

联网通信免不了对二进制数据的写入，所以在实现TPC和Socket网络连接传输消息之前，我们需要实现一个对二进制数据进行读取和写入工具类实现。

以下代码参考至:
Unity3D —— Socket通信(C#)

ByteBufferWriter.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/*
 * Description:             ByteBufferWriter.cs
 * Author:                  TONYTANG
 * Create Date:             2019/07/14
 */

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

namespace Net
{
    /// <summary>
    /// ByteBufferWriter.cs
    /// 二进制写入抽象类
    /// </summary>
    public class ByteBufferWriter
    {
        // Note:
        // 注意大小端问题
        // BinaryWriter和BinaryReader都是小端读写

        /// <summary>
        /// 内存写入类
        /// </summary>
        private MemoryStream mMemoryStream;

        /// <summary>
        /// 二进制流写入类
        /// </summary>
        private BinaryWriter mBinaryWriter;

        public ByteBufferWriter()
        {
            mMemoryStream = new MemoryStream();
            mBinaryWriter = new BinaryWriter(mMemoryStream);
        }

        public ByteBufferWriter(byte[] data)
        {
            if(data != null)
            {
                mMemoryStream = new MemoryStream(data);
                mBinaryWriter = new BinaryWriter(mMemoryStream);
            }
            else
            {
                mMemoryStream = new MemoryStream();
                mBinaryWriter = new BinaryWriter(mMemoryStream);
            }
        }

        /// <summary>
        /// 关闭二进制读取写入
        /// </summary>
        public void Close()
        {
            mBinaryWriter.Close();
            mMemoryStream.Close();
            mBinaryWriter = null;
            mMemoryStream = null;
        }

        /// <summary>
        /// 写入一个字节数据
        /// </summary>
        /// <param name="v"></param>
        public void WriteByte(byte v)
        {
            mBinaryWriter.Write(v);
        }

        ******
        
        /// <summary>
        /// 获取字节数据
        /// </summary>
        /// <returns></returns>
        public byte[] ToBytes()
        {
            mBinaryWriter.Flush();
            return mMemoryStream.ToArray();
        }

        /// <summary>
        /// 写入数据
        /// </summary>
        public void Flush()
        {
            mBinaryWriter.Flush();
        }
    }
}

ByteBufferReader.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/*
 * Description:             ByteBufferReader.cs
 * Author:                  TONYTANG
 * Create Date:             2019/07/14
 */

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

namespace Net
{
    /// <summary>
    /// ByteBufferReader.cs
    /// 二进制读取抽象类
    /// </summary>
    public class ByteBufferReader
    {
        // Note:
        // 注意大小端问题
        // BinaryWriter和BinaryReader都是小端读写

        /// <summary>
        /// 内存写入类
        /// </summary>
        private MemoryStream mMemoryStream;

        /// <summary>
        /// 二进制流读取类
        /// </summary>
        private BinaryReader mBinaryReader;

        public ByteBufferReader()
        {
            mMemoryStream = new MemoryStream();
            mBinaryReader = new BinaryReader(mMemoryStream);
        }

        public ByteBufferReader(byte[] data)
        {
            if(data != null)
            {
                mMemoryStream = new MemoryStream(data);
                mBinaryReader = new BinaryReader(mMemoryStream);
            }
            else
            {
                mMemoryStream = new MemoryStream();
                mBinaryReader = new BinaryReader(mMemoryStream);
            }
        }

        /// <summary>
        /// 关闭二进制读取写入
        /// </summary>
        public void Close()
        {
            mBinaryReader.Close();
            mMemoryStream.Close();
            mBinaryReader = null;
            mMemoryStream = null;
        }
        
        /// <summary>
        /// 读取一个字节数据
        /// </summary>
        public byte ReadByte()
        {
            return mBinaryReader.ReadByte();
        }

        ******
    }
}

测试用例:
NetMessage.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using System;
using System.Collections.Generic;

namespace Net
{
    /// <summary>
    /// 网络消息抽象类
    /// </summary>
    public class NetMessage
    {
        /// <summary>
        /// 消息ID
        /// </summary>
        public ushort MessageID
        {
            get;
            private set;
        }

        /// <summary>
        /// 消息二进制数据
        /// </summary>
        public byte[] MessageData
        {
            get;
            private set;
        }

        /// <summary>
        /// 消息长度
        /// </summary>
        public ushort MessageLength
        {
            get;
            private set;
        }

        private NetMessage()
        {

        }

        public NetMessage(ushort messageid, byte[] messagedata)
        {
            MessageID = messageid;
            MessageData = messagedata;
            MessageLength = (ushort)messagedata.Length;
        }
    }
}

NetMessage msg = new NetMessage(1, Encoding.UTF8.GetBytes("我是消息内容"));
ByteBufferWriter bbw = new ByteBufferWriter();
bbw.WriteShort(msg.MessageLength);
bbw.WriteShort(msg.MessageID);
bbw.WriteBytes(msg.MessageData);
var bytesdata = bbw.ToBytes();
bbw.Close();
ByteBufferReader bbb = new ByteBufferReader(bytesdata);
var msglength = bbb.ReadShort();
var msgid = bbb.ReadShort();
var msgcontent = bbb.ReadBytes(msglength);
Debug.Log("msglength = " + msglength);
Debug.Log("msgid = " + msgid);
Debug.Log("MessageContent = " + Encoding.UTF8.GetString(msgcontent));

输出:
ByteBufferOutput

注意问题：

  1. 大小端问题(前后端写入和读取字节的大小端方式必须一致)

大小端知识:
理解字节序
浅谈字节序（Byte Order）及其相关操作

网络通信

TCP + Socket
流程：

  1. 启动服务器端套接字监听等待客户端连接
  2. 服务器端启动线程监听客户端消息
  3. 启动客户端套接字连接服务器套接字端口
  4. 客户端启动消息发送线程等待向服务器发送客户端消息
  5. 服务器端接受并返回客户端消息
  6. 客户端处理服务器端消息

NetConnector.cs(网络连接抽象类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/// <summary>
/// 网络连接抽象类
/// </summary>
public class NetConnector
{
    /// <summary>
    /// IP地址
    /// </summary>
    public string IpAddress
    {
        get;
        private set;
    }

    /// <summary>
    /// 端口号
    /// </summary>
    public int Port
    {
        get;
        private set;
    }

    /// <summary>
    /// 网络套接字
    /// </summary>
    public Socket NetSocket
    {
        get;
        private set;
    }

    /// <summary>
    /// 是否连接成功
    /// </summary>
    public bool IsConnected
    {
        get;
        private set;
    }

    /// <summary>
    /// IP地址
    /// </summary>
    public IPAddress IP
    {
        get;
        private set;
    }

    /// <summary>
    /// IP以及端口地址
    /// </summary>
    public IPEndPoint IPEndPoint
    {
        get;
        private set;
    }

    public NetConnector()
    {
        NetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IsConnected = false;
    }

    public NetConnector(ProtocolType protocoltype = ProtocolType.Tcp)
    {
        NetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, protocoltype);
        IsConnected = false;
    }

    /// <summary>
    /// 监听指定ip和端口地址
    /// </summary>
    /// <param name="ipaddress"></param>
    /// <param name="port"></param>
    public void ListenTo(string ipaddress, int port)
    {
        IpAddress = ipaddress;
        Port = port;
        IP = IPAddress.Parse(IpAddress);
        IPEndPoint = new IPEndPoint(IP, Port);
        NetSocket.Bind(IPEndPoint);
        NetSocket.Listen((int)SocketOptionName.MaxConnections);
        Console.WriteLine("启动监听{0}成功", NetSocket.LocalEndPoint.ToString());
    }

    /// <summary>
    /// 连接指定地址
    /// </summary>
    /// <param name="ipaddress"></param>
    /// <param name="port"></param>
    public bool ConnectTo(string ipaddress, int port)
    {
        IpAddress = ipaddress;
        Port = port;
        IP = IPAddress.Parse(IpAddress);
        IPEndPoint = new IPEndPoint(IP, Port);

        try
        {
            // 连接指定地址
            NetSocket.Connect(IPEndPoint);
            IsConnected = true;
        }
        catch
        {
            IsConnected = false;
        }
        return IsConnected;
    }

    /// <summary>
    /// 断开连接
    /// </summary>
    public void Close()
    {
        IsConnected = false;
        NetSocket.Shutdown(SocketShutdown.Both);
        NetSocket.Close();
    }
}

NetServer.cs(网络服务器抽象类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/// <summary>
/// 网络服务器抽象类
/// </summary>
public class NetServer : SingletonTemplate<NetServer>
{
    /// <summary>
    /// 服务器是否启动
    /// </summary>
    public bool IsServerStart
    {
        get;
        private set;
    }

    /// <summary>
    /// 网络连接器
    /// </summary>
    private static NetConnector mNetConnector;

    /// <summary>
    /// 限定长度的客户端消息接受二进制数组
    /// </summary>
    private static byte[] ClientMsg = new byte[1024 * 1024];

    public NetServer()
    {
        mNetConnector = new NetConnector();
        IsServerStart = false;
    }

    public NetServer(ProtocolType protocoltype = ProtocolType.Tcp)
    {
        mNetConnector = new NetConnector(protocoltype);
        IsServerStart = false;
    }

    /// <summary>
    /// 启动服务器端口监听
    /// </summary>
    public void StartServer()
    {
        if(IsServerStart == false)
        {
            // 启动服务器端口监听以及等待客户端连接线程
            IsServerStart = true;
            mNetConnector.ListenTo("192.168.1.3", 8888);
            Thread clientconnectthread = new Thread(ClientConnectListener);
            clientconnectthread.Start();                
        }
        else
        {
            Console.WriteLine("服务器端已启动!");
        }
    }

    /// <summary>
    /// 发送消息到客户端
    /// </summary>
    /// <param name="msg"></param>
    public void SendMessage(NetMessage msg)
    {
        //clientsocket.Send(WriteMessage(msg));
    }

    /// <summary>
    /// 客户端连接请求监听线程
    /// </summary>
    private void ClientConnectListener()
    {
        while(true)
        {
            // 检查是否有客户端连接(阻塞的)
            Socket clientsocket = mNetConnector.NetSocket.Accept();
            Console.WriteLine("客户端{0}成功连接", clientsocket.RemoteEndPoint.ToString());
            // 想客户端发送连接成功数据(这里的二进制数据可以换成Protobuf序列化的)
            NetMessage netmsg = new NetMessage(1, Encoding.UTF8.GetBytes("连接成功!"));
            clientsocket.Send(WriteMessage(netmsg));
            // 为连接的客户端创建接受消息的线程
            Thread resmsgthread = new Thread(ReceiveMessage);
            resmsgthread.Start(clientsocket);
        }
    }

    /// <summary>
    /// 写入网络传输所需数据
    /// 1. 数据长度(short - 2字节) -- 用于存储消息数据长度
    /// 2. 消息ID(short - 2字节) -- 用于区分消息类型
    /// 3. 二进制数据(Protobuf) -- 用于序列化和反序列化数据
    /// </summary>
    /// <param name="netmsg"></param>
    private byte[] WriteMessage(NetMessage netmsg)
    {
        ByteBufferWriter bbw = new ByteBufferWriter();
        bbw.WriteShort(netmsg.MessageLength);
        bbw.WriteShort(netmsg.MessageID);
        bbw.WriteBytes(netmsg.MessageData);
        bbw.Flush();
        var bytesdata = bbw.ToBytes();
        bbw.Close();
        return bytesdata;
    }

    /// <summary>
    /// 接受客户端消息
    /// </summary>
    /// <param name="clientsocket"></param>
    private void ReceiveMessage(object clientsocket)
    {
        Socket cltsocket = (Socket)clientsocket;
        while(true)
        {
            try
            {
                int receivenumber = cltsocket.Receive(ClientMsg);
                if(receivenumber == 0)
                {
                    Console.WriteLine("客户端 : {0}断开了连接!", cltsocket.RemoteEndPoint.ToString());
                    cltsocket.Shutdown(SocketShutdown.Both);
                    cltsocket.Close();
                    break;
                }
                else
                {
                    Console.WriteLine(string.Format("接收客户端{0}消息， 长度为{1}", cltsocket.RemoteEndPoint.ToString(), receivenumber));
                    ByteBufferReader bbr = new ByteBufferReader(ClientMsg);
                    // 消息数据长度
                    int msglen = bbr.ReadShort();
                    // 消息id
                    int msgid = bbr.ReadShort();
                    // 数据二进制内容
                    byte[] msgdata = bbr.ReadBytes(msglen);
                    var msgcontent = Encoding.UTF8.GetString(msgdata);
                    Console.WriteLine(string.Format("消息数据长度 : {0} 消息ID : {1} 消息数据内容：{2}", msglen, msgid, msgcontent));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                cltsocket.Shutdown(SocketShutdown.Both);
                cltsocket.Close();
                break;
            }
        }
    }
}

NetClient.cs(网络客户端抽象)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
/// <summary>
/// NetClient.cs
/// 网络客户端抽象
/// </summary>
public class NetClient : SingletonTemplate<NetClient>
{
    /// <summary>
    /// 服务器端的二进制数据缓存区
    /// </summary>
    private static byte[] ServerMsg = new byte[1024 * 1024];

    /// <summary>
    /// 客户端网络连接器
    /// </summary>
    private NetConnector mNetConnector;

    /// <summary>
    /// 是否已连接服务器
    /// </summary>
    public bool IsServerConnected
    {
        get
        {
            return mNetConnector.IsConnected;
        }
    }

    /// <summary>
    /// 消息接受线程
    /// </summary>
    private Thread mMsgReceiveThread;

    public NetClient()
    {
        mNetConnector = new NetConnector();
        mMsgReceiveThread = null;
    }

    public NetClient(ProtocolType protocoltype = ProtocolType.Tcp)
    {
        mNetConnector = new NetConnector(protocoltype);
        mMsgReceiveThread = null;
    }

    /// <summary>
    /// 连接服务器
    /// </summary>
    /// <param name="ip">ip地址</param>
    /// <param name="port">端口号</param>
    public void ConnectToServer(string ipaddress, int port)
    {
        if(IsServerConnected)
        {
            mNetConnector.Close();
        }
        try
        {
            // 连接服务器
            mNetConnector.ConnectTo(ipaddress, port);
            Debug.Log(string.Format("连接服务器:{0}成功!", mNetConnector.IPEndPoint.ToString()));
        }
        catch
        {
            Debug.Log(string.Format("连接服务器:{0}失败!", mNetConnector.IPEndPoint.ToString()));
        }

        if (IsServerConnected)
        {
            // 启动客户端线程去监听接受服务器消息
            mMsgReceiveThread = new Thread(ReceiveMessage);
            mMsgReceiveThread.Start(mNetConnector.NetSocket);
        }
    }

    /// <summary>
    /// 断开连接
    /// </summary>
    public void Close()
    {
        if (IsServerConnected)
        {
            Debug.Log(string.Format("断开服务器地址 : {0}连接!", mNetConnector.NetSocket.RemoteEndPoint.ToString()));
            mNetConnector.Close();
        }
    }

    /// <summary>
    /// 发送消息到服务器
    /// </summary>
    /// <param name="msg"></param>
    public void SendMessage(NetMessage msg)
    {
        if (IsServerConnected == false)
        {
            Debug.Log("服务器未连接成功，无法发送数据!");
            return;
        }
        else
        {
            try
            {
                mNetConnector.NetSocket.Send(WriteMessage(msg));
            }
            catch
            {
                mNetConnector.Close();
            }
        }
    }


    /// <summary>
    /// 写入网络传输所需数据
    /// 1. 数据长度(short - 2字节) -- 用于存储消息数据长度
    /// 2. 消息ID(short - 2字节) -- 用于区分消息类型
    /// 3. 二进制数据(Protobuf) -- 用于序列化和反序列化数据
    /// </summary>
    /// <param name="netmsg"></param>
    private byte[] WriteMessage(NetMessage netmsg)
    {
        ByteBufferWriter bbw = new ByteBufferWriter();
        bbw.WriteShort(netmsg.MessageLength);
        bbw.WriteShort(netmsg.MessageID);
        bbw.WriteBytes(netmsg.MessageData);
        bbw.Flush();
        var bytesdata = bbw.ToBytes();
        bbw.Close();
        return bytesdata;
    }

    /// <summary>
    /// 服务器连接消息接受监听线程
    /// </summary>
    private void ReceiveMessage(object clientsocket)
    {
        Socket cltsocket = (Socket)clientsocket;
        while (true)
        {
            try
            {
                if(mNetConnector.IsConnected)
                {
                    if(mNetConnector.NetSocket.Available > 0)
                    {
                        int receivenumber = cltsocket.Receive(ServerMsg);
                        if (receivenumber == 0)
                        {
                            Debug.Log(string.Format("服务器端 : {0}断开了连接!", cltsocket.RemoteEndPoint.ToString()));
                            break;
                        }
                        else
                        {
                            ByteBufferReader bbr = new ByteBufferReader(ServerMsg);
                            var msglength = bbr.ReadShort();
                            var msgid = bbr.ReadShort();
                            var msgdata = bbr.ReadBytes(msglength);
                            string msgcontent = Encoding.UTF8.GetString(msgdata);
                            Debug.Log(string.Format("服务器返回数据: 消息ID : {0} 消息长度 : {1} 消息内容 : {2}", msgid, msglength, msgcontent));
                        }
                    }
                }
                else
                {
                    break;
                }                    
            }
            catch (Exception ex)
            {
                Debug.Log(ex.Message);
                mNetConnector.NetSocket.Close();
                break;
            }
        }
    }
}

NetMessage.cs(网络消息格式抽象)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/// <summary>
/// 网络消息抽象类
/// </summary>
public class NetMessage
{
    /// <summary>
    /// 消息ID
    /// </summary>
    public ushort MessageID
    {
        get;
        private set;
    }

    /// <summary>
    /// 消息二进制数据
    /// </summary>
    public byte[] MessageData
    {
        get;
        private set;
    }

    /// <summary>
    /// 消息长度
    /// </summary>
    public ushort MessageLength
    {
        get;
        private set;
    }

    private NetMessage()
    {

    }

    public NetMessage(ushort messageid, byte[] messagedata)
    {
        MessageID = messageid;
        MessageData = messagedata;
        MessageLength = (ushort)messagedata.Length;
    }
}

测试用例:

  1. 启动服务器
1
2
NetServer.Singleton.StartServer();
Console.ReadLine();
  1. 启动客户端
1
2
NetClient.Singleton.ConnectToServer("192.168.1.3", 8888);
NetClient.Singleton.SendMessage(new NetMessage(2, Encoding.UTF8.GetBytes("测试客户端发送给服务器!")));

服务器端输出:
ServerOutput

客户端输出:
ClientOutput

可以看到通过Socket编程，我们使用TPC连接成功将消息从客户端发送到服务器以及服务器发送到客户端进行处理。NetMessage的简单封装是为了上层逻辑能区分收到的是什么消息以及消息数据有多少，基于byte[]的存储让我们可以快速的切换数据序列化和反序列化的方式(为后面使用Protobuf打下基础)。

待续……

数据格式解析

服务器

数据库Redis

Reference

进阶

对于网络框架的设计和理论知识进阶学习：
教你从头写游戏服务器框架

基础知识

关系数据库
NoSQL
关系数据库还是NoSQL数据库
数据库选择历程
Redis
SQLite
SQLite和MySQL数据库的区别与应用
两种同步模式：状态同步和帧同步
游戏服务器架构的演进简史
TCP和UDP的区别
OSI模型

相关资料

SQL 教程
SQL Tutorial

实战讲解

我们来用Unity做一个局域网游戏（上）
Unity3D —— Socket通信(C#)
Unity网络服务器搭建【中高级】
教你从头写游戏服务器框架

unity3d联网游戏：客户端与服务器端的交互

IOShootGameDemo

其他

11种服务器编程语言对比（附游戏服务器框架） 2020.06

NoahGameFrame

By

前言

本篇文章是为了记录学习使用Unity第三方插件Odin，通过深入学习Odin，加快平时我们编写编辑器工具的效率。

Odin

Odin是一款可以帮助我们快速制作友好编辑器界面的工具。

功能特性

Serialize Anything

那么什么是序列化？
熟悉二进制导表工具和Proto协议数据发送解析的话，对序列化不会陌生。
从平时我们编写代码的角度来说序列化就是把数据对象存储成二进制(序列化)的过程，然后再通过读取二进制数据能构造出原始对象(反序列化)。

接下来看看Unity官方对序列化的定义：
Serialization is the automatic process of transforming data structures or object states into a format that Unity can store and reconstruct later.(序列化就是将数据结构或对象状态转换成可供Unity保存和随后重建的自动化处理过程。)

官方的序列化远比我们平常说的数据对象序列化更宏大:

  1. 文件的保存/读取，包括Scene、Asset、AssetBundle，以及自定义的ScriptableObject等。
  2. Inspector窗口
  3. 编辑器重加载脚本脚本
  4. Prefab
  5. Instantiation
    所有这些都是通过Unity序列化和反序列化来完成的。

Unity序列化有一套规则，这里就不详细介绍了，详情查看官网:
Script Serialization

众所周知，Unity官方序列化并非所有类型都支持，比如：Dictionary，OOP多态。
这些限制让我们在编写代码时受到诸多限制，而我们一般是通过特定的处理方式去支持这些缺失的特性(e.g. 通过两个List去模拟Dictionary的序列化或者通过自定义序列化去支持OOP多态)
详情查看:
Unity插件开发基础—浅谈序列化系统

所以这里再引出Odin的一大特性：
Serialize Anything(所有序列化都支持(e.g. Dictionary，OOP多态问题等))
这一大特性就已经是相当的强大了，这也是我们采用Odin能够快速编写更加友好的编辑器界面工具的一大原因。

Note:
Odin’s serialization is currently supported on all platforms, save Universal Windows Platform without IL2CPP..

实战

While Odin by default injects itself into the inspector for every type that doesn’t already have a custom editor defined, the serialization system is more conservative than that. You always have to explicitly decide to make use of Odin’s serialization system.

  1. 开启Odin代码Inspector
1
2
3
4
5
6
7
8
9
10
11
12
public class SerializeStudy : MonoBehaviour
{
    /// <summary>
    /// Unity自身不支持序列化的Dictionary
    /// </summary>
    public Dictionary<int, string> SerializeDictionary = new Dictionary<int, string>();

    /// <summary>
    /// Unity自身支持序列化的List
    /// </summary>
    public List<string> SerializeNormalList = new List<string>();
}

UnityListSerializationUI
可以看到默认的Dictionary是不支持序列化的，同时默认的List面板是长上面那样的。

接下来我们通过打开Odin序列化再来对比下区别：
Tools -> Odin Inspector -> Preference -> Editor Types -> User Types
指定我们自定义的SerializeStudy类使用Odin的序列化:
TurnOnCustomClassOdinSerialization
再次对比查看序列化面板:
TurnOnOdinSerializationListUI
可以看到List默认的面板显示已经变成了Odin自定义的了，但是Dictionary依然没有被序列化显示出来，因为我们只是指定了SerializeStudy类使用Odin的Inspector，但还未指定SerializeStudy使用Odin的序列化。

  1. 指定使用Odin序列化
    要支持Dictionary使用Odin的序列化，我们需要显示指定(继承至SerializedMonoBehaviour or SerializedScriptableObject)使用Odin的序列化:
1
2
3
4
public class SerializeStudy : SerializedMonoBehaviour
{
    ******
}

OdinSerializationUI
可以看到我们成功的使用Odin序列化了Dictionary且采用Odin自定义的Inspector显示。

这里再展现一个Odin二维数组类型的序列化使用，从这个可以看出Odin的强大之处:

1
2
3
4
5
6
7
public class SerializeStudy : SerializedMonoBehaviour
{
    /// <summary>
    /// Unity的自身不支持的二维数组
    /// </summary>
    public bool[,] TwoDimensionArray = new bool[5, 5];
}

OdinSerializationTwoDimensionArrayUI
可以看到一句简单的定义在Odin序列化和Odin自定义Inspector的帮助下，帮助我们快速构建和支持了Dictionary和二维数组的序列化，这对于我们构建自己的编辑器可以说是如有神助，而这正式Odin的强大之处。

Note:
关于OOP多态序列化问题，本人测试和Unity插件开发基础—浅谈序列化系统文章里的测试结果不一致(Unity自带序列化支持多态)，本人使用的是2017.4.3f1，所以这里就不实战Odin的OOP多态功能了。

New Attributes

这里的Attribute指的是C#语言里的那个标签Attribute。
A core feature of Odin is how easy it makes it to change the appearance of your scripts in the editor - essentially letting you create powerful, complex custom editors at a whim merely by applying a few attributes to your members.

在不使用Odin前，我们一般是类通过自定义CustomEditor的形式去自定义Editor UI或者是直接通过继承EditorWindow去编写Editor UI工具，主要是通过EditorGUILayout，GUILayout一系列的类来手动完成布局和排版显示等功能。
使用Odin后，我们可以通过Odin提供的Attribute可以快速影响我们自定义脚本的Editor表现，帮助我们快速创建友好的可视化界面。

实战

  1. PropertyOrder(快速指定面板显示顺序)
    Unity默认排序是跟Public可序列化成员变量定义的顺序挂钩的：
1
2
3
4
5
6
public class AttributeStudy : MonoBehaviour
{
    public int Second;

    public int First;
}

UnitySerializationOrderUI
通过Odin的PropertyOrder属性我们可以快速的指定排版顺序

1
2
3
4
5
6
7
8
public class AttributeStudy : MonoBehaviour
{
    [PropertyOrder(2)]
    public int Second;

    [PropertyOrder(1)]
    public int First;
}

OdinPropertyOrderUI
2. ValueDropdown属性(显示指定成员变量下拉可选值)

1
2
3
4
5
6
7
8
9
10
11
public class AttributeStudy : MonoBehaviour
{
    [ValueDropdown("DropDownListString")]
    public string DropDownListStringName;

    private List<string> DropDownListString = new List<string>(){
        "Tony",
        "Tang",
        "Huan",
    };
}

OdinValueDropDownAttributeUI
3. TabGroup属性(指定序列化显示分组)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class AttributeStudy : MonoBehaviour
{
    [TabGroup("Normal List Tab")]
    [PropertyOrder(2)]
    public List<string> NormalListString = new List<string>(){
        "Tony2",
        "Tang2",
        "Huan2",
    };

    [TabGroup("Drop Down Tab")]
    [PropertyOrder(1)]
    [ValueDropdown("DropDownListString")]
    public string DropDownListStringName;

    private List<string> DropDownListString = new List<string>(){
        "Tony1",
        "Tang1",
        "Huan1",
    };
}

OdinTabGroupAttributeUI
4. MetaAttributes属性(e.g. ValidateInput, Required 验证序列化数据输入)

1
2
3
4
5
6
7
8
9
10
11
12
13
public class AttributeStudy : MonoBehaviour
{
    [ValidateInput("IsGreaterThanZero")]
    public int GreaterThanZero;

    private bool IsGreaterThanZero(int value)
    {
        return value > 0;
    }

    [Required]
    public GameObject RequiredValue;
}

OdinValideInputAndRequiredAttributeUI
这里就不所有都一一举例了，从上面可以看出，借助于Odin的Attribute和序列化以及Ordin自定义的Inspector，可以快速帮助我们管理UI排版以及编写高效准确的UI。
更多Attribute详情:
Odin Attributes
Odin官方给的Demo(Assets\Plugins\Sirenix\Demos\Attributes Overview.unitypackage)

Effortless Integration

容易集成这一特性从前面的Serialize Anything和Attribute的简单易用其实已经不言而喻了。

接下来主要学习Odin是如何帮助我们快速创建自定义窗口UI显示的。

  1. Odin普通编辑器窗口
    一般来说我们要自定义窗口UI，我们会继承EditorWindow然后结合EditorGUILayout和GUILayout之类的类来定义窗口UI的显示排版以及逻辑处理。
    基础的Odin窗口需要继承至OdinEditorWindow：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class CustomClassInfoDisplayOdinEditorWindow : OdinEditorWindow
{
    public class CustomClass
    {
        public int Index;
        public string Name;
        public GameObject Go;
    }

    [MenuItem("/TonyTang/Tools/OdinEditorWindow/MyFirstOdinEditorWindow")]
    private static void OpenWindow()
    {
        var window = GetWindow<CustomClassInfoDisplayOdinEditorWindow>();
    }

    public List<CustomClass> CustomClassListData = new List<CustomClass>();
}

​ OdinEditorWindowCustomClassInfoDisplayUI
​ 可以看到借助于继承OdinEditorWindow,我们不再需要重写OnGUI之后去自己定义GUI排版显示以及数据处理，直接编写public可序列化变量就能达到快速显示UI操作交互界面。

  1. Odin带菜单栏的自定义编辑器窗口
    1. 带菜单栏的Odin窗口需要继承至OdinMenuEditorWindow
    2. OdinMenuTree用于创建窗口菜单管理
    3. OdinMenuItem用于创建自定义菜单节点(重写OnDrawMenuItem可自定义菜单节点显示)
    4. 自定义类结合Odin Attribute做自定义显示界面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities;
using System;
using System.Collections;
using UnityEditor;
using UnityEngine;

/// <summary>
/// 自定义含菜单的Odin窗口
/// </summary>
public class CustomOdinMenuEditorWindow : OdinMenuEditorWindow
{
    /// <summary>
    /// 自定义的OdinMenuItem类
    /// </summary>
    public class CustomMenuItem : OdinMenuItem
    {
        /// <summary>
        /// 自定义OdinMenuItem类的数据抽象类
        /// </summary>
        public class CustomMenuItemContentClass
        {
            public int Index;
            public string Name;
            public GameObject Go;
            public bool CheckOn;

            public CustomMenuItemContentClass(int index, string name, GameObject go, bool checkon)
            {
                Index = index;
                Name = name;
                Go = go;
                CheckOn = checkon;
        }
        }

        public CustomMenuItem(OdinMenuTree tree, string name, IList value) : base(tree, name, value)
        {
        }

        public CustomMenuItem(OdinMenuTree tree, string name, object value) : base(tree, name, value)
        {
        }
    }

    /// <summary>
    /// 自定义显示界面的OdinMenuItem类
    /// </summary>
    public class CustomDrawMenuItem : OdinMenuItem
    {
        /// <summary>
        /// 自定义显示界面OdinMenuItem类的数据抽象类
        /// </summary>
        public class CustomDrawMenuItemContentClass
        {
            //利用Odin Attribute排版显示UI
            [FoldoutGroup("自定义折叠组")]
            public int Index;
            [FoldoutGroup("自定义折叠组")]
            public string Name;
            [FoldoutGroup("自定义折叠组")]
            public GameObject Go;
            [FoldoutGroup("自定义折叠组")]
            public bool CheckOn;

            public CustomDrawMenuItemContentClass(int index, string name, GameObject go, bool checkon)
            {
                Index = index;
                Name = name;
                Go = go;
                CheckOn = checkon;
            }
        }

        /// <summary>
        /// 自行保存需要显示的数据
        /// </summary>
        private CustomDrawMenuItemContentClass mCustomDrawMenuData;

        public CustomDrawMenuItem(OdinMenuTree tree, string name, CustomDrawMenuItemContentClass data) : base(tree, name, data)
        {
            mCustomDrawMenuData = data;
        }

        public CustomDrawMenuItem(OdinMenuTree tree, string name, IList value) : base(tree, name, value)
        {

        }

        public CustomDrawMenuItem(OdinMenuTree tree, string name, object value) : base(tree, name, value)
        {

        }

        /// <summary>
        /// 自定义MenuItem显示
        /// </summary>
        /// <param name="rect"></param>
        /// <param name="labelRect"></param>
        protected override void OnDrawMenuItem(Rect rect, Rect labelRect)
        {
            labelRect.x -= 16;
            this.mCustomDrawMenuData.CheckOn = GUI.Toggle(labelRect.AlignMiddle(18).AlignLeft(16), this.mCustomDrawMenuData.CheckOn, GUIContent.none);
        }
    }

    [MenuItem("TonyTang/Tools/OdinMenuEditorWindow/CustomOdinMenuEditorWindow")]
    private static void OpenWindow()
    {
        var window = GetWindow<CustomOdinMenuEditorWindow>();
    }

    protected override OdinMenuTree BuildMenuTree()
    {
        var menutree = new OdinMenuTree(true);

        var custommenustyle = new OdinMenuStyle
        {
            BorderPadding = 0f,
            AlignTriangleLeft = true,
            TriangleSize = 16f,
            TrianglePadding = 0f,
            Offset = 20f,
            Height = 23,
            IconPadding = 0f,
            BorderAlpha = 0.323f
        };

        menutree.DefaultMenuStyle = custommenustyle;
        //添加菜单风格控制显示菜单
        menutree.AddObjectAtPath("菜单风格", custommenustyle);

        //添加MenuItem节点
        var custommenuitemdata = new CustomMenuItem.CustomMenuItemContentClass(1, "CustomMenuItemContentClass", null, false);
        var custommenuitemobj = new CustomMenuItem(menutree, "默认菜单子子节点名", custommenuitemdata);
        menutree.AddMenuItemAtPath("菜单子节点1", custommenuitemobj);

        var customdrawmenuitemdata = new CustomDrawMenuItem.CustomDrawMenuItemContentClass(1, "CustomDrawMenuItemContentClass", null, false);
        var customdrawmenuitemobj = new CustomDrawMenuItem(menutree, "自定义菜单子子节点名", customdrawmenuitemdata);
        menutree.AddMenuItemAtPath("菜单子节点2", customdrawmenuitemobj);


        menutree.EnumerateTree().AddThumbnailIcons().SortMenuItemsByName();

        return menutree;
    }
}

OdinCustomMenuStyleUI
可以看到借助于Odin我们很轻松的创建定义了复杂的编辑器窗口UI显示，不再需要手动通过EditorGUILayout去编写排版，开发效率大大提升，编写出来的UI也更加美观。

这里就不再一一学习使用Odin相关特性，详情查询:
Code Reference
Odin官方给的Demo(Assets\Plugins\Sirenix\Demos\Editor Windows.unitypackage)

Extendable

在了解Odin的高度扩展性之前，我们需要了解Odin的Drawer机制。

The single most important part of understanding how Odin’s drawing system works, is understanding the drawing chain. In Odin, any single property is not drawn by a single drawer; instead each property has many drawers assigned to it.

从上面可以看到，理解Odin drawing system工作机制，我们需要了解Odin的drawing chain(绘制链)。在Odin里每一个显示在面板的Property(这里的Property不等价于C#里的Property)都不是单一一个drawer绘制出来的而是许多个drawers的连续绘制的结果。

首先Odin提供我们了一个叫ShowDrawerChain的Attibute属性，可视化的显示二楼每一个Property的绘制Drawer组合(每一个Drawer有一个优先级，优先级高的在前面)。

OdinShowDrawerChainAttribute

从上图可以看出，我们定义一个int的可序列化字段，通过Odin绘制出来需要三个Drawer:

  1. PropertyContextMenuDrawer (并不做任何的绘制，只做了右键Content Menu显示的检查)
  2. PrimitiveValueConflictDrawer (检查值冲突(比如多选时有不一样的值类型))
  3. Int32Drawer(最终负责绘制int值面板显示的Drawer)

理解了Odin绘制Property是通过连续的多个Drawer组合的形式后，让我们来学习了解Odin里不同种类的Drawer是如何组成Odin的Drawer绘制机制的。

  1. Value Drawers(继承至OdinValueDrawer，优先级(0, 0, 1)，类型默认的Drawer)
  2. Attribute Drawers(继承至OdinAttributeDrawer，优先级(0, 0, 1000)，Attibute绘制)
  3. Attribute Value Drawers(Value Drawers和Atrribute Drawers两者的结合)
  4. Group Drawers(继承至PropertyGroupAttribute，不同于前面三个Drawers，Group Drawers是负责一组Property的指定绘制方式)
  5. Gemeric Drawers(泛型 – 解决显示指定Drawers类型信息的问题)

这里不过多的去纠结Odin底层源代码设计和实现，只是通过了解Odin的绘制设计方式来加深对Odin使用的理解，便于应用到实际工程里去解决具体问题。

更多学习请参考Odin里的Demo和官方文档。

Note:

Note that all drawers in Odin are always strongly typed, and do not allow type polymorphism.(Odin里的Drawer是强类型，不支持多态)

官方使用建议

Getting Started

实战

目标

  1. 编写一个基于Odin的游戏模块的文档说明编辑器工具(Odin)
  2. 自动根据编译信息反射生成最新类型和字段信息(反射判定)
  3. 提供字段可编写自定义介绍的内容并存储共享(ScriptableObject存储共享)
  4. 提供类型，枚举搜索查看功能

先上最终效果图(这里只挑个别展示，主要是学习编写过程中Odin的小知识和小技巧):

  1. 模块文档整体界面
    ModuleDocIntroductionUI
  2. 基础类型说明
    ModuleDocBasicTypeIntroductionUI
  3. Effect详情
    ModuleDocEffectTypeDetailUI

实现

接下来主要从三个方面来学习讲解上面文档工具通过Odin编写所需要注意的技巧和实现。

  1. Odin自定义编辑器菜单实现
  2. Odin自定义类型+Odin自定义编辑器布局显示实现
  3. 自定义编辑器数据序列化存储

自定义编辑器菜单

自定义菜单主要是通过继承Odin的OdinMenuEditorWindow类然后结合自定义OdinMenuTree + 自定义OdinMenuStyle来实现自定义的菜单布局加风格显示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*
 * Description:             GameModuleDocumentEditorWindow.cs
 * Author:                  TANGHUAN
 * Create Date:             2019/06/04
 */

using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities.Editor;
using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// 游戏模块文档编辑器窗口
/// </summary>
public class GameModuleDocumentEditorWindow : OdinMenuEditorWindow
{
    public static OdinMenuStyle MenuStyle  = new OdinMenuStyle
    {
        BorderPadding = 0f,
        AlignTriangleLeft = true,
        TriangleSize = 16f,
        TrianglePadding = 0f,
        Offset = 20f,
        Height = 30,
        IconPadding = 0f,
        BorderAlpha = 0.323f
    };

    *******

    protected override OdinMenuTree BuildMenuTree()
    {
        DocDataUtility.CheckAndCreateFolder(DocDataUtility.DocumentDataSaveFolderPath);
        LoadAllData();

        var menutree = new OdinMenuTree(true);
        menutree.DefaultMenuStyle = MenuStyle;

        menutree.AddObjectAtPath("游戏模块文档", IntroductionEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单", null);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/基础类型说明", DataTypeIntroEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块", EffectModuleIntroEditorWindowData);
        //menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/Effect基础配置介绍", EffectModuleBasicConfigEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/Effect", EffectIntroEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/Effect/Effect预览", EffectPreviewEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/Effect/Effect查询", EffectQueryEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/Effect/Effect详情", EffectDetailEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/EffectView", EffectViewIntroEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/EffectView/EffectView预览", EffectViewPreviewEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/EffectView/EffectView查询", EffectViewQueryEditorWindowData);
        menutree.AddObjectAtPath("游戏模块文档/模块菜单/Effect模块/EffectView/EffectView详情", EffectViewDetailEditorWindowData);

        return menutree;
    }

    [MenuItem("TonyTang/Tools/GameModuleDocument/GameModuleDocumentMenuEditorWindow")]
    private static void OpenWindow()
    {
        var window = GetWindow<GameModuleDocumentEditorWindow>();
    }
    
    ******
}

代码已经很清晰了，这里就不详细说明了。
通过继承OdinMenuEditorWindow重写BuildMenuTree()方法，使用OdinMenuTree自定义菜单栏，配合自定义OdinMenuStyle决定惨淡显示风格。

自定义编辑器布局

自定义编辑器布局主要是通过使用Odin的OdinEditorWindow + Odin自定义序列化类型显示 + Odin序列化标签来实现的。

Effect详细信息自定义窗口部分代码(工作原因，不方便放出全部代码，这里只用作学习记录分享Odin的使用):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/*
 * Description:             EffectDetailEditorWindow.cs
 * Author:                  TONYTANG
 * Create Date:             2019/06/04
 */

using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;

/// <summary>
/// EffectDetailEditorWindow.cs
/// Effect详情窗口
/// </summary>
[TypeInfoBox("子类不会显示父类字段信息!要查询父类字段信息直接查询父类类型!")]
public class EffectDetailEditorWindow : OdinEditorWindow
{
    public class EffectDetailData
    {
        /// <summary>
        /// Effect参数说明数据
        /// </summary>
        public class EffectDetailParamDesData
        {
            /// <summary>
            /// 参数类型信息
            /// </summary>
            [LabelText("")]
            [VerticalGroup("参数类型")]
            [TableColumnWidth(150, Resizable = false)]
            [ReadOnly]
            public string ParamType;

            /// <summary>
            /// 参数名
            /// </summary>
            [LabelText("")]
            [VerticalGroup("参数名")]
            [TableColumnWidth(150, Resizable = false)]
            [ReadOnly]
            public string ParamName = "参数名";

            /// <summary>
            /// 参数介绍
            /// </summary>            
            [LabelText("")]
            [VerticalGroup("参数介绍")]
            [TextArea]
            public string ParamIntro;

            /// <summary>
            /// 参数额外信息
            /// </summary>
            [LabelText("")]
            [VerticalGroup("参数额外信息")]
            [TextArea(3, 6)]
            public string ParamExtraInfo;
        }

        /// <summary>
        /// Effect名
        /// </summary>
        [LabelText("Effect名")]
        [VerticalGroup("基础信息")]
        [TableColumnWidth(220, Resizable = false)]
        [ReadOnly]
        public string EffectName;

        /// <summary>
        /// Effect父类名字
        /// </summary>
        [LabelText("父Effect名")]
        [VerticalGroup("基础信息")]
        [TableColumnWidth(220, Resizable = false)]
        [ReadOnly]
        public string ParentTypeName;

        /// <summary>
        /// Effect参数说明数据
        /// </summary>
        [LabelText("")]
        [VerticalGroup("参数详细信息")]
        [TableList(DrawScrollView = false, IsReadOnly = true)]
        public List<EffectDetailParamDesData> EffectParamDesDetailList = new List<EffectDetailParamDesData>();
    }

    /// <summary>
    /// Effect详细数据列表
    /// </summary>
    [LabelText("Effect详细数据")]
    [TabGroup("Effect参数详情")]
    [TableList(DrawScrollView = true, MaxScrollViewHeight = 800, MinScrollViewHeight = 800, IsReadOnly = true)]
    public List<EffectDetailData> EffectDetailDataList = new List<EffectDetailData>();

    /// <summary>
    /// 枚举说明数据
    /// </summary>
    public class EffectEnumData
    {
        /// <summary>
        /// 参数类型信息
        /// </summary>
        [LabelText("")]
        [VerticalGroup("枚举类型全名")]
        [HideInInspector]
        [ReadOnly]
        public string QualifiedEnumType;

        /// <summary>
        /// 参数类型信息
        /// </summary>
        [LabelText("")]
        [VerticalGroup("枚举名")]
        [ReadOnly]
        public string EnumType;

        /// <summary>
        /// 枚举可选值
        /// </summary>
        [LabelText("")]
        [VerticalGroup("枚举可选值")]
        [ListDrawerSettings(HideAddButton = true, HideRemoveButton = true)]
        public string[] EnumValues;

        /// <summary>
        /// 枚举值说明
        /// </summary>
        [LabelText("")]
        [VerticalGroup("枚举值说明")]
        [TextArea]
        public string EnumValueDecs;
    }

    /// <summary>
    /// 枚举详细数据列表
    /// </summary>
    [LabelText("枚举详细数据")]
    [TabGroup("枚举详情")]
    [TableList(DrawScrollView = true, MaxScrollViewHeight = 800, MinScrollViewHeight = 500, IsReadOnly = true)]
    public List<EffectEnumData> EffectEnumDataList = new List<EffectEnumData>();

    ******
}
  • OdinEditorWindow实现了基于Odin的自定义编辑器入口。
1
public class EffectDetailEditorWindow : OdinEditorWindow
  • 结合自定义类型 + Public类型成员定义决定自定义编辑器显示内容。
1
2
3
4
5
6
7
8
9
10
11
12
13
public class EffectDetailData
{
    ******
}

public List<EffectDetailData> EffectDetailDataList = new List<EffectDetailData>();

public class EffectEnumData
{
    ******
}

public List<EffectEnumData> EffectEnumDataList = new List<EffectEnumData>();
  • 自定义类型需要序列化显示的参数结合Odin序列化标签实现指定方式显示字段。
1
2
3
4
5
6
7
[LabelText("枚举详细数据")]
[VerticalGroup("枚举类型全名")]
[HideInInspector]
[ReadOnly]
[TableColumnWidth(220, Resizable = false)]
[TabGroup("枚举详情")]
[TableList(DrawScrollView = true, MaxScrollViewHeight = 800, MinScrollViewHeight = 500, IsReadOnly = true)]
LabelText -- 表示显示标题
VerticalGroup -- 表示显示分组
HideInInspector -- 表示不显示在编辑器上
ReadOnly -- 表示字段只读不可编辑
TableColumnWidth -- 表示字段单列显示宽度
TabGroup -- 表示标签页分组
TableList -- 表示按表格列表形式显示(DrawScrollView = true, MaxScrollViewHeight = 800, MinScrollViewHeight = 500, IsReadOnly = true -- 是TableList里的细节显示控制)
更多标签详情查看官网:
[OdinDocumentation](https://odininspector.com/documentation)

数据序列化存储

数据序列化存储主要是采用Odin + Unity ScriptableObject
Odin的OdinEditorWindow是继承至EditorWindow，而EditorWindow是继承至ScriptableObject，所以我们直接按序列化ScriptableObject的方式序列化OdinEditorWindow即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 加载指定文档数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="datafullpath"></param>
/// <returns></returns>
public static T LoadDocumentData<T>(string datafullpath) where T : ScriptableObject
{
    if(File.Exists(datafullpath))
    {
        Debug.Log(string.Format("{0}数据加载成功!", datafullpath));
        return AssetDatabase.LoadAssetAtPath<T>(datafullpath);
    }
    else
    {
        Debug.Log(string.Format("{0}数据不存在!", datafullpath));
        return null;
    }
}

/// <summary>
/// 存储指定文档数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="documentdata"></param>
/// <param name="datafullpath"></param>
/// <returns></returns>
public static void SaveDocumentData<T>(T documentdata, string datafullpath) where T : ScriptableObject
{
    AssetDatabase.CreateAsset(documentdata, datafullpath);
    AssetDatabase.SaveAssets();
    Debug.Log(string.Format("保存资源：{0}完成!", documentdata));
}

Reference

Odin Asset Store链接
Odin官网
Script Serialization
Unity插件开发基础—浅谈序列化系统
OdinDocumentation