🎮 시작 계기

코로나 팬데믹으로 인생이 뒤바뀌고, 어머니 간병이라는 뜻밖의 임무를 마친 뒤, 인생 2막을 고민하던 중 우연히 접한 게임 개발! 이때부터 “아, 이거구나!” 하고 반짝이는 눈으로 경일게임IT아카데미 온라인 부트캠프 8개월 과정을 선택했습니다. ‘이게 내 길일지도?’ 하는 설렘과 함께 대장정을 시작했죠.

💻 온라인 학습의 속살

처음엔 ‘혼자 온라인이라 괜찮으려나’ 했는데, 의외로 수업 녹화본과 라이브 강의를 무한 반복하며 나만의 페이스로 배웠어요. Notion과 diagrams, Figma 덕분에 팀원들과 실시간으로 교감하고, 과제·프로젝트 진행 리듬도 척척 맞췄죠. 자기주도 학습, 멋지게 해내기 위한 ‘나만의 비법’도 터득! 꾸준한 복습과 토론이 진짜 실력으로 이어졌습니다.

📃 찐 프로젝트 경험 – WinterCup

"이것이 진짜 게임 개발이다!" 강렬한 첫맛을 느낀 프로젝트였어요. 동계 올림픽 국가대표 팀을 관리하는 모바일 시뮬레이터, Unity와 C#으로 튜토리얼 시스템, 사운드매니저, 선수·코치 관리 UI까지 싹싹 직접 만들며 개발세계에 ‘입덕’했습니다. 팀원과의 소통 덕분에 Git 충돌, 코드 꼬임, 버그 수십 개도 웃으며 넘겼죠. 완성작을 보고 “우와, 내가 만들었어?” 하며 뿌듯함이 끝없이 밀려왔던 순간 기억나요.

✈️ 수료 소감과 미래를 향해

8개월이란 시간에 뼈를 깎는 노력과 웃음, 갈등, 배움이 공존했지만 전 지금 화면 아래에 ‘입문→초급→중급’ 올라가는 계단을 딛고 서 있습니다. 미래 수강생 분들께는 ‘포기 말고, 소통하고, 팀플을 즐겨라!’ 권하고 싶어요. 경일게임IT아카데미는 단지 학원이나 강의가 아니라 게임 개발자의 꿈을 현실로 만들어주는 여행이니까요!

1. 개요

애니메이션 이벤트 : 실행되는 애니메이션의 특정 타이밍에 함수를 호출할 수 있는 기능, 프레임 단위로 설정 가능

사용 예시>

1. 발이 지면에 닿을 때 먼지 이펙트 및 발걸음 사운드
2. 공격 타이밍에 맞춰 파티클 생성
3. 무기를 휘두르는 타이밍에 맞춰 공격 로직과 이펙트 발생

사용 에셋

https://www.mixamo.com/#/?page=1&query=slash 애니메이션(Great Sword Pack)

https://www.mixamo.com/#/?page=1&query=&type=Character 캐릭터(Maia W/Prop J J Ong)

2. 애니메이션 이벤트 사용 방법

• 1. 애니메이션 클립에서 이벤트 추가 (Read-Only 파일 불가능)
  1. 애니메이션 클립 더블 클릭하여 Animation 창 진입

2. 프레임 단위로 이동하여 메서드를 호출할 프레임 지정
3. 이벤트 버튼 클릭하여 추가 가능

• 2. 애니메이션 모델 파일 (클립X)의 Animation 설정에서 이벤트 추가
  1. 애니메이션 모델 파일 클릭

2. Animation 클릭하고 아래에서 Event 토글 열기

3. 미리보기 클릭하여 재생하며 메서드 호출할 프레임 지정 (아바타 설정 필요)

    Other 클릭하여 파일에 맞는 아바타 선택

4. Add Event 버튼을 눌러 지정한 프레임에 이벤트 추가

5. 오브젝트에 부착되어 있는 스크립트에 포함되어 있는 메서드 이름 작성
    1. 메서드에 매개변수가 있다면 추가 가능
    2. Object에 참조 필요 X
6. Apply 눌러 저장

3. 주의점

• 해당 애니메이션이 100% 재생되기 전에 Transition되면서 다음 애니메이션으로 넘어가면 호출이 되지 않는 문제 발생
  • 다음 애니메이션으로 Transition되는 부분에서 50% 이상 진행된 이후로는 이벤트 호출 X

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

public abstract class Item : MonoBehaviour
{
    public string itemName; // 아이템 이름
    public string itemDescription; // 아이템 설명

    public abstract void Use();

    //private void OnCollisionEnter(Collision collision)    
    //{
    //    if (collision.gameObject.CompareTag("Player"))
    //    {
    //        Use();
    //        Destroy(gameObject); // 아이템 사용 후 파괴
    //    }
    //}

}

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

public class Potion : Item
{
    Player player; // 플레이어 객체
    private float rotSpeed = 100f;        // 돌아가는 속도

    public Potion()
    {
        itemName = "힐링 포션"; // 아이템 이름 설정ㄴㄴㄴ
        itemDescription = "소량의 체력을 회복하는 아이템"; // 아이템 설명 설정
    }

    public override void Use()
    {
        Debug.Log("포션 사용 체력 30 회복"); // 포션 사용 로그 출력
        player.Heal(30); // 플레이어 체력 회복
    }

    private void OnCollisionEnter(Collision collision)
    {
        if(collision.gameObject.CompareTag("Player"))
        {
            player = collision.gameObject.GetComponent<Player>(); // 플레이어 컴포넌트 가져오기
            Inventory inventory = collision.gameObject.GetComponentInChildren<Inventory>();
            inventory.AddItem(this); 
            Use(); // 포션 사용
            //Destroy(gameObject); // 포션 오브젝트 파괴
        }
    }

    void Update()
    {
        Rotate(); // 포션 회전
    }

    private void Rotate()
    {
        transform.Rotate(Vector3.up, rotSpeed * Time.deltaTime);    // Vector3.up 을 기준으로 돈다. -> Up 위를 기준!으로 도는 것 
    }
}

using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class PlayerPresenter : MonoBehaviour
{
    [Header("Model")]
    [SerializeField] PlayerModel model;

    [Header("View")]
    [SerializeField] TMP_Text playerHPTextUI;
    [SerializeField] TMP_Text playerMaxTextUI;
    [SerializeField] Slider playerHPSliderUI;
    //[SerializeField] TMP_Text playerSpeedTextUI;
    [SerializeField] TMP_Text playerJumpTextUI;
    private int jump = 0;

    private void OnEnable()
    {
        model.OnHpChanged += SetHP;
        model.OnMaxHPChanged += SetMaxHP;
        SetMaxHP(model.MaxHP);
        SetHP(model.HP);
    }

    private void OnDisable()
    {
        model.OnHpChanged -= SetHP;
        model.OnMaxHPChanged -= SetMaxHP;
    }

    private void Update()
    {
        //SetSpeed(model.Velocity);

        if (Input.GetKeyDown(KeyCode.Space)){
            SetJumpCount();
        }

    }

    public void SetHP(int hp)
    {
        playerHPTextUI.text = $"{hp}";
        playerHPSliderUI.value = hp;
    }

    public void SetMaxHP(int maxHP)
    {
        playerMaxTextUI.text = $"{maxHP}";
        playerHPSliderUI.maxValue = maxHP;
    }

    //public void SetSpeed(Vector3 velocity)
    //{
    //    playerSpeedTextUI.text = $"{velocity.magnitude}";
    //}

    public void SetJumpCount()
    {
        jump += 1;  // 점프시 카운트
        playerJumpTextUI.text = $"jump : {jump}";   // 현제 카운트 시각화

    }
}

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

public class PlayerModel : MonoBehaviour
{
    [SerializeField] int hp;
    public int HP { set { hp = value; OnHpChanged?.Invoke(hp); } get { return hp; } }
    public event Action<int> OnHpChanged;    // 이벤트 

    [SerializeField] int maxHP;
    public int MaxHP { set { maxHP = value; OnMaxHPChanged?.Invoke(maxHP); } get { return maxHP; } }
    public event Action<int> OnMaxHPChanged;

    [SerializeField] Rigidbody rigid;
    public Vector3 Velocity { set { rigid.velocity = value; OnVelocityChanged?.Invoke(rigid.velocity); } get { return rigid.velocity; } }
    public Action<Vector3> OnVelocityChanged;
}

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

// 컨트롤러 : 논리로직(동작)
public class PlayerController : MonoBehaviour
{
    [SerializeField] PlayerModel model;
    [SerializeField] Rigidbody rigid;
    [SerializeField] float jumpPower;

    private void Update()
    {
        //Move();  

        if (Input.GetKeyDown(KeyCode.Space))
        {
            rigid.AddForce(Vector3.up * jumpPower, ForceMode.Impulse);  // Impulse = 한번 펑! 힘을 주는 것
        }
        if (Input.GetKeyDown(KeyCode.A))
        {
            model.HP += 1;
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            model.HP -= 1;
        }
    }

    private void Move()
    {
        float xInput = Input.GetAxis("Horizontal");
        float zInput = Input.GetAxis("Vertical");

        Vector3 dir = new Vector3(xInput, 0, zInput);
        if (dir.sqrMagnitude > 1)
        {
            dir = dir.normalized;
        }

        model.Velocity = Vector3.MoveTowards(model.Velocity, dir * 5, 10 * Time.deltaTime);
    }
}

public static class LayerUtil
{
    public static void AddLayer(ref LayerMask target, params string[] names)
    {
        foreach(string n in names)
        {
            target |= 1 << LayerMask.NameToLayer(n);
        }
    }

    public static void RemoveLayer(ref LayerMask target, string name)
    {
        target &= ~(1 << LayerMask.NameToLayer(name));  // name으로 layer의 번호를 반환, 그리고 반전, 엔드 연산
    }
}

• 유니티에서 게임 월드를 구성하는 단위
• 프로젝트에 원하는 수만큼 씨능 포함할 수 있고 씬전환을 통해 다른 게임월드를 불러올 수 있음
• 다중 씬을 이용하여 여러 씬을 동시에 열어 같은 게임월드에서 사용도 가능함

<빌드설정>

• 유니티에서 여러 씬을 사용하기 위해선 빌드 설정에서 씬을 포함해야 함
• 빌드 설정에서 포함한 씬을 게임 빌드 결과물에 포함함

< 씬 전환>

• 프로젝트에 포함된 다른 씬을 로딩하고 기존의 씬의 내용을 삭제함.

  public class SceneChanger : MonoBehaviour
  {
        private void Awake()
        {
            Debug.Log("씬 체인저 생성!");
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.Alpha0))
            {
                SceneManager.LoadScene("TitleScene");  //씬 순서 번호 or 씬 이름 으로 로드 가능
            }
            else if (Input.GetKeyDown(KeyCode.Alpha1))
            {
                SceneManager.LoadScene("GameScene");
            }

        }

    /**********************************************************/


    // <씬 전환>
    // 프로젝트에 포함된 다른 씬을 로딩하고 기존의 씬의 내용을 삭제함
    public void ChageScene(string sceneName)
    {
        SceneManager.LoadScene(sceneName);
    }


    // <씬 추가>
    // 프로젝트에 포함된 다른 씬을 로딩하고 기존의 씬의 내용을 유지함
    public void AddScene(string sceneName)
    {
        SceneManager.LoadScene(sceneName, LoadSceneMode.Additive);
    }


    // <비동기 씬 로드>
    // 씬 로딩을 백그라운드로 진행하여 게임 중 멈춤이 없도록하는 비동기 방법
    public void ChangeSceneASync()
    {
        AsyncOperation operation = SceneManager.LoadSceneAsync("StageScene2", LoadSceneMode.Additive);

        operation.allowSceneActivation = true;      // 씬 로딩 완료시 바로 씬 전환을 진행하는지 여부
        bool isLoaded = operation.isDone;           // 씬 로딩의 완료여부 확인
        float progress = operation.progress;        // 씬 로딩의 진행률 확인
        operation.completed += (oper) => { };       // 씬 로딩의 완료시 진행할 이벤트 추가
    }


    // <씬 언로드>
    // 로딩되어 있는 씬을 언로드 시키는 방법
    public void UnloadScene()
    {
        Scene scene = SceneManager.GetSceneByName("StageScene2");
        if (scene.isLoaded == true)
        {
            SceneManager.UnloadSceneAsync(scene);
        }
    }


    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.tag != "Player")
            return;

        SceneManager.LoadSceneAsync("StageScene2", LoadSceneMode.Additive);
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.tag != "Player")
            return;

        SceneManager.UnloadSceneAsync("StageScene2");
    }
}

<싱글톤 패턴>

• 오직 한 개의 클래스 인스턴스만을 갖도록 보장
• 이에 대한 전역적인 접근점을 제공

<구현>

1. 단일 인스턴스를 유지하기 위해 생성자의 접근권한을 외부에서 생성할 수 없도록 제한
2. 단일 인스턴스를 보관할 정적 변수를 구성
3. 외부에서 접근이 가능한 GetInstance 함수를 구성
4. GetInstance 함수에서 단일 인스턴스가 없을 경우 인스턴스를 생성하여 정적 변수에 참조
5. GetInstance 함수에서 단일 인스턴스가 있을 경우 정적 변수에 참조된 인스턴스를 반환

<장점>

1. 하나뿐인 존재로 주요 클래스 & 관리자 역할에 적합함
2. 전역적 접근으로 참조에 필요한 작업이 없이 빠른 접근이 가능함
3. 인스턴스들이 싱글톤을 통하여 데이터를 공유하기 쉬워짐

<주의점>

1. 싱글톤은 너무 많은 책임을 짊어지는 경우가 많으며 단일책임원칙을 위반
2. 싱글톤은 전역접근으로 코드의 결합도를 높이므로 남발하지 않아야함
3. 싱글톤은 단위 테스트를 하기 어렵게 함

public class Singleton : MonoBehaviour
{
    private static Singleton instance; 

    public static Singleton GetInstance()   // 반드시 하나만 있음.
    {
        if (instance == null)
        {
            instance = new Singleton(); // 처음만 만들어 주고 
        }
        return instance;    // 다음부턴 만들어 진 것을 가져다 씀.
    }

    private Singleton() { }
}

디자인 패턴 Adapter Pattern

public class DamageAdapter : MonoBehaviour, IDamagable
{
    public UnityEvent<GameObject, int> OnDamaged;

    // Switch 가 직접 데미지를 받지 않고 현제 어뎁터를 통해서 Switch를 이벤트를 통해 SwitchAction 을 연결시켜서 스위치 기능 활성화
    public void TakeDamage(GameObject dealer, int damage)
    {
        OnDamaged?.Invoke(dealer, damage);
    }
}

 public interface IDamagable
{
    public GameObject gameObject {  get; }
    public void TakeDamage(GameObject dealer, int damage);
} 

public class Monster : MonoBehaviour, IDamagable
{
    [Header("Component")]
    [SerializeField] Transform eyeTransform;

    [Header("Property")]
    [SerializeField] float sightRange;
    [SerializeField] float moveSpeed;
    [SerializeField] int hp;
    public int HP {  get { return hp; } private set { hp = value; } }

    [SerializeField] GameObject target;

    private void Update()
    {
        DetectTarget(); // Physics로 타겟확인

        if (target != null) // target 이 있으면
        {
            Trace();    // 쫒아가라
        }
    }

    private void DetectTarget() // Player를 찾아라
    {
        if (Physics.Raycast(eyeTransform.position, eyeTransform.forward, out RaycastHit hitInfo, sightRange))
        {
            Debug.DrawLine(eyeTransform.position, hitInfo.point, Color.green);
            if (hitInfo.collider.gameObject.tag == "Player")    //DrawLine으로 player접촉시 타겟 확인
            {
                target = hitInfo.collider.gameObject;
            }
            else
            {
                target = null;
            }
            //TankController tank = hitInfo.collider.gameObject.GetComponent<TankController>();
            //if (tank != null)
            //{
            //    // 부딪쳤을때 탱크야? 그럼 데미지줘.
            //}
        }
        else
        {
            Debug.DrawLine(eyeTransform.position, eyeTransform.position + eyeTransform.forward * sightRange, Color.red);
            target = null;
        }

    }

    private void Trace()    // 쫒아가는 함수
    {
        transform.position = Vector3.MoveTowards(transform.position, target.transform.position, moveSpeed * Time.deltaTime);
        transform.LookAt(target.transform.position);
    }

    public void TakeDamage(GameObject dealer, int damage)
    {
        // TODO : 
        Debug.Log($"{gameObject.name} 이/가 {dealer.name}에게 피해를 {damage} 받았습니다.");
        HP -= damage;
        if (HP <= 0)    // 몬스터 hp가 0이 되면
        {
            Die();  // 몬스터 오브젝트 삭제
        }
    }

    private void Die()
    {
        GameManager.Instance.score += 10;   // 몬스터 제거시 10점
        Destroy(gameObject);    // 몬스터 제거
    }


}  

* 코루틴 (Coroutine)   -> 시간 절약 X! , 작업을 분산

* 작업을 다수의 프레임에 분산하여 처리하는 비동기식 작업
* 실행을 일시정지하고 중단한 부분부터 재개하여 처리하는 것으로 작업을 분산처리함
* 코루틴은 스레드가 아니며 코루틴의 작업은 메인 스레드에서 실행

IEnumerator Routine()   // 코루틴은 IEnumerator 을 사용
{
    yield return null;                      // Update 끝날 때
    yield return new WaitForSeconds(1f);    // n초간 기다리고, Update 끝날 때
    yield return new WaitForSecondsRealtime(1f);    // 현실시간 n 초간 기다리고, Update 끝날 떄
    yield return new WaitForFixedUpdate();          // FixedUpdate 끝날 때
    yield return new WaitForEndOfFrame();           // 프레임이 끝날 때 (LateUpdate 다음)

    yield return new WaitUntil(() => Input.GetKeyDown(KeyCode.Space));  // 조건이 맞을때까지 대기
}

[SerializeField] Rigidbody rigid;
[SerializeField] float junpPower;

private Coroutine countDownCoroutine;

private void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        if (countDownCoroutine == null) // 코루틴이 없을때 1번사용 - 중복해서 여러번 작업하는것을 방지
        {
            countDownCoroutine = StartCoroutine(Routine());
        }
    }
    if (Input.GetKeyDown(KeyCode.Escape))
    {
        //StopCoroutine(Routine());   // 루틴을 멈추는 것이 아닌 코루틴 담당자를 멈춰야 함

        if (countDownCoroutine != null) // 코루틴이 있어야 멈출 수 있다.
        {
            StopCoroutine(countDownCoroutine);
            countDownCoroutine = null;   // 다시 초기화 해줘야 재사용 가능.
        }
    }

}


 <코루틴 반복 작업>
//IEnumerator를 반환형으로 함수를 구성

IEnumerator Routine()   // 코루틴은 IEnumerator 을 사용
{
    WaitForSeconds delay = new WaitForSeconds(1f);  // 아래 방법보다 이방법을 권장. 계속 new 하면 메모리 누수
    Debug.Log(5);
    yield return delay;     // yield 일서정지, 양보
    Debug.Log(4);
    yield return delay;
    Debug.Log(3);
    yield return delay;
    Debug.Log(2);
    yield return delay;
    Debug.Log(1);
    yield return delay;


    Debug.Log(5);
    yield return new WaitForSeconds(1f);    // 아래 방법
    Debug.Log(4);
    yield return new WaitForSeconds(1f);
    Debug.Log(3);
    yield return new WaitForSeconds(1f);
    Debug.Log(2);
    yield return new WaitForSeconds(1f);
    Debug.Log(1);
    yield return new WaitForSeconds(1f);

    Debug.Log("점프 대기 시작");
    yield return new WaitForSeconds(5f);    // yield는 뒤에 조건만큼 기다리다가 -> 5초 뒤에
    Debug.Log("점프!!");
    rigid.AddForce(Vector3.up * junpPower, ForceMode.Impulse);  // 점프 시작

    countDownCoroutine = null;  // 다시 초기화 해줘야 재사용 가능.

    //yield return WaitUntil -> 사용으로 중간에 멈췄다 다시 사용 가능
}

유니티이벤트

public class UnityEventTester : MonoBehaviour
{
    public UnityEvent myEvent;  // 유니티 이벤트 사용 -> 클래스
    //public UnityEvent<int> myEvent;   //매개변수 있는 이벤트

    //public event Action<int> OnHpChanged;

    public event UnityAction OnDied;    // UnityAction -> 델리게이트
    public event Action myDelegate;     // UnityAction 과 같은 거임. 차이 없음.

    private void Awake()
    {
        //myEvent.AddListener(Test); // AddListener 로 함수를 추가 해서 사용 가능
        //myEvent.RemoveListener(Test);

        //OnHpChanged += Test;
        //OnHpChanged += Func;
    }

    public void Test(){}

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            myEvent.Invoke(); // Invoke 로 발생시키다.
            //myEvent.Invoke(10); // 매개변수 있는 경우
        }
    }
}

public class RaycastTester : MonoBehaviour
{
    private void Update()
    {
        // 레이캐스트 : 시작 위치에서 방향으로 레이저를 발사하여 부딪히는 충돌체를 감지
        if(Physics.Raycast(transform.position, transform.forward, out RaycastHit hitInfo, 10f ))
        {
            // 레이저에 닿은 충돌체가 있다.
            Debug.Log(hitInfo.collider.gameObject.name);
            Debug.DrawLine(transform.position, hitInfo.point, Color.green);
        }
        else
        {
            // 레이저에 닿은 출돌체가 없다.
            Debug.Log("None");
            Debug.DrawLine(transform.position, transform.position + transform.forward * 10f, Color.red);
        }


    }

    private void OnDrawGizmos()   // 그냥 계속 충돌체를 그려줌
    {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, 3f);    // 감지범위?
    }

    private void OnDrawGizmosSelected()   // 오브젝트를 선택하면 충돌체를 그려줌
    {
        Gizmos.color = Color.green;
        Gizmos.DrawLine(transform.position, transform.forward * 10);
    }
}

Rigidbody

public class RigidbodyTest : MonoBehaviour
{
    [SerializeField] Rigidbody rigid; // new를 붙이거나 rigidbody가 아닌 다른 이름을 쓰자.
    [SerializeField] float power; // 힘의 세기

    private float xInput;

    private void Update()
    {
        xInput = Input.GetAxis("Horizontal"); // A, D키 입력 - 좌 우

        if (Input.GetButtonDown("Jump"))
        {
            rigid.AddForce(Vector3.up * power, ForceMode.Impulse);  // Impulse 점프는 예외로 Update() 에 사용
        }

    }

    private void FixedUpdate()  // addForce 는 FixedUpdate()에서 써야함. 컴퓨터 성능에 따라 달라질 수 있기 때문.
    {
        // 1. 힘 가해주기 : 가속시키기
        rigid.AddForce(Vector3.right * xInput * power, ForceMode.Force); // Force는 지속적으로 힘을 가하는 메서드. 무게에 따라 힘이 달라짐
        // Acceleration 무게에 상관없이 속도가 빨라짐
        // Impulse 는 한방에 힘을 펑! 하고 줌

        // 2. 속도를 설정하기 : 속도를 원하는 대로 설정
        rigid.velocity = Vector3.right * power * xInput;

        // 3. 회전력 가해주기
        rigid.AddTorque(Vector3.up * xInput * power);

        // 4. 회전속도 설정하기
        rigid.angularVelocity = Vector3.up * power * xInput;
    }
}

Prefab

public class Monster : MonoBehaviour
{
     * 프리팹 (Prefab)

     * 미리 만들어 놓은 게임오브젝트, 템플릿, 설계도
     * 프리팹 시스템을 이용하여 게임오브젝트를 생성, 설정 및 저장할 수 있음
     * 자주 사용하는 게임오브젝트 구성을 복사하여 런타임 시점에 생성하려는 경우 사용


     <프리팹 생성>
     유니티 하이어라키 창의 게임오브젝트를 프로젝트 창을 드래그 & 드롭하여 프리팹에셋 생성


     <프리팹 특징>
    *게임오브젝트를 프리팹화 시킨 프리팹에셋은 게임오브젝트의 모든 컴포넌트, 속성값, 자식 게임오브젝트를 가지고 있음
    * 프리팹에셋을 게임씬에 추가할 경우 프리팹인스턴스로 생성
    * 프리팹에셋의 변경사항은 프리팹인스턴스에게 자동으로 반영
    * 프리팹인스턴스에 변경사항이 있을 경우 해당 변경사항은 프리팹인스턴스에 영향을 받지 않음
    * 프리팹에셋을 클래스, 프리팹인스턴스를 클래스의 인스턴스로 볼 수 있음


    [SerializeField] Transform eyeTransform;
    [SerializeField] float sightRange;
    [SerializeField] float moveSpeed;

    [SerializeField] GameObject target;

    private void Update()
    {
        DetectTarget();    // Physics로 타겟확인

        if (target != null)    // target 이 있으면
        {
            Trace();    // 쫒아가라
        }
    }

    private void DetectTarget()
    {
        if (Physics.Raycast(eyeTransform.position, eyeTransform.forward, out RaycastHit hitInfo, sightRange))
        {
            Debug.DrawLine(eyeTransform.position, hitInfo.point, Color.green);
            if (hitInfo.collider.gameObject.tag == "Player")    //DrawLine으로 player접촉시 타겟 확인
            {
                target = hitInfo.collider.gameObject;
            }
            else
            {
                target = null;
            }
            //TankController tank = hitInfo.collider.gameObject.GetComponent<TankController>();
            //if (tank != null)
            //{
            //    // 부딪쳤을때 탱크야? 그럼 데미지줘.
            //}
        }
        else
        {
            Debug.DrawLine(eyeTransform.position, eyeTransform.position + eyeTransform.forward * sightRange, Color.red);
            target = null;
        }

    }

    private void Trace()    // 쫒아가는 함수
    {
        transform.position = Vector3.MoveTowards(transform.position, target.transform.position, moveSpeed * Time.deltaTime);
        transform.LookAt(target.transform.position);
    }
}

• 충돌체 : 게임오브젝트의 물리적 충돌을 목적으로 모양을 정의
• 게임오브젝트 간의 충돌체로 부딪힘과 반발력을 처리
• 충돌체는 충돌상황에 있을 경우 유니티 충동 메시지를 받아 상황을 확인

 < 유니티 충돌 메시지>
private void OnCollisionEnter(Collision collision)  // 3D 물리 충돌
{
    // 충돌 진입시 호출
    Debug.Log($"{collision.gameObject.name} 랑 충돌을 시작함");       // 총을 맞았을때 대미지 입을때
}

private void OnCollisionStay(Collision collision)
{
    // 충돌중 호출
    Debug.Log($"{collision.gameObject.name} 랑 충돌중");        // 범위공격 지속 대미지
}

private void OnCollisionExit(Collision collision)
{
    // 충돌 해제시 호출
    Debug.Log($"{collision.gameObject.name} 랑 충돌 끝남");
}

트리거 ( Trigger )

• 하나의 충돌체가 충돌을 일으키지 않고 다른 충돌체의 공간에 들어가는 것을 감지
• 트리거는 겹침상황에 있을 꼉우 유니티 트리거 메시지를 받아 상황을 확인

// Box Collider 안에 Is Trigger 박스를 체크시 가능 -> 트리거로 사용하겠다

private void OnTriggerEnter(Collider other)
{
    Debug.Log("트리거 Enter");
}

private void OnTriggerStay(Collider other)
{
    Debug.Log("트리거 stay");
}

private void OnTriggerExit(Collider other)
{
    Debug.Log("트리거 Exit");
}

레이어기반 충돌 & 트리거 감지

• 게임오브젝트의 레이어를 활용하여 충돌체간의 충돌가능 여부를 설정 가능
• 충돌 여부를 제외한 레이어간의 충돌은 무시됨
• edit -> ProjectSettings -> Physics -> Layer Collision Matrix

충돌체 & 트리거 종류

• 두 게임오브젝트가 충돌하면 리지드바디의 환경설정에 따라 다른 반응을 할 수 있음
• 일부 조합의 경우 두 게임오브젝트 중에서 하나만 충돌의 영향을 받음
• 일반적으로 Rigidbody 컴포넌트가 있는 게임오브젝트가 물리가 적용되는 것이 원칙

<충돌체 종류> (1) 정적 충돌체 (Static Collider) Rigidbody가 없는 충돌체, 외부에 힘에 움직이지 않음 절대로 움직이지 않는 지형, 구성요소에 주로 사용

(2) 리지드바디 충돌체 (Rigidbody Collider) Rigidbody가 있는 충돌체, 외부에 힘을 받아 움직임 충돌하여 힘을 받아 움직이는 물체에 사용

(3) 키네마틱 충돌체 (Kinematic Collider) Kinematic Rigidbody가 있는 충돌체, 외부의 힘에 반응하지 않음 움직이지만 외부 충격에는 밀리지 않는 물체에 사용 Kinematic 상태를 활성화/비활성화 하여 움직임 여부를 설정하는 경우에도 사용

<충돌체 & 트리거 상호작용 매트릭스>

• 충돌체와 트리거의 종류에 따라 메시지가 전송되는 경우가 다름
• 편의상 정적충돌체(SC), 리지드바디충돌체(RC), 키네마틱충돌체(KC)로 표현
• 편의상 정적트리거(ST), 리지드바디트리거(RT), 키네마틱트리거(KT)로 표현

 충돌시 충돌 메시지가 전송
      SC  RC  KC  ST  RT  KT
 SC        O
 RC    O   O   O
 KC        O
 ST
 RT
 KT

 트리거시 트리거 메시지가 전송
      SC  RC  KC  ST  RT  KT
 SC                    O   O
 RC                O   O   O
 KC                O   O   O
 ST        O   O       O   O
 RT    O   O   O   O   O   O
 KT    O   O   O   O   O   O

Transform

• Transform 컴포넌트는 오브젝트의 위치, 회전각, 크기(배율)에 대한 데이터를 가지고 있습니다.

• 유니티에서는 더 빠른 연산을 위해 오브젝트의 위치, 회전, 크기에 대한 연산을 4x4 행렬로 구현합니다.
• 추가로 자신이 가진 데이터를 쉽게 컨트롤 할 수 있는 지원 함수들이 내장되어 있습니다.

Position
유니티에서 오브젝트의 위치 정보는 x, y, z 3축으로 구성됩니다. 이는 유니티에서 Vector3 클래스를 통해 간편하게 다룰 수 있으며, 이를 사용해 게임 오브젝트의 위치 이동을 구현할 수 있습니다.
// Position을 직접적으로 변경하는 방법
Transform.position = new Vector3(x, y, z);

// Translate 함수를 이용한 축(x, y, z) 기준의 위치이동 방법
Transform.Translate(Direction * Speed);

// 선형 보간을 이용해 거리에 따라 빠르게 이동하며 천천히 감속하는 방법
Transform.position = Vector3.Lerp(StartPosition, EndPosition, Interpolation)

// 목표지점을 향해 일정한 속도로 이동하는 방법
Transform.position = Vector3.MoveTowards(transform.position, Target.Position, Speed);

Rotation
인스펙터의 Transform 컴포넌트에서는 회전값이 포지션과 동일하게 x, y, z축으로 보여지지만 내부 동작은 4원소를 사용하는 쿼터니언을 통해 이뤄집니다. 이는 연산속도가 빠르고 3축을 사용했을 때의 짐벌락 현상을 방지하는 데 효과적입니다.
쿼터니언은 연산적으로 효과적이지만, 유니티 입문 시점에서는 이해하기 복잡한 개념입니다. 이 때문에 보다 직관적인 3축으로 컨트롤 할 수 있도록 Quaternion클래스의 Euler를 사용합니다.
// rotation에 값을 직접 지정해 회전하는 방법
Transform.rotation = Quaternion.Euler(x, y, z);

// Rotate 함수를 이용한 회전
Transform.Rotate(Vector3.up, Speed);

// RotateAround를 이용한 중심축 기준으로 회전
Transform.RotateAround(Target.position, Vector3.up, Speed);

// LookAt을 이용한 대상을 향해 회전시키기
Transform.LookAt(Target.position);

Tip : Quaternion (펼치기/접기)

Scale
직관적인 이름 그대로 게임 오브젝트의 크기를 비율로 지정할 수 있는 요소입니다
// Scale 조절
Transform.localScale = new Vector3(x, y, z);

// lossyScale은 부모 오브젝트의 스케일에 상관 없이 자신 고유의 Scale 수치를 반환
Transform.lossyScale

World Space VS Local Space

• 게임 내에서 모든 오브젝트는 Transform 컴포넌트를 가집니다.

• 형체가 없는 오브젝트라 할 지라도, 위치를 지니고 있다는 뜻이죠 이때, 게임 환경 내의 절대 좌표와 상속 관계에서의 상대 좌표를 사용할 수 있습니다.
• 우리는 이를 월드 스페이스(World Space)와 로컬 스페이스(Local Space)라고 부릅니다.

월드 스페이스 (World Space)

• 월드 스페이스는 게임 환경 내의 고정된 글로벌 좌표계를 의미하며, 절대 좌표라고도 표현할 수 있습니다.
• 이 좌표계는 게임의 시작부터 끝까지 변하지 않으며, 모든 오브젝트들이 이 월드 스페이스 내에서 위치를 가지게 됩니다.
• 월드 스페이스에서의 오브젝트의 위치, 회전, 크기는 월드 포지션(World Position), 월드 회전(World Rotation), 월드 스케일(World Scale)로 표현됩니다.

로컬 스페이스 (Local Space)

• 로컬 스페이스는 오브젝트나 컴포넌트의 개별적인 좌표계를 의미하며, 상대 좌표라고도 표현할 수 있습니다.
• 특히 부모-자식 관계에서 중요하며, 자식 오브젝트의 로컬 스페이스는 부모 오브젝트에 대해 상대적입니다.

1. Ex> 자식 오브젝트의 로컬 포지션이 (0, 0, 0)이라면, 이는 부모 오브젝트의 위치와 동일하다는 것을 의미합니다.
2. 로컬 스페이스에서의 오브젝트의 위치, 회전, 크기는 로컬 포지션(Local Position), 로컬 회전(Local Rotation), 로컬 스케일(Local Scale)로 표현됩니다.

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

public class TransformTester : MonoBehaviour
{

        트랜스폼 (Transform)
        게임  오브젝트의 위치, 회전, 크기를 정의하는 컴포넌트
        게임오브젝트의 부모-자식 상태를 자장하는 컴포넌트
        게임오브젝트는 반드시 하나의 트랜스폼 컨포넌트를 가지고 있으며, 추가 & 삭제할 수 없다.


    public Vector3 targetPos;
    [SerializeField] float moveSpeed; // 이동 속도
    [SerializeField] float rotateSpeed; // 회전 속도
    [SerializeField] Transform turret;


    [SerializeField] Transform source;
    [SerializeField] Transform target;
    [Range(0f, 1f)]
    [SerializeField] float rate; // 보간 비율



    private void Update()
    {
        #region Position
        // 1. 벡터를 이용한 위치 설정
         transform.position = new Vector3(1, 2, 3); // 트랜스폼의 위치를 (1, 2, 3)으로 설정

        if (Input.GetKeyDown(KeyCode.Space))
        {
            transform.position = targetPos; // 트랜스폼의 위치를 targetPos로 설정
        }

         2. 트랜스레이트를 이용한 위치 설정 -> 원하는 방향으로 이동시키기
        if (Input.GetKeyDown(KeyCode.Space))
        {
            transform.Translate(Vector3.forward); // 트랜스폼을 forward-> 앞으로 이동
        }

        transform.Translate(Vector3.forward * moveSpeed * Time.deltaTime);
        // 1프레임당 걸린시간 -> 단위시간 : 델타타임
        // 1프레임당 걸린시간 = Time.deltaTime

        // 3. 목적지로 이동시키기
        transform.position =  Vector3.MoveTowards(transform.position, target.position, moveSpeed * Time.deltaTime);
        //Towards : 방향을 설정하는 메서드 -> ~을 향해서

        // 4. 보간해서 이동시키기
        transform.position = Vector3.Lerp(transform.position, target.position, rate);
        // linearly interpolate 선형보간
        #endregion


        #region Rotation
        // 3축을 사용했을 때, 짐벌락 현상이 발생할 수 있다. Quaternion을 사용하자
        // 1. 회전 직접 지정 : Euler를 이용하여 Quaternion으로 변환하여 사용 권장
        transform.rotation = Quaternion.Euler(0, 60, 0);

        // 1-1 오일러를 쿼터니언으로 변환 -> Quaternion.Euler
        Quaternion a = Quaternion.Euler(0, 60, 0);
        // 1-2. 쿼터니언을 오일러로 변환   -> .eulerAngles
        Vector3 b = transform.rotation.eulerAngles;
        // 1-3. 방향벡터를 쿼터니언으로 변환
        Quaternion c = Quaternion.LookRotation(Vector3.right);
        // 1-4. 현재 회전을 방향백터로 변환
        Vector3 d = transform.right; // 오른쪽 방향벡터

        // 2. 축을 기준으로 회전
        transform.Rotate(Vector3.up, rotateSpeed * Time.deltaTime); // y축을 기준으로 회전
        transform.Rotate(Vector3.forward, rotateSpeed * Time.deltaTime); // z축을 기준으로 회전

        // 3. 지점을 기준으로 회전
        transform.RotateAround(target.position, Vector3.up, rotateSpeed * Time.deltaTime); // y축을 기준으로 회전

        // 4. 지점을 바라보도록 회전
        transform.LookAt(target.position); // target을 바라보도록 회전

        // <target 방향만 바라 봄. 위아래는 무시함>
        Vector3 t = target.position;
        t.y = 0f;
        transform.LookAt(t); 

        //<target 방향을 바라보는 속도 조절>
        Vector3 targetDir = (target.position - transform.position).normalized; // target 방향벡터
        Quaternion targetRot = Quaternion.LookRotation(targetDir); // target 방향벡터를 쿼터니언으로 변환
        transform.rotation = Quaternion.Lerp(transform.rotation, targetRot, rotateSpeed * Time.deltaTime); // 현재 회전과 목표 회전을 보간하여 회전
        #endregion


        // 월드기준
        Vector3 worldPostion = transform.position; // 월드좌표계에서의 위치
        Quaternion worldRotation = transform.rotation; // 월드좌표계에서의 회전

        // 로컬기준
        Vector3 localPosition = transform.localPosition; // 로컬좌표계에서의 위치
        Quaternion localRotation = transform.localRotation; // 로컬좌표계에서의 회전

        turret.rotation = Quaternion.identity;  

        transform.Translate(Vector3.forward * moveSpeed * Time.deltaTime, Space.World); // Space.World -> 월드좌표계에서 앞으로 이동

        transform.Rotate(Vector3.up, rotateSpeed * Time.deltaTime, Space.World); // Space.World -> 월드좌표계에서 y축을 기준으로 회전

    }
}

<위치 이동 구현>

• 유니티는 게임엔진이라는 타이틀에 걸맞게 여러 기본 지원기능을 내장하고 있습니다.

• Input Class를 통해 여러 키 여부를 알수 있고, 이를 통해 오브젝트의 포지션을 변경해 주는 것이 우리의 목표입니다.

GetKey

• 단일 키 입력에 대한 여부를 반환받기 위한 함수입니다.
• 키가 눌리는 판정에 따라 세 가지 bool 타입 반환 함수를 적절하게 사용합니다.

  Input.GetKey()      // 키 입력이 진행되는 동안 true를 반환합니다. 
  Input.GetKeyDown()  // 키 입력이 시작되는 순간 1회만 true를 반환합니다.
  Input.GetKeyUp()    // 키 입력이 종료되는 순간 1회만 true를 반환합니다.

GetAxis

• 유니티에서 제공하는 Input Manager에 대응하는 코드입니다.
• 유니티 좌표상의 X(Horizontal), Z(Vertical)축에 해당하는 입력 데이터이며, 미 입력시 0, 방향과 입력에 따라 -1.0 ~ 1.0 사이의 float 타입을 반환합니다.
• 이 함수는 게임패드(조이스틱)와도 연동되는 코드이며, 숙련된다면 유용하게 사용할 수 있습니다.

GetAxisRaw

• GetAxis와 마찬가지로 Input Manager에 대응하고 유니티 좌표상의 X, Z축에 해당하는 입력 데이터를 -1, 0, 1로 반환합니다.
• 이는 키보드 입력에 대한 이동 구현에 적합한 함수입니다.

public class InputTester : MonoBehaviour
{
    public float result; // 결과값을 저장할 변수

    private void Update()
    {
        #region Device
        // <Device>
         특정한 장치를 기준으로 입력 감지.
         특정한 장치의  입력을 감지하기 위해서는 Input.GetKey()를 사용한다.

         1. 키보드 입력 && 게임패드 입력
        if (Input.GetKey(KeyCode.Space))     // 키 입력이 진행되는 동안 true
        {
            Debug.Log("Get Key!");
        }
        if (Input.GetKeyDown(KeyCode.Space))    // 눌렀을 때 한번만 true
        {
            Debug.Log("Get Key Down!");
        }
        if (Input.GetKeyUp(KeyCode.Space))      // 눌렀다 떼었을 때 한번만 true
        {
            Debug.Log("Get Key Up!");
        }

        // 2. 마우스 입력
        if (Input.GetMouseButton(0)) // 0 왼쪽 버튼 클릭
        {
            Debug.Log("Left Mouse Button Clicked");
        }
        if (Input.GetMouseButtonDown(1)) // 1 오른쪽 버튼 클릭
        {
            Debug.Log("Right Mouse Button Clicked");
        }
        if (Input.GetMouseButtonUp(2)) // 2 가운데 버튼 클릭
        {
            Debug.Log("Middle Mouse Button Released");
        }
        #endregion       


         <InputManager> -> Edit > Project Settings > Input Manager
         여러 장치의 입력을 입력매니저에 이름과 입력을 정의
         입력매니저의 이름으로 정의한 입력의 변경사항을 확인
         유니티 에디터의 Edit > Project Settings > Input Manager에서 관리
         단, 유니티 초창기의 방식이기 때문에 키도드, 마우스, 조이스틱에 대한 장치만을 고려함

        <InputManager>방식으로 입력을 감지
        if (Input.GetButton("Fire1")) // 입력매니저에 정의된 이름으로 입력을 감지
        {
            Debug.Log("Fire1 버튼 눌림");
        }

        result = Input.GetAxis("Horizontal"); 
        result = Input.GetAxisRaw("Horizontal");

        float axis = 0;
        if(Input.GetKey(KeyCode.LeftArrow))
        {
            axis = -1;
        }
        if (Input.GetKey(KeyCode.RightArrow))
        {
            axis = +1;
        }
    }
}

public class TankMover : MonoBehaviour
{
    [SerializeField] float moveSpeed;// 이동 속도
    [SerializeField] float rotateSpeed; // 회전 속도

    private void Update()
    {
        Move(); // 이동
        Rotate(); // 회전
    }

    private void Move()
    {
        float input = Input.GetAxis("Vertical"); // W, S키 입력
        transform.Translate(Vector3.forward * moveSpeed * input * Time.deltaTime); // 전진 후진
        //transform.Translate(Vector3.forward * moveSpeed * input * Time.deltaTime, Space.World); // Space.World -> 월드를 기준으로 전진 후진
    }

    private void Rotate()
    {
        float input = Input.GetAxis("Horizontal"); // A, D키 입력
        transform.Rotate(Vector3.up * rotateSpeed * input * Time.deltaTime); // 좌우 회전
    }
}

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

public class Spawner : MonoBehaviour
{
    public GameObject prefab;
    public GameObject target;
    //public GameObject makeOne;


    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            Spawn();
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            DeSpawn();
        }
    }

    public void Spawn()
    {
        //makeOne = new GameObject("Spawned GameObject"); // 새로운 게임 오브젝트 생성
        Instantiate(prefab, new Vector3(1, 1, 1), Quaternion.identity);    // Quaternion -> 회전값 / identity 회전없이
        // Instantiate 로 프리팹을 생성
    }

    public void DeSpawn()
    {
        Destroy(target, 3); // 3초 뒤에 target을 파괴
    }
}

<디자인 패턴 ObjectPool>

포탄을 미리 일정 수 풀에 생성해서 보관 및 사용

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

/*      디자인 패턴 ObjectPool       */

/*
<오브젝트 풀 패턴>
프로그램 내에서 빈번하게 재활용하는 인스턴스들을 풀에 보관한 뒤
인스턴스의 생성&삭제 대신 대여&반납을 사용하는 기법

<구현>
1. 인스턴스들을 보관할 풀을 생성
2. 프로그램의 시작시 풀에 인스턴스들을 생성하여 보관
3. 인스턴스 생성이 필요할 때 풀에서 대여하여 사용
4. 인스턴스 삭제가 필요할 때 풀에 반납하여 보관

<장점>
1. 빈번하게 사용하는 인스턴스 생성에 소요되는 오버헤드를 줄임
2. 빈번하게 사용하는 인스턴스 삭제에 부담되는 가비지 콜렉터의 동작을 줄임

<주의점>
1. 미리 생성해놓은 인스턴스들이 사용하지 않는 경우에도 메모리를 차지하고 있음
2. 오브젝트 풀을 힙영역의 여유공간이 줄어들어 오히려 프로그램에 부담이 되는 경우가 있음.
 */


public class ObjectPool : MonoBehaviour
{
    [SerializeField] List<PooledObject> pool = new List<PooledObject>();    // 미리 보관할 풀을 리스트로 생성
    [SerializeField] PooledObject prefab;
    [SerializeField] int size;  // 처음에 춘비해놓을 인스턴스 개수
    [SerializeField] int capacity; // 풀의 최대 개수

    private void Awake()
    {
        for (int i = 0; i < size; i++)
        {
            PooledObject instance = Instantiate(prefab);    // prefab을 복제하여 인스턴스 생성
            instance.gameObject.SetActive(false);   // 비활성화 해서 
            pool.Add(instance); // 인스턴스를 풀에 보관
        }
    }

    public PooledObject GetPool(Vector3 position, Quaternion rotation)  // 대여
    {                           //      어느위치에서 어느각도로 생성할건지
        if (pool.Count == 0) // 풀에 인스턴스가 없으면
        {
            return Instantiate(prefab, position, rotation); // 새로 생성
        }

        PooledObject instance = pool[pool.Count - 1];   // 풀에서 인스턴스 맨 마지막거 가져오기
        pool.RemoveAt(pool.Count - 1); // 풀에서 인스턴스 제거

        instance.returnPool = this; // 인스턴스의 returnPool 변수에 현재 풀을 설정
        instance.transform.position = position; // 위치 설정
        instance.transform.rotation = rotation; // 회전 설정
        instance.gameObject.SetActive(true); // 활성화

        return instance; // 인스턴스 반환
    }

    public void ReturnPool(PooledObject instance)   // 반납
    {
        if (pool.Count >= capacity)
        {
            Destroy(instance.gameObject); // 풀의 개수가 최대치면 인스턴스 삭제
        }
        instance.gameObject.SetActive(false); // 인스턴스 비활성화
        pool.Add(instance); // 풀에 추가
    }

}

사용한 오브젝트 풀에 반납

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

public class PooledObject : MonoBehaviour
{
    public ObjectPool returnPool; // 오브젝트 풀을 참조하기 위한 변수
    [SerializeField] float returnTime; // 오브젝트 풀에 반납될 시간
    private float timer; // 현재 시각

    private void OnEnable()
    {
        timer = returnTime; // 오브젝트가 활성화될 때 타이머 초기화
    }
    private void Update()
    {
        timer -= Time.deltaTime; // 타이머 감소 - 프레임 마다 진행된 시간
        if (timer <= 0) // 타이머가 0 이하가 되면
        {
            RetuenPool(); // 오브젝트 풀에 반납
        }
    }

    public void RetuenPool()
    {
        if (returnPool == null)
        {
            Destroy(gameObject); // returnPool이 null이면 오브젝트 풀에 반납하지 않고 삭제
        }
        else
        {
            returnPool.ReturnPool(this); // 오브젝트 풀에 반납
        }

    }
}

포탄 발사 코드 - 발사 후 3초뒤 삭제

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

public class Shooter : MonoBehaviour
{
    [SerializeField] GameObject bulletPrefab; // 총알 프리팹
    [SerializeField] Transform muzzlePoint; // 총알 발사 위치
    [SerializeField] ObjectPool bulletPool; // 총알 오브젝트 풀

    [Range(10, 30)]
    [SerializeField] float bulletSpeed; // 발사 속도


    public void Fire()
    {
        // 총알을 발사하는 메서드
        GameObject instance = Instantiate(bulletPrefab, muzzlePoint.position, muzzlePoint.rotation); // 총알 인스턴스 생성
                                                                                                     // 머즐 포인트 위치와 회전으로 총알 생성
        //PooledObject instance = bulletPool.GetPool(muzzlePoint.position, muzzlePoint.rotation);   
        // 총알 풀에서 총알 인스턴스 가져오기
        Rigidbody bulletRigidbody = instance.GetComponent<Rigidbody>(); // 총알의 리지드바디 컴포넌트 가져오기
        bulletRigidbody.velocity = muzzlePoint.forward * bulletSpeed; // 총알의 속도 설정

        Destroy(instance, 3); // 3초 후 총알 삭제

    }


}                     

StringBuilder -> 매모리 효과적, 스트링을 만드는 과정을 가지고 있다가 마지막에 만듬

static void Main(string[] args)
{
    StringBuilder stringBuilder = new StringBuilder();  // 스트링 빌더를 사용하여 문자열을 조합함
    stringBuilder.AppendLine("안녕하세요")   // AppendLine() 한줄 붙이기
        .AppendLine("반갑습니다.")   // AppendLine() 메소드를 사용하여 줄바꿈을 추가함
        .Append("저는 ")
        .Append("Name")             // Append() 메소드를 사용하여 줄바꿈 없이 붙이기
        .AppendLine("라고 합니다.")
        .Replace("Name", "김전사");   // Replace() 메소드를 사용하여 문자열을 바꿈

    Console.WriteLine(stringBuilder.ToString());   // ToString() 메소드를 사용하여 최종 문자열을 출력함
}

안녕하세요 반갑습니다. 저는 김전사라고 합니다.

internal class Program
{
    static void Main(string[] args)
    {
        GameObject gameObject = new GameObject();

        gameObject.SetX(10).SetY(5).SetZ(3);    // 아래의 return this; 를 사용하여 체인 메소드를 구현함
    }

}


public class GameObject
{
    public int x;
    public int y;
    public int z;

    public GameObject SetX(int x)
    {
        this.x = x;
        return this;    // this 는 gameObject.SexX(10) 의 gameObject 를 의미함
    }

    public GameObject SetY(int y)
    {
        this.y = y;
        return this;    // this 는 gameObject.SetX(10).SetY(5) 의 gameObject 를 의미함
    }

    public GameObject SetZ(int z)
    {
        this.z = z;
        return this;    // this 는 gameObject.SetX(10).SetY(5).SetZ(3) 의 gameObject 를 의미함
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        MonsterBuilder orcArcherBuilder = new MonsterBuilder();
        orcArcherBuilder.SetName("오크 궁수")   // 체인 메소드를 사용하여 MonsterBuilder 를 설정함
            .SetWeapon("나무 활")
            .SetArmor("가죽갑옷");

        MonsterBuilder orcWarriorBuilder = new MonsterBuilder();
        orcWarriorBuilder.SetName("오크 전사")   // 체인 메소드를 사용하여 MonsterBuilder 를 설정함
            .SetWeapon("철 검")
            .SetArmor("철 갑옷");

        Monster orcArcher = orcArcherBuilder.Build();
        Console.WriteLine("이름 : {0}, 무기 : {1}, 갑옷 : {2}", orcArcher.name, orcArcher.weapon, orcArcher.armor);

        Monster orcWarrior = orcWarriorBuilder.Build();
        Console.WriteLine("이름 : {0}, 무기 : {1}, 갑옷 : {2}", orcWarrior.name, orcWarrior.weapon, orcWarrior.armor);

    }

}


public class MonsterBuilder
{
    public string name;
    public string weapon;
    public string armor;

    public MonsterBuilder()
    {
        name = "몬스터";
        weapon = "기본무기";
        armor = "기본갑옷";
    }
    public Monster Build()
    {
        Monster monster = new Monster();
        monster.name = this.name;
        monster.weapon = this.weapon;
        monster.armor = this.armor;
        return monster;
    }
    public MonsterBuilder SetName(string name)
    {
        this.name = name;
        return this;    
    }
    public MonsterBuilder SetWeapon(string weapon)
    {
        this.weapon = weapon;
        return this;    
    }
    public MonsterBuilder SetArmor(string armor)
    {
        this.armor = armor;
        return this;    
    }
}
public class Monster
{
    public string name;
    public string weapon;
    public string armor;
}

static void Main(string[] args)
{
    HambergerBuilder chickbergerBuilder = new HambergerBuilder();
    chickbergerBuilder           // 체인 메소드를 사용하여 HambergerBuilder 를 설정함
        .SetSource("매운양념")
        .SetPatty("치킨 패티");

    HambergerBuilder bigmacBuilder = new HambergerBuilder();
    bigmacBuilder.SetBread("참깨빵")   // 체인 메소드를 사용하여 HambergerBuilder 를 설정함
        .SetPatty("순쇠고기패티두장")
        .SetSource("특별한 소스")
        .SetVegetable("양상추");

    HambergerBuilder shirimpbergerBuilder = new HambergerBuilder();
    shirimpbergerBuilder.SetBread("호밀빵")   // 체인 메소드를 사용하여 HambergerBuilder 를 설정함
        .SetPatty("새우 패티")
        .SetSource("마요네즈");

    Hamberger chickberger = chickbergerBuilder.Build();
    Console.WriteLine("빵 : {0}, 소스 : {1}, 패티 : {2}, 야채 : {3}", chickberger.bread, chickberger.source, chickberger.patty, chickberger.vegetable);
}


public class HambergerBuilder
{
    public string bread;
    public string source;
    public string patty;
    public string vegetable;
    public HambergerBuilder()
    {
        bread = "기본빵";
        source = "캐찹";
        patty = "기본패티";
        vegetable = "양상추";
    }
    public Hamberger Build()
    {
        Hamberger hamberger = new Hamberger();
        hamberger.bread = this.bread;
        hamberger.source = this.source;
        hamberger.patty = this.patty;
        hamberger.vegetable = this.vegetable;
        return hamberger;
    }
    public HambergerBuilder SetBread(string bread)
    {
        this.bread = bread;
        return this;    
    }
    public HambergerBuilder SetSource(string source)
    {
        this.source = source;
        return this;
    }
    public HambergerBuilder SetPatty(string patty)
    {
        this.patty = patty;
        return this;
    }
    public HambergerBuilder SetVegetable(string vegetable)
    {
        this.vegetable = vegetable;
        return this;
    }
}
public class Hamberger
{
    public string bread;
    public string source;
    public string patty;
    public string vegetable;
}

프로그래밍 디자인 패턴은 소프트웨어 개발에서 자주 발생하는 문제를 해결하기 위한 재사용 가능한 설계 솔루션입니다. 쉽게 말해, 세상 수많은 프로그래머 선배분들이 각자의 프로그래밍을 해오다가 공통되게 나타난 비슷한 설계 구조들이 있는데, 그 중 이런 설계 구조에 이름을 붙여서 설계 원칙으로 만든 것 입니다.

<디자인 패턴 개요>

• 디자인 패턴은 게임뿐만이 아니라, 다양한 모든 프로그래밍 분야에서 활용 가능한 가이드라인입니다.

• 디자인 패턴은 구체적인 코드를 제공하지 않으며, 일반적인 구조와 상호작용을 설명하는 템플릿으로 이해할 수 있습니다.
• 예를 들어, 세상 다양한 프로그래머들이 제작하던 코드 중, "수많은 객체를 동시에 인스턴스화 시켜 한 곳에 담아두고, 사용이 끝난 후 메모리가 해제" 방식이 프로그래밍 언어나 구현 방식만 차이가 있을 뿐 마치 공통된 무늬와 같이 여러 코드에서 발견되었다고 가정하겠습니다.
• 영향력이나 이름이 있는 프로그래머가, 혹은 상용엔진을 만드는 회사가 이러한 방식을 보고 A패턴이라고 이름을 붙여서 널리 알려지게 되면, 추후 다른 개발자들이 비슷한 내용을 구현해아 할 상황에 편하게 A패턴이란 이름으로 정보를 구하고 적용할 수 있게 되는것 입니다.

• 하나의 예시를 들자면, 본인이 만들고자 하는 음악플레이어라는 기능이 프로그램 상에 하나만 존재하여야 하고 어느곳에서도 음악을 재생할 수 있게끔, 전역적으로 접근 가능할 수 있게 구현해야 하는 상황이라고 가정하겠습니다.

• 잘 알려진 디자인 패턴 중, '프로그램에서 유일한 인스턴스를 보장하고 전역적인 접근을 제공' 하는 개념의 싱글톤 패턴이라는 것이 있는데, 이러한 디자인 패턴 개념을 활용하여 본인이 원하는 코드를 해당 개념에 맞추어 작성하면 손쉽게 작성할 수 있는것 입니다.

<게임에 자주 쓰이는 패턴>

• 수많은 디자인 패턴들이 존재하는데 일부는 확장성에 초점을 맞추기도, 일부는 최적화 및 재활용성에 초점을 맞추기도 합니다.

• 게임의 경우, 퍼포먼스가 중요하기에 최적화와 직결되는 디자인 패턴들의 선호도가 높습니다.

싱글톤 패턴

• 개요에서 설명이 나왔던 싱글톤 패턴은 게임에서 유일한 인스턴스를 보장하고, 전역적인 접근이 필요한 경우에 사용되는 패턴입니다.

• 싱글톤 패턴은 클래스의 인스턴스가 하나만 생성되도록 보장하고, 어디서든 동일한 인스턴스에 접근할 수 있게 합니다.
• 예를 들어, 게임 매니저, 자원 관리자 등에서 활용됩니다.

상태 패턴

• 게임에서 오브젝트의 동작이 상태에 따라 달라지는 경우 사용되는 패턴입니다.

• 상태 패턴은 각 상태를 클래스로 구현하고, 상태에 따라 다른 동작을 수행합니다.
• 예를 들어, 캐릭터의 이동 상태, 공격 상태, 대기 상태 등을 다루는 데 유용합니다.
• 캐릭터의 상태를 객체로 구현하게 되면, 추후 새로운 상태가 추가 되어도 이 상태를 사용하는 캐릭터 클래스의 코드를 대폭 수정할 필요 없이 유연하게 대처가 가능합니다.

오브젝트 풀 패턴

• 게임에서 반복적으로 생성되고 소멸되는 객체들을 효율적으로 관리하기 위한 패턴입니다.

• 객체 풀 패턴은 미리 생성된 객체들을 풀에 저장해두고, 필요할 때마다 객체를 재사용하여 생성 및 소멸의 오버헤드를 줄입니다.
• 게임에서 객체는 정말 많은데, 이 객체들을 필요한 상황마다 생성하여 사용하거나, 사용이 종료되는 순간순간 없애는 작업이 반복된다면 꽤 큰 부하가 걸릴것입니다.
• 미리 큰 메모리 공간을 확보해 둔 후에, 객체의 사용이 끝나도 객체를 지우는 것이 아닌, 잠시 비활성화 해 두었다가 재활용하는 방법으로 사용하면 성능상 큰 이득을 볼 수 있습니다.

컴포넌트 패턴

• 게임 오브젝트의 동작과 기능을 구현하는 데 사용되는 패턴입니다.

• 각각의 게임 오브젝트는 여러 개의 컴포넌트로 구성되며, 컴포넌트는 독립적으로 동작하고 상호작용합니다.
• 다시 말해, 자동차라는 객체가 있을 경우, 이 객체를 만드는 방법으로 엔진객체, 휠 객체, 미션 객체, 브레이크 객체 등 세분화 된 객체들을 조립하여 하나의 객체를 구성해 나가는 패턴입니다.
• Unity 엔진에서 만들어내는 객체들이 컴포넌트 패턴의 예시라고 볼 수 있습니다.
• 캐릭터를 하나 만들고, 거기에 필요에 따라 물리가 필요하면 물리 객체, 네트워킹이 필요하면 네트워크관련 객체등을 붙여나가며 원하는 객체를 만들어 냅니다.

옵져버 패턴

• 이 패턴은 객체 간의 일대다 관계를 구성하여, 한 객체의 상태 변화에 따라 다른 객체들이 자동으로 업데이트되도록 하는 것을 목적으로 합니다.

• 옵저버 패턴은 주제(Subject)와 옵저버(Observer)라는 두 가지 주요 요소로 구성됩니다.
• 주제는 상태를 가지며, 상태가 변경될 때 옵저버에게 알립니다.
• 옵저버는 주제를 구독하고, 주제의 상태가 변경되면 업데이트를 수신하여 필요한 동작을 수행합니다.
• 플레이어의 정보를 표시하는 UI가 있다고 가정 시, 이 UI가 플레이어의 정보를 항시 받아 출력하는 형태는 비효율적일것입니다.
• 변동사항이 있을때만, 변동사항이 있다는 것을 관련된 객체들에게 전달시키는 방식을 채용하게 되면 객체간의 결합도를 낮추고, 유연성 및 확장성을 제공할 수 있습니다. 이럴때 옵저버 패턴을 고려할 수 있습니다.

기타 디자인 패턴들 및 유의사항

이외에도 컬렉션 객체를 유용하게 관리하게 도와주는 이터레이터 패턴, 많은 수의 유사한 객체를 관리하기 위한 플라이웨이트 패턴, 플레이어 입력 자체를 캡슐화 하여 상호작용 및 제어 흐름에 도움을 주는 커맨드 패턴, 게임 내에서 객체를 새로 만들어 내는 과정을 단일 지점에 집중시켜 코드 단순화를 이루어낼 수 있는 팩토리 패턴 등 유용한 패턴들이 상당히 많습니다.

게임의 종류가 다양하듯, 적용시킬 수 있는 디자인 패턴도 상황에 따라 다릅니다. 만들고자 하는 게임에 따라 어울리지 않는 디자인 패턴을 무리하여 적용시키거나, 무리하게 많은 디자인패턴을 적용시켜버리면 구현 시간보다 설계시간이 반대로 더욱 길어져서 자칫 옳지 못한 결과로 이어질 수도 있습니다. 다양한 디자인 패턴 중, 충분히 본인 프로젝트에 어울리는지 판단한 후에 적용시킬지 여부를 결정하는 것이 좋습니다.

<순차 탐색>

• 자료구조에서 순차적으로 찾고자 하는 데이터를 탐색

• 반드시 찾을 수 있지만, 시간 효율이 높은 탐색은 아니다.
• 데이터가 1억개 있으면 1억개를 찾아야 할 수 있음
• 시간복잡도 0(n)

public static int LinearSearch(int[] array, int target)
{
    for (int i=0; i < array.Length; i++)
    {
        if (array[i] == target)
        {
            return i;
        }
    }
    return -1;
}


static void Main(string[] args)
{
    int[] array = { 1, 3, 5, 7, 9, 8, 6, 4, 2, 0 };
    int fixdIndex = LinearSearch(array, 9);
    Console.WriteLine("탐색 결과 : {0}", fixdIndex);
}

<이진 탐색> -> 꼭 정렬 되어 있어야 함!!

• 정렬이 되어있는 자료구조에서 2분할을 통해 데이터를 탐색

• 단, 이진 탐색은 정렬이 되어 있는 자료에만 적용 가능
• 시간복잡도 - O(logn)

public static int BinarySearch(int[] array, int target)
{
    int low = 0;    // 처음
    int high = array.Length - 1;    // 끝
    while (true) // 찾을때까지 || 없을때까지
    {
        int mid = (low + high) / 2;
        // 중간 위치를 mid로 잡는다;
        if (array[mid] > target)   //중간값이 찾고자 하는 값보다 더 큰경우
        {
            // 오른쪽 더 큰 값들은 제외
            high = mid - 1;
        }
        else if (array[mid] < target)   //중간값이 찾고자 하는 값보다 더 작은경우
        {
            // 왼쪽 작은 값들은 제외
            high = mid + 1;
        }
        else
        {
            return mid; // 중간 위치가 찾는 값이다
        }
        return -1;
    }
}

static void Main(string[] args)
{
    int[] ints = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int binIndex = BinarySearch(ints, 5);
    Console.WriteLine("탐색 결과 : {0}", binIndex); }                                    

<너비 우선 탐색 (Breadth-First Search)>

• 그래프의 분기를 만났을 때 모든 분기들을 탐색한 뒤,

• 다음 깊이의 분기들을 탐색
• 큐를 통해 탐색
• 장점 : 최단 경로를 보장!!
• 단점 : 지금 탐색상황에서 필요하지 않은 정점데이터도 큐에 보관할 필요가 있다.
• 일반적으로 그래프에 사용을 선호함

public static void BFS(bool[,] graph, int start, out bool[] visited, out int[] parents)
{
    int size = graph.GetLength(0);
    //인접행렬 그래프의 특징상 n개 정점의 그래프는[n, m] 으로 만드니
    //GetLength(0) 을 구하면 n을 가질수 있고 이는 곧 정점의 갯수를 의미함
    visited = new bool[size];
    parents = new int[size];

    for (int i = 0; i < size; i++)
    {
        visited[i] = false;
        parents[i] = -1;
    }

    Queue<int> queue = new Queue<int>();   
    queue.Enqueue(start);
    visited[start] = true;

    while (queue.Count > 0) 
    {
        // 큐에서 다음으로 탐색할 정점을 확인한다
        int next = queue.Dequeue();

        //다음으로 탐색할 정점을 기준으로 탐색할 수 있는 정점들을 큐에 담는다
        for (int vertex = 0; vertex <size; vertex++)  // 정점들을 반복하면서
        {    // 연결이 되어 있는 정점이면서 && 방문한 적 없는 정점
            if (graph[next,vertex] ==true && visited[vertex]==false)   
            {
                //큐에 탐색할 수 있는 정점을 추가한다.
                queue.Enqueue(vertex);
                //탐색할 수 있는 정점을 방문 표시
                visited[vertex] = true;
                //탐색할 수 있는 정점의 이전 정점을 표시한다
                parents[vertex] = next;
            }
        }
    }

}


static void Main(string[] args)
{
    bool[,] graph = new bool[8, 8];
    graph[0, 1] = true;
    graph[1, 0] = true;
    graph[0, 2] = true;
    graph[2, 0] = true;
    graph[0, 4] = true;
    graph[4, 0] = true;
    graph[1, 3] = true;
    graph[3, 1] = true;
    graph[1, 5] = true;
    graph[5, 1] = true;
    graph[2, 6] = true;
    graph[6, 2] = true;
    graph[4, 7] = true;
    graph[7, 4] = true;
    graph[5, 7] = true;
    graph[7, 5] = true;
    graph[6, 7] = true;
    graph[7, 6] = true;

    // BFS 탐색
    Console.WriteLine("<BFS>");
    BFS(graph, 0, out bool[] visited, out int[] parents);
    Console.WriteLine($"{"Vertex",8}{"Visited",8}{"Parents",8}");
    for (int i = 0; i < visited.Length; i++)
    {
        Console.WriteLine($"{i,8}{visited[i],8}{parents[i],8}");
    }                                           
}

<깊이 우선 탐색 (Depth-First Search)>

• 그래프의 분기를 만났을 때 최대한 깊이 내려간 뒤,

• 분기의 탐색을 마쳤을 때 다음 분기를 탐색
• 스택을 통해 구현
• 장점 : 지금 탐색상황에서 필요한 정점데이터만 보관 가능하고, 탐색이 끝나면 버려도 무관하다.
• 단점 : 최단 경로를 보장하지 않음!!
• 일반적으로 트리에 사용을 선호함 -> 최단 경로가 하나밖에 없음

public static void DFS(bool[,] graph, int start, out bool[] visited, out int[] parents)
{
    int size = graph.GetLength(0);  // 정점의 갯수
    visited = new bool[size];
    parents = new int[size];

    for (int i = 0; i < size; i++)
    {
        visited[i] = false; // 시작전 방문한 적 없다
        parents[i] = -1;    // 나를 찾을 필요는 없다
    }
    // 함수 호출 스텍 쓰는 방법
    SearchNode(graph, start, visited, parents);
}

private static void SearchNode(bool[,] graph, int vertex, bool[] visited, int[] parents)
{
    int size = graph.GetLength(0);  // 정점의 갯수
    visited[vertex] = true;

    for (int i = 0; i < size; i++)  // 모든 정점을 확인
    {
        if (graph[vertex, i]==true &&     // 연결되어 있는 정점이며,
            visited[i]==false)            // 방문한적 없는 정점
        {
            parents[i] = vertex;
            SearchNode(graph, i, visited, parents); // 재귀함수
        }
    }
}


static void Main(string[] args)
{
    bool[,] graph = new bool[8, 8];
    graph[0, 1] = true;
    graph[1, 0] = true;
    graph[0, 2] = true;
    graph[2, 0] = true;
    graph[0, 4] = true;
    graph[4, 0] = true;
    graph[1, 3] = true;
    graph[3, 1] = true;
    graph[1, 5] = true;
    graph[5, 1] = true;
    graph[2, 6] = true;
    graph[6, 2] = true;
    graph[4, 7] = true;
    graph[7, 4] = true;
    graph[5, 7] = true;
    graph[7, 5] = true;
    graph[6, 7] = true;
    graph[7, 6] = true;

    // DFS 탐색
    Console.WriteLine("<DFS>");
    DFS(graph, 0, out bool[] visited, out int[] parents);
    Console.WriteLine($"{"Vertex",8}{"Visited",8}{"Parents",8}");
    for (int i = 0; i < visited.Length; i++)
    {
        Console.WriteLine($"{i,8}{visited[i],8}{parents[i],8}");
    }

<다익스트라 알고리즘>

• 특정한 노드에서 출발하여 다른 노드까지 가는 각각의 최단 경로를구하는 알고리즘

1. 방문하지 않은 노드 중에서 가장 가까운 노드를 선택한 후,
2. 선택한 노드를 거쳐서 더 짧아지는 경로가 있는 경우 대체

const int INF = 99999;
public static void Dijkstra(int[,] graph, int start, out bool[] visited, out int[] parents, out int[] cost)
{
    int size = graph.GetLength(0);    // 정점의 갯수
    visited = new bool[size];
    parents = new int[size];
    cost = new int[size];

    for (int i = 0; i < size; i++)
    {
        visited[i] = false; // 탐색한적 없음. 초기값
        parents[i] = -1;
        cost[i] = INF;
    }
    cost[start] = 0;    // 시작지점 0 부터

    for (int i = 0; i < size; i++)  // 전부 다 보기 위해
    {
        // 1.방문하지 않은 정점 중 가장 가까운 정점 선택
        int minIndex = -1;    //최소값을 확인하기 위해
        int minCost = INF;
        for (int j = 0; j < size; j++)
        {
            if (visited[j]==false &&   // 방문한 적 없으며
                cost[j] < minCost)      // 가장 가까운 정점
            {
                minIndex = j;
                minCost = cost[j];      // 가장 가까운 정점 찾으면 교체
            }
        }
        if (minIndex < 0)
        {
            break;  // 하나도 없는 경우 (-1)
        }
        visited[minIndex] = true;

        // 2. 직접 연결된 거리보다 거쳐서 더 짧아지면 대체
        for (int j = 0; j < size; j++)
        {
            // cost[j] : 목적지까지 직접 연결된 거리    (AB)
            // cost[minIndex] : 중간점까지의 거리 - 탐색중인 정점까지 거리    (AC)
            // graph[minIndex, j] : 중간점 부터 목적지까지 거리 - 탐색중인 정점부터 목적지의 거리    (CB)
            if (cost[j] > cost[minIndex] + graph[minIndex, j])
            {
                cost[j] = cost[minIndex] + graph[minIndex, j];
                parents[j] = minIndex;
            }
        }
    }
}


static void Main(string[] args)
{
    // 다익스트라 최단 경로 알고리즘
    int[,] dijkstra = new int[8, 8]
    {
        {   0,  6,  7,  2,  INF, INF, INF,  INF },
        {   6,  0,  8, INF, INF, INF,   2,  INF },
        {   7,  8,  0, INF, INF,   2,   7,  INF },
        {   2,INF,INF,   0, INF,   2, INF,  INF },
        { INF,INF,INF, INF,   0, INF,   8,  INF },
        { INF,INF,  2,   2, INF,   0,   1,    1 },
        { INF,  2,  7, INF,   8,   1,   0,    4 },
        { INF,INF,INF, INF, INF,   1,   4,    0 },
    };

    Console.WriteLine("다익스트라");
    Dijkstra(dijkstra, 0, out bool[] visited, out int[] parent, out int[] cost);

}

<선택정렬> -> 느릴수 있으나 16개 이하에서는 오히려 더 빠름

• 데이터 중 가장 작은 값부터 하나씩 선택하여 정렬 시간복잡도 - O(n²) 공간복잡도 - O(1) 불안정정렬

public static void SelectionSort(int[] array)
{
    for (int i=0; i<array.Length; i++)// 배열의 첫 번째 요소부터 마지막까지 반복
    {
        int minIndex = i; // 현재 위치를 최소값의 인덱스로 설정
        for (int j=0; j<array.Length; j++)
        {
            if (array[j] < array[minIndex])// 더 작은 값이 발견되면 최소값 인덱스를 갱신
            {
                minIndex = j;
            }
        }
        Swep(array, i, minIndex);// 현재 위치와 최소값 위치를 교환
    }
}

<삽입정렬>

• 데이터를 하나씩 꺼내어 정렬된 자료 중 적합한 위치에 삽입하여 정렬 시간복잡도 - O(n²) 공간복잡도 - O(1) 안정정렬 - O

public static void InsertionSort(int[] array)
{
    for (int i = 1; i < array.Length; i++)   // 두 번째 요소부터 시작 -> 맨 처음칸은 정렬될 장소이기 때문 필요없음
    {
        for (int j = i; j > 0; j--)    // 현재 요소를 정렬된 부분과 비교하며 적합한 위치로 이동
        {
            if (array[j - 1] > array[j])  // 다음숫자를 하나씩 꺼내서 앞의 요소가 더 큰지 비교
            {
                Swep(array, j - 1, j);   // 앞 숫자와 비교해서 더 작으면 한칸 뒤로 밀고
            }
            else
            {
                break;                  // 적합한 위치를 찾으면 종료
            }
        }
    }
}

<버블정렬> -> 인덱스 사용이 불가능 할때 사용가능

• 서로 인접한 데이터를 비교하여 정렬 시간복잡도 - O(n²) 공간복잡도 - O(1) 안정정렬 - O

public static void BubbleSort(int[] array)
{
    for (int i = 1; i < array.Length; i++)  // 처음부터 끝까지 여러 번 스캔
    {
        for (int j = 0; j < array.Length - i; j++)  // 인접한 두 요소를 비교
        {
            if (array[j] > array[j + 1])    // 서로 인접한 두 데이터의 앞의 요소가 더 크면
            {
                Swep(array, j, j + 1);    // 교환
            }
        }
    }
}

<병합정렬>

• 데이터를 2분할하여 정렬 후 합병

• 데이터 갯수만큼의 추가적인 메모리가 필요 시간복잡도 - O(nlogn) 공간복잡도 - O(n) 안정정렬 - O

public static void MergeSort(int[] array) => MergeSort(array, 0, array.Length - 1);
public static void MergeSort(int[] array, int start, int end)
{
    if (start == end)    // 배열이 하나의 요소만 남으면 반환
        return;

    int mid = (start + end) / 2;
    MergeSort(array, start, mid);  // 왼쪽 부분 정렬
    MergeSort(array, mid + 1, end);  // 오른쪽 부분 정렬
    Merge(array, start, mid, end);  // 두 부분 병합
        }
}

public static void Merge(int[] array, int start, int mid, int end)
{
    List<int> sortedList = new List<int>();
    int leftIndex = start;
    int rightIndex = mid + 1;

    while (leftIndex <= mid && rightIndex <= end)
    {
        if (array[leftIndex] < array[rightIndex])
        {
            sortedList.Add(array[leftIndex]);
            leftIndex++;
        }
        else
        {
            sortedList.Add(array[rightIndex]);
            rightIndex++;
        }
    }

    if (leftIndex <= mid)
    {
        while (leftIndex <= mid)
        {
            sortedList.Add(array[leftIndex]);
            leftIndex++;
        }
    }
    else // if (rightIndex <= end)
    {
        while (rightIndex <= end)
        {
            sortedList.Add(array[rightIndex]);
            rightIndex++;
        }
    }

    for (int i = 0; i < sortedList.Count; i++)
    {
        array[start + i] = sortedList[i];
    }
}

<퀵정렬>

• 하나의 기준(피벗)을 기준으로 작은값과 큰값을 2분할하여 정렬

• 최악의 경우(피벗이 최소값 또는 최대값)인 경우 시간복잡도가 O(n²) 시간복잡도 - 평균 : O(nlogn) 최악 : O(n²) 공간복잡도 - O(1) 불안정정렬

public static void QuickSort(int[] array) => QuickSort(array, 0, array.Length - 1);

public static void QuickSort(int[] array, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int pivot = start;
    int left = pivot + 1;
    int right = end;

    while (left <= right)   //left와 right가 교차할때까지 반복
    {
        while (array[pivot] >= array[left] && left < right)   // left는 pivot 보다 더 큰값을 볼 떄까지 오른쪽으로 이동;
        {
            left++;
        }
        while (array[pivot] < array[right] && left <= right)  // right는 pivot보다 더 작은 값을 볼때까지 왼쪽으로 이동;
        {
            right--;
        }

        if (left < right)   //left와 right가 교차 안했다면
        {
            Swep(array, left, right);    //left와 right 값을 교체
        }
        else
        {
            Swep(array, pivot, right);   // 아니라면 pivot과 right를 교체
            break;
        }
    }

    QuickSort(array, start, right - 1);
    QuickSort(array, right + 1, end);
}

<힙정렬>

• 힙을 이용하여 우선순위가 가장 높은 요소가 가장 마지막 요소와 교체된 후 제거되는 방법을 이용

• 배열에서 연속적인 데이터를 사용하지 않기 때문에 캐시 메모리를 효율적으로 사용할 수 없어 상대적으로 느림 시간복잡도 - O(nlogn) 공간복잡도 - O(1) 불안정정렬

public static void HeapSort(int[] array)
{
    MakeHeap(array);

    for (int i = array.Length - 1; i > 0; i--)
    {
        Swep(array, 0, i);
        Heapify(array, 0, i);
    }
}

private static void MakeHeap(int[] array)
{
    for (int i = array.Length / 2 - 1; i >= 0; i--)
    {
        Heapify(array, i, array.Length);
    }
}

private static void Heapify(int[] array, int index, int size)
{
    int left = index * 2 + 1;
    int right = index * 2 + 2;
    int max = index;
    if (left < size && array[left] > array[max])
    {
        max = left;
    }
    if (right < size && array[right] > array[max])
    {
        max = right;
    }

    if (max != index)
    {
        Swep(array, index, max);
        Heapify(array, max, size);
    }
}

static void Main(string[] args)
{
    int num = 200;
    Console.WriteLine($"{num, 5}");  // 문자 간격 조결. 5 -> 5칸을 가지겠다. 200 이3칸 띄어쓰기2칸 = 5
    Console.WriteLine(num);

    Random random = new Random();
    int count = 100;

    int[] selectArray = new int[count];
    int[] insertArray = new int[count];
    int[] bubbleArray = new int[count];
    int[] mergeArray = new int[count];
    int[] quickArray = new int[count];


    Array.Sort(selectArray);    // c#은 인트로 Sort(정렬)로 되어있다. 하이브리드 정렬. (퀵, 힙, 삽입 정렬로 이루어짐)


    Console.WriteLine("랜덤 데이터: ");
    for (int i = 0; i < count; i++)
    {
        int rand = random.Next(0, 100);     // 0부터 100미만 랜덤한 숫자 생성
        Console.Write($"{rand, 3}");

        selectArray[i] = rand;
        insertArray[i] = rand;
        bubbleArray[i] = rand;
        mergeArray[i] = rand;
        quickArray[i] = rand;
    }
    Console.WriteLine();
    Console.WriteLine();

    SelectionSort(selectArray);
    Console.WriteLine("선택 정렬 결과 : ");
    foreach (int value in selectArray)
    {
        Console.Write($"{value,3}");
    }
    Console.WriteLine();

    InsertionSort(insertArray);
    Console.WriteLine("삽입 정렬 결과 : ");
    foreach (int value in insertArray)
    {
        Console.Write($"{value,3}");
    }
    Console.WriteLine();

    Stopwatch sw1 = new Stopwatch();
    sw1.Start();
    BubbleSort(bubbleArray);
    sw1.Stop();

    Console.WriteLine("버블 정렬 결과: { 0}", sw1.ElapsedTicks);
    foreach (int value in bubbleArray)
    {
        Console.Write($"{value,3}");
    }
    Console.WriteLine();

    Stopwatch sw2 = new Stopwatch();
    sw2.Start();
    MergeSort(mergeArray);
    sw2.Stop();

    Console.WriteLine("병합 정렬 결과: { 0}", sw2.ElapsedTicks);
    foreach (int value in mergeArray)
    {
        Console.Write($"{value,3}");
    }
    Console.WriteLine();


    QuickSort(quickArray);
    Console.WriteLine("퀵 정렬 결과: ");
    foreach (int value in quickArray)
    {
        Console.Write($"{ value,3}");
    }
    Console.WriteLine();
}


public static void Swep(int[] array, int left, int right) 
{ 
    int temp = array[left];
    array[left] = array[right];
    array[right] = temp;
}

알고리즘 (Algorithm)

• 문제를 해결하기 위해 정해진 진행절차나 방법

• 컴퓨터에서 알고리즘은 어떠한 행동을 하기 위해서 만들어진 프로그램 명령어의 집합

<알고리즘 조건>

1. 입력 : 알고리즘은 0개 이상의 입력을 가져야 함
2. 출력 : 알고리즘은 최소 1개 이상의 결과를 가져야 함
3. 명확성 : 수행 과정은 모호하지 않고 정확한 수단을 제공해야 함
4. 유한성 : 수행 과정은 무한하지 않고 유한한 작업 이후에 정지해야 함
5. 효과성 : 모든 과정은 명백하게 실행 가능해야 함

static void Main(string[] args)
{   
    <의사코드> -> 인간의 언어로 흐름도를 먼저 그려보는것
    // 가장 큰 수를 찾기
    int[] array = { 1, 2, 3, 4, 5 };
    // 1. 가장 큰 수를 저장할 변수 만들기
    int max;
    // 2. 맨 처음부터 시작
    int index = 0;
    // 3. 맨 처음부터 시작한 수가 다음 수보다 작으면 큰 수를 다음수로 변경
    // 4. 다음 수를 또 다시 반복
}

재귀 (Recursion)

• 어떠한 것을 정의할 때 자기 자신을 참조 하는것

• 함수를 정의할 때 자기자신을 이용하여 표현하는 방법

<재귀함수 조건>

1. 함수내용 중 자기자신함수를 다시 호출해야함
2. 종료조건이 있어야 함

###<재귀함수 장점>

1. 코드로 표현하기 어려운 경우도 직관적이고, 처리가 가능
2. 분할정복을 통한 반절 계산이 가능해서 효율이 높아지게 구현이 가능

<재귀함수 사용>

 Factorial : 정수를 1이 될 때까지 차감하며 곱한 값
 x! = x * (x-1)!;
 1! = 1;
 ex) 5! = 5 * 4!
        = 5 * 4 * 3!
        = 5 * 4 * 3 * 2!
        = 5 * 4 * 3 * 2 * 1!
        = 5 * 4 * 3 * 2 * 1

 재귀함수는 예외 처리가 안되면(종료 조건) -> 오버플로우에 빠짐 (터짐)


int Factorial(int x)
{
    if (x == 1)
        return 1;
    else
        return x * Factorial(x - 1);
}



public class Folder
{
    //public List<string> files;
    public List<Folder> children;
}

public static void RemoveFolder(Folder folder)
{
    // 파일들 삭제하고

    foreach (var child in folder.children)
    {
        RemoveFolder(child);
    }
}

int Fibonaachi(int n)       //  재귀를 써도 최악의 알고리즘. -> 소모되는 시간 2배
{
    if(n==1) return 1;
    else if(n==2) return 1;
    return Fibonaachi(n - 1) + Fibonaachi(n - 2);
}

static void Main(string[] args)
{
    Console.WriteLine("Hello, World!");
}

그래프 (Graph)

• 정점의 모음과 이 정점을 잇는 간선의 모음의 결합

• 한 노드에서 출발하여 다시 자기 자신의 노드로 돌아오는 순환구조를 가짐
• 간선의 방향성에 따라 단방향 그래프, 양방향 그래프가 있음
• 간선의 가중치에 따라 연결 그래프, 가중치 그래프가 있음

<인접행렬 그래프>

• 그래프 내의 각 정점의 인접 관계를 나타내는 행렬

• 2차원 배열을 [출발정점, 도착정점] 으로 표현
• 장점 : 인접여부 접근이 빠름
• 단점 : 메모리 사용량이 많음

int[,] graph0 = new int[8,8];

graph0[0, 2] = 122;
graph0[2, 0] = 13;
graph0[0, 4] = 22;
graph0[4, 0] = 14;
graph0[1, 2] = 66;
graph0[2, 1] = 155;
graph0[1, 3] = 55;
graph0[3, 1] = 32;

graph0[0, 1] = 5;  //가중치
graph0[1, 3] = 6;

/********************************************************/
bool[,] graph0 = new bool[8,8];

graph0[0, 2] = true;
graph0[2, 0] = true;
graph0[0, 4] = true;
graph0[4, 0] = true;
graph0[1, 2] = true;
graph0[2, 1] = true;
graph0[1, 3] = true;
graph0[3, 1] = true;

Console.WriteLine("0에서 3으로 연결되어 있는가? {0}", graph0[0,3]);    //false


// 예시 - 양방향 연결 그래프
bool[,] matrixGraph1 = new bool[5, 5]
{
{ false, false, false, false,  true },
{ false, false,  true, false, false },
{ false,  true, false,  true, false },
{ false, false,  true, false,  true },
{  true, false, false,  true, false },
};

// [0,2] => 출발정점(0) -> 도착정점(2)
bool connect = matrixGraph1[0, 2];   // 연결 여부 확인
matrixGraph1[0, 2] = true;           // 연결추가
matrixGraph1[0, 2] = false;          // 연결헤제



const int INF = int.MaxValue;
// 예시 - 단방향 가중치 그래프 (단절은 최대값으로 표현) INF
int[,] matrixGraph2 = new int[5, 5]
{
{   0, 132, INF, INF,  16 },
{  12,   0, INF, INF, INF },
{ INF,  38,   0, INF, INF },
{ INF,  12, INF,   0,  54 },
{ INF, INF, INF, INF,   0 },
};

// [0,2] => 출발정점(0) -> 도착정점(2)
int distance = matrixGraph2[0, 2];   // 0에서 2까지 가중치
matrixGraph2[0, 2] = 10;           // 가중치 변경. 

<인접리스트 그래프>

• 그래프 내의 각 정점의 인접 관계를 표현하는 리스트

• 인접한 간선만을 리스트에 추가하여 관리
• 장점 : 메모리 사용량이 적음!!
• 단점 : 인접여부를 확인하기 위해 리스트 탐색이 필요 (빠르지 않음)

List<int>[] listGraph = new List<int>[5];

listGraph[0] = new List<int>() { 2, 4 };
listGraph[1] = new List<int>() { 2, 3 };
listGraph[2] = new List<int>() { 0, 1 , 4 };
listGraph[3] = new List<int>() { 1, 7 };
listGraph[4] = new List<int>() { 0, 2 };
listGraph[5] = new List<int>() { 6, 7 };
listGraph[6] = new List<int>() { 5, 7 };
listGraph[7] = new List<int>() { 3, 5, 6 };

listGraph[0].Add(5);        // 연결 추가
listGraph[5].Add(0);

listGraph[1].Remove(2);     // 연결 끊기
listGraph[2].Remove(1);

bool connect0 = listGraph[0].Contains(1);   // 연결 여부 확인. -> 0에 1이 연결되어있으면 true

public class GraphNode<T>       // 채개적으로 관리 가능. -> 코드가 많이 늘어남.
{
    private T vertax;

    public T Vertax { get { return vertax; } set { vertax = value; } }

    private List<GraphNode<T>> edges = new List<GraphNode<T>>();

    public GraphNode(T vertex)
    {
        this.vertax = vertex;
    }

    public void AddEdge(GraphNode<T> node) 
    {   
        // 연결 하기
        edges.Add(node);
    }

    public void RemoveEdge(GraphNode<T> node)
    {
        // 연결 끊기
        edges.Remove(node);
    }

    public bool IsConnect(GraphNode<T> node)
    {
        return edges.Contains(node); 
    }
}

static void Main(string[] args)
{
    GraphNode<int> node0 = new GraphNode<int>(0);
    GraphNode<int> node1 = new GraphNode<int>(1);
    GraphNode<int> node2 = new GraphNode<int>(2);
    GraphNode<int> node3 = new GraphNode<int>(3);
    GraphNode<int> node4 = new GraphNode<int>(4);
    GraphNode<int> node5 = new GraphNode<int>(5);
    GraphNode<int> node6 = new GraphNode<int>(6);
    GraphNode<int> node7 = new GraphNode<int>(7);

    node0.AddEdge(node3);
    node3.AddEdge(node0);
    node0.AddEdge(node4);
    node4.AddEdge(node0);
}