一、Unity简介

1. Unity界面

Shift + Space : 放大界面

• Scene
  • 界面按钮
    • 渲染模式
    • 2D/3D
    • 光源
    • 声音
    • 各种显示开关
    • 场景中元素图标的显示开关（Gizmos）
    • 搜索框
  • 界面操作
    • 缩放
    • 旋转
    • 移动
    • QWERTY快捷键
• Game
  最终给玩家看到的界面，由场景中的摄像机拍摄到的画面
  • 界面按钮
    • Display 通道
    • 分辨率
    • 缩放Scale：将摄像机拍摄到的画面缩放
    • 播放时最大化
    • 静音
    • 状态信息面板开关
    • 场景中元素图标的显示开关（Gizmos）
• Hierarchy（层级面板）
  能够看到场景中所有的层级对象，与其层级关系
  • 新建
  • 搜索
• Project （项目面板）
  • 一列展示 / 两列展示
  • 与硬盘中的/Project/Assets文件夹同步
• Inspector（属性面板）
  • 作用
    • 选中游戏对象后，在面板看到物体身上的组件
    • 看到一个资源文件的属性
• Console（控制台面板）
  • 按钮
    • Clear：清空
    • Collapse：合并重复项
    • Clear on Play：运行时清空上一次的日志
    • ErrorPause：当程序遇到错误（异常）时暂停
• AssetStore（资源商店）
  • 修改语言
  • 价格以美元做单位

2. 坐标系

• 世界坐标系
  “东西南北”
• 物体坐标系
  “前后左右”
• 中心点 Pivot/Center 快捷键Z
• 坐标系 Global/Local 快捷键X

3. 材质球（Material）

想要修改一个游戏对象的外观，需要使用材质球

4. 资源包（Assets package）

*路径和名字不要有中文

• 导入 Import
• 导出 Export
• 标准资源包 Standard Assets
• 天空盒使用的两种方式
  • Window -> Lighting -> Settings
  • 给摄像机加组件Skybox

5. 预设体（Prefab）

• 设置
  • Select
  • Revert
  • Apply

6. 地形系统（Terrain）

• 上升/下降地形
  最低高度为0
• 恒高地形
• 平滑地形
• 绘制地面纹理
• 绘制树木
  • 可以添加多种树
  • 笔刷大小
  • 树木密度
  • 锁定宽高比
  • 删除
    • 按住shift：删除范围内全部
    • 按住ctrl：删除范围内选择的树木
• 绘制草坪
  • 删除
    同删除树木
• 设置
  • 长宽高

7. 向量

• 标量
  只有大小没有方向
• 基本运算
  • 向量的加减
    • 加法：将两个向量首尾相连，和等于第一个向量的头到第二个向量的尾这个向量
    • 减法：等于被减数的终点到减数的终点这个向量
  • 向量的点乘
  • 向量的叉乘
  • 向量的几何含义

8. 2D 项目与 3D 项目

• 2D与3D项目区别

  • 2D没有天空盒
  • 2D没有默认光源
  • 摄像机的成像模式2D是正交视图，3D是透视图

• 将动画中的所有Sprite帧选中，拖到Hierarchy中就自动生成了一个精灵动画

• 组件

  • Transform
  • Sprite Renderer：精灵图渲染器
    • Sprite：素材图片
    • Color：颜色
    • Flip：翻转
      • FlipX：水平翻转
      • FlipY：垂直翻转
    • Material：材质
    • Sorting Layer：在哪个层排序
    • Order In Layer：决定谁在屏幕前，数字越大越靠前
  • Collider2D
  • Rigidbody2D
  • PhysicsMaterial2D
    • Edit -> Project Settings -> Physics2DSettings 修改默认物理材质

二、Unity脚本

• 脚本在创建后名称不能被修改
• 脚本可以当做一个组件来使用
• 脚本是一个类，继承自MonoBehaviour
• 脚本文件的名称和类名一定要保持一致，否则会不能将脚本挂在GameObject上
• 继承关系：GameObject -> Component -> Behaviour -> MonoBehaviour -> Scripts
  • 此GameObject不是彼Object，是UnityEngine定义的GameObject
• Runtime/Editor 脚本
  • Runtime脚本，执行随着游戏运行时进行而运行
  • Editor脚本，执行在游戏运行前

Unity脚本的生命周期

• Unity中什么都是对象
• 脚本的声明周期：一个脚本对象从最开始执行到最后销毁的全部过程
• Unity中的打印
  • Debug.Log("Message");
  • print("Message"); //不是脚本不能用此方法
• 脚本前的对勾：
  • 脚本是否激活。依赖于Start()和OnEnable()
• 生命周期
  • void Awake()：游戏开始后第一个调用的回调函数。无论脚本是否激活，始终都执行。如果游戏对象未激活，他身上所有的组件是不会触发的
  • void Start()：游戏开始后第一帧执行的回调函数，只会执行一次
  • void OnEnable()：当脚本激活的时候触发一次，可以重复触发
  • void OnDisable()：当脚本取消激活的时候触发一次，可以重复触发
  • void OnDestroy()：当脚本被销毁前触发。脚本被移除或者游戏对象被销毁触发。游戏对象在销毁前会移除身上所有的组件，所以就是脚本被移除的时候触发
  • void Update()：每帧触发一次
  • void LateUpdate()：每帧触发一次，晚于Update()
  • void FixedUpdate()：每隔固定的时间间隔触发一次，时间间隔默认0.02s，在Edit->Project Settings->Time中修改
  • void OnGUI()（基本不用了）：每帧触发两次

graph LR
Awake-->OnEnable
OnEnable-->Start
OnDisable-->OnDestroy
Start-->Update
Update-->LateUpdate
LateUpdate-->Update
LateUpdate-->OnDisable
Start-->FixedUpdate
FixedUpdate-->FixedUpdate
FixedUpdate-->OnDisable

• 先挂的脚本后执行，后挂的脚本先执行。执行顺序可以在Inspector->Execution Order中设置，Default Time数值越小的先执行

三、常用类

1. GameObject类

• GameObject 是一个用来描述游戏对象的类
• gameObject 表示游戏对象，脚本挂给谁，gameObject就是谁

常用属性与方法

• gameObject.name 设置/获取一个游戏对象的名字
• gameObject.tag 设置/获取一个游戏对戏的标签
  • Inspector -> Tag -> Add Tag 或 Edit -> Project Settings -> Tags and Layers 管理标签
  • 标签可以用来查询获取游戏对象
  • 注意：设置的Tag值需要是预先设置好的tag值
• gameObject.layer 设置/获取一个游戏对象的层
  • int型 代表层的序号
  • LayerMask 结构体
    • LayerMask.NameToLayer() 通过层名字获取层号
      gameObject.layer = LayerMask.NameToLayer("abc");
    • LayerMask.LayerToName() 通过层号获取层名字
      gameObject.layer = LayerMask.LayerToName(8);
  • Inspector -> Layer -> Add Layer 或 Edit -> Project Settings -> Tags and Layers 管理层
  • 层是有序号的，前8个不能更改，是系统自定的
  • 层的作用：
    • 场景中可以分层显示
    • Main Camera -> Culling Mask 分层获取图像
    • 指定层接收/屏蔽射线
• 游戏对象的激活
  • 获取游戏对象的激活状态 bool active = gameObject.activeSelf;
  • 设置一个游戏对象的激活状态 gameObject.SetActive(false);
• 查找游戏对象
  • 通过名字查找 GameObject obj = GameObject.Find(string name);
    • 名字不能打错
    • 同名的时候，后创建的先找到，返回找到的这个游戏物体
      GameObject obj = GameObject.Find("/Sphere/Sphere"); 通过路径查找
  • 通过标签查找
    • GameObject obj = GameObject.FindWithTag(string tag); 找到一个，后创建的先找到
    • GameObject[] obj = GameObject.FindGameObjectsWithTag(string tag); 找到所有这个标签的游戏物体
    • 推荐使用tag查找，效率高
  • 通过组件类型查找
    • SphereCollider[] colliders = GameObject.FindGameObjectsOfType<SphereCollider>();
  • GameObject中所有的查询方法，都不能找到非激活的物体
• 获取组件
  • BoxCollider collider = gameObject.GetComponent<BoxCollider>(); 获取组件
  • BoxCollider collider = gameObject.GetComponentInChildren<BoxCollider>(); 从自己开始往子物体中找，获取组件。如果自己有，选中自己的；自己没有，选中子物体的
  • collider.enabled = false; 设置组件的激活状态
• 添加组件 BoxCollider boxCollider = gameObject.AddComponent<BoxCollider>();
  • 添加脚本 gameObject.AddComponent<ScriptName>();
• 销毁游戏对象或者组件

Rigidbody rigi = gameObject.GetComponent<Rigidbody>();
Destroy(rigi);      // 直接销毁
Destroy(rigi, 3);   // 延迟3秒销毁

Destroy(gameObject, 2);     // 2秒后销毁游戏对象

2. Mathf 类

• 角度：360° = 弧度：2π
• 反三角函数求出的都是弧度

Mathf.Lerp不是为了求一个具体的插值，而是一个趋势，t越小，越趋近于a，t越大，越趋近于b

3. Random 类

求随机数

取[min, max)范围内的整型随机数
Random.Range(int min, int max);
取[min, max)范围内的浮点型随机数
Random.Range(float min, float max);

4. Time 类

5. Vector3 结构体

表示一个三维空间中的点的坐标，或者表示一条三维向量

// 实例化一个
Vector3 a = new Vector();   // 默认x,y,z都是0
Vector3 a = new Vector(1, 2);   // x=1, y=2, z=0
Vector3 a = new Vector(1, 2, 3);   // x=1, y=2, z=3

5.1 Vector3的常量

x轴正方向为右，y轴正方向为上，z轴正方向为前

5.2 Vector3中的运算符重载

• + ：x相加 y相加 z相加得到新的点
• - ：x相减 y相减 z相减得到新的点
• * ：例 p * 4 是x/y/z分别乘4 得到新的点
• == ：判断是否相等
• != ：判断是否不等

5.3 Vector3的属性

5.4 Vector3的方法

6. 调试

• 划线调试

// 在两点之间划线
Debug.DrawLine(Vector3 start, Vector3 end);
Debug.DrawLine(Vector3 start, Vector3 end, Color color);
Debug.DrawLine(Vector3 start, Vector3 end, Color color, float duration);
// 从p点开始向direction方向发射射线，长度可以固定
Debug.DrawRay(Vector3 start, Vector3 direction);
Debug.DrawRay(Vector3 start, Vector3 direction, Color color, float duration);

• 日志调试

Debug.Log(string message);
Debug.LogWarning(string message);
Debug.LogError(string message);

7. Transform 类

表示一个物体的位置旋转缩放，维系一个物体的父子关系

// 获取Transform组件
Transform t = GetComponent<Transform>();
gameObject.transform
transform

• 属性

• 常量

• 方法

• transform中所有的查找方法可以找到非激活的

// 速度每秒10米 用10 * Time.deltaTime
transform.Translate(Vector3.right * 10 * Time.deltaTime);        // 沿物体坐标
transform.Translate(Vector3.right * 10 * Time.deltaTime, Space.World); // 沿世界坐标

// 获取主摄像机的Camera组件
// 主摄像机：具有MainCamera的tag值的物体
Camera c = Camera.main;

8. Quaternion 类

• 欧拉角转四元数

Quaternion rotation = Quaternion.Euler(Vector3 euler);
Quaternion rotation = Quaternion.Euler(float x, float y, float z);

• 四元数转欧拉角

Vector3 euler = rotation.eulerAngles;

• 空旋转

Quaternion.identity

• 插值函数

Quaternion.Lerp(Quaternion a, Quaternion b, float t);

• 将一个向量转成一个四元数，用来取方向

Quaternion.LookRotation(Vector3 forward);

• 向量右乘（Quaternion * Vector3）
  几何含义：将向量旋转指定的四元数角度

Vector3 result = Quaternion.Euler(0, 90, 0) * Vector3.forward;
// result是 Vector3.right (1, 0, 0)

9. Input 类

9.1 键盘、鼠标

• 检测按键一定不能写在FixedUpdate()中，检测是每一帧检测一次，FixedUpdate可能一帧触发多次
• 获取鼠标在屏幕上的位置
  • 屏幕坐标是左下角为(0, 0, 0)点，右上角为(Screen.width, Screen.height, 0)点
  • Screen.width屏幕宽Screen.height屏幕高

Vector3 mousePosition = Input.mousePosition;

• 点击鼠标键盘

// KeyCode是一个枚举，包含几乎所有按键
bool isPress = Input.GetKey(KeyCode key)      // 按住按键持续触发
bool isUp = Input.GetKeyUp(KeyCode key)    // 按键抬起的时候触发一次
bool isDown = Input.GetKeyDown(KeyCode key)  // 按键按下的时候触发一次
bool isDown = Input.GetKeyDown(string name) // 容易写错，不推荐

// 专门检测鼠标按键的，用button数字代表按钮
Input.GetMouseButton(int button)
Input.GetMouseButtonUp(int button)
Input.GetMouseButtonDown(int button)

9.2 Input虚拟轴

• Horizontal轴：水平
• Vertical轴：垂直
• Mouse X轴：鼠标在水平方向上的偏移量
• Mouse Y轴：鼠标在垂直方向上的偏移量
• Mouse ScrollWheel轴：鼠标滚轮的偏移量

float horizontal = Input.GetAxis("Horizontal");
float vertical = Input.GetAxis("Vertical");
// 容错判断
if (Mathf.Abs() < 0.1f || Mathf.Abs() < 0.1f) return;
// 做一个方向向量
Vector3 direction = new Vector3(horizontal, 0, vertical);
if (direction != Vector3.zero)
{
    // 得到目标方向
    Quaternoin target = Quaternion.LookRotation(direction);
    // 旋转
    transform.rotation = Quaternion.Lerp(tranform.rotation, target, Time.deltaTime * speed);
    // 移动
    transform.translate(Vector3.forward * speed * Time.deltaTime);
}

父物体想要放在子物体中心：

1. 将父物体作为子物体的子物体
2. reset transform
3. 再将子物体作为父物体的子物体

10. Application 类

都是静态的，用Application.xxxx

• runInBackground：游戏是否支持后台运行
• dataPath：返回当前工程的Assets文件夹路径
• persistentDataPath：根据发布的平台，返回一个持久化路径
• streamingAssetsPath：返回一个StreamingAssets文件夹的路径，是Assets文件夹的一个子文件夹，打包后这个文件夹依然存在
• OpenURL：打开指定的网页
• Quit()：关闭当前应用程序（只有打完包（发布应用程序）后才有效，手游几乎没有）

11. ScreenCapture 类

ScreenCapture.CaptureScreenshot("绝对路径")：截图

• 使用代码截图

using System;
using System.IO;

// 判断
bool exists = Directory.Exists(Application.persistentDataPath + "/Images");
if (exists == false)
{
    // 创建文件夹
    Directory.CreateDirectory(Application.persistentDataPath + "/Images");
}

// 获取时间
DateTime now = DateTime.Now;
// 格式化为自定义的格式
string name = now.ToString("yyyy年MM月dd日 HH时mm分ss秒");

string filePath = Application.persistentDataPath + "/Images/" + name + ".png";

ScreenCapture.CaptureScreenshot(filePath);

• 时间格式化（部分）

12. Scene Manager 类

• 场景切换：在发起切换的场景中做一个panel，做切换画面，放一个Slider把Handler删除，Interactable取消勾选，动态修改value值为asyncOperation.progress

using UnityEngine.SceneManagement;

// 1. 将需要切换的场景添加到Scenes In Build
// File -> Build Settings -> Scenes In Build 
// 按按钮添加，右键选场景删除
// 拖拽后每一个场景都有一个编号
// 2. 使用SceneManager类来切换
// 同步切换
void SceneManager.LoadScene(string name);    // 通过场景名字切换
void SceneManager.LoadScene(int index);      // 通过场景下标编号切换
// 异步切换
AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(string name);   // 通过场景名字切换
AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(int index);     // 通过场景下标编号切换
// 可以通过asyncOperation拿到切换的进度
// 在Update()中使用进度
private void Update()
{
    if (asyncOperation != null)
    {
        print(asyncOperation.progress);
    }
}

• DontDestroyOnLoad 静态方法
  此静态方法允许游戏物体在加载任何场景的时候不销毁，只能让根物体不销毁，可以用来管理全局的事务

DontDestroyOnLoad(Object target);

使用此方法存在一个问题，当在A场景生成了DontDestroyOnLoad的游戏物体后，切换B场景，再切回A场景，会出现多次调用该方法，从而无限循环，解决办法如下：

1. 将需要全局保留的物体放到一个初始场景里，游戏运行第一时间就加载，加载完成再跳到初始页面
2. 判断该方法是否已经调用过，设一个全局（静态）变量默认False，当运行过一次之后将其变为True，之后每次进入判断True是否调用
3. 使用静态构造方法，当第一次使用这个类的时候调一次，所以这个静态构造方法全局只会调用一次，在这个构造方法中创建空物体，将此脚本绑定上去，再DontDestroyOnLoad这个空物体，此时这个DontDestroyOnLoad全局只会调用一次，这个脚本也做成了类似单例脚本，使用方便

13. Audio Source 类

用于管理播放声音文件

• AudioSource组件
  • AudioClip：音源文件
  • Output：混音调音
  • Mute：静音
  • Loop：循环
  • Volume：音量
  • Spatial Blend：使用2D还是3D声音。2D声音没有位置；3D声音有位置，可以调声音曲线

// 获得AudioSource组件
private AudioSource _audio;
_audio = GetComponent<AudioSource>();

// 加载播放音效
AudioClip clip = Resources.Load<AudioClip>(string path);

// 播放一次
_audio.PlayOneShot(clip);

// 设置一个新的要播放的声音片段
_audio.clip = clip;
// 设置其他的
_audio.loop = loop;
// 背景音播放
_audio.Play();

// 死亡第一段
private void Die1()
{
    // 延迟播放第二段
    Invoke("Die2", 0.5f);
}
// 死亡第二段
private void Die2()
{
    
}

14. Invoke 延迟调用

• Invoke(string functionName, float delay); 延迟调用方法
• CancelInvoke(string functionName); 取消指定方法的延迟调用
• Cancel(); 取消所有延迟调用的方法

15. Gizmos 类

• Gizmos是用于在场景视图可视化调试或辅助设置
• 所有gizmo绘制需要在脚本的OnDrawGizmos或OnDrawGizmosSelected里完成
• OnDrawGizmos在每帧调用。所有在OnDrawGizmos中渲染的gizmos都是可见的。OnDrawGizmosSelected仅在脚本附加的物体被选择时被调用。
• 静态变量

• 静态方法

引用自http://wiki.ceeger.com/script/unityengine/classes/gizmos/gizmos

四、物理引擎

1. 碰撞体 Collider

1.1 属性

• Edit Collider：编辑碰撞体的大小
• Is Trigger：是否是触发器
• Material：物理材质
• Center：中心点位置
• Size：缩放比例
• Radius：半径
• ...

1.2 碰撞体的作用

• 碰撞
• 射线

1.3 回调方法

1.4 获取范围内碰撞体

1.5 碰撞

• 碰撞三要素
  • 碰撞双方都有Collider组件，并且不是Trigger
  • 至少有一方有rigidbody组件
  • 双方需要保持相对运动
• 回调方法

collision 是碰撞的信息

// 存有所有接触点的数组
Vector3 point = collision.contacts[0].point;
// 获取到和哪一个碰撞体发生碰撞了
Collider c = collision.collider;

1.6 设置物理引擎相关参数

Edit -> Project Settings -> Physic

2. 刚体 Rigidbody

完成逼真的物理效果的物理组件

2.1 属性

• Mass：质量
• Drag：阻力
• Angular Drag：角阻力
• Use Gravity：使用重力
• Is Kinematic：开启动力学，不受任何力
• Interpolate：插值
  • none：无
  • interpolate：内插值
  • extrapolage：外插值
• Collision Detection：碰撞检测模式
  • Discrete：离散检测，精度不高，性能消耗低，检测不到极端情况
  • Continuous：连续检测，提高检测精度，性能消耗大
  • Continuous Dynamic：连续动态检测，提高检测精度，性能消耗大
• Constraints 约束

2.2 代码中的属性和方法

Inspector面板上显示的属性都可以用代码获取到

2.3 层检测与层屏蔽

// 已知cube1是第9层，cube2是第10层
// 层检测
LayerMask mask = 1 << 10 | 1 << 9; // 获取第9和10层
LayerMask mask = 1 << LayerMask.NameToLayer("cube1"); // 获取第9层
LayerMask mask = GetMask(params stirng[] layerNames);
// 层屏蔽
mask = ~mask;  // 按位取反mask

3. 触发 Trigger

触发会用到Collider的IsTrigger

• 触发三要素
  • 两个物体都有碰撞体
  • 至少有一个带有刚体
  • 至少有一个是触发器
• 触发的回调

4. 射线 Ray

• 射线包含起点和方向，Unity中可以限定射线长度（Vector3的长度）
• 有Collider的物体会被射线打中，碰撞体和触发器都能被触发
• 系统提供了一个层叫Ignore Raycast，用于忽略射线

// 生成射线
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
// 声明一个RaycastHit，用来存储射线打中的物体的信息，**是一个结构体，值类型**
RaycastHit hit;
// 发射射线
// true：打中物体了  false：没有打中物体
bool result = Physics.Raycast(ray, out hit);
if (result)
{
    // 获取射线打中的物体
    hit.collider;
    // 获取射线打中的坐标（世界坐标）
    hit.point;
}

// 发射一条射线，返回射线打中的所有物体
RaycastHit[] hits = Physics.RaycastAll(ray);

5. 动态生成游戏物体

// 生成谁
public GameObject plane;
// 在哪生成
// 旋转是什么
Instantiate(Object obj, Transform parent);  // 游戏对象生成并绑定父物体
Instantiate(Object obj, Transform position, Quaternion q)   // 在指定的位置position使用指定的旋转q生成游戏对象obj

• 代码读取 Resources 中的Prefab

// 资源路径一定是 /Resources/ 或其子文件夹中，否则读取不到
// 示例中放在了 /Resources/Bullet/bullet1
GameObject _bulletPre;
private void Start(){
    // Load()的返回值是Object，所以要向下转型
    _bulletPre = Resources.Load("Bullet/bullet1") as GameObject;
    // 使用泛型的返回值是 T 类型，可以不用转型
    _bulletPre = Resources.Load<GameObject>("Bullet/bullet1");
    // 加载文件夹中所有的 T 类型资源
    GameObject[] objs = Resources.LoadAll<GameOBject>("Bullet");
}

五、UGUI

• 用于绘制2D界面，Z轴方向的缩放是无效的
• 需要引用命名空间using UnityEngine.UI;

1. Text：文本

• W工具会改变内容的宽高比，T工具不会改变内容的宽高比
• Rect Transform：是Transform的子类
• Canvas Renderer：画布渲染器
• Text(Script)组件
  • Text：显示的文本
  • Character：字体
    • Font：字体
    • Font Style：文字风格
      • 粗体
      • 斜体
      • 粗体+斜体
    • Font Size：字体大小
    • Line Spacing：行间距
    • Rich Text：是否支持富文本（富文本：可以单独修改某些文字的风格）
      例：<b>hello</b> <i>world</i>
  • Paragraph
    • Alignment：对齐方式
    • Align By Geometry：是否对齐到网格
    • Horizontal Overflow：水平方向溢出
      • Wrap：正常
      • Overflow：溢出还显示
    • Vertical Overflow：垂直方向溢出
      • Truncate：正常
      • Overflow：溢出还显示
    • Best Fit：根据文本内容的多少和Text的大小，动态调节文字的大小（条件：需要水平和垂直方向不能是Overflow）
      • Min Size：最小文字大小
      • Max Size：最大文字大小
  • Color：字体颜色
  • Material：字体材质
  • Raycast Target：能否接收射线
• 可添加组件
  • Shadow：Text阴影
    • Effect Color：阴影颜色
    • Effect Distance：阴影距离
    • Use Graphic Alpha：
  • Outline：字体描边
    • Effect Color：描边颜色
    • Effect Distance：描边距离
    • Use Graphic Alpha：
• 代码中的设置

// 获取属性
_text = GetComponent<Text>();
// 属性设置
_text.text = "hello world";
_text.font = Resources.Load<Font>(string path); // 通过Resources文件load
_text.fontStyle = FontStyle.Bold;   // FontStyle枚举
_text.fontSize = 14;
// 段落设置
_text.alignment = TextAnchor.LowerCenter; // 枚举
_text.color = Color.Red;
_text.color = new Color(float r, float g, float b, float a);  // rgba颜色

2. Image 与 Raw Image 图片

• 区别
  • Image显示Sprite，精灵图
  • Raw Image显示Texure，纹理图
• 图片设置
  • Texture Type：图片类型
    • Default：默认为纹理图
    • Sprite(2D and UI)：精灵图
      • Sprite Mode：精灵图模式
        • Single：单图
        • Multiple：多图
• 组件
  • Image(Script)
    • Source Image：图片源，若代码中想修改，需要使用Image.sprite改图片
    • Color：图片颜色
    • Material：图片材质
    • Raycast Target：是否标记为光线投射目标。默认勾选，表明鼠标无法点击该图片后面的物体；不勾选代表可以点击后面的物体
    • Image Type：填充方式
      • Simple：默认填满整个Image
      • Sliced：图片为单张的时候，除了四个角都拉伸，用于做边框
      • Tiled：平铺
      • Filled：填满
        • Fill Method：填充方式
          • Horizontal：水平方向填充
          • Vertical：垂直方向填充
          • Radial 90：以左下角为圆心，按角度填充
          • Radial 180：以下边中心点为圆心，按角度填充
          • Radial 360：以图片中心点为圆心，按角度填充
        • Fill Origin：填充起始位置
        • Fill Amount：填充比例
        • Clockwise：顺时针逆时针
        • Preserve Aspect：保持宽高比
    • Set Native Size：设置原图大小
  • Raw Image
    • Source Image：图片源，需要sprite 代码中使用Image.texure改图片
    • UV Rect：令图片的一部分显示在Raw Image中，可根据x,y坐标让图片动起来
      • X：图片左下角的坐标x
      • Y：图片左下角的坐标y
      • W: 宽 Width
      • H: 高 Height

3. Button 按钮

• 有一个子物体Text
• Button(Scrite)组件
  • Interactable：用户能否交互
  • Transition：在不同的状态间切换的时候显示的效果
    • Normal Color： 按钮实例化后显示的颜色
    • Highlighted Color：鼠标移动到button上显示的颜色
    • Pressed Color：鼠标点击了按钮显示的颜色
    • Disabled Color：禁用按钮时的颜色
    • Color Multipier：颜色切换速度，越大则颜色变化越快
    • Fade Duration：渐变动画的时长，越长越不明显
• 按钮的点击事件
  • 一定是无返回值的事件
  • 通过代码给一个按钮添加一个点击事件

// 声明一个按钮
private Button _button;
// 获取按钮组件
_button = GetComponent<Button>();

// 给按钮添加一个点击事件（监听）
// UnityAction 是void返回无参的委托
_button.onClick.AddListener(UnityAction call);
// 用 Lambda表达式添加一个点击事件
_button.onClick.AddListener(()=>
{
    Debug.Log("Hello world");
});

// 删除按钮的点击事件
_button.onClick.RemoveListener(UnityAction call);
// 删除按钮的所有点击事件
_button.onClick.RemoveAllListeners();

4. Toggle 选项框

由背景Background（Image），对勾Checkmark（Image），标签Lable组成（Text）

• Toggle(Script)
  • Transition：渐变
    • None：无渐变
    • Color Tint：使用color为按钮染色，同button
    • Sprite Swap：在精灵图中切换
      • Tartget Graphic：目标图形，默认的是子物体的Background，是一个Image组件
      • Highlighted Sprite：高亮显示的精灵图
      • Pressed Sprite：点击时显示的精灵图
      • Disabled Sprite：禁用时显示的精灵图
    • Animation：使用Toggle controller控制渐变
  • Navigation：选项框导航，用于遥控器或手柄等设备
  • Is On：设置/获取选项框的勾选状况
  • Toggle Transision：效果
    • Fade：淡入淡出效果
  • Group：分组，将想要单选的所有Toggle放在同一个组中，每组中只能勾选一个
    • Toggle Group组件
      • Allow Switch Off：勾选后，可以一个选项都不选，不勾选时，至少选择一项
• On Value Changed(boolean)：按钮的回调方法，勾选状态变更，会触发一次

// 声明一个Toggle组件
private Toggle _toggle;
// 获取Toggle组件
_toggle = GetComponent<Toggle>();
// 添加事件
_toggle.onValueChanged.AddListener(status =>
{
    // 参数status：表示发生变化后，toggle的isOn
    Debug.Log(_toggle.isOn);
    // 或者就使用status
    Debug.Log(status);
});

5. Slider 滑块

• 由背景background(Image)、Fill Area -> 进度条Fill(Image)、Handle Slide Area -> 滑块Handle(Image)组成
• 用于场景加载进度、下载进度、调音量等等
• Slider
  • Rill Rect：进度条的填充，默认使用子物体的Fill
  • Handle Rect：滑块的填充，默认使用子物体的Handle
  • Direction：方向
    • Left To Right：从左到右
    • Right To Left：从右到左
    • Bottom To Top：从下到上
    • Top To Bottom：从上到下
  • Min Value：最小值
  • Max Value：最大值
  • Whole Numbers：滑块代表的值只能是整数
  • Value：当前滑块所在的值（属性value：可读可写）
• OnValueChanged(Single)
  • Single是单精度浮点型
  • 代码同toggle

6. Input Field 输入框

• 由子物体Placeholder(Text)和Text(Text)组成
• Input Field自带一个Image组件，代表输入框的背景
  • Placeholder：没有任何字符输出的时候，显示在输入框中
  • Text：用户输入的内容文本
• Input Field(Script) 组件
  • Text Component：用户输入的文本显示在哪个文本框中，按本身的输入框文本样式的显示
  • Text：输入框中的文本
  • Character Limit：位数限制，0是不限位置
  • Content Type：文本类型
    • Standard：标准
      • Line Type：换行方式
        • Single Line：单行显示
        • Multi Line Submit：超出显示范围另起一行
        • Multi Line Newline：可以使用回车键另起一行
    • Autocorrected：自动纠错
    • Integer Number：只能输入整型数字
    • Decimal Number：可以输入浮点型数字
    • Alphanumeric：可以输入字母和数字
    • Name：每个单词的首字母自动大写
    • Email Address：可以输入邮件格式
    • Password：将输入的文字以星号*显示
    • Pin：将输入的文字以星号*显示，只能输入数字
    • Custom：自定义
      • Line Type：换行方式
        • Single Line
        • Multi Line Submit
        • Multi Line Newline
      • Input Type：输入方式
        • Standard
        • Auto Correct
        • Password
      • Keyboard Type：键盘模式
        • Default
        • ASCII Capable
        • Numbers And Punctuation
        • URL
        • Number Pad
        • Phone Pad
        • Name Phone Pad
        • Email Address
        • Nintendo Network Account
      • Character Validation：字符验证
        • None
        • Integer
        • Decimal
        • Alphanumeric
        • Name
        • Email Address
  • Caret Blink Rate：光标闪烁频率（1秒几次，默认0.85次）
  • Caret Width：光标宽度
  • Custom Caret Color：自定义光标颜色
  • Selection Color：自定义选择颜色
  • Hide Mobile Input：隐藏系统键盘，iOS专用
  • Read Only：只读不能写
• On Value Changed(Stirng) 每次输入框改变都触发
• On End Edit(String) 停止编辑后触发一次

7. Dropdown 下拉菜单

• 由标签label 箭头arrow 模板template（下拉菜单每一个选项的模板）组成
• Dropdown(Script)组件
  • Template
  • Caption Text：将选择的选项中的文字显示在指定的Text组件中
  • Caption Image：将选择的选项中的图片显示在指定的Image组件中
  • Item Text：每个选项中的文字显示在指定的Text组件中
  • Item Image：每个选项中可以加图片，显示在指定的Image组件中
  • Options
• OnValueChanged(Int32)
  参数是Option的序号，从0开始
• 代码设置Dropdown

// 声明一个dropdown
Dropdown _dropdown = GetComponent<Dropdown>();
// Dropdown.OptionData用来存Option数据
List<Dropdown.OptionData> data = new List<Dropdown.OptionData>()
{
    new Dropdown.OptionData(){ text = "helloworld1" },
    new Dropdown.OptionData(){ text = "helloworld2" }
};
// 两种方式设置options
// 1. 覆盖之前的所有设置
_dropdown.options = data;
// 2. 添加设置
_dropdown.AddOptions(List<Dropdown.OptionData> data);

8. Panel

• 自带一个Image组件，是一个有勾边有圆角的Image，默认alpha通道小
• 更多情况下来做容器，默认和父物体一样大

9. Rect Transform

继承自Transform，拥有transform的所有属性方法

• Pivot：轴（心）点
  • 一个物体的中心，T工具中心的空心蓝点，
  • 如果选择了Center，不能移动轴点
  • 如果选择了Pivot，可以移动轴点
  • X：轴点的X比例，1是最右侧，0是最左侧
  • Y：轴点的Y比例，1是最上侧，0是最下侧
  • (0, 0)是左下角，(1, 1)是右上角
• Anchor：锚点
  • 锚点是两个点
  • 锚点之间的关系
    • 锚点：Min = Max 是一个点
      • Pos X：轴点到锚点水平方向的间距，轴点 - 锚点
      • Pos Y：轴点到锚点垂直方向的间距，轴点 - 锚点
      • Width：物体的宽度
      • Height：物体的高度
    • 锚线：Min != Max 坐标有一个相同，有一个不同，两点连成一条线
      • 水平
        • Left：物体的左边缘到左边锚点的水平间距
        • Pos Y：轴点到锚点垂直方向的间距
        • Right：物体的右边缘到右边锚点的水平间距
        • Height：物体的高度
      • 垂直
        • Pos X：轴点到锚点水平方向的间距
        • Top：物体的上边缘到上边锚点的垂直间距
        • Width：物体的宽度
        • Bottom：物体的下边缘到下边锚点的垂直间距
    • 锚框：Min != Max坐标都不同，连城一个矩形，min在左下角，max在右上角
      • Left：物体的左边缘到左边锚点的水平间距
      • Right：物体的右边缘到右边锚点的水平间距
      • Top：物体的上边缘到上边锚点的垂直间距
      • Bottom：物体的下边缘到下边锚点的垂直间距
  • 锚点是相对于父物体的
• 代码中修改RectTransform

// 获得RectTransform组件
RectTransform rect = GetComponent<RectTransfor>();

// 矩形右上角的相对于父物体的按比例坐标位置
rc.anchorMax = new Vector2(0.7f, 0.7f);
// 矩形左下角的相对于父物体的按比例坐标位置
rc.anchorMin = new Vector2(0.7f, 0.7f);

// 矩形的右上角相对于右上角锚点的偏移量(x轴，y轴)
// 两个参数是RectTransform的(-左下角，-右上角)
rc.offsetMax = new Vector2(10, 10);
// 矩形的左下角相对于左下角锚点的偏移量(x轴，y轴)
// 两个参数是RectTransform的(左上角，右下角)
rc.offsetMin = new Vector2(10, 10);

// 矩形的轴点相对于锚点的偏移量
rc.anchoredPosition = new Vector2(10, 10);

// 轴点的按比例坐标位置
rc.pivot = new Vector2(5, 5);

// 当两点重合时，代表高度和宽度
// 当两点不重合时（？跟失了智一样）
rc.sizeDelta = new Vector2(10, 10);

10. UGUI事件的回调

UGUI事件使用接口回调，使用时要使脚本类实现接口的方法

11. Canvas 画布

• 添加UI组件时自动添加，所有的UI元素必须是canvas的子物体
• 一个场景中可以放多个画布
• 画布的大小：和屏幕一样大
• Canvas组件
  • Render mode：渲染模式
    • Screen Space - Overlay：平铺，呈现在所有物体之前
      • Sort Order：决定多个画布的前后顺序，数字越大越靠前
      • Target Display：在指定通道渲染
    • Screen Space - Camera：指定摄像机渲染，物体前后顺序由Plane Distance决定。在UI上做些特效的时候使用。
      • Render Camera：指定使用哪个摄像机进行渲染
      • Plane Distance：画布距离摄像机的间距
      • Sorting Layers：在哪个图层排序
      • Order in Layer：在排序图层中的顺序，数字越大越靠前
    • World Space：可以把画布当做一个三维的物体来使用，此时Rect Transform可以修改
      • Event Camera：使用的摄像机
      • Sorting Layers：在哪个图层排序
      • Order in Layer：在排序图层中的顺序，数字越大越靠前
• Canvas Scaler：多分辨率适配：找一个模板，按该模板的分辨率做UI，其他分辨率缩放
  • UI Scale Mode：屏幕缩放的模式
    • Constant Pixel Size：按恒定的像素大小缩放
    • Scale With Screen Size：按屏幕尺寸缩放
      • Reference Resolution：分辨率
      • Screen Match Mode：缩放模式
        • Match (Width ~ Height)：按宽或高的比例缩放，或者是其中的某一个比例
    • Constant Physical Size：按恒定的物理尺寸缩放
• Graphic Raycaster：决定能否相应事件
  按照默认设置即可

12. EventSystem 事件系统

添加UI组件时自动添加，表示这个场景中的所有画布能否响应事件

13. Camera 摄像机

• 一个场景可以放多个摄像机
• Camera组件
  • Clear Flags：摄像机背景，默认是Skybox
    • Skybox：天空盒
    • Solid Color：纯色背景
    • Depth Only：透明背景，显示物体不显示天空盒
    • Don't Clear：不清除物体原来的轨迹
  • Culling Mask：摄像机显示指定层的物体，默认Everything
    • Nothing
    • Everything
    • 各个层的名字...
  • Projection：摄像机的成像模式，默认Perspective透视图
    • Perspective：透视图，近大远小，视野范围是一个金砖型空间
      • Feild of View：视角，角度[0, 180]，一般为60
    • Orthographic：正交图，物体的真实大小，视野范围就是一个立方体空间，可以做对齐操作
      • Size：摄像机的视野平面范围
  • Clipping Planes：摄像机视野的纵向范围，在近景面和远景面之间的物体可以被拍到
    • Near：近景面
    • Far：远景面
  • Viewpoint Rect：最终摄像机拍到的画面在屏幕中的位置和大小
    • 坐标点在左下角
    • XYWH四个值都是[0, 1]取值范围，代表比例
  • Depth：深度，控制摄像机的前后，数字越大越靠前，显示的越靠上
  • Target Texture：目标纹理图
• 可添加组件
  • Skybox组件：使用指定的Skybox
• 小地图的制作思路
  在Project中新建一个Render Texture（是一个纹理图，存在文件中），把Camera拍摄到的画面存到Render Texture中，在Hierarchy中新建一个Raw Image，用来展示Render Texture，此Raw Image就是小地图

14. Layout 布局组件

为了方便对某个物体的子物体布局位置和大小进行调整，布局组件互相之间冲突，最多只能有一个布局组件

• Horizontal Layout Group：水平布局
  • Padding：内间距
    • Left
    • Right
    • Top
    • Bottom
  • Spacing：每两个物体之间的间距
  • Child Alignment：子物体的整体的对齐方式
  • Child Controls Size：能否通过布局组件修改子物体的宽高，勾选后子物体的宽高不能修改
  • Child Force Expand：通过调整物体位置，适当拉伸，填满整个屏幕
• Vertical Layout Group：垂直布局，内容同水平布局
• Grid Layout Group：网格布局
  • Padding：内间距
  • Cell Size：单元格大小
  • Spacing：间距，包含水平间距X和垂直间距Y
  • Start Corner：布局起始的位置和方向
  • Start Axis：布局轴，向哪个方向布局
  • Child Alignment：子物体的整体的对齐方式
  • Constraint：默认Flexible
    • Flexible：自由
    • Fixed Column Count：固定列数
    • Fixed Row Count：固定行数

15. Scroll View 滚动视图

由 ViewPort（展示区域） -> Content（展示内容） 和两个 ScrollBar（滚动条） -> Sliding Area（滑轨） -> Handle（滑块） 组成

• Scroll View
  • Image组件：展示区域的背景
  • Scroll Rect(Script)组件
    • Content：关联能够显示的范围
    • Horizontal：是否支持在水平方向滚动，拖滚动条可以动，滚轮和拖内容不能动
    • Vertical：是否支持在垂直方向滚动
    • Movement Type：默认越界回弹
      • Unrestricted：不限制，越界之后原地停留
      • Elastic：越界回弹
        • Elasticity：弹性系数，值越大回弹越慢
      • Clamped：限制，不让越界
    • Inertia：是否有惯性
      • Deceleration Rate：减速率，0为没有惯性马上停，1为没有减速，1以上是加速
    • Scroll Sensitivity：滚动灵敏度，用滚轮滚动的时候的灵敏度
    • 关联子物体
    • Visibility：滚动条的显示与隐藏
    • On Value Changed(Vector2) 回调方法
• Viewport：展示区域
  • Image组件
  • Mask组件：遮罩，遮住父物体外面的物体
• Content：空物体，内容集合
  • 把想滚动的物体作为Content的子物体，Content的大小决定了能否滚动
  • 借助布局组件的方式
    • 任意添加一个布局组件
    • 添加一个组件Content Size Fitter：可以根据布局组件自动计算Content的大小
• Scroll Bar：滚动条
  • Handele Rect：关联拖拽的滑块是哪一个
  • Value：滑块滑动表示一个值[0, 1]
  • Size：滑块的大小，表示一个比例[0, 1]，如果是0，不会消失，以最小的形式出现
  • Number Of Steps：一个滑轨上有几个点可以让滑块出现，范围[0, 11]，0的时候为平滑滑动
  • On Value Changed(Single)回调方法

六、动画

1. 一些知识

• 模型中包含动画，由模型师来做，我们在获得的时候就决定了模型能做什么动画
• Unity模型格式推荐.fbx
• 模型在Inspector面板上类似Prefab
• 模型子物体中包含各种零件、网格和动画

2. 旧版动画

• Window -> Animation 创建动画（ctrl + 6 / Command + 6）
• 需选中一个游戏对象
• Samples：每秒播放多少帧
• 横轴表示帧数
• 编辑时选上录制按钮，改帧的Image和把图片拖到时间条上都可以
• Add Property：添加动画物体需要修改属性
  • Rect Transform
  • Image
• Doposheet：逐帧编辑
• Curves：曲线图

3. 新版动画

• Mecanim动画系统
  • 方便的实现任性动画的设置和重用
  • 方便的实现动画剪辑的设置
  • 可视化的动画控制界面
  • 对动画播放的精确控制
• 模型及动画设置
  • Model 模型标签
    • Scale Factor：模型的缩放比例 Unity长度单位为米，一些模型软件长度单位是厘米，所以默认要设置0.01
  • Rig 动画配置标签
    • Animation Type
      • None：无动画
      • Legacy：旧版动画
      • Generic：通用动画（非人型动画）
      • Humanoid：新版人型动画
        • Avatar Definition：骨骼配置
        • Configure：配置，成功后前面会有个✔
          • 会打开新场景，能看到模型骨骼
          • Mapping：骨骼映射图
            • 实线圈：必须配置的骨骼，如果缺失，会影响整个动画的执行
            • 虚线圈：可选骨骼，配置会让动画更精细
            • 人是面对我们的，屏幕右边的是左臂，屏幕左边的是右臂
            • 三种方法做映射：屏幕上选中拖进去，Hierarchy中选中拖进去，拖到下面的列表中
            • Mapping -> Automap 自动映射
          • Muscles & Settings
            • Preview：预览
  • Animation 动画面板
    • Import Animation：导入动画，必选
    • Clips：动画片段
      • 截取片段：调整Start和End的帧数，横轴单位是由（秒:帧）表示的，帧率是30FPS
        • loop match：绿色没有问题，黄色红色都表示有问题
          • Loop Time：是否循环播放
          • Loop Pose：会结合最后一帧和第一帧做一个中和
        • Root Transform Rotation：动画旋转
          • Bake into Pose：动画朝向不会改变
        • Root Transform Position(X)
        • Root Transform Position(Y)
          • Bake into Pose：动画位移不会改变
        • Mirror：镜像动画

4. Animation组件

• 用来播放旧版动画
• Animation：默认在执行什么动画
• Animations：集合，表示这个模型会什么动画，如果模型中包含A动画但是这个集合中没有A动画，则不能切换

// 声明动画组件
private Animation _animation;
// 获得组件
_animation = GetComponent<Animation>();
// 按键切换动画
if (Input.GetKeyDown(KeyCode.W))
{
    _animation.CrossFade("Walk");
}
else if (Input.GetKeyUp(KeyCode.W))
{
    _animation.CrossFade("Idle");
}

5. Animator 组件

• Controller：动画状态机Runtime Animator Controller
• Avatar：骨骼
• Apply Root Motion：应用根动画，跟Bake into Pose联动

6. Animator Controller 动画状态机

滚轮缩放，alt加左键移动画面，把动画拖到状态机中松手，会自动新建状态，delete键删除联系

• Inspector面板设置

  • Motion：执行的动画
  • Speed：动画播放速度
  • Mirror：镜像动画
  • Transitions：联系列表
    • Has Exit Time：有停止播放的时间，勾选上之后播放完前一个动画才会切换到下一个动画
    • Settings：过渡设置
      • Fixed Duration：自动过渡
      • Transition Duration：过渡时间
      • Transition Offset：过渡的偏移量
      • Interruption Source：打断源，动画可以被打断
    • Conditions：切换条件
      • 参数，大于或小于，具体数值
      • 多个条件的时候，是与的关系，满足了所有条件之后才会切换

• Animator状态机设置

  • Layers：层
  • Parameters：参数，切换不同的状态
    • Float
    • Int
    • Bool
    • Trigger
  • 右键
    • Make Transition：建立联系，可以联系自己
    • Set as Layer Default State：设置为层默认状态
    • Copy
    • Create new BlendTree in State
    • Delete

  通过代码控制状态机：

  // 获取Animator组件
  private Animator _animator;
  _animator = GetComponent<Animator>();
  
  // 设置
  _animator.SetInteger(string name, int value);
  _animator.GetInteger(string name);
  _animator.SetFloat(string name, float value);
  _animator.GetFloat(string name);
  _animator.SetBool(string name, bool value);
  _animator.GetBool(stirng name);
  _animator.SetTrigger(string name);
  
  // 将一个字符串类型的参数名称转成一个对应的HashCode
  int Animator.StringToHash(string name);
  
  // 使用整型id设置，可以稍微提高效率
  _animator.SetInteger(int id, int value);
  _animator.GetInteger(int id);
  _animator.SetFloat(int id, float value);
  _animator.GetFloat(int id);
  _animator.SetBool(int id, bool value);
  _animator.GetBool(int id);
  _animator.SetTrigger(int id);
  
  

  • Add Behaviour 给状态添加行为，会生成一个脚本，里面包含StateMachineBehaviour回调

  // 参数 
  // animator：状态机所在的Animator组件，可以通过它.gameObject拿到游戏对象
  // stateInfo：动画状态信息，用来区分不同的状态
  // layerIndex：动画层下标，从0开始
  
  // 回调函数
  // 进入状态的时候调用一次
  override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {}
  // 在某个状态停留的时候持续调用，每帧一次
  override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {}
  // 退出状态的时候调用一次
  override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {}
  // 会在OnAnimatorMove方法之前调用，如果使用了Apply Root Motion进行移动，就不要使用这个，unity会放弃自动位移
  override public void OnStateMove(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {}
  // 调用IK动画方法OnAnimatorIK之后调用
  override public void OnStateIK(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {}
  
  // 判断状态名字是否为指定的
  if (stateInfo.IsName("idle"))
  {
      Debug.Log("name idle");
  }
  // 判断状态的标签是否为指定的
  if (stateInfo.IsTag("idle"))
  {
      Debug.Log("tag idle");
  }
  

7. BlendTree 动画融合树

可以给几个动画做一个融合
右键 -> Create -> From new Blend Tree，双击编辑，点左上角导航条返回，右键Add motion添加动画
就是一种状态

• Blend Type：融合类型
  • 1D：用一个参数来控制这些动画的切换
  • 2D：用两个参数来控制
    • Simple：所有被融合的动画方向不一致
    • Freedom Direction：相比第一个，需要有一个没有方向的动画
    • Freedom Cartesian：随意融合
    • Pos X：第一个参数
    • Pos Y：第二个参数
  • Direct：做表情动画
• Thresholds：阈值
• 播放倍数
• 镜像动画
• Automate Thresholds：是否自动设置阈值
• Compute Thresholds：根据计算的值来设置阈值
  • speed：速率
  • Velocity X
  • Velocity Y
  • Velocity Z
  • AngularSpeed Deg
  • AngularSpeed Red

8. Layers 分层动画

每个层是有权重的

• Base Layer：权重不能设置，默认为1
• Avatar Mask：骨骼遮罩，添加遮罩后，该层上会有“M”标记
• 层有下标，从0开始
• 用代码修改层的权重

private Animator _animator;
_animator = GetComponent<Animator>();

if (Input.GetKeyDown(KeyCode.R)
{
    // 设置权重
    SetLayerWeight(int layerIndex, float value);
}

9. IK 动画

• IK：反向动力学
• 人型模型的IK部位：双手 双脚 眼睛
• 动画状态机中的层设置，IK Pass按钮需要勾选，选上后该层上有“IK”标记

// 获取组件
private Animator _animator;
_animator = GetComponent<Animator>();
// 获取敌人
private Transform _enemy;
_enemy = GameObject.Find("enemy").transform;
// 如果要做IK动画，必须在这个方法中完成
private void OnAnimatorIK(int layerIndex)
{
    // 角度限制
    // 做一个角色指向敌人的向量
    Vector3 direction = _enemy.position - transform.position;
    // 求这个向量和角色前方的向量的夹角
    float angle = Vector3.Angle(direction, transform.forward);
    // 判断
    if (Mathf.Abs(angle)) <= 60)
    {
        // 设置IK部位的权重
        _animator.SetIKPositionWeight(AvatarIKGoal.RightHand, 1);
        // 设置IK部位的位置
        _animator.SetIKPosition(AvatarIKGoal.RightHand, _enemy.position);
    }
    
}

10. Curves 动画曲线

Animation标签中设置

• 横轴：范围[0, 1]，到1动画结束
• 纵轴：随时间改变而变，代表一个值，而且我们能随时获取到

// 需求：根据动画中曲线Curve的值，来实时调整BoxCollider的高度
// 获取Animator组件
private Animator _animator;
_animator = GetComponent<Animator>();
// 获取BoxCollider
private BoxCollider _collider;
_collider = GetComponent<BoxCollider>();
// 获取Curve曲线的值
// 方式：在状态机中添加一个Float类型的参数，名字和曲线名字一致即可
float curve = _animator.GetFloat(Animator.StringToHash("Curve"));
_collider.size = new Vector3(_collider.size.x, curve, _collider.size.z);    // 这样会缩在人物中间
_collider.center = new Vector3(_collider.center.x, curve / 2, _collider.center.z);  // 再控制一下高度

11. Event 动画事件（帧事件）

在动画播放的过程中，让它去执行一个特定的方法，这个方法必须是在玩家身上的脚本中，必须是public，返回值是void，名字和设置的名字相同，参数可以是无参，如果需要参数，则参数类型必须是Float，Int，String，Object这四种之一，不能写多个，值就是Inspector面板上写的值

public void Shout ()
{
    _audio.Play();
}

七、粒子特效

1. 创建

• 右键 -> Effect -> Particle System
• Scene面板中的Particle Effect
  • Play：播放特效
  • Restart：重新播放特效
  • Stop：停止播放特效
  • Playback Speed：播放的速度
  • Playback Time：已播放的时长（有速度加成）
  • Particles：粒子的数量
  • Speed Range：
  • Simulate layers：模拟的层
  • Resimulate：对粒子系统的更改是否马上生效
  • Show Bounds：显示边界

2. Particle System 组件

• Particle System：粒子系统
  • Duration：粒子生成的持续时间
  • Looping：循环生成
  • Prewarm：预热，满数量开始特效
  • Start Delay：延迟生成
    下箭头展开
    • Constant：常量
    • Random Between Two Constants：在两个常量之间随机
  • Start Lifetime：粒子的生命周期，一个粒子从生成到销毁需要经历多长时间，默认5s
    下箭头展开
    • Constant：常量
    • Curve：曲线
      • 横轴：Duration 粒子生成的持续时间
      • 纵轴：常量
    • Random Between Two Constants：在两个常量之间取随机数
    • Random Between Two Curves：在两个曲线之间取随机数
  • Start Speed：粒子的初始移动速度
  • 3D Start Size：分轴调整粒子的初始大小
  • Start Size：粒子的初始大小
  • 3D Start Rotation：分轴设置粒子的初始旋转
  • Start Rotation：粒子的初始旋转
  • Flip Rotation：范围[0, 1]，有这些比例的粒子会以反方向生成
  • Start Color：粒子的初始颜色
    • Color：纯色
    • Gradient：渐变
      上标签表示透明度，下标签表示颜色，最多加8个标签
      • Mode：调色板模式
        • Blend：渐变
        • Fixed：没有渐变直接改变颜色
      • Location：在时间轴的位置代表生命周期比例
    • Random Between Two Colors：在两种颜色重随机
    • Random Betwwen Two Gradients：在两个调色板中随机
    • Random Color：随机颜色
  • Gravity Modifier：重力调整
  • Simulation Space：坐标系，设置粒子特效会随哪个物体移动而移动
    • Local：本地坐标
    • World：世界坐标
    • Custom：自定义坐标
  • Simulation Speed：调整特效播放速度
  • Delta Time：是否使用Time.deltaTime属性来计算特效播放，用于在暂停的时候播放特效
  • Scaling mode：如何使用scale值
    • Hierarchy：从Hierarchy组合计算出自己的缩放值
    • Local：只使用自己的坐标系，忽略任何父物体
    • Shape：将缩放使用给粒子的位置，而不是缩放大小
  • Play On Awake：程序激活后就播放特效，会影响到同一个粒子系统中的其他特效
  • Emitter Velocity：当粒子系统移动的时候使用哪种方式计算速度
    • Transform：使用坐标计算速度
    • Rigidbody：使用刚体计算速度
  • Max Particles：在这个特效系统中的最大粒子数量
  • Auto Random Seed：是否每次激活时使用新的随机种子生成随机数
  • Stop Action：当粒子系统停止产生粒子并且所有的粒子都消失后，对游戏物体做什么动作
    • None：什么都不做
    • Disabled：取消激活
    • Destroy：销毁游戏物体
    • Callback：回调
• Emission：生成
  • Rate Over Time：粒子每秒生成的数量（粒子生成速度）
  • Rate Over Distance：每移动单位长度能产生多少粒子，需要配合世界坐标系使用
  • Bursts：爆发产生粒子
    • Time：从特效播放开始多长时间开始Burst
    • Count：一次Burst产生多少数量的粒子
    • Cycles：这个特效产生多少次Burst
    • Interval：两次Burst之间的时间间隔
• Shape：形状
  • Shape：
    • Sphere：球形
    • 半球形，上半球
    • Cone：锥形
    • Donut：环形
    • Box：立方体形
    • Mesh：网格
    • Circle：圆形
    • Line：线形
• Velocity Over Lifetime：随生命周期修改粒子的速度
• Force Over Lifetime：随生命周期修改粒子收到的力
• Color Over Lifetime：随生命周期修改粒子的颜色
• Size Over Lifetime：随声明周期修改粒子的大小
• Renderer：渲染
  • 材质决定效果，标准资源包中有一些材质

3. Trail Renderer 轨迹渲染，拖尾

• Trail Renderer 组件
  • Width：宽度，数值代表缩放比例

4. Line Renderer 线性渲染

• Line Renderer 组件
  • Materials：材质
  • Loop：首尾相连
  • Width：宽度
  • Positions：位置
    • Size：位置集合的长度
    • Element 0：位置
• 用代码控制线性渲染

// 获得组件
private LineRenderer _line;
_line = GetComponent<LineRenderer>();

// 设置线性渲染需要
// 1. 设置一共要经过多少个点
_line.positionCount = 3;
// 2. 设置每个点的坐标
// 通过每个点的序号设置每个点的坐标
_line.SetPosition(int index, Vecotr3 position); 
// 传一个向量数组作为所有点的坐标，导航的NavMeshPath返回的就是一个Vector3[]，但是不包含起始点和终点
_line.SetPositions(Vector3[] positions);

// 设置loop，导航获得的路径不需要首尾相连
_line.loop = false;

八、导航

1. 导航的定义

• 不同于现实中的GPS，unity中的导航主要体现在鼠标点击地面移动和自动寻路
• 如果有多条路，会选择最近的路线进行导航
• 导航物体需要放置在可移动的导航网格上的时候才可以开始导航

2. 步骤

1. 设置导航静态物体（Navigation Static），哪些东西是不能动的
   方法如下：
   1. 在 Inspector 面板上 name 后面选择 Navigation Static
   2. 在 Navigation 面板上的 Object 中也能设置
   3. 可以设置父物体为导航静态物体，然后选择应用于子物体
2. 烘焙地图
   但凡是场景发生改变，都需要重新烘焙地图
3. 实现导航，添加 NavMeshAgent 组件
   脚本控制，脚本导航谁就挂给谁

// 使用命名空间
using UnityEngine.AI;
// 获取导航组件
private NavMeshAgent _agent;
_agent = GetComponent<NavMeshAgent>();
// 获取终点
private Transform _target;
_target = GameObject.Find("target").transform;
// 开启导航
if (Input.GetMouseButtonDown(0))
{
    // 想开启导航只需要设置终点即可
    // 设置属性
    _agent.destination = _target.position;
    // 使用方法
    _agent.SetDestination(_target.position);
}

3. Navigation 面板

• window -> Navigation面板
  • Agents：可以设一些导航物体模型，给NavMeshAgent中的Agent Type用
  • Areas：分层
    • 系统自带三个层，也可以新建层，颜色对应地图上导航网格的颜色
      • Built-in 1：Not Walkable
      • Built-in 0：Walkable 默认为这个层
      • Built-in 2：Jump
      • 自定义的层...
    • Cost：Unity在计算线路时候附加的权重
  • Bake：烘焙地图
    • Baked Agent Size：根据多大的角色来烘焙地图
      导航物体是一个圆柱体
      • Agent Radius：圆柱体半径，不能设置太小，如果设置太小，Unity会提示；如果设为0，会被调为1
      • Agent Height：圆柱体高度
      • Max Slope：最大爬坡的坡度限制，范围[0, 60]
      • Step Height：台阶的高度，角色能迈上去的最高高度，最高和身高一样，超过的话按最高身高算
    • Generated Off Mesh Links：分离路面导航路线连接设置
      • Drop Height：允许向下掉落的最高高度
      • Jump Distance：允许跳跃的最大距离
    • Clear按钮，点击一次清除Scene面板中所有的导航网格
    • Bake按钮，点击一次获得蓝色导航网格，根据地图的复杂程度来决定烘焙时间，只能在导航面板才会看到导航网格，点击一次变成Cancel，不要连点
  • Object：更改指定物体的导航属性
    只有带Mesh Renderer的物体或Terrain才能被更改
    • Scene Filter：显示过滤器
      • All：所有物体
      • Mesh Renderers：所有带Mesh Renderer的物体
      • Terrain：所有地形
    • Navigation Static：导航静态物体
    • Generate OffMeshLinks：分离路面导航
    • Navigation Area：分层路面导航所在的层

4. NavMeshAgent组件

• Agent Type：此物体的导航物体类型
• Base Offset：导航圆柱体的物体本身的偏移量
• Steering：导航速度相关设置
  • Speed：导航移动的最大速度
  • Angular Speed：导航移动的最大角速度
  • Acceleration：加速率
  • Stopping Distance：距离终点还有多远就停下来（例：去找npc，找到后会和npc保持一段距离，到达停止距离的时候开始减速，停的位置会比设置的距离近一些）
  • Auto Braking：自动刹车，当角色到导航终点的时候自动减速
• Obstacle Avoidance：障碍物的回避设置
  • Radius：回避半径
  • Height：回避高度
  • Quality：回避质量，如果有大量的Agent，将这个值设为0，只处理碰撞，不处理其他的Agent和障碍，节省CPU性能
  • Priority：优先级，范围[0, 99]，数字越低优先值越高，物体只会回避数字比自己低的障碍
• Path Finding：寻路相关设置
  • Auto Traverse Off Mesh Link：自动通过OffMeshLink
  • Auto Repath：自动重新计算路线
  • Area Mask：物体能走哪些层

5. 代码控制

// 设置终点，自动开始导航
// 设置属性
_agent.destination = _target.position;
// 使用方法
_agent.SetDestination(_target.position);
    
// 能让导航圆柱体带动物体的位置更新
_agent.updatePosition = false;
_agent.updateRotation = false;

// 导航剩余距离
_agent.remainingDistance;   // 过大的时候显示Infinity

// 停止导航
_agent.Stop();  // 弃用
// 恢复导航
_agent.Resume();    // 弃用
// 建议使用
_agent.isStopped = true;    // true 为停 false 为导航

// 期望速度（Vector3），Scene面板上的红箭头
_agent.desiredVelosity
// 实际速度（Vector3），Scene面板上的蓝箭头
_agent.velosity

// 声明 path 储存路径信息
NavMeshPath path = new NavMeshPath();
// 计算能否导航到指定的点，如果能，把路径信息存到path中（返回值为bool）
_agent.CalculatePath(vector3 targetPosition, NavMeshPath path);
// 获取路径信息，信息包含了所有的拐点
Vector3[] corners = path.corners;

// 控制物体可以走哪些层（int）
// 0：Nothing
// -1：Everything
// 1：Walkable      1 << 0
// 2：Not Walkable  1 << 1
// 4: Jump          1 << 2
_agent.areaMask = 1 << 1 | 1 << 2;  // 可以走Not Walkable和Jump层

6. 动态路障

需要加Nav Mesh Obstacle组件，不用重新烘焙，不会影响导航网格，碰到路障后等待

• Shape：形状
  • Capsule
  • Box
• Center：中心点设置
  • X
  • Y
  • Z
• Size：大小设置
  • X
  • Y
  • Z
• Carve：碰到路障后是否重新规划路径，如果路都不通，就找一个距离终点最近的地方等待

7. 分离路面导航

• 从一个路面到另一个路面上，两个路面没有联系
• 一般情况下我们把除了地面之外的物体设为分离路面，Navigation面板上设置Off Mesh Link Generation下面的内容
• 跳下去和跳过去的问题通过修改Navigation -> Bake -> Generate Off Mesh Links下面的值就可以，跳上去的问题需要用到Off Mesh Link组件
• Off Mesh Link组件
  点到点跳跃时需要用到次组件
  • Start（Transform）：起始点
  • End（Transform）：终点
  • Cost Override：计算路径时候的权重
  • Bi Direction：是否为双向通行
  • Activated：是否激活
  • Auto Update Position：是否随着起点终点的改变而改变导航的线路
  • Navigation Area：导航线路所在的层

九、数据持久化存储

将数据存储在硬盘中

1. Player Prefs类

• Unity内置的一个用来做数据存储的类
• 优点：使用方便，简单
• 缺点：存储的数据类型有限 int float string
• 适用于：关卡数，最高分，UesrID等...

// 存
PlayerPrefs.SetInt(string key, int value);
PlayerPrefs.SetFloat(string key, float value);
PlayerPrefs.SetString(string key, string value);
// 取
PlayerPrefs.GetInt(string key);
PlayerPrefs.GetInt(string key, int defaultValue);   // 尝试取，如果能取到，返回值，如果取不到，返回默认值
PlayerPrefs.GetFloat(string key);
PlayerPrefs.GetFloat(string key, float defaultValue);   // 尝试取，如果能取到，返回值，如果取不到，返回默认值
PlayerPrefs.GetString(string key);
PlayerPrefs.GetString(string key, string defaultValue);   // 尝试取，如果能取到，返回值，如果取不到，返回默认值

• 存储路径
  • Mac OS X：~/Library/Preferences/
  • Windows：HKCU\Software\ [company name]\ [product name]
• 存储的内容不会互相转型，用什么类型存的就要用什么类型取
• 存储的内容更新不及时，在程序结束的时候才会同步，需要及时Save()

// 删除：
// 删除指定键值对
PlayerPrefs.DeleteKey(string key);
// 删除所有的键值对
PlayerPrefs.DeleteAll();
// 判断文件中是否包含指定的键值对
bool has = PlayerPrefs.HasKey(string key);

// 将对文件的修改同步到文件
PlayerPrefs.Save();

2. XML

• XML是一个特殊格式文档
• XML的结构
  • 节点
    • 元素节点：成对出现 <x> </x>
    • 属性节点：包含name = "xiaoming"
    • 文本节点：元素节点包含的内容是文本节点
  • 元素节点是互相嵌套的，属性节点依赖于元素节点，文本节点包含在元素节点尖括号中
  • 根节点：直接写在文档中的元素节点，被称为是根节点（ROOT），在一个XML文档中，根节点有且只有一个

<!-- 头部信息 -->
<?xml verson="1.0" encoding="utf-8"?>
<Person>
    <name type="string" type1="hello world">xiaoming</name>
    <age>10</age>
    <Pet>
        <Dog>
            <name>hashiqi</name>
            <age>1</age>
        </Dog>
    </Pet>
    <Pets>
        <Dog>
            <name>hashiqi</name>
            <age>2</age>
        </Dog>
        <Dog>
            <name>taidi</name>
            <age>3</age>
        </Dog>
        <Dog>
            <name>keji</name>
            <age></age>
            <!-- 如果节点没有任何内容和子节点，可以直接内部闭合 -->
            <age />
        </Dog>
    </Pets>
</Person>

• C# 中的 System.Xml 类

  • 继承结构：

    • System.Object
      • System.Xml.XmlNode（表示XML节点）
        • System.Xml.XmlDocument（表示XML文档）
        • System.Xml.XmlAttribute（表示XML属性节点）
        • System.Xml.XmlLinkedNode
          • System.Xml.XmlElement（表示XMl元素节点）

  • 属性和方法：

    • System.Xml.XmlNode：所有节点的父类

    属性和方法	作用
    InnerText	获取或设置文本节点的值
    InnerXml	获取 或 通过直接编写XML设置子节点
    Value	获取或设置属性节点的值
    AppendChild(XmlNode node)	将制定的节点添加到该节点的子节点列表的末尾
    XmlNodeList ChildNodes	获取所有子节点
    XmlNode FirstChild	获取第一个子节点
    bool HasChildNode	判断该节点是否包含任何子节点
    SelectSingleNode(string XPath)	选择匹配XPath表达式的第一个节点
    SelectNodes(string XPath)	选择所有匹配XPath表达式的节点

    • System.Xml.XmlDocument：文档

    属性和方法	作用
    CreateXmlDeclaration(string version, string encoding, string standalone)	创建一个具有指定参数的描述（头节点）
    CreateElement(string name)	创建具有指定名称的元素节点
    CreateNode	创建任意一种节点，使用时需要向下转型
    AppendChild(XmlNode node)	继承自XmlNode，添加子节点
    Save(string path)	将XML文档保存到指定的文件
    Load(string filename) +3 overload	从指定的URL加载XML文档
    LoadXML(string xml)	从指定的字符串加载XML文档

    • XmlElement：元素节点

    属性和方法	作用
    SetAttribute(string attributeName, string attributeValue)	设置具有指定名称的属性节点
    GetAttribute(string attributeName)	返回具有指定名称的属性值
    GetAttributeNode(string name) +1overload	获得具有指定名称的属性节点
    HasAttributes(string name)	判断该元素节点是否包含属性

• 生成XML的步骤

  1. 引用命名空间 System.Xml
  2. 生成XML文档（XmlDocument类）
  3. 生成根元素（XmlElement类）添加给文档对象
  4. 依次生成子元素添加给父元素
  5. 将生成的XML文档保存

• 使用代码生成XML文档

// 1. 引用命名空间
using System.Xml;

// 2.1 设定文档路径
private string path = Application.dataPath + "/File/boxCollider.xml";
// 2.2 创建XML文档
// 2.2.1 创建一个XmlDocument文档对象
XmlDocument document = new XmlDocument();
// 2.2.2 创建一个头部描述文件，version需要是一个可以转型成float类的值，standalone传null
XmlDeclaration declaration = document.CreateXmlDeclaration("1.0", "utf-8", null);
// 2.2.3 将生成的描述信息添加到文档中
document.AppendChild(declaration);

// 3.1 创建一个根元素节点
XmlElement root = document.CreateElement("BoxCollider");
// 3.2 将这个节点添加到文档中
document.AppendChild(root);

// 4.1.1 创建元素节点
XmlElement trigger = document.CreateElement("isTrigger");
// 4.1.2 给root添加子节点
root.AppendChild(trigger);
// 4.1.3 给元素节点设置文本节点
trigger.InnerText = "False";

// 4.1.1 创建元素节点
XmlElement material = document.CreateElement("material");
// 4.1.2 给root添加子节点
root.AppendChild(material);
// 4.1.3 给元素节点设置文本节点
trigger.InnerText = "None";

// 5 添加属性节点
// 5.1.1 创建一个属性节点
XmlAttribute attribute1 = document.CreateAttribute("type");
// 5.1.2 设置属性节点的值
attribute1.Value = "Physic Material";
// 5.1.3 给元素节点添加属性节点
material.setAttributeNode(attribute1);

// 5.2 设置属性节点的方法
material.SetAttribute("type", "Physic Material");

// 6. 删除节点
trigger.RemoveAll();
root.RemoveChild(material);

// 7. 直接设置内部xml元素
root.InnerXml = "<size><x>0</x><y>0</y><z>0</z></size>";

// 8. 保存xml文件
document.Save(path); // 需要传入完整的路径加文件名，如果路径文件存在，则会覆盖原文件

• 使用代码读取XML文档

// 创建一个XmlDocument对象
XmlDocument document = new XmlDocument();

// 2. 用document读取内容
// 读取指定的文档
document.load(path);
// 读取指定的xml字符串
document.loadXml(@"
<size>
    <x>1</x>
    <y>1</y>
    <z>1</z>
</size>
")

// 1. 获取所有的子节点
XmlNodeList list = document.ChildNodes;

// 2. 获取第一个子节点
XmlNode root = document.FirstChild;

// 3. 获取指定的节点
XmlNode node = document.SelectSingleNode("Inspector");

// 4. 获取一个节点的InnerText
XmlNode node = document.SelectSingleNode("//BoxCollider");
string innerText = node.InnerText;

// 5. 获取一个节点的属性
XmlNode node = document.SelectSingleNode("/Inspector/BoxCollider/Material");      
// 将node强转为Element
XmlElement element = node as XmlElement;
// 获取element身上的属性节点
XmlAttribute attr = element.GetAttributeNode("type");

// 5.2 获取属性
string result = element.GetAttribute("type");

• 常用的XPath语法

// 1. / 路径分隔符
XmlNode node = document.SelectSingleNode("/Inspector/GameObject");

// 2. // 查找节点, 无论这个节点在哪都能找到
XmlNode trigger = node.SelectSingleNode("//IsTrigger");

// 3. .当前目录  ..父目录
XmlNode node = document.SelectSingleNode("//Center");
XmlNode x = node.SelectSingleNode("../IsTrigger");

// 4. 查找指定下标的节点
// 查询第2个x
XmlNode node = document.SelectSingleNode("/Inspector/x[2]");
// 查询最后一个x
XmlNode node = document.SelectSingleNode("/Inspector/x[last()]");
// 查询倒数第二个
XmlNode node = document.SelectSingleNode("/Inspector/x[last() - 1]");
// 查询序号大于1小于4的x
XmlNodeList list = document.SelectNodes("/Inspector/x[position() < 4 and position() > 1]");

// 5. |
// 查找所有的x和y节点
XmlNodeList list = document.SelectNodes("//x | //y");

// 6. 查找Pet中第二个Dog元素的name元素
XmlNode node = document.SelectSingleNode("//Pet/Dog[2]/name");

// 7. 查找指定的Person元素，要求Person中的age元素必须大于30
XmlNodeList list = document.SelectNodes("/Inspector/Person[age>30]");

// 8. 查找具有指定属性type的material节点
XmlNodeList list = document.SelectNodes("//Material[@type]");

// 9. 查找指定的属性type
XmlNodeList list = document.SelectNodes("//@type");

3. JSON

• 语法：
  • 大括号：写键值对，键和值之间用冒号分隔，键值对之间用逗号分隔，类似字典
  • 中括号：写数据，类似数组

// json的注释
/*
json的注释
*/

{
    "name": "xiaoming",
    "age": 10,
    "gender": '男'
    "pet":
    {
        "name": "hashiqi",
        "age": 3
    }
}

// 另一段json
{
    "name": "诺克萨斯之手",
    "hp": 582.24,
    "attack": 55.88,
    "skills":
    [{
        "name": "被动技能-出血"
    },{
        "name": "Q技能-大杀四方",
        "cd": [9, 8, 7, 6, 5],
        "mp": [30, 30, 30, 30, 30]
    },{
        "name": "W技能-致残打击",
        "cd": [9, 8, 7, 6, 5],
        "mp": [30, 30, 30, 30, 30]
    },{
        "name": "E技能-无情铁手",
        "cd": [24, 21, 18, 15, 12]
    },{
        "name": "R技能-诺克萨斯断头台",
        "cd": [120, 100, 80],
        "mp": [100, 100, 0]
    }]
}

• Unity使用的是 .net 2.0，没有对Json的支持，需要用第三方库
  • System.Json（便于Json生成）
  • LitJson（便于Json解析）
• System.Json 中的类
  • JsonArray：数组
  • JsonObject：键值对
  • JsonValue：具体的值，可以是一个数字，一个字符串等，也可以是一个JsonArray或JsonObject
• LitJson
  • 对象转Json：JsonMapper.ToJson(T model)
  • Json转对象：JsonMapper.ToObject<T>(string jsonString)
  • Project文件夹中建立Plugins文件夹，用于存放第三方库
    Model.cs

public class Player
{
    public string name;
    public int age;
    public char gender;
    public Dog pet;
}

public class Dog
{
    public string name;
    public int age;
    public char gender;
}

JSONOperation.cs

using LitJSON;

// 实例化一个对象
Player player = new Player();
// 输入对象的信息
player.name = "xiaoming";
...

// 将Player的信息生成一个json
string json = JsonMapper.ToJson(player);
PlayerPrefs.SetString("json", json);

// 根据一个Json字符串解析成模型
string json = PlayerPrefs.GetString("json");
Player player = JsonMapper.ToObject<Player>(json);

• JsonUtility 类
  • Unity集成的用来解析生成json的类，用法和LitJson一模一样，效率完胜LitJson
  • 模型中嵌套的类需要添加特性[System.Serializable]
    Model.cs

public class Player
{
    public string name;
    public int age;
    public char gender;
    public Dog pet;
}

[System.Serializable]
public class Dog
{
    public string name;
    public int age;
    public char gender;
}

JsonUtility.cs

// 模型转Json
string json = JsonUtility.ToJson(player);
// Json转模型
Player player = JsonUtility.FromJson<Player>(json);

• JsonUtility 中无法存 List<T> 和 Dictionary<Tkey, Tvalue> 的解决办法：

  • List<T>：使用一个类来包含List<T>

    public class PersonModel : ISerializationCallbackReceiver
    {
        public List<Person> person;
    
        public PersonModel()
        {
            person = new List<Person>();
        }
    }
    
    [Serializable]
    public class Person
    {
        public string name;
        public int age;
        public Dog[] dogs;
    
        public Person()
        {
            dogs = new Dog[2];
        }
    }
    
    [Serializable]
    public class Dog
    {
        public string name;
        public int age;
        public Gender gender;
    }
    
    public enum Gender
    {
        male, female
    }
    

  • Dictionary<Tkey, Tvalue>：使用接口ISerializationCallbackReceiver

    public class PersonModel : ISerializationCallbackReceiver
    {
        [SerializeField]
        List<int> keys;
        [SerializeField]
        List<Person> values;
    
        public Dictionary<int, Person> personList;
    
        public PersonModel()
        {
            personList = new Dictionary<int, Person>();
        }
    
        // 接口的实现方法，解序列化
        public void OnAfterDeserialize()
        {
            var count = Math.Min(keys.Count, values.Count);
            personList = new Dictionary<int, Person>(count);
            for (var i = 0; i < count; ++i)
            {
                personList.Add(keys[i], values[i]);
            }
        }
    
        // 接口的实现方法，序列化
        public void OnBeforeSerialize()
        {
            keys = new List<int>(personList.Keys);
            values = new List<Person>(personList.Values);
        }
    }
    

• JsonObject插件

  • JsonUtility转对象的时候，如果对象包含子类，是无法转换到子类的，这时候需要使用JsonObject
  • 在AssetStore下载JsonObject插件，并导入到Unity中
  • 使用代码解析Json字符串，代码实例：

  private List<Item> itemList = new List<Item>();
   
  /// <summary>
  /// 解析物品Json
  /// </summary>
  public void ParseItemJson(string itemsJson)
  {
      JSONObject j = new JSONObject(itemsJson);
  
      foreach (JSONObject temp in j.list)
      {
          int id = (int)temp["id"].n;
          string name = temp["name"].str;
          Item.ItemType type = (Item.ItemType)System.Enum.Parse(typeof(Item.ItemType), temp["type"].str);
  
          Item item = null;
          switch (type)
          {
              case Item.ItemType.Consumable:
                  int hp = (int)temp["hp"].n;
                  int mp = (int)temp["mp"].n;
                  item = new Consumable(id, name, type, hp, mp);
                  break;
              // 其他类型省略
              default:
                  break;
          }
  
          Debug.Log("item.id = " + item.ID + " , consumable.hp = " + ((Consumable)item).HP);
          itemList.Add(item);
      }
  }
  

4. 数据库

4.1 基础知识

• 数据库分类
  • 本地数据库
    • Sqlite 轻便
  • 网络数据库
    • Oracle
    • SQL Server
    • MySQL
    • DB2
• SqliteManager 可视化管理工具
  • Unity支持的数据库后缀名 .sqlite .db
• 数据库中数据的存储格式
  • 表格
    • 字段（键），不会重复的键称为主键，主键最多1个，可以没有
      • 值

4.2 SQL语句

• SQL语句不区分大小写，表名和键是区分大小写的
• 每一个键都可以有修饰，修饰语句放到类型后面
  常用修饰符：
  • PRIMARY KEY：主键
  • NOT NULL：非空类型
• 类型可以不写，默认是TEXT类型

// 需求：Person
// 字段：姓名（主键），年龄，性别

// 建表
CREATE TABLE Person (name TEXT PRIMARY KEY NOT NULL, age INTEGER, gender);
CREATE TABLE IF NOT EXISTS Person (name TEXT PRIMARY KEY NOT NULL, age INTEGER, gender);
// 增
INSERT INTO Person VALUES ('小明', 10, '男');
INSERT INTO Person (name, age) VALUES ('小红', 12);
// 删
DELETE FROM Person WHERE age > 100 AND age < 20000;
DELETE FROM Person WHERE age % 2 = 1;
// 改
UPDATE Person SET gender = '不知道';
UPDATE Person SET gender = '知道' WHERE age > 100;
// 查
SELECT * FROM Person WHERE age > 100 ORDER BY gender DESC;

4.3 代码使用SQL语句

• 需要用到的动态链接库
  • Sqlite3.dll
  • Mono.Data.Sqlite.dll
  • System.Data.dll
    • Window：\Unity\Editor\Data\Mono\lib\mono\2.0\
    • MacOS：/Application/Unity/Unity.app/contents/Mono/lib/mono/2.0
• 使用到的类

• SqliteConnection的方法

• SqliteCommand的方法

• SqliteDataReader的属性与方法
  使用SqliteDataReader之后要关闭它，否则被视为上次的查询操作还没完成，无法再设置CommandText

using Mono.Data.Sqlite;

// 类
// 与数据库的连接对象
SqliteConnection _connection;
// 执行SQL语句的对象
SqliteCommand _command;
// 读取数据的对象
SqliteDataReader _reader;

// 1. 建立与数据库的连接
// 如果路径下没有数据库，系统会自动帮我们新建一个数据库，如果路径下有数据库，则建立连接
// 1.1 拼接一个数据库的路径
string path = "Data Source = " + Application.dataPath + "/Database/myDatabase.sqlite";
// 1.2 建立与数据库的连接
_connection = new SqliteConnection(path);
// 1.3 创建操作指令对象
_command = _connection.CreateCommand();
// 1.4 打开数据库
// 有打开数据库，就需要有关闭数据库，如果程序结束后数据库没关，数据库会锁上自己，再解锁很麻烦
_connection.Open();

// 2. 建表
// 2.1 写SQL语句
string sql = @"CREATE TABLE IF NOT EXISTS Hero (name TEXT PRIMARY KEY, gender TEXT, book TEXT);";
// 2.2 设置操作指令
_command.CommandText = sql;
// 2.3 执行SQL操作
// 执行一个非查询的语句
_command.ExecuteNonQuery();

// 3. 添加数据
// 3.1 添加一行数据
string sql = @"INSERT INTO Hero VALUES ("萧炎", "男", "斗破苍穹");";
_command.CommandText = sql;
_command.ExecuteNonQuery();

// 3.2 添加多行数据，并返回这个语句对多少行数据产生影响
string[] names = { "林动", "牧尘", "叶凡", "石昊", "唐三", "秦羽" };
string[] genders = {"男", "男", "男", "男", "女", "女"};
string[] books = { "武动乾坤", "大主宰", "遮天", "完美世界", "斗罗大陆", "星辰变" };
// SQL语句
string sql = "";
// 循环拼接
for (int i = 0; i < names.Length; i++)
{
    sql += string.Format("insert into Hero values ('{0}', '{1}', '{2}');", names[i], genders[i], books[i]);
}
_command.CommandText = sql;
// 执行非查询语句并记录返回值
int result = _command.ExecuteNonQuery();
Debug.Log(result);

// 4. 删除数据
_command.CommandText = @"delete from Hero where gender = '女';";
int result = _command.ExecuteNonQuery();
Debug.Log("删除了" + result + "行数据");

// 5. 修改数据
_command.CommandText = @"update Hero set gender = '不知道' where name = '牧尘';";
_command.ExecuteNonQuery();

// 6. 查询数据
// 6.1 返回查询到的数据中的第一行第一列
_command.CommandText = @"select * from Hero;";
object result = _command.ExecuteScalar();
Debug.Log(result);

// 6.2 使用_reader来遍历获取所有的查询结果
_command.CommandText = @"select * from Hero;";
_reader = _command.ExecuteReader();

while (_reader.Read())
{
    string s = "";
    // 6.2.1 通过键的名字来取
    s += _reader["name"] + " | ";
    s += _reader["gender"] + " | ";
    s += _reader["book"];         
    Debug.Log(s);

    // 6.2.2 通过键的下标来取
    s += _reader[0] + " | ";
    s += _reader[1] + " | ";
    s += _reader[2];
    Debug.Log(s);

    // 6.2.3 循环遍历
    for (int i = 0; i < _reader.FieldCount; i++)
    {
        // 通过键下标, 获取键的名称
        string key = _reader.GetName(i);
        // 通过键的下标, 获取键的值
        object value = _reader.GetValue(i);
        s += _reader[i] + " | ";
    }
    Debug.Log(s);
}

// 注意！: _reader在使用结束后, 记得要关闭
_reader.Close();

// 7. 关闭数据库
private void OnDestroy()
{
    _connection.Close();
}

十、进程，线程与协程

1. 进程

• 程序的执行单元，是程序执行所需要所有资源的总和，一个进程就相当于是一个程序，一个程序可以起多个进程，解决了多任务并发的问题
• PC端多用进程，移动端多用线程

2. 线程

• 程序执行的最小单元，进程包含线程，进程创建的时候会自动创建一个进程，称为主线程
• 一个进程可以包含多个线程，线程之间也有层级关系，A线程开辟了B线程，当A线程结束的时候，B线程也结束了
• 理论上说，线程越多，程序执行的效率越高，但是如果无限开辟线程反而会使程序执行效率降低，因为开辟线程需要消耗资源，同时线程会去分掉CPU的时间片
• 线程之间可以资源共享，而进程不能，为了避免多个线程同时访问一个资源，使用了线程锁，保证了同时只有一个线程访问资源
• 线程对游戏引擎不友好，游戏中需要执行的任务几乎都需要用主程序来执行

3. 协程（协同程序)

• 协程不是多线程，是运行在主线程中的一个程序
• 协程每帧执行一次，顺序是Update() -> coroutine -> LateUpdate()

// 动态返回一个枚举器接口的实现类
// 每调用一次yield return，将i加入到一个可枚举的序列里
public IEnumerator GetNumber()
{
    for (int i = 0; i < 10; i++)
    {
        // 输出i
        Console.WriteLine(i);
        // 动态返回
        yield return 0;
    }
}

public IEnumerator GetNumber2()
{
    for (int i = 0; i < 10; i++)
    {
        // 输出i
        Console.WriteLine(i);
        // 每3秒执行一次
        yield return new WaitForSeconds(3);
    }
}

// 协程的嵌套
public IEnumerator GetNumber3()
{
    for (int i = 0; i < 10; i++)
    {
        // 输出i
        Console.WriteLine(i);
        // 等待下面的协程执行结束，继续执行
        yield return StartCoroutine(GetNumber4());
        // 是下面这种写法的简写
        // Coroutine t = GetNumber4();
        // yield return t;
    }
}
public IEnumerator GetNumber4()
{
    for (int i = 0; i < 10; i++)
    {
        // 输出i
        Console.WriteLine(i);
        yield return 0;
    }
}

• 开启协程

// 用IEnumerator开启协程
StartCoroutine(IEnumerator enumerator);
// 使用方法名开启协程，返回值一定是IEnumerator
StartCoroutine(string MethodName);
StartCoroutine(stirng MethodName, object value);

• 停止协程

Coroutine t = StartCoroutine("GetNumber2");
StopCorountine(t);
// 停止全部的协程
StopAllCoroutine();
// 关键字跳出协程
yield break;

• WWW类
  数据下载的类，使用它在网络中下载资源，一定要放在协程里面做下载

void Start()
{
    string path = "http://...想下载图片的url";
    StartCoroutine(Download(path));
}

private IEnumerator Download(string path)
{
    WWW www = new WWW(path);
    
    while(www.isDone == false)
    {
        // 下载中，打印进度
        Debug.Log(www.progress);
        yield return 0;
    }
    
    // 跳出循环，说明下载完成
    
}

private IEnumerator Download2(string path)
{
    WWW www = new WWW(path);
    // 等待下载
    yield return www;
    // 下载完成
}

十一、开发时遇到的一些问题

1. 鼠标点击穿透UI

• EventSystem
  EventSystem中有方法IsPointerOverGameObject()用于判定是否鼠标划入了UI游戏物体

void Update()
{
    // 判断鼠标是否在UI游戏物体上，如果在，就return
    if(EventSystem.current.IsPointerOverGameObject())   return;
    // 处理点击逻辑
    // ...
}

• 利用UI的GraphicRaycaster判定

3D场景中Canvas和场景不是在一个平面上，所以在做鼠标点击事件的时候射线不会被UI挡住，在操作UI的时候背后的场景内也会与点击互动，解决办法如下：

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystem;

public class UIInterceptRaycast : MonoBehaviour 
{
    // EventSystem
    private EventSystem _eventSystem;
    // GraphicRaycaster
    private GraphicRaycaster _caster;

    private void Awake()
    {
        _eventSystem = GameObject.Find("EventSystem").GetComponent<EventSystem>();
        _caster = GameObject.Find("Canvas").GetComponent<GraphicRaycaster>();
    }

    private void Update()
    {
        if (CheckGuiRaycastObjects()) return;
        
        // 在这里处理点击事件
        // ...
    }

    // 检查射线是否打中UI上的物体
    bool CheckGuiRaycastObjects()
    {
        PointerEventData eventData = new PointerEventData(_eventSystem)
        {
            pressPosition = Input.mousePosition,
            position = Input.mousePosition
        };

        List<RaycastResult> list = new List<RaycastResult>();
        _caster.Raycast(eventData, list);
        //Debug.Log(list.Count);
        return list.Count > 0;
    }
}

注意：在做UI的时候一般会用一个Panel做根目录，这个panel也会被添加到GraphicRegistry中的公共列表中，如果是这样的话记得把list.Count > 0改成list.Count > 1，或者直接删除Panel上的继承自Graphic的组件

2. A*算法二维世界寻路

算法核心是存在两个集合，Open和Close，Open集合用于存可以移动的点，Close集合用于存舍弃的点。然后计算Open集合中每个点的F = G + H，G是从起点出发到当前点所消耗的数值，H是当前点到终点的预计消耗，取F最小的点为下一个移动的点，将其从Open集合中删除，加入到Close集合，循环执行，直到Open集合中没有元素，则找到了end

• Point.cs 用于存放点的信息的模型

public class Point 
{
    public Point Parent { get; set; }
    public float H;
    public int X;
    public int Y;
    public float G;
    public float F;
    public bool IsWall;
    public Point(int x,int y,Point parent=null)
    {
        this.X = x;
        this.Y = y;
        this.Parent = parent;
    }
    public void UpdateParent(Point parent,float g)
    {
        this.Parent = parent;
        this.G = g;
        this.F = G+H;
    }
}

• AStar.cs 寻路算法

using System.Collections.Generic;
using UnityEngine;

public class AStar : MonoBehaviour
{
    private const int mapWidth = 15;
    private const int mapHeight = 15;

    private Point[,] map = new Point[mapWidth, mapHeight];

    // Use this for initialization
    void Start()
    {
        InitMap();  //初始化地图
        Point start = map[2, 2];
        Point end = map[12, 12];
        FindPath(start, end);
        ShowPath(start, end);
    }

    private void ShowPath(Point start, Point end)
    {
        int z = -1;
        Point temp = end;
        while (true)
        {
            //Debug.Log(temp.X + "," + temp.Y);
            Color c = Color.gray;
            if (temp == start)
            {
                c = Color.green;
            }
            else if (temp == end)
            {
                c = Color.red;
            }
            CreateCube(temp.X, temp.Y, z, c);

            if (temp.Parent == null)
                break;
            temp = temp.Parent;
        }
        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                if (map[x, y].IsWall)
                {
                    CreateCube(x, y, z, Color.blue);
                }
            }
        }
    }

    private void CreateCube(int x, int y, int z, Color color)
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
        go.name = x + "," + y;
        go.transform.position = new Vector3(x, y, z);
        go.GetComponent<Renderer>().material.color = color;
    }

    private void InitMap()
    {
        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                map[x, y] = new Point(x, y);
                CreateCube(x, y, 0, Color.black);
            }
        }
        map[4, 1].IsWall = true;
        map[4, 2].IsWall = true;
        map[4, 3].IsWall = true;
        map[4, 4].IsWall = true;
        map[4, 5].IsWall = true;
        map[4, 6].IsWall = true;
    }

    /// <summary>
    /// 查找最优路径
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    private void FindPath(Point start, Point end)
    {
        List<Point> openList = new List<Point>();
        List<Point> closeList = new List<Point>();
        openList.Add(start);    //将开始位置添加进Open列表
        while (openList.Count > 0)//查找退出条件
        {
            Point point = FindMinFOfPoint(openList);//查找Open列表中最小的f值
            //print(point.F + ";" + point.X + "," + point.Y);
            openList.Remove(point); closeList.Add(point);//不再考虑当前节点

            List<Point> surroundPoints = GetSurroundPoints(point);//得到当前节点的四周8个节点
            PointsFilter(surroundPoints, closeList);//将周围节点中已经添加进Close列表中的节点移除
            foreach (Point surroundPoint in surroundPoints)
            {
                if (openList.IndexOf(surroundPoint) > -1)//如果周围节点在open列表中
                {
                    float nowG = CalcG(surroundPoint, surroundPoint.Parent);//计算经过的Open列表中最小f值到周围节点的G值
                    if (nowG < surroundPoint.G)
                    {
                        print("123");
                        surroundPoint.UpdateParent(point, nowG);
                    }
                }
                else//周围节点不在Open列表中
                {
                    surroundPoint.Parent = point;//设置周围列表的父节点
                    CalcF(surroundPoint, end);//计算周围节点的F，G,H值
                    openList.Add(surroundPoint);//最后将周围节点添加进Open列表
                }
            }
            //判断一下
            if (openList.IndexOf(end) > -1)
            {
                break;
            }
        }
    }

    private void PointsFilter(List<Point> src, List<Point> closeList)
    {
        foreach (Point p in closeList)
        {
            if (src.IndexOf(p) > -1)
            {
                src.Remove(p);
            }
        }
    }

    private List<Point> GetSurroundPoints(Point point)
    {
        Point up = null, down = null, left = null, right = null;
        Point lu = null, ru = null, ld = null, rd = null;
        if (point.Y < mapHeight - 1)
        {
            up = map[point.X, point.Y + 1];
        }
        if (point.Y > 0)
        {
            down = map[point.X, point.Y - 1];
        }
        if (point.X > 0)
        {
            left = map[point.X - 1, point.Y];
        }
        if (point.X < mapWidth - 1)
        {
            right = map[point.X + 1, point.Y];
        }
        if (up != null && left != null)
        {
            lu = map[point.X - 1, point.Y + 1];
        }
        if (up != null && right != null)
        {
            ru = map[point.X + 1, point.Y + 1];
        }
        if (down != null && left != null)
        {
            ld = map[point.X - 1, point.Y - 1];
        }
        if (down != null && right != null)
        {
            rd = map[point.X + 1, point.Y - 1];
        }
        List<Point> list = new List<Point>();
        if (down != null && down.IsWall == false)
        {
            list.Add(down);
        }
        if (up != null && up.IsWall == false)
        {
            list.Add(up);
        }
        if (left != null && left.IsWall == false)
        {
            list.Add(left);
        }
        if (right != null && right.IsWall == false)
        {
            list.Add(right);
        }
        if (lu != null && lu.IsWall == false && left.IsWall == false && up.IsWall == false)
        {
            list.Add(lu);
        }
        if (ld != null && ld.IsWall == false && left.IsWall == false && down.IsWall == false)
        {
            list.Add(ld);
        }
        if (ru != null && ru.IsWall == false && right.IsWall == false && up.IsWall == false)
        {
            list.Add(ru);
        }
        if (rd != null && rd.IsWall == false && right.IsWall == false && down.IsWall == false)
        {
            list.Add(rd);
        }
        return list;
    }

    private Point FindMinFOfPoint(List<Point> openList)
    {
        float f = float.MaxValue;
        Point temp = null;
        foreach (Point p in openList)
        {
            if (p.F < f)
            {
                temp = p;
                f = p.F;
            }
        }
        print("返回open列表中最小的f:" + temp.F);
        return temp;
    }

    private float CalcG(Point now, Point parent)
    {
        return Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(parent.X, parent.Y)) + parent.G;
    }

    private void CalcF(Point now, Point end)
    {
        //F = G + H
        float h = Mathf.Abs(end.X - now.X) + Mathf.Abs(end.Y - now.Y);
        float g = 0;
        if (now.Parent == null)
        {
            g = 0;
        }
        else
        {
            g = Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(now.Parent.X, now.Parent.Y)) + now.Parent.G;
        }
        float f = g + h;
        now.F = f;
        now.G = g;
        now.H = h;
    }
}

引用自 https://blog.csdn.net/truck_truck/article/details/77373514#

十二、游戏内的常用系统

1. 背包系统

1.1 UI搭建

1.2 拖拽物品

使用OnDrag()方法，将需要移动的物体的位置改变

1.3 物品交换

需要在一个能够拿到所有物品Image的父物体上挂control脚本，在脚本中处理交换逻辑。每个子物体中挂相同脚本，在OnPointerEnter方法中设置target值，在OnPointerExit方法中将target设置为null，在OnBeginDrag方法中设置Original，在OnDrag方法中更改original的位置，在OnEndDrag方法中决定要不要交换。关键细节：需要将在上的物体的Raycast Target取消勾选，否则会影响OnPointerEnter方法中的target设置

1.4 制作背包系统的常用思路

设置一个子物体序号最高的Image类型UI的“temp”用于拖拽，大小和想拖动的Image一样，开始的时候取消激活。序号最高决定了拖拽的时候始终在上，将temp的Raycast Target取消勾选，OnBeginDrag中将temp放到original的位置，temp的图片设置成original的图片，将original的图片隐藏，OnDrag中改变的是temp的位置，OnEndDrag中再将temp取消激活，将original还原即可

附代码实现：

• Item.cs

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

public class Item : MonoBehaviour, IDragHandler, IBeginDragHandler, IEndDragHandler , IPointerEnterHandler, IPointerExitHandler
{
    //获得脚本
    private ItemManager _manager;

    private void Awake()
    {
        _manager = transform.parent.parent.parent.GetComponent<ItemManager>();
    }

    // 开始拖拽
    public void OnBeginDrag(PointerEventData eventData)
    {
        // 设定交换源
        _manager.Original = transform;
        // 通知开始交换
        _manager.BeginDrag();
    }

    // 拖拽中
    public void OnDrag(PointerEventData eventData)
    {
        // 调用拖拽中的方法
        _manager.OnDrag(eventData.position);
    }

    // 结束拖拽
    public void OnEndDrag(PointerEventData eventData)
    {
        // 调用结束方法
        _manager.EndDrag();
    }

    // 鼠标划入
    public void OnPointerEnter(PointerEventData eventData)
    {
        // 设定target
        _manager.Target = transform;
    }

    // 鼠标划出
    public void OnPointerExit(PointerEventData eventData)
    {
        // 将target放空
        _manager.Target = null;
    }

}

• ItemManager.cs

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

public class ItemManager : MonoBehaviour {

    // 发起交换的源
    private Image _original;
    // 交换的目标
    private Image _target;
    // 用于临时拖拽的Image
    private Image _temp;

    public Transform Original
    {
        set
        {
            _original = value.GetComponent<Image>();
        }
    }

    public Transform Target
    {
        set
        {
            if (value != null)
            {
                _target = value.GetComponent<Image>();
            }
        }
    }

    // Use this for initialization
    void Start () {
        // 获取temp
        _temp = transform.Find("Temp").GetComponent<Image>();
    }

    // 开始拖拽
    public void BeginDrag ()
    {
        // 判断是否是空物体
        if (_original.sprite.name == "Character_Slots_Background")
        {
            // 是拖拽的空物体，则什么都不做直接跳出
            return;   
        }
        // 隐藏original的图片
        _original.enabled = false;
        // 把temp位置设置到original的位置
        _temp.transform.position = _original.transform.position;
        // 把temp图片换成original的图片
        _temp.sprite = _original.sprite;
        // 把temp激活
        _temp.gameObject.SetActive(true);
    }

    // 拖拽中
    public void OnDrag (Vector2 position)
    {
        // 移动temp的位置
        _temp.transform.position = position;
    }

    // 结束拖拽
    public void EndDrag ()
    {
        // 因为之前拖拽物体判断是空物体的时候直接跳出，所以没有将
        // temp激活，所以当temp为非激活的物体时，什么都不用做，直
        // 接跳出
        if (_temp.gameObject.activeSelf == false)
            return;
        // 判断是否要交换
        if (_target != null)
        {
            Debug.Log("Need Swap");
            // 需要交换
            _original.sprite = _target.sprite;
            _target.sprite = _temp.sprite;
        }
        // 还原original
        _original.enabled = true;
        // 隐藏temp
        _temp.gameObject.SetActive(false);
    }
}

2. 第一人称 FPS Demo

• 第一人称其实是在控制摄像机的移动，在官方的标准资源包里有一个设置好的第一人称镜头（Standard Assets/Character/FirstPersonCharacter）
• 枪作为摄像机的子物体，可以实现随摄像机旋转枪也跟着旋转
• 换枪就是激活要换的枪的GameObject，取消激活上一次的枪的GameObject
• 开枪的动画，音效随着点击鼠标而触发，需要添加一个计时器控制射速
• 刚换枪和换子弹的时候不能开枪，需要在状态机中两个状态的Behaviour中控制
• UI搭建子弹数，血量等内容

3. 塔防Demo

• 地图搭建
  1. 烘焙地图
• 摄像机控制
  1. CameraControl.cs
• 生成怪物
  1. MonsterInfo.cs，不继承Monobehaviour，做每波的波次信息的类，整个类Serializable
  2. WaveInfo.cs，用集合存所有的波次信息，做单例
  3. MonsterInit.cs，生成怪物，在start点生成
  4. Monster.cs，控制每个怪物的行为，在生成的时候挂给每一个怪物
  5. EndCheck.cs，怪物走到终点，销毁
• 生成防御塔（与生成怪物差不多）
  1. TowerInfo.cs，存储防御塔的信息类
  2. TowerCollection.cs，单例，用集合存所有的塔的信息
  3. TowerInit.cs，防御塔生成
  4. Tower.cs，控制每个塔
  5. TowerAttack.cs，防御塔攻击
  6. Bullet.cs，控制炮弹的脚本
• 玩家血量
  1. PlayerInfo.cs，记录玩家的信息
• UI
  1. 倍速按钮
  2. 暂停按钮
  3. 炮塔列表侧边栏

十三、插件

1. DOTween

DOTween is a fast, efficient, fully type-safe object-oriented animation engine for Unity, optimized for C# users, free and open-source, with tons of advanced features

附：有关脚本的一些琐碎知识点

1. this和gameObject区别

• gameObject：当前脚本挂载给的游戏对象，类型是GameObject
• this：当前脚本的对象，类型是脚本类型

2. gameObject可以省略

gameObject.GetComponent<BoxCollider>(); 中 gameObject.可以省略

3. .gameObject与.transform

• 任意的组件对象，都可以通过.gameObject获取到游戏对象，
• 任意的游戏对象，都可以通过.transform获取到transform组件

4. 在Inspector面板中设置脚本内字段

• 只有用public修饰的字段会在面板中出现，并且List<T>会自动实例化
• 只要面板中编辑过该字段的值，脚本代码无论改什么值，面板中都不会改变

public string name = "hello world";
public bool c;
public GameObject d;
public BoxCollider e;
public List<int> f;

public List<Person> p;
[System.Flags]
public enum Gender{
    Male, Female
}
[System.Serializable]
public class Person{
    public string name;
    public int age;
    public Gender gender;
}

5. 特性的使用

• 给类添加

// 不允许重复添加多个组件
[DisallowMultipleComponent]
// 组件依赖，添加的时候自动添加刚体组件
[RequireComponent(typeof(Rigidbody))]

• 给字段添加

// 在Inspector面板给字段添加说明头
[Header(string description)]
// 限制字段范围（浮点型和整型可以用）
[Range(float min, float max)]
// Inspector面板两行之间的间距
[space(100)]
// 可序列化，使得自定义类可以显示在Inspector面板上
[System.Serializable]
// 在Inspector面板上隐藏
[HideInInspector]

6. 单例脚本

如果一个脚本想要在其它脚本中频繁使用，可以做一个单例脚本

public static Joystick Instance;

private void Awake()
{
    Instance = this;    // this 指脚本对象
}

7. 设计模式

高内聚，低耦合

7.1 MVC

• Model：数据层，用来管理数据
• View：视图层，用来显示数据
• Controller：控制层，用来控制将数据给视图展示，协调数据层和视图层

7.2 MVVM

• Model：数据层
• View：视图层
• View-Model：绑定在视图层

8. 游戏物体标签

游戏物体在Inspector面板上第一个图标即为设置图标标签的地方，选择后会在Scene面板中显示一个图标，可以快捷的选中所设置的游戏物体，避免了多部分组成的模型点选时选不到总体的游戏物体，在搭建场景的时候可以提高效率