참된코딩 :: 참된코딩

[C#] interface

C# 2017. 4. 3. 20:45

interface

- 추상 클래스와 비슷하다.

- 상속하는 모든 클래스 형식에서는 해당 메소드를 모두 구현해야 한다.

- 직접 인스턴스화할 수 없다.

- 이벤트, 인덱서, 메소드, 프로퍼티만을 가질 수 있다.

- 메소드 구현을 하지 않는다. (선언은 있고 정의는 없다.)

- 클래스와 구조체는 여러 인터페이스를 상속 받을 수 있다.

- 인터페이스 자체는 여러 인터페이스를 상속 받을 수 있다.

- 접근자는 쓸 수 없고 모두 public이다.

사용하는 이유?

- 의도하지 않은 속성,메소드 공개를 막을수 있다.

- OOP의 상속에 억매이지 않고, 구현할 수 있도록 개방성을 제공한다.

※ 주의사항

- 속성, 메소드의 변화 가능성이 많다면, 아예 사용하지 않는것이 좋다.

=> 인터페이스에 변경이 일어난다면, 아주 위험한 상황이 올 수 있다.

인터페이스라는 것이 상속의 원형이 되는 것이므로, 원형이 변경되면

자식들도 변경이 일어난다는 뜻이다. 인터페이스에 경우, 전혀 다른 제품으로의

확장도 지원할 수 있으므로, 인터페이스 설계 시 아주 조심해야 한다.

형태

1
2
3
4
interface 인터페이스이름
{
    메소드
}
cs

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
using System;
 
namespace IUnit
{
    interface IUnit
    {
        void Move(int x, int y);
        void Attack(int x, int y);
        void Die();
    }
 
    class Marine : IUnit
    {
        public void Move(int x, int y)
        {
            Console.WriteLine("아장아장");
        }
 
        public void Attack(int x, int y)
        {
            Console.WriteLine("두두");
        }
 
        public void Die()
        {
            Console.WriteLine("으악");
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Marine M = new Marine();
            M.Attack(5,5);
            M.Move(5, 5);
            M.Die();
        }
    }
}
Colored by Color Scripter
cs

IUnit 인터페이스는 구현은 정읳지 않으며, 메소드의 목록만을 제공한다.

저작자표시 비영리 변경금지 (새창열림)

'C#' 카테고리의 다른 글

[C#] 메소드 오버로딩, 가변길이 매개 변수, 선택적 매개 변수 (0)	2017.03.25
[C#] 참조에 의한 매개 변수 전달. ref / 출력 전용 매개 변수. out (0)	2017.03.24
[C#] 공용 형식 시스템. (0)	2017.03.24
[C#] var형식 (0)	2017.03.24
[C#] Object형식, 박싱과 언박싱. (1)	2017.03.23

Posted by 비선형구조

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

Unity3D/Project 2017. 4. 3. 11:43

※ 주의

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

0. 미리보기

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

- 프리팹 제작.

- 싱글톤 제작.

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

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

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

추가.

3. 적 생성

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

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

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

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

- 적 리스폰

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

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

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

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

미리보기

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

유한 상태 기계 (Finite State Machine) 라고 불린다.

- 유한한 개수의 상태를 가진 기계.

- 한 번에 오로지 하나의 상태만을 가진다.

- 이러한 기계는 어떠한 이벤트에 의해서 다른 상태로 변화할 수 있다.

유한 상태 기계를 사용하면 코드의 가독성이 오르고 관리하기도 편해진다.

enum으로 에너미의 상태를 설정해주고,

각 상태들을 switch case문으로 갈라서 코루틴을 사용하여 지속적으로 체크해준다.

'Enemy' Script

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Enemy : MonoBehaviour
{
    public enum STATE { IDLE, WALK, ATTACK }
 
    // 공개
    public STATE state;          // 에너미의 상태.
    public float HP;             // 현재 체력
    public float Speed;          // 움직임 스피드.
    public float TraceDis;       // 추적 거리.
 
    // 비공개
    private Transform player;    // 플레이어.
    private Vector3 RandomPoint; // 랜덤한 위치. 
    private Vector3 AreaPos;     // 부모 에리어의 처음 위치.
 
    private float MAX_HP;        // 최대 체력
    private bool Life;           // 살아있는지에 대한 여부.
    private bool trace;          // 추적 플래그.
 
    // 각 상태의 코루틴을 시작하기 위한 플래그.
    private bool idle;      
    private bool walk;
    private bool attack;
 
    // 정보 초기화 함수.
    public void Init(Vector3 _AreaPos)
    {
        AreaPos = _AreaPos;
 
        MAX_HP = 100;
        HP = MAX_HP;
 
        Life   = true;
        trace  = false;
        state  = STATE.IDLE;
 
        idle   = false;
        walk   = false;
        attack = false;
 
        ReandomPos();
        StartCoroutine("DisCheck");
        StartCoroutine("StateCheck");
    }
 
    void Awake()
    {
        player = GameObject.FindGameObjectWithTag("Player").transform;
    }
 
    // 플레이어와의 거리를 체크.
    IEnumerator DisCheck()
    {
        while (Life)
        {
            // 거리측정.
            float dis = Vector3.Distance(player.position, transform.position);
 
            // 범위 5안에 플레이어가 있으면.
            if (dis <= TraceDis)
                trace = true;   // 추적 플래그 on
            else
                trace = false;  // 추적 플래그 off
 
            // 0.2초마다 1번씩 거리를 체크한다.
            yield return new WaitForSeconds(0.2f);
        }
    }
 
    // 상태체크.
    IEnumerator StateCheck()
    {
        // 적 AI
        // 살아있는 동안에만 반복문을 돌림.
        while (Life)
        {
            switch (state)
            {
                case STATE.IDLE:
                {
                    if (!idle)
                    {
                        idle = true;
                        StartCoroutine("IdleState");
                    }
                    break;
                }
                case STATE.WALK:
                {
                    if (!walk)
                    {
                        walk = true;
                        StartCoroutine("WalkState");
                    }
                    break;
                }
                case STATE.ATTACK:
                {
                    if (!attack)
                    {
                        attack = true;
                        StartCoroutine("AttackState");
                    }
                    break;
                }
            }
            yield return new WaitForSeconds(0.2f);
        }
    }
 
    // 정보 갱신.
    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");
            }
        }
    }
 
    // 랜덤한 위치 선정.
    void ReandomPos()
    {
        RandomPoint = AreaPos + new Vector3(Random.Range(-5, 5f), transform.position.y, Random.Range(-5, 5f));
    }
 
    // 목표(매개변수) 방향으로 회전.
    void Rotations(Vector3 _Pos)
    {
        Vector3 vec = (_Pos - transform.position).normalized;
        Quaternion q = Quaternion.LookRotation(vec);
        Vector3 eu = q.eulerAngles;
        eu.x = eu.z = 0;
 
        transform.rotation = Quaternion.Euler(eu);
    }
 
    // 거리체크 및 상태변화.
    void DisCheckToState(Vector3 _Pos, float _Dis, STATE _state, bool _UpDown)
    {
        float dis = Vector3.Distance(transform.position, _Pos);
 
        if (_UpDown)
        {
            if (dis <= _Dis)
                state = _state;
        }
        else
        {
            if (dis > _Dis)
                state = _state;
        }
    }
 
//------------- 각 상태에 따른 코루틴-----------------//
 
    // 평화상태.
    IEnumerator IdleState()
    {
        float timer = 0;
        float RandomTime = Random.Range(3, 7);
 
        while(Life)
        {
            timer += Time.deltaTime; // 시간을 축적.
 
            // 시간이 다 되면 다른상태로 전환하기 위해 반복문을 빠져나감.
            if (timer >= RandomTime || trace)
                break;
 
            yield return null;
        }
 
        ReandomPos();           // 다음 걸어갈 위치를 정한다.
        state = STATE.WALK;        // 걷는 상태로 전환.
        idle = false;
    }
 
 
    // 걷는상태.
    IEnumerator WalkState()
    {
        while (Life)
        {
            if(state != STATE.WALK)
                break;
 
            if (trace) // 플레이어 추적.
            {
                Rotations(player.position); // 회전
                DisCheckToState(player.position, 2f, STATE.ATTACK, true); // 거리체크 및 상태변환.
            }
            else // 랜덤한 위치로 이동.
            {
                Rotations(RandomPoint);
                DisCheckToState(RandomPoint, 2f, STATE.IDLE, true); 
            }
            
            // 전진.
            transform.Translate(Vector3.forward * Speed * Time.deltaTime);
            yield return null;
        }
 
        walk = false;
    }
 
    // 공격 상태.
    IEnumerator AttackState()
    {
        while (Life)
        {
            if(state != STATE.ATTACK)
                break;
 
            Rotations(player.position);
            DisCheckToState(player.position, 3f, STATE.IDLE, false);
 
            yield return null;
        }
 
        attack = false;
    }
}
Colored by Color Scripter
cs

Enemy 인스펙터창 정보

새로 추가된 사항의 구조.

저작자표시 비영리 변경금지 (새창열림)

'Unity3D > Project' 카테고리의 다른 글

[Unity3D] 인벤토리 [Part 0] (0)	2017.04.06
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 5] 추가사항 (2)	2017.04.05
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 4] (0)	2017.03.28
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 3] (0)	2017.03.27
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 2] (0)	2017.03.21

Posted by 비선형구조

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

Unity3D/Project 2017. 3. 28. 11:36

※ 주의

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

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번째 인자 값의 기본값을 설정

1
2
3
4
5
6
7
8
9
10
11
12
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);
}
Colored by Color Scripter
cs

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

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

"ObjManager" 풀 소스

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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;
    }
}
Colored by Color Scripter
cs

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

1
2
3
4
5
6
7
8
    void Start()
    {
        // 총알 생성 요청.
        ObjManager.Call().SetObject("Bullet");
        Vec = GameObject.Find("CameraVector").transform;
 
        Init();
    }
Colored by Color Scripter
cs

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
        }
    }
}
Colored by Color Scripter
cs

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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);
    }
}
Colored by Color Scripter
cs

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

설명은 주석으로.

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
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;
    }
}
Colored by Color Scripter
cs

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

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

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

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
68
69
70
71
72
73
74
75
76
77
78
79
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--;
    }
}
Colored by Color Scripter
cs

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

'Enemy' Script

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
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");
            }
        }
    }
}
 
Colored by Color Scripter
cs

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

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

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

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

저작자표시 비영리 변경금지 (새창열림)

'Unity3D > Project' 카테고리의 다른 글

[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 5] 추가사항 (2)	2017.04.05
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 5] (0)	2017.04.03
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 3] (0)	2017.03.27
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 2] (0)	2017.03.21
[Unity3D] 객체 미리 생성 후 재활용 - Memory pool [Part 1] (0)	2017.03.20