场景加载#

场景切换#

一个场景本质上就是一些GameObject的集合

很显然，任何一个游戏都不能只依靠单一场景实现，那么我们怎么样实现在多个场景之间切换呢？

答：加载场景

所谓加载场景，可以理解为把当前场景中的物体全部删除，并换成新场景中的物体。

这也是为什么有些游戏在加载场景的时候会很需要很长时间

加载场景主要分为两类：同步加载和异步加载

同步加载（sync）：当我们下达加载新场景的命令时，游戏会卡住，等待加载完毕后直接切换到新场景。
- 这样能让玩家更快进入新的场景，通常用于加载游戏的第一个场景时。
异步加载（async）：当下达指令时，游戏会继续而场景会在后台加载。加载完成后再切换到新的场景。
- 这是更常见的，因为加载场景时对玩家体验影响较小。缺点是相较于同步加载速度更慢。

同步与异步注意区分哦

Scene和SceneManager#

Unity为我们提供了一些与场景管理相关的数据结构与方法。

它们在 UnityEngine.SceneManagement这个命名空间中。

Scene代表了一个场景文件，其中包含了以下信息：

buildIndex：该场景在打包（导出）时的顺序。数字越小优先级越高。
name：场景名
isDirty：场景是否被修改
Get Root Game Objects()：获取场景中的所有的根物体
······

而SceneManager提供了许多用于管理场景的工具：

GetActiveScene()：获得当前场景
GetSceneByBuildIndex()：通过buildIndex获取场景
GetSceneByName()：通过文件名来获取场景
LoadScene()：同步加载场景
LoadSceneAsync()：异步加载场景
······

简单示例#

让我们来编写一个简单的场景切换脚本吧

既然我们要写场景加载相关的功能，别忘了 UnityEngine.SceneManager 命名空间

重新加载场景#

首先我们来实现按R重新加载场景

1
if  (Input.GetKeyDown(KeyCode.R))
2
{
3
    SceneManager.LoadScene(SceneManager.GetActiveScene().name);
4
}

这里我们是通过获取到当前激活的场景来进行重新加载，因此此处使用name/buildindex均不影响效果。不过要注意的是，要使用BuildIndex这种方法，必须将该场景添加至BuildSettings里面

那么在 SceneManager.GetActiveScene() 后面能接什么呢

首先需要明确的是 GetActiveScene() 返回的是一个Scene结构体 ，所以后面能接的，本质上就是Scene这个类型自带的属性和方法 。

name

1
SceneManager.GetActiveScene().name;

场景名（.unity 文件名）

buildIndex

1
SceneManager.GetActiveScene().buildIndex;

Build Settings 中的索引

path

1
SceneManager.GetActiveScene().path;

场景文件在 Assets 中的路径

例子：

1
Assets/Scenes/Level1.unity

用途：

调试
编辑器工具
区分同名场景

isLoaded

1
SceneManager.GetActiveScene().isLoaded;

是否已经被加载到内存
返回 bool

常用于 多场景加载（Additive）

1
if (SceneManager.GetActiveScene().isLoaded)
2
{
3
    Debug.Log("场景已加载");
4
}

IsValid()

1
SceneManager.GetActiveScene().IsValid();

判断 Scene 是否有效
防止空引用 / 非法场景

1
if (!SceneManager.GetActiveScene().IsValid())
2
{
3
    return;
4
}

rootCount

1
int count = SceneManager.GetActiveScene().rootCount;

当前场景中 根物体（没有父物体的 GameObject）数量

GetRootGameObjects()

1
GameObject[] roots = SceneManager.GetActiveScene().GetRootGameObjects();

获取所有根物体典型用途：
场景扫描
管理器查找
编辑器工具

1
foreach (var go in roots)
2
{
3
    Debug.Log(go.name);
4
}

这里先介绍几个常用的，还有部分可自行探索

同步加载#

我们可以使用SceneManager.LoadScene()方法进行场景的同步加载。

例如：

1
SceneManager.LoadScene("MainMenu");  //加载名为“MainMenu”这个场景
2
SceneManager.LoadScene(2);           //加载buildindex为2的场景

我们现在来实现一个从主页面点击 Start 进入游戏场景的效果

我们要实现什么

场景切换函数
将这个函数与按钮切换事件绑定

非常简单就可以实现

1
public void LoadSceneSync()
2
{
3
    SceneManager.LoadScene("class_06");
4
}

不过需要注意，如果目标场景内物体过多，会出现明显卡顿的现象，这是非常影响游戏体验的，那么我们就要使用异步加载。

异步加载#

我们可以使用 SceneManager.LoadSceneAsync()方法进行场景的异步加载。

异步加载相较于同步加载会更加复杂一些：SceneManager.LoadSceneAsync()方法会返回一个类型为**AsyncOperation** 的变量，其中记录着这次加载的相关信息。

AsycOperation 中有以下常用的成员：

isDone

1
bool done = asyncOp.isDone;

是否完成
true 表示异步任务结束（不一定已经显示）

1
if (asyncOp.isDone)
2
{
3
    Debug.Log("加载完成");
4
}

progress

1
float p = asyncOp.progress;

进度值：0 ~ 1

注意如果将 allowSceneActivation设为false，progress会卡在0.9，即**场景加载时最大只到 **0.9

1
Debug.Log(asyncOp.progress);

为什么到 0.9？

剩下 0.1 等待 激活场景

allowSceneActivation

1
asyncOp.allowSceneActivation = false;

是否允许场景激活
默认是 true

常见写法（加载完成但不切场）

1
AsyncOperation op = SceneManager.LoadSceneAsync("Game");
2
op.allowSceneActivation = false;
3

4
while (op.progress < 0.9f)
5
{
6
    yield return null;
7
}
8

9
// 等玩家点击“开始”
10
op.allowSceneActivation = true;

completed（事件）

1
asyncOp.completed += OnLoaded;
2

3
void OnLoaded(AsyncOperation op)
4
{
5
    Debug.Log("异步任务完成");
6
}

异步完成时自动触发
推荐事件方式 ，比 while 更优雅

priority

1
asyncOp.priority = 100;

加载优先级
数值越大，优先级越高（默认 0）

用于：
后台加载
多资源同时异步加载时调度顺序

那么，完成一个较为完整的异步加载的步骤是：

使用 SceneManager.LoadSceneAsync() 发出异步加载的指令并得到 AsyncOperation
将 allowSceneActivation设为false
用进度条将progress展现出来
当加载完成时将 allowSceneActivition设为true

为什么我们需要先将 allowSceneActivition先设为false再改为true？

接下来，我们就可以实现一个异步加载的流程了

1
[SerializeField] private GameObject loading;
2
[SerializeField] Slider progressBar;
3
[SerializeField] TMP_Text progressText;
4
[SerializeField] private GameObject mainmenu;
5

6
public void LoadSceneAsync()
7
{
8
    StartCoroutine(LoadAsyncScene("class_06"));
9
}
10

11
IEnumerator LoadAsyncScene(string scenename)
12
{
13
    mainmenu.SetActive(false);
14
    loading.SetActive(true);
15
    AsyncOperation asyncLoad = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(scenename);
16

17
    asyncLoad.allowSceneActivation = false;
18
    while (!asyncLoad.isDone)
19
    {
20
        float progress = Mathf.Clamp01(asyncLoad.progress / 0.9f);
21
        progressText.text = progress * 100 + "%";
22
        progressBar.value = progress;
23
        if (asyncLoad.progress >= 0.9f)
24
        {
25
            progressText.text = "Press any key to continue";
26
            if (Input.anyKeyDown)
27
            {
28
                asyncLoad.allowSceneActivation = true;
29
            }
30
        }
31

32
        yield return null;
33
    }
34
}

简易场景加载管理器#

1
public class LoadSceneManager
2
{
3
    //单例模式
4
    private static LoadSceneManager _instance = new LoadSceneManager();
5
    public static LoadSceneManager Instance => _instance;
6

7
    ///<summary>
8
    /// 异步加载场景
9
    ///</summary>
10
    ///<param name="sceneName">目标场景名称</param>
11
    ///<param name="onLoadProgressUpdateCallBack">加载进度回调函数，每次更新加载进度时都会触发，且将加载进度作为参数传入</param>
12
    ///<param name="onLoadFinishedCallBack">当场景加载完毕后，触发的回调函数</param>
13
    public void LoadSceneAsync(string sceneName,Action<float> onLoadProgressUpdateCallBack = null,Action onLoadFinishedCallBack = null)
14
    {
15
        StartCoroutine(AsyncLoadScene(sceneName , onLoadProgressUpdateCallBack , onLoadFinishedCallBack));
16
    }
17

18

19

20
    IEnumerator AsyncLoadScene(string sceneName, Action<float> onLoadProgress =null,Action onLoadFinished = null)
21
    {
22

23
        var ao = SceneManager.LoadSceneAsync(sceneName);
24
        ao.allowSceneActivation = false;
25

26
        float curProgress = 0f;
27

28
        float maxProgress = 100f;
29

30
        while (curProgress < 90)
31
        {
32
            curProgress = ao.progress * 100;
33

34
            //触发加载进度回调函数，比如更新加载界面UI进度条
35
            onLoadProgress?.Invoke(curProgress);
36
            yield return null;
37
        }
38

39

40
        //伪造进度，防止加载进度过快导致UI闪现
41
        //一定会至少加载0.1s
42
        while (curProgress < maxProgress)
43
        {
44
            curProgress++;
45

46
            //触发加载进度回调函数，比如更新加载界面UI进度条
47
            onLoadProgress?.Invoke(curProgress);
48
            yield return  null;
49
        }
50

51
        //激活场景
52
        ao.allowSceneActivation = true;
53

54
        //等待下一帧
55
        yield return null;
56

57
        //触发回调函数 ， 比如隐藏加载界面UI
58
        onLoadFinished?.Invoke();
59

60
    }
61
}

保持在场景中的物体#

当我们加载新的场景时，原来场景中的物体会被全部销毁。

但是有些时候我们希望能将一些重要的物体保留下来。

那么 DontDestroyOnLoad() 可以实现这个要求

其作用是标记一个物体为“不被场景加载销毁的”

所以在想留下来的物体上加上下面一段代码就可

1
void Awake()
2
{
3
    DontDestroyOnLoad(gameObject);
4
}

简单存档#

存档是什么？#

几乎每个游戏或多或少都有自己的存档机制，所谓存档，其实是将当前游戏的 状态信息 （玩家进度、装备、位置等）以某种编码存储在本地中。下一次打开游戏时，程序会读取该存档并复原之前的状态。

一个简易的存档系统会做这么几件事：

当收到存档（Save）指令时，程序会获取当前的状态信息并写在一个文件里假设我们存了角色的位置（vector3）
当收到读档（load）指令时，程序会逐个读取存档中的信息，并应用到当前场景中这时我们读取到之前存的vector3的值，并把玩家的位置设为该值

那么现在最大的问题就是：如何将状态信息写入一个文件里

PlayerPrefs#

其实不建议使用这个方法

Unity为我们提供了一个简易的保存数据的方法：PlayerPrefs

如果使用PlayerRrefs，我们不需要真的和读写文件打交道，只需要使用PlayerPrefs中几个方法即可。

可以把PlayerPrefs想象成一个存储在游戏外的Dictionary,我们可以通过key访问其中的value

API:

1
PlayerPrefs.SetString(String key , string value);
2
PlayerPrefs.GetString(string key);
3
以及对应的int、float版本

显然和Dictionary很像

现在我们来试一试吧

1
    [SerializeField] private Transform Player;
2

3
void Update()
4
    {
5
        if (Input.GetKeyDown(KeyCode.S))
6
        {
7
            Save();
8
        }
9

10
        if (Input.GetKeyDown(KeyCode.L))
11
        {
12
            Load();
13
        }
14
    }
15

16
    public void Save()
17
    {
18
        UnityEngine.PlayerPrefs.SetFloat("PlayerX", Player.position.x);
19
        UnityEngine.PlayerPrefs.SetFloat("PlayerY", Player.position.y);
20
        UnityEngine.PlayerPrefs.SetFloat("PlayerZ", Player.position.z);
21
        Debug.Log("Game Saved"+ UnityEngine.PlayerPrefs.GetFloat("PlayerX"));
22
    }
23

24
    public void Load()
25
    {
26
        Debug.Log("Loaded Ready"+ UnityEngine.PlayerPrefs.GetFloat("PlayerX"));
27
        float x = UnityEngine.PlayerPrefs.GetFloat("PlayerX");
28
        float y = UnityEngine.PlayerPrefs.GetFloat("PlayerY");
29
        float z = UnityEngine.PlayerPrefs.GetFloat("PlayerZ");
30
        Player.position = new Vector3(x, y, z);
31
        Debug.Log("Game Loaded"+ Player.transform.position.x);
32
    }

PlayerPrefs的限制#

虽然PlayerPrefs很容易使用也很好理解，但是我们并不推荐大家在自己的项目中去使用它

原因：

PlayerPrefs是很不安全的通过PlayerPrefs存储的数据是完全未经加密的，这使玩家可以非常轻易的在电脑中修改其数值。
PayerPrefs支持的类型非常有限它仅支持存储int、float、string类型的数值，更加复杂的数据结构（类、结构体）等并不能通过其进行存储
playerPrefs的性能并不好相比于一般的存储方式，PlayerPrefs在处理大文件和复杂文件的效率非常低下
PlayerPrefs对多平台并没有足够的支持在每种操作系统上其存储位置都是不一样的，可能导致跨平台的数据丢失

Json与序列化#

为了将游戏中各式各样的数据转换成文本并存储进文件中,我们需要用到Json。

Json (Javascript Object Notation)是一种数据编码模式。它可以将一个数据结构(比如一个类)用一

篇文本文件来表示。这个操作叫做序列化(Serialization)。

相反地,我们也可以根据一个Json文件构造出原来的数据结构。这叫做反序列化(Deserialization)。

这时我们可能会联想到之前见到序列化这个概念的地方 Field!

之前我们说Serialize Field的作用是将private变量公开显示在引擎里,但其实它本质是“序列化(serialize)”了那个变量,使其加入了Unity自身的存档系统。public变量都会被Unity序列化,这也是为什么当我们在引擎中设定了public变量的数值后它会一直保存下来。(而private变量是不会的!)

使用Json进行存档#

那么,我们该如何将需要存储的信息转换成一个Json文件呢?

存档:

第一步:我们需要将这些信息整合进一个类里,这样就可以一起存储/读取了。
第二步:我们需要将这个类序列化为Json格式。Unity提供了JsonUtility.ToJson()方法为我们实现这个需求。
第三步:我们需要指定一个文件路径并使用File.WriteAllText()方法将得到的Json文本写入该文件里。

读档:

第四步:读档时,我们首先使用File.ReadAllText()读取到存档文件里的文本。
第五步:读取到的文本是Json格式的,于是我们使用JsonUtility.FromJson()方法将其反序列化为Save类。
第六步:得到存档类后,我们逐个获取其中的数据并应用在场景中。

实现：

1
public class JsonSave: MonoBehaviour
2
{
3
    [SerializeField] Transform player;
4

5
void Update()
6
    {
7
        if (Input.GetKeyDown(KeyCode.S))
8
        {
9
            Save();
10
        }
11

12
        if (Input.GetKeyDown(KeyCode.L))
13
        {
14
            Load();
15
        }
16
    }
17

18
    public void Save()
19
    {
20
        SaveData saveData= new SaveData();
21
        saveData.playerPosition = player.position;
22
        string json = JsonUtility.ToJson(saveData);
23
        File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);
24
        Debug.Log("Game Saved");
25
    }
26

27
    public void Load()
28
    {
29
        string json = File.ReadAllText(Application.persistentDataPath + "/savefile.json");
30
        SaveData saveData = JsonUtility.FromJson<SaveData>(json);
31
        player.position = saveData.playerPosition;
32
        Debug.Log("Game Loaded");
33
    }
34
}
35

36
public class SaveData
37
{
38
    public Vector3 playerPosition;
39
}

音乐

场景加载#

场景切换#

Scene和SceneManager#

简单示例#

重新加载场景#

同步加载#

异步加载#

简易场景加载管理器#

保持在场景中的物体#

简单存档#

存档是什么？#

PlayerPrefs#

PlayerPrefs的限制#

Json与序列化#

使用Json进行存档#

评论区

文章目录

音乐

Unity场景加载及简单存档系统

场景加载#

场景切换#

Scene和SceneManager#

简单示例#

重新加载场景#

同步加载#

异步加载#

简易场景加载管理器#

保持在场景中的物体#

简单存档#

存档是什么？#

PlayerPrefs#

PlayerPrefs的限制#

Json与序列化#

使用Json进行存档#

评论区

文章目录