EN中文
开发者社区 > 程序

Unity3D教程：如何在网络游戏中实现资源动态加载

发表于2017-02-23
评论0 2.7k浏览
在使用Unity3D做网络游戏开发时，不可避免的会使用到资源动态加载技术，毕竟在网络游戏中场景都很大，如果因为等待时间过长导致玩家流失那就不好了，所以常用的方法都是优先加载用户附近的场景资源，在游戏的过程中，不影响操作的情况下，后台加载剩余的资源，直到所有加载完。

本文包含一些代码片段讲述实现这个技术的一种方法，代码是C#写的，用到了Json，还有C#的事件机制。

在讲述代码之前，先想象这样一个网络游戏的开发流程。首先美工制作场景资源的3D建模，游戏设计人员把3D建模导进Unity3D，托托拽拽编辑场景，完成后把每个gameobject导出成XXX.unity3d格式的资源文件（参看BuildPipeline），并且把整个场景的信息生成一个配置文件，xml或者Json格式（本文使用Json）。最后还要把资源文件和场景配置文件上传到服务器，最好使用CMS管理。客户端运行游戏时，先读取服务器的场景配置文件，再根据玩家的位置从服务器下载相应的资源文件并加载，然后开始游戏，注意这里并不是下载所有的场景资源。在游戏的过程中，后台继续加载资源直到所有加载完毕。

一个简单的场景配置文件的例子：
MyDemoSence.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
{ 
    "AssetList" : [{ 
        "Name" : "Chair 1", 
        "Source" : "Prefabs/Chair001.unity3d", 
        "Position" : [2,0,-5], 
        "Rotation" : [0.0,60.0,0.0] 
    }, 
    { 
        "Name" : "Chair 2", 
        "Source" : "Prefabs/Chair001.unity3d", 
        "Position" : [1,0,-5], 
        "Rotation" : [0.0,0.0,0.0] 
    }, 
    { 
        "Name" : "Vanity", 
        "Source" : "Prefabs/vanity001.unity3d", 
        "Position" : [0,0,-4], 
        "Rotation" : [0.0,0.0,0.0] 
    }, 
    { 
        "Name" : "Writing Table", 
        "Source" : "Prefabs/writingTable001.unity3d", 
        "Position" : [0,0,-7], 
        "Rotation" : [0.0,0.0,0.0], 
        "AssetList" : [{ 
            "Name" : "Lamp", 
            "Source" : "Prefabs/lamp001.unity3d", 
            "Position" : [-0.5,0.7,-7], 
            "Rotation" : [0.0,0.0,0.0] 
        }] 
    }] 
}

AssetList：场景中资源的列表，每一个资源都对应一个unity3D的gameobject
Name：gameobject的名字，一个场景中不应该重名
Source：资源的物理路径及文件名
Position：gameobject的坐标
Rotation：gameobject的旋转角度

你会注意到Writing Table里面包含了Lamp，这两个对象是父子的关系。配置文件应该是由程序生成的，手工也可以修改。另外在游戏上线后，客户端接收到的配置文件应该是加密并压缩过的。

主程序：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
。。。 
public class MainMonoBehavior : MonoBehaviour { 
   
    public delegate void MainEventHandler(GameObject dispatcher); 
   
    public event MainEventHandler StartEvent; 
    public event MainEventHandler UpdateEvent; 
   
    public void Start() { 
        ResourceManager.getInstance().LoadSence("Scenes/MyDemoSence.txt"); 
   
        if(StartEvent != null){ 
            StartEvent(this.gameObject); 
        } 
    } 
   
    public void Update() { 
        if (UpdateEvent != null) { 
            UpdateEvent(this.gameObject); 
        } 
    } 
} 
。。。 
}

这里面用到了C#的事件机制，大家可以看看我以前翻译过的国外一个牛人的文章。C# 事件和Unity3D

在start方法里调用ResourceManager，先加载配置文件。每一次调用update方法，MainMonoBehavior会把update事件分发给ResourceManager，因为ResourceManager注册了MainMonoBehavior的update事件。

ResourceManager.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
。。。 
private MainMonoBehavior mainMonoBehavior; 
private string mResourcePath; 
private Scene mScene; 
private Asset mSceneAsset; 
   
private ResourceManager() { 
    mainMonoBehavior = GameObject.Find("Main Camera").GetComponent(); 
    mResourcePath = PathUtil.getResourcePath(); 
} 
   
public void LoadSence(string fileName) { 
    mSceneAsset = new Asset(); 
    mSceneAsset.Type = Asset.TYPE_JSON; 
    mSceneAsset.Source = fileName; 
   
    mainMonoBehavior.UpdateEvent += OnUpdate; 
} 
。。。 

在LoadSence方法里先创建一个Asset的对象，这个对象是对应于配置文件的，设置type是Json，source是传进来的“Scenes/MyDemoSence.txt”。然后注册MainMonoBehavior的update事件。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void OnUpdate(GameObject dispatcher) { 
    if (mSceneAsset != null) { 
        LoadAsset(mSceneAsset); 
        if (!mSceneAsset.isLoadFinished) { 
            return; 
        } 
   
        //clear mScene and mSceneAsset for next LoadSence call 
        mScene = null; 
        mSceneAsset = null; 
    } 
   
    mainMonoBehavior.UpdateEvent -= OnUpdate; 
}

OnUpdate方法里调用LoadAsset加载配置文件对象及所有资源对象。每一帧都要判断是否加载结束，如果结束清空mScene和mSceneAsset对象为下一次加载做准备，并且取消update事件的注册。

最核心的LoadAsset方法：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Asset LoadAsset(Asset asset) { 
   
    string fullFileName = mResourcePath + "/" + asset.Source; 
       
    //if www resource is new, set into www cache 
    if (!wwwCacheMap.ContainsKey(fullFileName)) { 
        if (asset.www == null) { 
            asset.www = new WWW(fullFileName); 
            return null; 
        } 
   
        if (!asset.www.isDone) { 
            return null; 
        } 
        wwwCacheMap.Add(fullFileName, asset.www); 
    } 
。。。

传进来的是要加载的资源对象，先得到它的物理地址，mResourcePath是个全局变量保存资源服务器的网址，得到fullFileName类似http://www.mydemogame.com/asset/Prefabs/xxx.unity3d。然后通过wwwCacheMap判断资源是否已经加载完毕，如果加载完毕把加载好的www对象放到Map里缓存起来。看看前面Json配置文件，Chair 1和Chair 2用到了同一个资源Chair001.unity3d，加载Chair 2的时候就不需要下载了。如果当前帧没有加载完毕，返回null等到下一帧再做判断。这就是WWW类的特点，刚开始用WWW下载资源的时候是不能马上使用的，要等待诺干帧下载完成以后才可以使用。可以用yield返回www，这样代码简单，但是C#要求调用yield的方法返回IEnumerator类型，这样限制太多不灵活。

继续LoadAsset方法：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
。。。 
    if (asset.Type == Asset.TYPE_JSON) { //Json 
        if (mScene == null) { 
            string jsonTxt = mSceneAsset.www.text; 
            mScene = JsonMapper.ToObject(jsonTxt); 
        } 
           
        //load scene 
        foreach (Asset sceneAsset in mScene.AssetList) { 
            if (sceneAsset.isLoadFinished) { 
                continue; 
            } else { 
                LoadAsset(sceneAsset); 
                if (!sceneAsset.isLoadFinished) { 
                    return null; 
                } 
            } 
        } 
    }  
。。。 

代码能够运行到这里，说明资源都已经下载完毕了。现在开始加载处理资源了。第一次肯定是先加载配置文件，因为是Json格式，用JsonMapper类把它转换成C#对象，我用的是LitJson开源类库。然后循环递归处理场景中的每一个资源。如果没有完成，返回null，等待下一帧处理。

继续LoadAsset方法：
?
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
。。。 
    else if (asset.Type == Asset.TYPE_GAMEOBJECT) { //Gameobject 
        if (asset.gameObject == null) { 
            wwwCacheMap[fullFileName].assetBundle.LoadAll(); 
            GameObject go = (GameObject)GameObject.Instantiate(wwwCacheMap[fullFileName].assetBundle.mainAsset); 
            UpdateGameObject(go, asset); 
            asset.gameObject = go; 
        } 
   
        if (asset.AssetList != null) { 
            foreach (Asset assetChild in asset.AssetList) { 
                if (assetChild.isLoadFinished) { 
                    continue; 
                } else { 
                    Asset assetRet = LoadAsset(assetChild); 
                    if (assetRet != null) { 
                        assetRet.gameObject.transform.parent = asset.gameObject.transform; 
                    } else { 
                        return null; 
                    } 
                } 
            } 
        } 
    } 
   
    asset.isLoadFinished = true; 
    return asset; 
}

终于开始处理真正的资源了，从缓存中找到www对象，调用Instantiate方法实例化成Unity3D的gameobject。UpdateGameObject方法设置gameobject各个属性，如位置和旋转角度。然后又是一个循环递归为了加载子对象，处理gameobject的父子关系。注意如果LoadAsset返回null，说明www没有下载完毕，等到下一帧处理。最后设置加载完成标志返回asset对象。

UpdateGameObject方法：
?
1
2
3
4
5
6
7
8
9
10
11
12
private void UpdateGameObject(GameObject go, Asset asset) { 
    //name 
    go.name = asset.Name; 
   
    //position 
    Vector3 vector3 = new Vector3((float)asset.Position[0], (float)asset.Position[1], (float)asset.Position[2]); 
    go.transform.position = vector3; 
   
    //rotation 
    vector3 = new Vector3((float)asset.Rotation[0], (float)asset.Rotation[1], (float)asset.Rotation[2]); 
    go.transform.eulerAngles = vector3; 
}

这里只设置了gameobject的3个属性，眼力好的同学一定会发现这些对象都是“死的”，因为少了脚本属性，它们不会和玩家交互。设置脚本属性要复杂的多，编译好的脚本随着主程序下载到本地，它们也应该通过配置文件加载，再通过C#的反射创建脚本对象，赋给相应的gameobject。

最后是Scene和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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public class Scene { 
    public List AssetList { 
        get; 
        set; 
    } 
} 
   
public class Asset { 
   
    public const byte TYPE_JSON = 1; 
    public const byte TYPE_GAMEOBJECT = 2; 
   
    public Asset() { 
        //default type is gameobject for json load 
        Type = TYPE_GAMEOBJECT; 
    } 
   
    public byte Type { 
        get; 
        set; 
    } 
   
    public string Name { 
        get; 
        set; 
    } 
   
    public string Source { 
        get; 
        set; 
    } 
   
    public double[] Bounds { 
        get; 
        set; 
    } 
       
    public double[] Position { 
        get; 
        set; 
    } 
   
    public double[] Rotation { 
        get; 
        set; 
    } 
   
    public List AssetList { 
        get; 
        set; 
    } 
   
    public bool isLoadFinished { 
        get; 
        set; 
    } 
   
    public WWW www { 
        get; 
        set; 
    } 
   
    public GameObject gameObject { 
        get; 
        set; 
    } 
}

这里只设置了gameobject的3个属性，眼力好的同学一定会发现这些对象都是“死的”，因为少了脚本属性，它们不会和玩家交互。设置脚本属性要复杂的多，编译好的脚本随着主程序下载到本地，它们也应该通过配置文件加载，再通过C#的反射创建脚本对象，赋给相应的gameobject。

最后是Scene和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
50
51
52
53
54
55
56
57
58
59
using UnityEngine;
using UnityEditor;
using System.IO;
using System;
using System.Text;
using System.Collections.Generic;
using LitJson;
public class BuildAssetBundlesFromDirectory
{
      static List config=new List();
      static Dictionary<string, list=< code="">"">> assetList=new Dictionary<string, list=< code="">"">>();
        [@MenuItem("Asset/Build AssetBundles From Directory of Files")]//这里不知道为什么用"@"，添加菜单
        static void ExportAssetBundles ()
        {//该函数表示通过上面的点击响应的函数
                   assetList.Clear();
                   string path = AssetDatabase.GetAssetPath(Selection.activeObject);//Selection表示你鼠标选择激活的对象
                  Debug.Log("Selected Folder: " + path);
        
        
                  if (path.Length != 0)
                  {
                           path = path.Replace("Assets/", "");//因为AssetDatabase.GetAssetPath得到的是型如Assets/文件夹名称，且看下面一句，所以才有这一句。
                            Debug.Log("Selected Folder: " + path);
                           string [] fileEntries = Directory.GetFiles(Application.dataPath+"/"+path);//因为Application.dataPath得到的是型如 "工程名称/Assets"
                            
                           string[] div_line = new string[] { "Assets/" };
                           foreach(string fileName in fileEntries)
                           {
                                    j++;
                                    Debug.Log("fileName="+fileName);
                                    string[] sTemp = fileName.Split(div_line, StringSplitOptions.RemoveEmptyEntries);
                                    string filePath = sTemp[1];
                                     Debug.Log(filePath);
                                    filePath = "Assets/" + filePath;
                                    Debug.Log(filePath);
                                    string localPath = filePath;
                                    UnityEngine.Object t = AssetDatabase.LoadMainAssetAtPath(localPath);
                                    
                                     //Debug.Log(t.name);
                                    if (t != null)
                                    {
                                            Debug.Log(t.name);
                                            JsonResource jr=new JsonResource();
                                            jr.Name=t.name;
                                            jr.Source=path+"/"+t.name+".unity3d";
                                              Debug.Log( t.name);
                                            config.Add(jr);//实例化json对象
                                              string bundlePath = Application.dataPath+"/../"+path;
                                               if(!File.Exists(bundlePath))
                                                {
                                                   Directory.CreateDirectory(bundlePath);//在Asset同级目录下相应文件夹
                                                }
                                              bundlePath+="/"  + t.name + ".unity3d";
                                             Debug.Log("Building bundle at: " + bundlePath);
                                             BuildPipeline.BuildAssetBundle(t, null, bundlePath, BuildAssetBundleOptions.CompleteAssets);//在对应的文件夹下生成.unity3d文件
                                    }
                           }
                            assetList.Add("AssetList",config);
                            for(int i=0;istring,>string,>

如社区发表内容存在侵权行为，您可以点击这里查看侵权投诉指引

标签：

游戏开发Unity网络游戏场景游戏视觉List
0

0个评论