在Unity中从对象池获取游戏对象时遇到问题

Question

我曾经遇到了将一个对象池脚本从UnityScript转换成C#的问题，这里得到了很多好的帮助。现在我遇到了一个问题，就是无法从对象池中获取游戏对象。我有三个脚本相互作用，所以我不太确定出了什么问题。以下是两个对象池脚本，我认为它们都没问题，也没有给出任何错误：

public class EasyObjectPool : MonoBehaviour {
    [System.Serializable]
    public class PoolInfo{
        [SerializeField]
        public string poolName;
        public GameObject prefab;
        public int poolSize;
        public bool canGrowPoolSize = true;

}

[System.Serializable]
public class Pool{

    public List<PoolObject> list = new List<PoolObject>();
    public bool  canGrowPoolSize;

    public void  Add (PoolObject poolObject){
        list.Add(poolObject);
    }

    public int Count (){
        return list.Count;
    }


    public PoolObject ObjectAt ( int index  ){

        PoolObject result = null;
        if(index < list.Count) {
            result = list[index];
        }

        return result;

    }
}
static public EasyObjectPool instance ;

[SerializeField]
PoolInfo[] poolInfo = null;

private Dictionary<string, Pool> poolDictionary  = new Dictionary<string, Pool>();


void Start () {

    instance = this;

    CheckForDuplicatePoolNames();

    CreatePools();

}

private void CheckForDuplicatePoolNames() {

    for (int index = 0; index < poolInfo.Length; index++) {
        string poolName= poolInfo[index].poolName;
        if(poolName.Length == 0) {
            Debug.LogError(string.Format("Pool {0} does not have a name!",index));
        }
        for (int internalIndex = index + 1; internalIndex < poolInfo.Length; internalIndex++) {
            if(poolName == poolInfo[internalIndex].poolName) {
                Debug.LogError(string.Format("Pool {0} & {1} have the same name. Assign different names.", index, internalIndex));
            }
        }
    }
}

private void CreatePools() {

    foreach(PoolInfo currentPoolInfo in poolInfo){

        Pool pool = new Pool();
        pool.canGrowPoolSize = currentPoolInfo.canGrowPoolSize;

        for(int index = 0; index < currentPoolInfo.poolSize; index++) {
            //instantiate
            GameObject go = Instantiate(currentPoolInfo.prefab) as GameObject;
            PoolObject poolObject = go.GetComponent<PoolObject>();
            if(poolObject == null) {
                Debug.LogError("Prefab must have PoolObject script attached!: " + currentPoolInfo.poolName);
            } else {
                //set state
                poolObject.ReturnToPool();
                //add to pool
                pool.Add(poolObject);
            }
        }

        Debug.Log("Adding pool for: " + currentPoolInfo.poolName);
        poolDictionary[currentPoolInfo.poolName] = pool;

    }
}

public PoolObject GetObjectFromPool ( string poolName  ){
    PoolObject poolObject = null;

    if(poolDictionary.ContainsKey(poolName)) {
        Pool pool = poolDictionary[poolName];

        //get the available object
        for (int index = 0; index < pool.Count(); index++) {
            PoolObject currentObject = pool.ObjectAt(index);

            if(currentObject.AvailableForReuse()) {
                //found an available object in pool
                poolObject = currentObject;
                break;
            }
        }


        if(poolObject == null) {
            if(pool.canGrowPoolSize) {
                Debug.Log("Increasing pool size by 1: " + poolName);

                foreach (PoolInfo currentPoolInfo in poolInfo) {    

                    if(poolName == currentPoolInfo.poolName) {

                        GameObject go = Instantiate(currentPoolInfo.prefab) as GameObject;
                        poolObject = go.GetComponent<PoolObject>();
                        //set state
                        poolObject.ReturnToPool();
                        //add to pool
                        pool.Add(poolObject);

                        break;

                    }
                }
            } else {
                Debug.LogWarning("No object available in pool. Consider setting canGrowPoolSize to true.: " + poolName);
            }
        }

    } else {
        Debug.LogError("Invalid pool name specified: " + poolName);
    }

    return poolObject;
}

}

并且：

public class PoolObject : MonoBehaviour {

[HideInInspector]
public bool availableForReuse = true;


void Activate () {

    availableForReuse = false;
    gameObject.SetActive(true);

}


public void ReturnToPool () {

    gameObject.SetActive(false);
    availableForReuse = true;


}

public bool AvailableForReuse () {
    //true when isAvailableForReuse & inactive in hierarchy

    return availableForReuse && (gameObject.activeInHierarchy == false);



}
}

原始的UnityScript代码中说，要使用以下语句从池中检索对象：

var poolObject : PoolObject = EasyObjectPool.instance.GetObjectFromPool(poolName);

以下是我在射击脚本中尝试使用对象池发射子弹预制件的方法：

public class ShootScript : MonoBehaviour {

public PoolObject poolObject;

private Transform myTransform;

private Transform cameraTransform;

private Vector3 launchPosition = new Vector3();

public float fireRate = 0.2f;

public float nextFire = 0;

// Use this for initialization
void Start () {

    myTransform = transform;

    cameraTransform = myTransform.FindChild("BulletSpawn");

}


void Update () {

    poolObject = EasyObjectPool.instance.GetObjectFromPool<poolName>();

    if(Input.GetButton("Fire1") && Time.time > nextFire){

        nextFire = Time.time + fireRate;

        launchPosition = cameraTransform.TransformPoint(0, 0, 0.2f);

        poolObject.Activate();

        poolObject.transform.position = launchPosition;
        poolObject.transform.rotation = Quaternion.Euler(cameraTransform.eulerAngles.x + 90, myTransform.eulerAngles.y, 0);

    }

}
}

我的拍摄脚本出现了两个错误：

1. 类型或命名空间名称 'poolName' 无法找到。是否缺少 using 指令或程序集引用？

这是因为以下代码行：

poolObject = EasyObjectPool.instance.GetObjectFromPool<poolName>();

2. 'PoolObject.Activate()'由于其保护级别而无法访问

对于以下这行代码:

poolObject.Activate();

我是否翻译了UnityScript中的错误，还是我错过了其他事情？非常感谢任何意见。

- user3776884

Answer 1

我认为你的对象池编程有误。当你有一个像CheckForDuplicatePoolNames()这样的方法时，问问自己是否需要一个不同的集合，比如字典。

保持简单。 最近我实现了一个，并进行了测试。它运行得非常好。

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

[System.Serializable]
public class PoolObject{
    public GameObject prefab;
    public int startNum;
    public int allocateNum;
    public Transform anchor;
}

public class ObjectPool<T> : MonoBehaviour where T:Component{
    public PoolObject[] poolObjects;
    public bool ______________;
    public Dictionary<string,Queue<T>> pool = new Dictionary<string, Queue<T>> ();
    public Dictionary<string, List<T>> spawned = new Dictionary<string, List<T>> ();
    public Transform anchor;


    public void Init(){
        InitPool ();
        StartAllocate ();
    }


    public T Spawn(string type){
        if (pool [type].Count == 0) {
            int i = FindPrefabPosition(type);
            if(poolObjects[i].allocateNum == 0)
                return null;
            Allocate(poolObjects[i], poolObjects[i].allocateNum);
        }
        T t = pool [type].Dequeue ();
        spawned[type].Add (t);
        t.gameObject.SetActive (true);
        return t;
    }


    public void Recycle(T t){
        if (spawned [t.name].Remove (t)) {
            pool[t.name].Enqueue(t);
            t.gameObject.SetActive(false);
        }
    }


    private void Allocate(PoolObject po, int number){
        for (int i=0; i<number; i++) {
            GameObject go = Instantiate (po.prefab) as GameObject;
            go.name = po.prefab.name;
            go.transform.parent = po.anchor != null? po.anchor : anchor;
            T t = go.GetComponent<T>();
            pool[t.name].Enqueue(t);
            t.gameObject.SetActive(false);  
        }
    }

    private int FindPrefabPosition(string type){
        int position = 0;
        while (poolObjects[position].prefab.name != type) {
            position++;     
        }
        return position;
    }

    void InitPool(){
        if(anchor == null)
            anchor = new GameObject("AnchorPool").transform;
        for (int i =0; i<poolObjects.Length; i++) {
            T t = poolObjects[i].prefab.GetComponent<T>();  
            t.name = poolObjects[i].prefab.name;
            pool[t.name] = new Queue<T>();
            spawned[t.name] = new List<T>();
        }
    }

    void StartAllocate(){
        for (int i=0; i<poolObjects.Length; i++) {
                Allocate(poolObjects[i], poolObjects[i].startNum );
        }
    }
}

例子：

public class CoinsPool : ObjectPool<CoinScript>{}

在Unity的检视面板中配置硬币预制件、开始数量和分配数量。

某处：

void Awake(){
  coinsPool = GetComponent<CoinsPool>();
  coinsPool.Init();
}

CoinScript cs = coinsPool.Spawn("Coin"); //Coin is the name of the coin prefab.

稍后

coinsPool.Recycle(cs);

- Roger Garzon Nieto

Answer 2

你在 <> 中写的应该是类名，比如 PoolObject，如果函数是通用的话，但它不是。所以要解决这个问题，你只需要改变

poolObject = EasyObjectPool.instance.GetObjectFromPool<poolName>();

到

string poolName = "thePoolNameYouWant";
poolObject = EasyObjectPool.instance.GetObjectFromPool(poolName);

函数默认是私有的，因此要解决“由于其保护级别而无法访问”的错误，您需要通过更改此函数使其公开。

void Activate () {
    availableForReuse = false;
    gameObject.SetActive(true);
}

转换成这个

public void Activate () {
    availableForReuse = false;
    gameObject.SetActive(true);
}

- Imapler

---

谢谢你的帮助。更改poolObject行导致了更多的错误： - user3776884

当前上下文中不存在名称为 `poolName' 的变量。 - user3776884

EasyObjectPool.GetObjectFromPool(string) 的最佳重载方法匹配存在一些无效的参数。 - user3776884

参数“#1”无法将“object”表达式转换为类型“string” - user3776884

poolName 应该是一个字符串变量，用于存储你想要的池名称。我已经更新了答案，我相信这三个错误都是由此引起的。所有这些错误对于初学者来说都非常常见，你可以通过谷歌搜索错误信息来找到大量的相关信息。 - Imapler