[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 4]

※ 주의 

이 글은 아마추어가 개인적으로 생각하여 작성하는 것으로, 이곳에 나오는 내용을 맹신하지 않는것을 당부드립니다.

Menu

0. 미리보기

1. 오브젝트를 미리 생성.

- 프리팹 제작.

- 싱글톤 제작.

- 오브젝트를 생성시킬 함수 제작.

- 오브젝트를 찾을 함수를 제작.

2. 만들어진 오브젝트 활용하기.

추가.

3. 적 생성

- 적 생성 후 프리팹으로 만들기.

- 적과 총알이 충돌하면 총알 비활성화.

- 적이 총알에 맞아 죽었을 때 단순한 객체로 이펙트 효과 표현하기.

4. 메모리 풀을 이용해서 적 생성하기.

- 적 리스폰

 * Enemy를 생산하는 Area만들기. (랜덤한 위치로 Area생산 및 Area간 간격조절.)

 * Araa범위 안에 Enemy 랜덤한 위치로 리스폰 시키기.

 * Enemy가 죽었을 경우 리스폰 되는 간격 조절.

5. FSM을 이용해 적 AI만들기.

미리보기

4. 메모리 풀을 이용해서 적 생성하기.

구조

ObjManager에서 Enemy를 자체 생산 해버리면 코드가 여러모로 더러워지고, 관리또한 힘들어진다.

현재 ObjManager는 잔해물 및 총알에 대해서 자체생산하고 있는데, 그 구조를 고쳐보도록 하자.

- 잔해물

- 총알

- 적

각 매니저는 ObjManager에게 필요한 객체의 생산을 요청하고 객체가 필요할때마다 ObjManager에게 요청하여

필요한 객체를 찾아 반환받아 사용할 것이다.

1). Player스크립트에서 ObjManager로 총알 생성 요청하기.

2). Wreckage스크립트에서 ObjManager로 잔해물 생성 요청하기.

3). CreateArea스크립트에서 ObjManager로 적 생성 요청하기.

4). CreateArea스크립트에서 Area생성하기.

5). 각 Area에서 ObjManager에게 비활성화인 Enemy객체 요청하기.

6). Area에서 Enemy소환하기.

7). Enemy가 죽을때 자신의 부모 Area에게 자신의 죽음을 알려, 다음 리스폰여부를 결정하게 한다.

0) ObjManager스크립트에 SetObject()함수 2번째 인자 값의 기본값을 설정

public void SetObject(string _Name, int _Count = 20)
{
    GameObject obj = null;
    int Count = Origin.Length;
    for(int i = 0; i < Count; i++)
    {
        if (Origin[i].name == _Name)
            obj = Origin[i];
    }
 
    SetObject(obj, _Count, _Name);
}

SetObject함수 호출 시 2번째 인자값을 입력하지 않아도 기본 값으로 20이 셋팅된다.

ps. 각 객체의 매니저가 생산요청을 하기 때문에 ObjManager에서 Start()는 할일이 없어졌으므로 지워버리면 된다.

"ObjManager" 풀 소스

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class ObjManager : MonoBehaviour {
 
    // 싱글톤
    static ObjManager st;
    public static ObjManager Call() { return st; }
    void Awake()                    { st = this; }
    // 게임종료 후 메모리 날려버림.
    void OnDestroy()                
    {
        MemoryDelete();
        st = null;
    }
    

 
    // 공개
    public GameObject[] Origin;         // 프리팹 원본.
    public List<GameObject> Manager;    // 생성된 객체들을 저장할 리스트.
 
    // 비공개.
    private Player.PINFO pInfo;         // 플레이어 정보.
 
    // 오브젝트를 받아 생성.
    public void SetObject( GameObject _Obj, int _Count, string _Name)
    {
        for (int i = 0; i < _Count; i++)
        {
            GameObject obj = Instantiate(_Obj) as GameObject;
            obj.transform.name = _Name;                     // 이름을 정한다.
            obj.transform.localPosition = Vector3.zero;     // 위치를 정한다.
            obj.SetActive(false);                           // 객체를 비활성화.
            obj.transform.parent = transform;               // 매니저 객체의 자식으로.
            
            // 레이어가 잔해물 레이어일 때.
            if(obj.layer == 9)
                obj.GetComponent<Renderer>().material.color = new Color(Random.value, Random.value, Random.value, 1.0f);
 
            Manager.Add(obj);                               // 리스트에 저장.
        }
    }
 
    public void SetObject(string _Name, int _Count = 20)
    {
        GameObject obj = null;
        int Count = Origin.Length;
        for(int i = 0; i < Count; i++)
        {
            if (Origin[i].name == _Name)
                obj = Origin[i];
        }
 
        SetObject(obj, _Count, _Name);
    }
 
    // 필요한 오브젝트를 찾아 반환.
    public GameObject GetObject(string _Name)
    {
        // 리스트가 비어있으면 종료.
        if (Manager == null)
            return null;
 
        int Count = Manager.Count;
        for (int i = 0; i < Count; i++)
        {
            // 이름이 같지 않으면.
            if (_Name != Manager[i].name)
                continue;
 
            GameObject Obj = Manager[i];
 
            // 활성화가 되어있다면.
            if (Obj.active == true)
            {
                // 리스트의 마지막까지 돌았지만 모든 객체가 사용중이라면.
                if (i == Count - 1)
                {
                    // 총알을 새롭게 생성.
                    SetObject(Obj, 1, _Name);
                    return Manager[i + 1];
                }
                continue;
            }
            return Manager[i]; 
        }
        return null;
    }
 
    // 메모리 삭제.
    public void MemoryDelete()
    {
        if (Manager == null)
            return;
 
        int Count = Manager.Count;
 
        for (int i = 0; i < Count; i++)
        {
            GameObject obj = Manager[i];
            GameObject.Destroy(obj);
        }
        Manager = null;
    }
 
    // 플레이어의 정보갱신.
    public void PlayerInfoUpdate(Player.PINFO _Info)
    {
        // 플레이어 정보 업데이트.
        pInfo = _Info;
 
        int Count = Manager.Count;
 
        for (int i = 0; i < Count; i++)
        {
            GameObject obj = Manager[i];
            if (obj.name == "Bullet")
                obj.GetComponent<Bullet>().BulletPower = _Info.BulletPower;
        }
    }
 
    // 플레이어의 정보를 가져간다.
    public object GetPlayerInfo(string _Type)
    {
        switch (_Type)
        {
            case "Life":        return pInfo.Life;
            case "MAXHP":       return pInfo.MAX_HP;
            case "HP":          return pInfo.HP;
            case "Speed":       return pInfo.MoveSpeed;
            case "BulletPower": return pInfo.BulletPower;
            case "All":         return pInfo;
        }
        return null;
    }
}

1). Player스크립트에서 ObjManager로 총알 생성 요청하기.

    void Start()
    {
        // 총알 생성 요청.
        ObjManager.Call().SetObject("Bullet");
        Vec = GameObject.Find("CameraVector").transform;
 
        Init();
    }

Start() 함수에 한 줄만 추가하면 끝.

2). Wreckage스크립트에서 ObjManager로 잔해물 생성 요청하기.

Wreckage스크립트 생성 후 하이러키창 ObjManager객체에 스크립트를 추가.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class WreckageManager : MonoBehaviour {
 
    void Start () 
    {
        string Name = "NoData";
 
        for (int i = 0; i < 4; i++)
        {
            switch (i)
            {
                case 0: Name = "Cube";     break;
                case 1: Name = "Cylinder"; break;
                case 2: Name = "Capsule";  break;
                case 3: Name = "Sphere";   break;
            }
            ObjManager.Call().SetObject(Name);
        }
    }
}

3). CreateArea스크립트에서 ObjManager로 적 생성 요청하기.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class EnemyArea : MonoBehaviour {
 
    public List<Transform> RespawnArea; // 리스폰 구역.
 
    public int AreaCount;   // 에리어 개수.
    public int AreaGap;     // 에리어간 간격.
    public int CreateCount; // 적 머리수.
 
    void Start ()
    {
        CreateArea(AreaCount);
 
        // 에너미 생산 요청.
        ObjManager.Call().SetObject("Enemy", CreateCount);
    }
}

4). CreateArea스크립트에서 Area생성하기.

설명은 주석으로.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class EnemyArea : MonoBehaviour {
 
    public List<Transform> RespawnArea; // 리스폰 구역.
 
    public int AreaCount;   // 에리어 개수.
    public int AreaGap;     // 에리어간 간격.
    public int CreateCount; // 적 머리수.
 
    void Start ()
    {
        CreateArea(AreaCount);
 
        // 에너미 생산 요청.
        ObjManager.Call().SetObject("Enemy", CreateCount);
    }
 
    // 위치 랜덤 설정.
    Vector3 RandomPos()
    {
        // AreaGap : 에리어와 에리어간의 간격.
        // 예를들어 에리어간 간격이 5라고 정해줬는데, 랜덤으로 돌려서 나온 위치가
        // 다른 에리어와 가까웠을 경우 다시 랜덤으로 돌려주는데, AreaGap보다 큰 위치 값으로 지정해줘야 한다.
        // 그렇지 않으면 AreaGap이하의 값만 나오게 되므로 무한 루프를 돌게 된다.
        float dis = AreaGap + 2;
        Vector3 Pos = new Vector3(Random.Range(-dis,dis),0,Random.Range(-dis,dis));
        return Pos;
    }
 
    // 리스폰 구역 생성.
    void CreateArea(int _Count = 1)
    {
        // 각 에리어의 부모가 될 객체를 생성.
        GameObject obj = new GameObject();
        obj.name = "EnemyArea";
 
        for(int i = 0; i < _Count; i++)
        {
            // 에리어의 위치를 랜덤으로 하기위한 position설정.
            Vector3 Pos = RandomPos();
            
            // 처음 객체는 아무곳에나 생성되도 된다.
            if(i != 0)
            {
                int Count = RespawnArea.Count;
 
                while(true)
                {
                    for(int j = 0 ;j < Count; j++)
                    {
                        // 새로 할당된 위치와 리스트에있는 에리어간 거리를 잰다.
                        float Dis = Vector3.Distance( Pos, RespawnArea[j].position);
 
                        // 그 거리가 설정한 간격보다 작으면
                        if(Dis < AreaGap)
                        {
                            // 위치를 재 설정한다.
                            Pos = RandomPos();
                            break;
                        }
 
                        // 모든 에리어간 거리가 일정하면 모든 반복문을 한 번에 빠져나간다.
                        if(j >= Count - 1)
                            goto EXIT;
                    }
                }
            }
 
        // goto문은 많이 사용하면 좋지 않지만, 이런경우에는 유용하게 사용 가능하다.
        EXIT:
            // 에리어 생성.
            GameObject Area = Instantiate(obj,Pos, Quaternion.identity) as GameObject;  // Area생성.
            Area.name = "EnemyArea_" + i;                                               // Area의 이름을 정한다.
            RespawnArea.Add(Area.transform);                                            // 리스트에 Area추가.
        }
 
        // 모든 에리어를 자식으로 두는 부모객체.
        for(int i = 0; i < RespawnArea.Count; i++)
        {
            Transform Area = RespawnArea[i];
            Area.parent = obj.transform;                    // 부모 객체지정.
            Area.gameObject.AddComponent<CreateEnemy>();    // Area객체에 CreateEnemy 스크립트를 추가.
        }
    }
 
    // 에너미 부모 에리어의 스크립트를 찾아준다.
    public CreateEnemy GetParentAreaScript(string _Name)
    {
        int Count = RespawnArea.Count;
        for(int i = 0; i < Count; i++)
        {
            if(RespawnArea[i].name == _Name)
                return RespawnArea[i].GetComponent<CreateEnemy>();
        }
        return null;
    }
}

하이러키창에 생성된 Area객체.

5). 각 Area에서 ObjManager에게 비활성화인 Enemy객체 요청하기. &

6). Area에서 Enemy소환하기.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class CreateEnemy : MonoBehaviour {
 
    public float SummonTimeGap;   // 소환간격.
    public int MaxCount;          // 최대 소환 가능한 수.
    public int EnemyCount;        // 현재 소환된 머리 수.
    
    public bool Summon;           // 소환 여부.
 
    // 값 초기화.
    void Init(float _SummonTimeGap, int _MaxCount, bool _Summon)
    {
        SummonTimeGap = _SummonTimeGap;
        MaxCount = _MaxCount;
        Summon = _Summon;
 
        StartCoroutine("SummonEnemy");
    }
 
    void Start () 
    {
        Init(Random.Range(5f,10f),3,false);
    }
    
    // 랜덤 위치.
    Vector3 RandomPos()
    {
        Vector3 Pos = new Vector3(Random.Range(0f, 5f), 1, Random.Range(0f, 5f));
 
        // 현재 에리어의 위치 + 랜덤한 위치
        return transform.position + Pos;
    }
 
    // 소환정보 체크 후 소환 결정.
    IEnumerator SummonEnemy()
    {
        while (true)
        {
            // 적 머리수가 0이면 소환여부를 false(소환가능)로 전환.
            if (EnemyCount <= 0)
            {
                // Enemy가 다 죽고 리스폰까지 시간지연.
                yield return new WaitForSeconds(SummonTimeGap);
                Summon = false;
            }
 
            // 소환된 적이 없으면 적 소환.
            if (!Summon)
                ESummon();
 
            // 1초마다 체크.
            yield return new WaitForSeconds(1f);
        }
    }
 
    // 소환!
    void ESummon()
    {
        for (int i = 0; i < MaxCount; i++)
        {
            GameObject obj = ObjManager.Call().GetObject("Enemy");      // Enemy객체 요청.
            obj.transform.position = RandomPos();                       // 위치 랜덤 설정.
            obj.transform.parent = transform;                           // 부모 설정.
            obj.SetActive(true);                                        // 적 활성화.
            obj.GetComponent<Enemy>().Init();                           // 적 정보 초기화.
            EnemyCount++;
        }
        Summon = true;
    }
 
    // 에너미가 죽었을 때 수신하는 함수.
    public void DeadEnemy()
    {
        EnemyCount--;
    }
}

7). Enemy가 죽을때 자신의 부모 Area에게 자신의 죽음을 알려, 다음 리스폰여부를 결정하게 한다.

'Enemy' Script

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Enemy : MonoBehaviour {
 
    // 공개
    public float HP;        // 현재 체력
 
    // 비공개
    private float MAX_HP;   // 최대 체력
    private bool Life;      // 살아있는지에 대한 여부.
 
    // 정보 초기화 함수.
    public void Init()
    {
        MAX_HP = 100;
        HP = MAX_HP;
 
        Life = true;
 
        StartCoroutine("StateCheck");
    }
 
    // 상태체크.
    IEnumerator StateCheck()
    {
        // 살아있는 동안에만 반복문을 돌림.
        while (Life)
        {
            // 적 AI
            yield return null;
        }
    }
 
    // 정보 갱신.
    public void InfoUpdate(float _Damage)
    {
        HP -= _Damage;
 
        if (HP <= 0)
        {
            // 폭발한다.
            explosion();
 
            HP   = 0;       // 체력의 수치가 음의 값으로 갔을 경우를 대비한 초기화.
            Life = false;   // 죽었음을 알림.
 
            // 내 죽음을 부모에리어에게 알려라!            
            // 부모 에리어가 가진 스크립트를 가져와 DeadEnemy()함수를 호출.
            transform.parent.GetComponent<CreateEnemy>().DeadEnemy();
            gameObject.SetActive(false);        
        }
    }
 
    // 폭발은 예술이다.
    void explosion()
    {
        string Name = "NoData";
        // 잔해물 소환.
        for (int i = 0; i < 4; i++)
        {
            // 잔해물 4종류.
            switch (i)
            {
                case 0: Name = "Cube";      break;
                case 1: Name = "Cylinder";  break;
                case 2: Name = "Capsule";   break;
                case 3: Name = "Sphere";    break;
            }
 
            // 잔해물을 4종류를 5개씩 총 20개를 찾아 뿌린다.
            for (int j = 0; j < 5; j++)
            {
                GameObject obj = ObjManager.Call().GetObject(Name);
                
                if (obj == null)
                    continue;
 
                obj.transform.position = transform.position;    // 현재 에너미의 위치로
                obj.SetActive(true);
 
                // 일정 시간 후 사라지기 위한 코루틴.
                obj.GetComponent<ExplosionHide>().StartCoroutine("StartExplosionHide");
            }
        }
    }
}
 

에너미의 HP가 0이 되었을 때

에너미 자신이 속한 에리어의 스크립트를 가져와 Dead함수를 호출하여 자신이 죽었다는 사실을 알린다.

에리어는 그 사실을 인지하고 현재 살아있는 에너미 머리수 중 1을 줄인다.

머리수가 0이 되면 일정 시간 후에 에너미를 리젠 시킨다.