自定义生成函数

通过使用生成处理程序函数可以自定义从客户端上的预制件生成衍生对象的默认行为。通过这种方式，您可以完全控制如何生成对象以及如何生成对象。您可以注册函数以使用ClientScene.RegisterSpawnHandler生成和取消生成客户端对象。服务器直接创建对象，然后通过此功能在客户端产生它们。该函数获取对象的assetID和两个函数委托，一个用于处理客户端上的创建对象，另一个用于处理客户端上的销毁对象。assetID可以是动态的，也可以是要生成的预制对象上的assetID（如果有的话）。

spawn / un-spawner需要有这个对象签名，这是在高级API中定义的。

  1.     // Handles requests to spawn objects on the client
  2.     public delegate GameObject SpawnDelegate(Vector3 position, NetworkHash128 assetId);
  4.     // Handles requests to unspawn objects on the client
  5.     public delegate void UnSpawnDelegate(GameObject spawned);

传递给spawn函数的assetID可以在NetworkIdentity.assetId中找到，用于预制，它自动填充。动态assetID的注册处理方式如下：

  1.     // generate a new unique assetId 
  2.     NetworkHash128 creatureAssetId = NetworkHash128.Parse("e2656f");
  4.     // register handlers for the new assetId
  5.     ClientScene.RegisterSpawnHandler(creatureAssetId, SpawnCreature, UnSpawnCreature);
  7.     // get assetId on an existing prefab
  8.     NetworkHash128 bulletAssetId = bulletPrefab.GetComponent<NetworkIdentity>().assetId;
  10.     // register handlers for an existing prefab you'd like to custom spawn
  11.     ClientScene.RegisterSpawnHandler(bulletAssetId, SpawnBullet, UnSpawnBullet);
  13.     // spawn a bullet - SpawnBullet will be called on client.
  14.     NetworkServer.Spawn(gameObject, creatureAssetId);

生成函数本身是通过委托签名实现的，这里是子弹生成器，但SpawnCreature看起来是相同的，但有不同的生成逻辑

  1.     public GameObject SpawnBullet(Vector3 position, NetworkHash128 assetId)
  2.     {
  3.         return (GameObject)Instantiate(m_BulletPrefab, position, Quaternion.identity);
  4.     }
  5.     public void UnSpawnBullet(GameObject spawned)
  6.     {
  7.         Destroy(spawned);
  8.     }

使用自定义spawn函数时，有时可以在不破坏对象的情况下取消对象。这可以通过调用NetworkServer.UnSpawn完成。这会导致将消息发送给客户端以取消生成该对象，以便在客户端上调用定制的未生成函数。调用此函数时，对象不会被销毁。

请注意，在主机上，不会为本地客户端生成对象，因为它们已经存在于服务器上。所以没有派生处理函数会被调用。

使用自定义spawn处理程序设置对象池

这里是一个例子，你可以用自定义的spawn处理程序设置一个非常简单的对象池系统。

  1.     using UnityEngine;
  2.     using UnityEngine.Networking;
  3.     using System.Collections;
  5.     public class SpawnManager : MonoBehaviour
  6.     {
  7.         public int m_ObjectPoolSize = 5;
  8.         public GameObject m_Prefab;
  9.         public GameObject[] m_Pool;
  11.         public NetworkHash128 assetId { get; set; }
  13.         public delegate GameObject SpawnDelegate(Vector3 position, NetworkHash128 assetId);
  14.         public delegate void UnSpawnDelegate(GameObject spawned);
  16.         void Start()
  17.         {
  18.             assetId = m_Prefab.GetComponent<NetworkIdentity> ().assetId;
  19.             m_Pool = new GameObject[m_ObjectPoolSize];
  20.             for (int i = 0; i < m_ObjectPoolSize; ++i)
  21.             {
  22.                 m_Pool[i] = (GameObject)Instantiate(m_Prefab, Vector3.zero, Quaternion.identity);
  23.                 m_Pool[i].name = "PoolObject" + i;
  24.                 m_Pool[i].SetActive(false);
  25.             }
  27.             ClientScene.RegisterSpawnHandler(assetId, SpawnObject, UnSpawnObject);
  28.         }
  30.         public GameObject GetFromPool(Vector3 position)
  31.         {
  32.             foreach (var obj in m_Pool)
  33.             {
  34.                 if (!obj.activeInHierarchy)
  35.                 {
  36.                     Debug.Log("Activating object " + obj.name + " at " + position);
  37.                     obj.transform.position = position;
  38.                     obj.SetActive (true);
  39.                     return obj;
  40.                 }
  41.             }
  42.             Debug.LogError ("Could not grab object from pool, nothing available");
  43.             return null;
  44.         }
  46.         public GameObject SpawnObject(Vector3 position, NetworkHash128 assetId)
  47.         {
  48.             return GetFromPool(position);
  49.         }
  51.         public void UnSpawnObject(GameObject spawned)
  52.         {
  53.             Debug.Log ("Re-pooling object " + spawned.name);
  54.             spawned.SetActive (false);
  55.         }
  56.     }

要使用此管理器，请执行以下操作

  1.     • 这适用于像“ 入门指南”中那样的场景。
  2.     • 创建一个名为“SpawnManager”的新空游戏对象
  3.     • 为上面的代码创建一个SpawnManager脚本，并将其添加到新的SpawnManager对象中
  4.     • 将想要多次产生的预制件拖到预制字段并设置大小（默认值为5）。
  5.     • 在玩家移动脚本中设置对spawn管理器的引用
  1.     SpawnManager spawnManager;
  3.     void Start()
  4.     {
  5.         spawnManager = GameObject.Find("SpawnManager").GetComponent<SpawnManager> ();
  6.     }
  1.     • 玩家逻辑可以包含这样的东西来移动和发射子弹
  1.     void Update()
  2.     {
  3.         if (!isLocalPlayer)
  4.             return;
  6.         var x = Input.GetAxis("Horizontal")*0.1f;
  7.         var z = Input.GetAxis("Vertical")*0.1f;
  9.         transform.Translate(x, 0, z);
  11.         if (Input.GetKeyDown(KeyCode.Space))
  12.         {
  13.             // Command function is called on the client, but invoked on the server
  14.             CmdFire();
  15.         }
  16.     }
  1.     • 在播放器的启动逻辑中，使其使用对象池
  1.     [Command]
  2.     void CmdFire()
  3.     {
  4.         // Set up bullet on server
  5.         var bullet = spawnManager.GetFromPool(transform.position + transform.forward);  
  6.         bullet.GetComponent<Rigidbody>().velocity = transform.forward*4;
  8.         // spawn bullet on client, custom spawn handler will be called
  9.         NetworkServer.Spawn(bullet, spawnManager.assetId);
  11.         // when the bullet is destroyed on the server it is automatically destroyed on clients
  12.         StartCoroutine (Destroy (bullet, 2.0f));
  13.     }
  15.     public IEnumerator Destroy(GameObject go, float timer)
  16.     {
  17.         yield return new WaitForSeconds (timer);
  18.         spawnManager.UnSpawnObject(go);
  19.         NetworkServer.UnSpawn(go);
  20.     }

自动销毁显示对象如何返回到池中，并在再次启动时重新使用。

?