从 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 或者我遗漏了其他内容？非常感谢任何输入

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>{}

在统一检查器中配置硬币预制件、startNum 和 allocateNum。

某处：

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

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

稍后

coinsPool.Recycle(cs);

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);
}