📌 오브젝트 풀 패턴으로 최적화 하기

• 프레임 속도를 유지하려면, 자주 생성되는 요소를 일부 메모리에 예약하는게 좋다.
• 최근 죽인 적을 메모리에서 업애는 대신 다시 사용할 수 있도록 오브젝트 풀에 추가.
• 엔티티의 새로운 인스턴스를 로드하는 초기의 촉기화 비용이 들지 않는다.
• Unity에는 오브젝트 풀링이 API에 구현되어 있다.

➔ 오브젝트 풀 패턴

• ObjectPool : 객체의 풀을 관리한다. 즉, 객체를 생성하고, 관리하고, 파기하는 책임

• ReusablePool : 실제로 재사용될 객체이다. ObjectPool이 여기 객체들을 관리한다.

• Client : 클라이언트는 필요할 때 ObjectPool에서 ReusablePool 객체를 요청하고, 사용 후에는 다시 풀에 반환한다.

장점

• 예측할 수 있는 메모리 사용

• 성능의 향상

단점

• 이미 C#이 메모리 최적화가 뛰어나서 굳이 필요없다는 이야기가 있다.

• 객체가 예측이 불가능하게 된다. (예측 불가능한 객체 상태)

➔ Client.cs

public class ClientObjectPool : MonoBehaviour
{
    private DroneObjectPool _pool;
    
    void Start()
    {
        _pool = gameObject.AddComponent<DroneObjectPool>();
    }

    void OnGUI()
    {
        if (GUILayout.Button("Spawn Drones"))
            _pool.Spawn();
    }
}

➔ Drone.cs

public class Drone : MonoBehaviour 
{
    public IObjectPool<Drone> Pool { get; set; }

    public float _currentHealth;

    [SerializeField] 
    private float maxHealth = 100.0f;
    [SerializeField] 
    private float timeToSelfDestruct = 3.0f;

    void Start() 
    {
        _currentHealth = maxHealth;
    }
    
    void OnEnable() 
    {
        AttackPlayer();
        StartCoroutine(SelfDestruct());
    }

    private void OnDisable() 
    {
        ResetDrone();
    }

    IEnumerator SelfDestruct() {
        yield return new WaitForSeconds(timeToSelfDestruct);
        TakeDamage(maxHealth);
    }
    
    private void ReturnToPool() {
        Pool.Release(this);
    }
    
    private void ResetDrone() {
        _currentHealth = maxHealth;
    }

    public void AttackPlayer() {
        Debug.Log("Attack player!");
    }

    public void TakeDamage(float amount) {
        _currentHealth -= amount;
        
        if (_currentHealth <= 0.0f)
            ReturnToPool();
    }
}

➔ ObjectPool.cs

public class DroneObjectPool : MonoBehaviour
{
    public int maxPoolSize = 10;
    public int stackDefaultCapacity = 10;

    // 필요할 떄 오브젝트 풀을 생성함
    public IObjectPool<Drone> Pool 
    {
        get 
        {
            if (_pool == null)
                _pool = 
                    new ObjectPool<Drone>(
                        CreatedPooledItem, 
                        OnTakeFromPool, 
                        OnReturnedToPool, 
                        OnDestroyPoolObject, 
                        true, 
                        stackDefaultCapacity,
                        maxPoolSize);
            return _pool;
        }
    }

    private IObjectPool<Drone> _pool;

    private Drone CreatedPooledItem() 
    {
        var go = 
            GameObject.CreatePrimitive(PrimitiveType.Cube);
        
        Drone drone = go.AddComponent<Drone>();
        
        go.name = "Drone";
        drone.Pool = Pool;
        
        return drone;
    }

    // 드론이 풀로 돌아올 때 호출됨
    private void OnReturnedToPool(Drone drone) 
    {
        drone.gameObject.SetActive(false);
    }

    // 드론이 풀에서 꺼내질 때 호출됨
    private void OnTakeFromPool(Drone drone) 
    {
        drone.gameObject.SetActive(true);
    }

    // 드론 오브젝트를 파괴할 때
    private void OnDestroyPoolObject(Drone drone) 
    {
        Destroy(drone.gameObject);
    }

    // 무작위 수의 드론을 생성하고 위치를 설정할 때
    public void Spawn() 
    {
        var amount = Random.Range(1, 10);
        
        for (int i = 0; i < amount; ++i) {
            var drone = Pool.Get();
            
            drone.transform.position = 
                Random.insideUnitSphere * 10;
        }
    }
}

---

📌 전략 패턴으로 드론 구현하기

• 드론의 다양한 동작을 구현하는 상황
• 런타임에 특정 동작을 객체에 바로 할당할 수 있다.

➔ 전략 패턴 개요

• Context : 자신의 작업을 수행하는데 필요한 전략을 선택하는 클래스

• Strategy : 전략 인터페이스를 구현한 클래스들로, 특정 행동을 제공한다.

• Client : 클라이언트에서 Context 클래스를 생성

장점

• 캡슐화가 잘될 수 있다.

• 런타임에 객체가 사용하는 알고리즘을 교환할 수 있다.

단점

• 전략 패턴과 상태 패턴이 혼동될 수 있다. 구조가 유사하지만 의도가 매우 다르다.
  - 전략 패턴 : 같은 문제를 해결하는 여러 알고리즘이 있을 때, 이들 중 하나를 런타임에 선택해야할 때. (ex : 상황에 따라 적합한 정렬 알고리즘 고르기), 즉, 알고리즘의 선택에 중점
  • 상태 패턴 : 객체가 여러 상태를 가지고 있고, 상태에 따라 행동이 달라져야할 때. 즉, 상태에 따른 행동 변경

➔ Drone.cs

public class Drone : MonoBehaviour {
    public void ApplyStrategy(IBehaviour strategy) {
        strategy.Maneuver(this);
    }
}

➔ Stategy.cs

public class ClientStrategy : MonoBehaviour {
    
    private GameObject _drone;
    private List<IBehaviour> 
        _components = new List<IBehaviour>();
    
    private void SpawnDrone() {
        _drone = 
            GameObject.CreatePrimitive(PrimitiveType.Cube);
        
        _drone.AddComponent<Drone>();
        
        _drone.transform.position = 
            Random.insideUnitSphere * 10;
        
        ApplyRandomStrategies();
    }

    private void ApplyRandomStrategies() {
        _components.Add(
            _drone.AddComponent<Weaving>());
        _components.Add(
            _drone.AddComponent<Bopping>());
        _components.Add(
            _drone.AddComponent<Fallback>());
        
        int index = Random.Range(0, _components.Count);
        
        _drone.GetComponent<Drone>().
            ApplyStrategy(_components[index]);
    }
    
    void OnGUI() {
        if (GUILayout.Button("Spawn Drone")) {
            SpawnDrone();
        }
    }
}

---

📌 커맨드 패턴으로 리플레이 시스템 구현하기

• 커맨드 패턴은 게임 내에서 발생하는 모든 행동 (이동, 점프)을 명령으로 캡슐화를 할 수 있다. 그리고 이 명령들이 모두 쉽게 기록이 된다.
• 기록을 재생하여 리플레이 시스템을 구현할 수 있다.

➔ 커맨드 패턴 개요

• Clint : 커맨드 객체를 생성, 그 커맨드가 어떤 Receiver와 연결될지를 결정한다.

• Invoker (호출자) : 커맨드를 받아서 실행한다.

• Command (커맨드) : 실행될 모든 명령에 대한 인터페이스

• Receiver (수신자) : 실제로 작업을 수행할 객체.

장점

• 분리 : 실행하는 객체와 호출하는 개체가 분리된다.

• 명령하는 것을 큐에 넣어서 리플레이, 매크로, 명령 큐 등을 구현할 수 있다.

단점

• 각각의 명령을 하나의 클래스로 구현해야되서 좀 복잡하다.

➔ Command.cs

public abstract class Command
{
    public abstract void Execute();
}

➔ Invoker.cs

class Invoker : MonoBehaviour
{
    private bool _isRecording;
    private bool _isReplaying;
    private float _replayTime;
    private float _recordingTime;
    private SortedList<float, Command> _recordedCommands = 
        new SortedList<float, Command>();

    public void ExecuteCommand(Command command)
    {
        command.Execute();
        
        if (_isRecording) 
            _recordedCommands.Add(_recordingTime, command);
        
        Debug.Log("Recorded Time: " + _recordingTime);
        Debug.Log("Recorded Command: " + command);
    }

    public void Record()
    {
        _recordingTime = 0.0f;
        _isRecording = true;
    }

    public void Replay()
    {
        _replayTime = 0.0f;
        _isReplaying = true;
        
        if (_recordedCommands.Count <= 0)
            Debug.LogError("No commands to replay!");
        
        _recordedCommands.Reverse();
    }
    
    void FixedUpdate()
    {
        if (_isRecording) 
            _recordingTime += Time.fixedDeltaTime;
        
        if (_isReplaying)
        {
            _replayTime += Time.fixedDeltaTime;

            if (_recordedCommands.Any()) 
            {
                if (Mathf.Approximately(
                    _replayTime, _recordedCommands.Keys[0])) {

                    Debug.Log("Replay Time: " + _replayTime);
                    Debug.Log("Replay Command: " + 
                                _recordedCommands.Values[0]);
                    
                    _recordedCommands.Values[0].Execute();
                    _recordedCommands.RemoveAt(0);
                }
            }
            else
            {
                _isReplaying = false;
            }
        }
    }
}

➔ TrunLeft.cs

public class TurnLeft : Command
{
    private CharacterController _controller;

    public TurnLeft(CharacterController controller)
    {
        _controller = controller;
    }

    public override void Execute()
    {
        _controller.Turn(CharacterController.Direction.Left);
    }
}

➔ TrunRight.cs

public class TurnRight : Command
{
    private CharacterController _controller;

    public TurnRight(CharacterController controller)
    {
        _controller = controller;
    }

    public override void Execute()
    {
        _controller.Turn(CharacterController.Direction.Right);
    }
}