1. 메뉴화면
2. 세이브
3. 로드
4. 빌드 앤 런
5. 최종결과
6. 오늘의 배운 점
7. 다음 계획

🖥️ 메뉴화면

처음부터 이어하기 설정 메뉴가 있는 메뉴화면을 제작합시다. MenuScene이라는 이름으로 Project 창에서 씬을 제작해주세요.

1. UI 제작

2. 씬전환

시작하기를 누르면 게임으로 들어가게 하겠습니다. MenuManager 스크립트와 빈 오브젝트를 생성하고, 오브젝트 컴포넌트로 넣습니다.

// MenuManager.cs

 public void StartGame()
 {
     SceneManager.LoadScene("MainScene");
 }

해당 버튼 오브젝트의 Inspector에서 Button의 On Click()에 MenuManager 오브젝트를 넣고, StartGame 함수로 설정해주세요.

그리고 File -> Build Settings 에서 메뉴와 메인씬을 Add Open Scenes로 추가합시다. 그러면 씬으로 등록되고, 전환이 가능하게 됩니다.

3. 로딩 중 표시

게임에서 보면 시작하기를 한 후, 로딩 중...이 뜨며 현재 몇 퍼센트인지 알 수 있습니다. 조금 더 구현해볼까요? AsyncOperation 클래스를 이용하시면 됩니다. 해당 클래스에 대한 설명은 이 게시글을 참고해주세요.

// MenuManager.cs

public GameObject loadingPanel;
public Text loadingText; 

public void StartGame()
{
    StartCoroutine(LoadGameScene());
}

IEnumerator LoadGameScene()
{
    loadingPanel.SetActive(true);

    AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("MainScene");

    while (!asyncLoad.isDone)
    {
        float progress = asyncLoad.progress;
        Debug.Log(loadingText);
        loadingText.text = $"로딩 중... {progress * 100:F0}%"; 
        yield return null;
    }
}

4. 테스트

성공적으로 로딩이 완료됩니다.

✅ 세이브

게임을 저장하면 해당 데이터가 필요합니다. 저장할 데이터를 정리해봅시다. SaveData 스크립트를 만들어볼까요?

1. SaveData

일단 저장할 데이터를 간단하게 정리합시다. 플레이어 현재 상태 및 아이템, 그리고 맵 상태를 저장합시다.

// SaveData.cs

[System.Serializable]
public class SavePlayerData
{
    public PlayerStats playerStats;
    public Vector3 playerPosition;
    public Quaternion playerRotation;

    public SavedItemInstance[] inventoryItems;
    public SavedItemInstance[] equipmentItems;

    public bool[] unlockedItems;
    public int[] quickSlotIndexs;
    public int currentHandleItemIndex;

    public bool isOperate;
    public DateTime currentTime;
}

[System.Serializable]
public class SaveMapData
{
    public SavedItemInstance[] mapItems;
    public int semaphoreNumber;
}

2. SaveManager

저장, 로드를 담당할 스크립트를 생성합니다.

// SaveManager.cs

public class SaveManager : MonoBehaviour
{
    [SerializeField] private PlayerState playerState;
    [SerializeField] private PlayerController playerController;
    [SerializeField] private GameManager gameManager;
    [SerializeField] private UIManager uiManager;
    private string savePlayerPath = "savePlayerData.json";
    private string saveMapPath = "saveMapData.json";


    public void GoMenuScene()
    {
        Debug.Log("메인 메뉴로 이동합니다.");
        Time.timeScale = 1f;
        playerController.isPaused = false;
        GameState.IsUIOpen = false;
        SceneManager.LoadScene("MenuScene");
    }
    public virtual void SaveGame()
    {
        Debug.Log("게임 저장 시작!");
        SavePlayerData savePlayerData = CollectAllPlayerData();
        SaveMapData saveMapData = CollectAllMapData();

        string json = JsonUtility.ToJson(savePlayerData, true);
        File.WriteAllText(savePlayerPath, json);
        json = JsonUtility.ToJson(saveMapData, true);
        File.WriteAllText(saveMapPath, json);

        Debug.Log("게임 저장 완료!");
    }

    private SavePlayerData CollectAllPlayerData()
    {
        SavePlayerData saveData = new SavePlayerData();
        if (playerState)
        {
            saveData.playerStats = playerState.stats;
            saveData.playerPosition = playerState.transform.position;
            saveData.playerRotation = playerState.transform.rotation;
            saveData.quickSlotIndexs = playerState.quickSlotIndexs;
            saveData.currentHandleItemIndex = uiManager.quickSlotPanel.GetComponent<QuickPanel>().currentSlotIndex;

            // equipmentItems 배열 초기화
            saveData.equipmentItems = new SavedItemInstance[playerState.equipmentItems.Length];
            for (int i = 0; i < playerState.equipmentItems.Length; i++)
            {
                if (playerState.equipmentItems[i])
                {
                    saveData.equipmentItems[i] = playerState.equipmentItems[i].ToSaveData();
                }
                else
                {
                    saveData.equipmentItems[i] = null;
                }
            }

            saveData.inventoryItems = new SavedItemInstance[playerState.inventoryItems.Length];
            for (int i = 0; i < playerState.inventoryItems.Length; i++) 
            {
                if (playerState.inventoryItems[i])
                {
                    saveData.inventoryItems[i] = playerState.inventoryItems[i].ToSaveData();
                }
                else
                {
                    saveData.inventoryItems[i] = null;
                }
            }

            saveData.unlockedItems = playerState.unlockedItems;
            saveData.isOperate = GameState.IsOperate;
            saveData.currentTime = System.DateTime.Now;
        }
        return saveData;
    }

    private SaveMapData CollectAllMapData()
    {
        SaveMapData saveData = new SaveMapData();
        List<SavedItemInstance> worldItems = new List<SavedItemInstance>();

        foreach (ItemInstance item in FindObjectsOfType<ItemInstance>())
        {
            if (item)
            {
                if (item.isWorldItem)
                {
                    worldItems.Add(item.ToSaveData());
                }
            }
        }
        saveData.mapItems = worldItems.ToArray();
        return saveData;
    }

    private ItemData FindItemDataByName(string itemName)
    {
        for (int i = 0; i < gameManager.allItems.Length; i++)
        {
            if (gameManager.allItems[i].itemName == itemName)
            {
                return gameManager.allItems[i];
            }
        }
        return Resources.Load<ItemData>("Items/" + itemName);
    }

}

3. Esc 후 이어하기, 저장하기, 나가기

Canvas에 이어하기, 저장하기, 나가기 버튼을 추가합니다. 그리고 Esc키를 통해 메뉴가 열리고 게임이 멈추게 하겠습니다.

(1) 이어하기

// UIManager.cs

[HideInInspector] public bool isPaused = false;

public GameObject menuPanel;

public void SetEscMenu()
{
    if (!menuPanel) return;
    menuPanel.SetActive(!menuPanel.activeSelf);
    if (menuPanel.activeSelf)
    {
        Time.timeScale = 0f;
        playerController.isPaused = true;
    }
    else
    {
        Time.timeScale = 1f;
        playerController.isPaused = false;
    }
    SetMouseSate();
}

// 이어하기의 On Click()에 넣기
public void ClickContinueButton()
{
    if (!menuPanel) return;
    menuPanel.SetActive(false);
    Time.timeScale = 1f;
    playerController.isPaused = false;
    SetMouseSate();
}

// PlayerController.cs

void Update()
{
    HandleEsc();
    if (isPaused) return;
}

void HandleEsc()
{
    if (Input.GetKeyDown(KeyCode.Escape))
    {
        uiManager.SetEscMenu();
    }
}

(2) 저장하기 저장하기 버튼의 On Click에 SaveManager의 SaveGame()을 적용해주세요. 그러면 SignalHome 파일에 savePlayerData.json과 saveMapData.json라는 세이브 파일이 생깁니다!

(3) 나가기

// SaveManager.cs

[SerializeField] private PlayerController playerController;

 public void GoMenuScene()
 {
     Debug.Log("메인 메뉴로 이동합니다.");
     Time.timeScale = 1f;
     playerController.isPaused = false;
     GameState.IsUIOpen = false;
     SceneManager.LoadScene("MenuScene");
 }

🔁 로드

저장까진 모두 해냈죠? 그럼 해당 Json파일을 게임 시작 전에 불러와 적용해야 합니다.

 // SaveManager.cs


public virtual void LoadGame()
{
    if (File.Exists(savePlayerPath))
    {
        string json = File.ReadAllText(savePlayerPath);
        SavePlayerData savePlayerData = JsonUtility.FromJson<SavePlayerData>(json);
        json = File.ReadAllText(saveMapPath);
        SaveMapData saveMapData = JsonUtility.FromJson<SaveMapData>(json);
        ApplyAllGameData(savePlayerData, saveMapData);
        Debug.Log("게임 불러오기 완료!");
    }
    else
    {
        Debug.LogWarning("저장된 게임 데이터가 없습니다. 새 게임을 시작합니다.");
    }
}

private void ApplyAllGameData(SavePlayerData savePlayerData, SaveMapData saveMapData)
{
    if (playerState)
    {
        playerState.quickSlotIndexs = new int[] { -1, -1, -1, -1, -1 };
        playerState.inventoryItems = new ItemInstance[GameConstants.MAX_INVENTORY_SIZE];
        playerState.stats = savePlayerData.playerStats;
        playerState.transform.position = savePlayerData.playerPosition;
        playerState.transform.rotation = savePlayerData.playerRotation;

        // inventoryItems 복원 (Create 메서드로 통일)
        for (int i = 0; i < savePlayerData.inventoryItems.Length; i++)
        {
            if (savePlayerData.inventoryItems[i] != null)
            {
                ItemData itemData = FindItemDataByName(savePlayerData.inventoryItems[i].itemName);
                if (itemData != null)
                {
                    playerState.inventoryItems[i] = ItemInstance.Create(itemData, savePlayerData.inventoryItems[i]);
                    playerState.inventoryItems[i].gameObject.SetActive(false);
                }
            }
        }
        uiManager.inventory.items = playerState.inventoryItems;
        uiManager.UpdateItemUI();
        // equipmentItems 복원 (Create 메서드로 통일)
        playerState.equipmentItems = new ItemInstance[savePlayerData.equipmentItems.Length];
        for (int i = 0; i < savePlayerData.equipmentItems.Length; i++)
        {
            if (savePlayerData.equipmentItems[i] != null)
            {
                ItemData itemData = FindItemDataByName(savePlayerData.equipmentItems[i].itemName);
                if (itemData != null)
                {
                    playerState.equipmentItems[i] = ItemInstance.Create(itemData, savePlayerData.equipmentItems[i]);
                    playerState.equipmentItems[i].gameObject.SetActive(false);
                }
            }
        }

        playerState.quickSlotIndexs = savePlayerData.quickSlotIndexs;
        uiManager.quickSlotPanel.GetComponent<QuickPanel>().currentSlotIndex = savePlayerData.currentHandleItemIndex;

        uiManager.RefreshQuickSlotItems(playerState.quickSlotIndexs);
        uiManager.RefreshEquipmentItems(playerState.equipmentItems);

        if (uiManager.quickSlotPanel.GetComponent<QuickPanel>().currentSlotIndex >= 0)
        {
            if (playerState.inventoryItems[savePlayerData.currentHandleItemIndex])
            {
                int index = playerState.quickSlotIndexs[savePlayerData.currentHandleItemIndex];
                if (index >= 0)
                {
                    playerState.playerItemHandler.currentItem = playerState.inventoryItems[index];
                    playerState.playerItemHandler.SetHoldingItem(playerState.playerItemHandler.currentItem, playerState.playerItemHandler.rightHandBone);
                }
            }
        }

        foreach (SavedItemInstance savedItem in saveMapData.mapItems)
        {
            if (savedItem != null)
            {
                ItemData itemData = FindItemDataByName(savedItem.itemName);
                if (itemData != null)
                {
                    ItemInstance worldItem = ItemInstance.Create(itemData, savedItem);
                    worldItem.isWorldItem = true;
                    worldItem.gameObject.SetActive(true);
                    worldItem.transform.position = savedItem.position;
                    worldItem.transform.rotation = savedItem.rotation;
                }
            }
        }

        playerState.unlockedItems = savePlayerData.unlockedItems;
        GameState.IsOperate = savePlayerData.isOperate;
        GameState.currentSemaphoreNumber = saveMapData.semaphoreNumber;
        playerState.RefreshUI();
    }
}

// GameManager.cs

private void Start()
{
    // 기존 로직...
     // 게임 데이터가 없을 경우 새로운 세이브 파일을 자동 생성
     if (!File.Exists(saveManager.savePlayerPath))
     {
         saveManager.SaveStart();
     }
     saveManager.LoadGame();
}

🛠️ 메인메뉴 수정

메인메뉴를 더 수정합시다. 아래와 같이 처음부터, 이어하기, 설정, 나가기가 있는 겁니다.

처음부터 : 현재 세이브 파일이 있는 경우, 새로운 게임을 할 것인지 물어보고 아니라면 바로 새게임을 시작합니다. 이어하기 : 현재 세이브 파일이 있는 경우에만 나타납니다. 설정 : 소리, 자막 크기 등을 설정할 수 있습니다. 나가기 : 게임을 끕니다.

// MenuManager.cs

public class MenuManager : MonoBehaviour
{
    public GameObject loadingPanel;
    public GameObject warningPanel;
    public GameObject continueButton;
    public Text loadingText;

    private string savePlayerPath => Path.Combine(Application.persistentDataPath, "savePlayerData.json");
    private string saveMapPath => Path.Combine(Application.persistentDataPath, "saveMapData.json");
    private string originMapPath => Path.Combine(Application.streamingAssetsPath, "originMapData.json");

    private void Start()
    {
        if (!File.Exists(savePlayerPath))
        {
            continueButton.SetActive(false);
        }
    }
    public void StartGame()
    {
        if (File.Exists(savePlayerPath))
        {
            warningPanel.SetActive(true);
        }
        else
        {
            File.Copy(originMapPath, saveMapPath, true);  
            StartCoroutine(LoadGameScene());
        }
    }

    public void ContinueGame()
    {
        StartCoroutine(LoadGameScene());
    }

    public void RestartGame(bool confirm)
    {
        if (confirm)
        {
            warningPanel.SetActive(false);
            File.Delete(savePlayerPath);
            File.Copy(originMapPath, saveMapPath, true);
            StartCoroutine(LoadGameScene());
        }
        else
        {
            warningPanel.SetActive(false);
        }
    }

    IEnumerator LoadGameScene()
    {
        loadingPanel.SetActive(true);

        AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("MainScene");

        while (!asyncLoad.isDone)
        {
            float progress = asyncLoad.progress;
            loadingText.text = $"로딩 중... {progress * 100:F0}%"; 
            yield return null;
        }
    }

    public void QuitGame()
    {
        Application.Quit();
    }
}

▶️ 빌드 앤 런

이제 게임을 실행파일 (exe)로 한 번 뽑아볼까요?

1. 원본 맵 데이터

이미 saveMapData.json이 있기는 하나, 우리에게는 처음 맵 데이터가 필요합니다. 그것을 유니티 에디터에서 아이템을 배치한뒤, 한 번 세이브 파일이 생기게끔 합시다. 그 다음 해당 프로젝트의 파일탐색기의 Assets에 StreamingAssets라는 폴더를 생성합니다. saveMapData.Json파일의 이름을 originMapData.json으로 하고 File -> Build And Run을 합니다. 전 SiganlHome_Build라는 파일을 따로 만들었습니다. 여기서 exe파일이 실행파일입니다!

2. 테스트 (Log Viewer Asset)

테스트를 해보는데, 혹시 자신이 의도한 것과 다르게 나오는 것이 있나요? 저는 에디터에서와 다르게 실행파일에서는 안되는 부분이 있었습니다. 에디터에서는 Debug.Log로 문제점을 파악할 수 있었는데 실행파일에서는 어떻게 할까요? 바로 Log Viewer 에셋 입니다. 해당 에셋을 다운 받은 후 상단바에 있는 Reporter -> Create를 하여 Hierarchy에 추가해주세요.

위와 같이 뜰텐데요. 해당 에셋은 마우스 클릭을 한 채로 동그라미를 그릴 경우 로그창을 보여주는 에셋입니다. 오류, 경고, 로그가 모두 뜹니다.

3. Log Viewer 활용

Build Settings에서 Develpment Build, Deep Profiling Support, Script Debugging을 true로 하고 Compression Method를 LZ4 (빠른 디버깅을 위함) 로 합시다. 그리고 다시 Build And Run을 해주세요. 실행파일에서 마우스로 동그라미를 그려주면 로그가 뜹니다. 간단하죠?

해당 로그를 클릭하면 스크립트 오류 위치 등의 정보도 볼 수 있습니다.

저의 문제는...

- Animator가 null인 문제

1. Animator가 없을 경우 GetComponent<Animator>()을 하여 값을 할당함
2. 적용 후 애니메이션이 보임

- PlayerState의 playerItemHandler가 null인 문제

1. playerItemHandler가 없을 경우 GetComponent<PlayerItemHandler>()을 하여 값을 할당함

- Inventory에 아이템이 할당되지 않은 문제

1. LoadGame을 할때 PlayerState의 inventoryItems값이 Inventory의 items에 제대로 할당되지 않음
2. items 변수를 삭제, 그리고 모두 PlayerState의 inventoryItems로 대체함 (얕은 복사 및 동기화 활용)

모두 로드 전 해당 스크립트의 변수값이 할당되어 있지 않아 생긴 문제였습니다.

🎮 최종결과

오늘은 빌드하고 실행파일을 실행 후, 세이브&로드가 제대로 됐는지 확인하는 작업까지! 완료했네요. 실제 빌드파일이 나오니 정말 게임 같아졌습니다!

영상 링크 (구글 드라이브)

📚 오늘의 배운 점

• 세이브&로드 방법
• 빌드 후 exe파일 사용법
• Log Viewer 활용

🎯 다음 계획

다음 글에서는:

1. 오프닝 연출
2. 자막 생성

코딩테스트에서 함수를 잘 몰라서 혹은 응용법을 잘 몰라서 때문에 로직이 복잡해지는 경우가 있죠? 이때 알아두면 좋은 기초 함수를 가져왔습니다.

📊 Math (수학 관련)

// 최댓값, 최솟값
Math.Max(a, b)        // 둘 중 큰 값
Math.Min(a, b)        // 둘 중 작은 값
Math.Max(Math.Max(a, b), c)        // 3개 중 최댓값

// 절댓값, 제곱근
Math.Abs(-5)        // 5 (절댓값)
Math.Sqrt(16)        // 4.0 (제곱근)
Math.Pow(2, 3)        // 8.0 (2의 3제곱)

// 올림, 내림, 반올림
Math.Ceiling(3.2)    // 4.0 (올림)
Math.Floor(3.8)        // 3.0 (내림)
Math.Round(3.6)        // 4.0 (반올림)

🔤 String (문자열)

string str = "Hello World";

// 기본 정보
str.Length                // 11 (길이)
str[0]                    // 'H' (인덱스 접근)
str.Contains("ell")        // true (포함 여부)

// 변환
str.ToUpper()            // "HELLO WORLD"
str.ToLower()            // "hello world"
str.Replace("World", "C#")        // "Hello C#"

// 분할/결합
str.Split(' ')            // ["Hello", "World"]
string.Join(",", arr)    // 배열을 ","로 연결

// 부분 문자열
str.Substring(0, 5)        // "Hello" (시작인덱스, 길이)
str.Substring(6)        // "World" (시작인덱스부터 끝까지)

// 찾기
str.IndexOf("o")        // 4 (첫 번째 'o'의 인덱스, 없으면 -1)
str.LastIndexOf("o")    // 7 (마지막 'o'의 인덱스)

📋 Array(배열)

int [] arr = {3, 1, 4, 1, 5};

// 정렬
Array.Sort(arr)            // 오름차순 정렬
Array.Reverse(arr)        // 배열 뒤집기

// 찾기
Array.IndexOf(arr, 4)    // 2 (값 4의 인덱스, 없으면 -1)
Array.Exists(arr, x => x > 3)    // true (조건 만족하는 요소 존재?)

// 복사
int[] copy = new int[arr.Length];
Array.Copy(arr, copy, arr.Length);

📚 List (리스트)

List<int> list = new List<int>();

// 추가/삭제
list.Add(1)            // 끝에 추가
list.Insert(0, 5)    // 특정 위치에 삽입
list.Remove(1)         // 첫 번째로 발견되는 1 제거
list.RemoveAt(0)    // 0번 인덱스 제거
list.Clear(0)        // 모든 요소 제거

// 정보
list.Count            // 개수
list.Contains(5)    // 포함 여부
list[0]                // 인덱스 접근

// 정렬/변환
list.Sort()            // 오름차순 정렬
list.Reverse()        // 뒤집기
list.ToArray()        // 배열로 변환

🗂️ Dictionary<K,V> (해시맵)

Dictionary<string, int> dict = new Dictionary<string, int>();

// 추가/수정
dict["apple"] = 5        // 키-값 추가/수정
dict.Add("banana", 3)    // 추가 (키가 이미 있으면 예외)

// 접근/확인
dict["apple"]            // 5 (값 접근)
dict.ContainsKey("apple")    // true (키 존재 여부)
dict.ContainsValue(5)        // true (값 존재 여부)
dict.TryGetValue("apple", out int value)    // 안전한 접근

// 정보
dict.Count                // 개수
dict.Keys                // 모든 키
dict.Values                // 모든 값

🔄 Queue & Stack

// Queue (FIFO - 먼저 들어간 게 먼저 나옴)
Queue<int> queue = new Queue<int>();
queue.Enqueue(1)        // 큐에 추가
int first = queue.Dequeue()        // 첫 번째 요소 제거하고 반환
int peek = queue.Peek()            // 첫 번째 요소 확인만 (제거 안함)

// Stack (LIFO - 나중에 들어간 게 먼저 나옴)
Stack<int> stack = new Stack<int>();
stack.Push(1)            // 스택에 추가
int top = stack.Pop()    // 맨 위 요소 제거하고 반환
int peek = stack.Peek()    // 맨 위 요소 확인만

🎯 LINQ

using System.Linq;

int[] numbers = {1, 2, 3, 4, 5, 6};

// 필터링
numbers.Where(x => x > 3)        // {4, 5, 6}
numbers.Where(x => x %2 == 0)    // {2, 4, 6} (짝수만)

// 변환
numbers.Select(x => x * 2)        // {2, 4, 6, 8, 10, 12}
numbers.Select((x, i) => x + i)    // 값과 인덱스 사용

// 집계
numbers.Sum()                    // 21 (합계)
numbers.Max()                    // 6 (최댓값)
numbers.Min()                    // 1 (최솟값)
numbers.Average()                // 3.5 (평균)
numbers.Count(x => x > 3)        // 3 (조건 만족하는 개수)

// 정렬
numbers.OrderBy(x => x)                // 오름차순
numbers.OrderByDescending(x => x)    // 내림차순

// 기타 유용한 것들
numbers.Take(3)                        // 처음 3개 {1, 2, 3}
numbers.Skip(2)                        // 처음 2개 건너뛰고 {3, 4, 5, 6}
numbers.First()                        // 1 (첫 번째, 없으면 예외)
numbers.FirstOrDefault()            // 1 (첫 번째, 없으면 기본값)
numbers.Last()                        // 6 (마지막)
numbers.Any(x => x > 5)                // true (조건 만족하는 게 하나라도 있나?)
numbers.All(x => x > 0)                // true (모두 조건 만족하나?)
numbers.Distinct()                    // 중복 제거

🔢 형변환

// 문자열 - 숫자
int Parse("123")        // 123 (문자열을 int로)
"123".ToString()        // "123" (int를 문자열로)
Convert.ToInt32("123")    // 123 (다른 방법)

// 안전한 변환
int.TryParse("123", out int result)        // 변환 성공하면 true

// char - int
'5' - '0'                // 5 (문자를 숫자로)
5 + '0'                    // '5' (숫자를 문자로)

🎲 자주 쓰는 패턴들

// 2차원 배열 순회
for (int i = 0; i < arr.getLength(0); i++)        // 행
    for (int j = 0; j < arr.GetLength(1); j++)    // 열

// 배열 초기화
int[] arr = new int[5];                // {0, 0, 0, 0, 0}
int[] arr = Enumerable.Repeat(1, 5).ToArray();    // {1, 1, 1, 1, 1}
int[] arr = Enumerable.Range(1, 5).ToArray();    // {1, 2, 3, 4, 5}

// 조건부 삼항 연산자
int result = condition ? valueIfTrue : valueIfFalse;

// null 체크 간단히
string result = str?.ToUpper() ?? "DEFAULT";

특히 꼭 외워두면 좋은 것들:

• Math.Max/Min - 비교문 대신 쓰면 훨씬 깔끔
• LINQ의 Where, Select, Sum, Max - 배열 처리가 한 줄로!
• dictionary - 해시 문제는 거의 이걸로 해결
• Queue/Stack = BFS/DFS 문제 필수

BFS란?

BFS(Breadth-First Search, 너비 우선 탐색)는 그래프나 트리에서 가까운 노드부터 차례대로 탐색하는 알고리즘입니다. 마치 풀이 퍼져나가는 것처럼 동심원 형태로 탐색하기 때문에 최단거리 문제에 매우 유용합니다.

BFS를 사용하는 이유

최단거리를 보장하는 이유입니다.

• 거리 1인 모든 지점을 먼저 탐색
• 거리 2인 모든 지점을 그 다음에 탐색
• 거리 3인 모든 지점을 그 다음에 탐색 ...

이런 식으로 진행하기 때문에 처음으로 목표지점에 도달한 순간이 바로 최단거리입니다!

BFS vs DFS 비교

실전 예제: 게임 맵 최단거리

해당 문제는 프로그래머스에서 검색하여 푸시면 됩니다. 먼저 풀고 나서 보시는걸 추천 드립니다!

1. 핵심 구성 요소

- Queue(큐)

Queue<(int x, int y, int distance)> queue = new Queue<(int, int, int)>();

• Enqueue: 뒤에 추가 (줄 서기)
• Dequeue: 앞에서 제거 (줄에서 빠지기)
• FIFO(First In First Out) 방식으로 동작

- Visited 배열

bool [,] visited = new bool[행, 열];

• 이미 방문한 곳을 다시 방문하지 않도록 체크
• 무한루프 방지의 핵심!

- 방향 배열

int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};

• 상하좌우 4방향 이동을 간단하게 처리

2. 완성된 코드

using System;
using System.Collections.Generic;

class Solution {
    public int solution(int[,] maps) {
        int n = maps.GetLength(0);  // 행의 개수
        int m = maps.GetLength(1);  // 열의 개수

        // 방문 체크 배열
        bool[,] visited = new bool[n, m];

        // BFS를 위한 큐: (행, 열, 거리)
        Queue<(int, int, int)> queue = new Queue<(int, int, int)>();

        // 상하좌우 이동을 위한 방향 배열
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // 시작점 초기화
        queue.Enqueue((0, 0, 1));
        visited[0, 0] = true;

        while (queue.Count > 0) {
            var (x, y, dist) = queue.Dequeue();

            // 목표지점 도달 체크
            if (x == n-1 && y == m-1) {
                return dist;
            }

            // 4방향 탐색
            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];

                // 이동 가능 조건 체크
                if (nx >= 0 && nx < n && ny >= 0 && ny < m
                   && maps[nx, ny] == 1
                   && !visited[nx, ny]) {

                    queue.Enqueue((nx, ny, dist + 1));
                    visited[nx, ny] = true;
                }
            }
        }

        return -1;  // 도달 불가능
    }
}

BFS 활용 분야

1. 최단거리 문제

• 미로 찾기
• 게임 맵 탐색
• 네트워크 최단 경로

  2. 레벨별 탐색

• 트리의 레벨 순회
• 그래프의 깊이별 탐색

  3. 연결성 문제

• 섬의 개수 구하기
• 연결 요소 찾기

마무리

BFS는 최단거리가 보장되는 강력한 알고리즘입니다. 핵심은:

1. Queue를 이용한 순차적 탐색
2. 동심원 형태로 퍼져나가는 탐색
3. Visited 배열을 통한 중복 방지

이 세가지만 확실히 이해하면 다양한 최단거리 문제를 해결할 수 있습니다!

유니티를 개발하다 보면 배열이나 리스트를 다루는 일이 많죠? GameObject들을 찾고, 필터링하고, 정렬하고... 이런 작업들을 반복문으로 하다 보면 코드가 길어지고 복잡해집니다.

그런데 LINQ를 알고 나면 이런 작업들이 놀라울 정도로 간단해져요! 오늘은 유니티 개발자 관점에서 LINQ를 어떻게 활용할 수 있는지 알아보겠습니다.

LINQ란?

Language Intergrated Query의 약자로 C#에서 컬렉션 데이터를 쉽게 다룰 수 있게 해주는 기능입니다. SQL처럼 데이터를 쿼리할 수 있어서 코드가 훨씬 직관적이고 간결해져요.

using System.Linq; // 추가!!

기본 활용법

기존 방식과 LINQ를 비교하며 공부해봅시다.

1. Select - 데이터 변환

// Enemy 리스트에서 이름만 가져와 리스트로 만들기

// 기존 방식
List<string> enemyNames = new List<string>();
foreach (GameObject enemy in enemies)
{
    enemyNames.Add(enemy.name);
}

// LINQ 방식
var enemyNames = enemies.Select(enemy => enemy.name).ToList();

2. Where - 조건 필터링

// 활성화된 적들만 찾기

// 기존 방식
List<GameObject> activeEnemies = new List<GameObject>();
foreach(GameObject enemy in allEnemies)
{
    if(enemy.activeInHierarchy)
    {
        activeEnemies.Add(enemy);
    }
}

// LINQ 방식
var activeEnemies = allEnemies.Where(enemy => enemy.activeInHierarchy).ToList();

// 특정 거리 내의 적들 찾기 (LINQ 방식)
var nearbyEnemies = enemies.Where(enemy =>
    Vector3.Distance(transform.position, enemy.transform.position) < 10f
).ToList()

3. OrderBy - 정렬

// 거리순으로 정렬
// 내림차순 정렬은 `OrderByDescending`
var sortedEnemies = enemies.OrderBy(enemy =>
    Vector3.Distance(transform.position, enemy.transform.position)
).ToList();

// 가장 가까운 적 찾기
// 1. Distance 사용
var closestEnemy = enemies.OrderBy(enemy =>
    Vector3.distance(transform.position, enemy.transform.position)
).FirstOrDefault();

// 2. sqrMagnitude 사용 (제곱근 계산 생략으로 성능 향상)
var closestEnemy = enemies.OrderBy(enemy =>
    (transform.position - enemy.transform.position).sqrMagnitude
).FirstOrDefault();

실전 유니티 활용 예시

1. GameObject 관리

// 모든 적 오브젝트 중 활성화되고 HP가 50 이상인 것들
var dangerousEnemies = GameObject.FindGameObjectsWithTag("Enemy")
    .Where(enemy => enemy.activeInHierarchy)
    .Where(enemy => enemy.GetComponent<EnemyHealth>().currentHP >= 50)
    .OrderByDescending(enemy => enemy.Getcomponent<EnemyHealth>().currentHP)
    .ToList();

// 모든UI 버튼을 한 번에 비활성화
GetComponentsInChildren<Button>()
    .ToList()
    .ForEach(btn => btn.interactable = false);

2. 인벤토리 시스템

// 아이템 타입별 개수 세기
var itemCounts = inventory
    .Where(item => item.itemType)
    .GroupBy(item => item.itemType)
    .ToDictionary(g => g.Key, g => g.Count());

// 판매 가능한 아이템들의 총 가치
var totalSellValue = inventory
    .Where(item => item.canSell)
    .Sum(item => item.sellPrice);

// 무기만 필터링해서 공격력 순으로 정렬
var sortedWeapons = inventory
    .Where(item => item.itemType == ItemType.Weapon)
    .OrderByDescending(Weapon => weapon.attackPower)
    .ToList();

3. 점수 시스템

// 리더보드 생성 (상위 10명)
var leaderboard = playerScores
    .OrderByDescending(score => score.points)
    .Take(10)
    .Select((score, index) => new {
        Rank = index + 1,
        Name = score.playerName,
        Points = score.points
    })
    .ToList();

// 평균 점수보다 높은 플레이어들
var averageScore = playerScores.Average(score => score.points);
var aboveAverageUsers = playerScores
    .Where(score => score.points > averageScore)
    .ToList();

4. 레벨 관리

// 언락된 레벨들만 난이도순으로
var availableLevels = allLevels
    .Where(level => level.isUnlocked)
    .OrderBy(level => level.difficulty)
    .ToList();

// 클리어하지 못한 레벨 중 가장 쉬운 것
var nextLevel = allLevels
    .Where(level => level.isUnlocked && !level.isCompleted)
    .OrderBy(level => level.difficulty)
    .FirstOrDefault();

고급 활용법

1. 체이닝으로 복잡한 작업 한 번에

// 활성화된 적들 중에서 플레이어 근처에 있고,
// HP가 낮은 순으로 정렬해서 상위 3마리만 가져오기
var targetEnemies = GameObject.FindGameObjectsWithTag("Enemy")
    .Where(enemy => enemy.activeInHierarchy)
    .Where(enemy => Vector3.Distance(player.position, enemy.transform.position) < 15f
    .Select(enemy => enemy.GetComponent<Enemy>())
    .Where(enemy => enemy != null)
    .OrderBy(enemy => enemy.currentHP)
    .Take(3)
    .ToList();

2. GroupBy로 데이터 분석

// 적들을 타입별로 그룹화
var enemyGroups = enemies
    .GroupBy(enemy => enemy.GetComponent<Enemy>().enemyType)
    .ToDictionary(g = g.Key, g => g.ToList());

// 아이템을 등급별로 개수 세기
var itemsByRarity = inventory
    .Where(item => item != null)
    .GroupBy(item => item.rarity)
    .Select(g => new {
        Rarity = g.Key,
        Count = g.Count(),
        TotalValue = g.Sum(item => item.value)
    })
    .ToList();

성능 고려사항

1. 좋은 사용법

// 게임 시작 시나 필요할 때만
void Start() {
    enemies = GameObject.FindGameObjectsWithTag("Enemy")
        .Where(e => e.activeInHierarchy)
        .ToList();
}


// 이벤트 발생 시
void OnEnemyDeath() {
    var remainingEnemies = enemies.Where(e => e != null).ToList();
}

2. 피해야 할 사용법

// Update에서 매 프레임마다 - 성능 저하!
void Update() {
    var nearbyEnemies = FindObjectsOfType<Enemy>()
        .Where(e => Vector3.Distance(transform.position, e.transform.position) < 10f)
        .ToList();
}

3. 성능 최적화 팁

1. 캐싱 활용 : 자주 사용하는 컬렉션은 미리 저장해두세요
2. ToList() 적절히 사용 : 지연 실행을 이해하고 필요할 때만 즉시 실행!
3. FindObjectsOfType 주의 : 비용이 크니 LINQ와 함께 사용할 때 특히 조심!

   // 캐싱 예시
   private List<Enemy> cachedEnemies;
   

void Start() { RefreshEnemyCache(); }

void RefreshEnemyCache() { cachedEnemies = FindObjectsOfType().ToList(); }

void UpdateEnemyLogic() { var activeEnemies = cachedEnemies .Where(enemy => enemy != null && enemy.gameObject.activeInHierarchy) .ToList(); }

---

### 그 외
게임 개발뿐만 아니라 다른 부분에서도 LINQ는 정말 강력합니다.
```csharp
// 배열에서 중복 제거
var unique = numbers.Distinct().ToArray();

// 두 배열의 교집합
var common = arr1.Intersect(arr2).ToArray();

// 문자열에서 각 문자의 빈도수
var frequency = text.GroupBy(c => c)
    .ToDictionary(g => g.Key, g => g.Count());

// k번째로 큰 수
var kthLargest = numbers.OrderByDescending(x => x)
    .Distinct()
    .Skip(k - 1)
    .First();

끝으로

LINQ를 익혀두면 유니티 개발이 정말 편해집니다. 복잡한 반복문 대신 한 줄로 해결되는 경우가 많아서 코드도 깔끔해지고 버그도 줄어들어요! 처음에는 낯설 수 있지만, 몇 번 써보면 없어서는 안 될 도구가 될 거예요. 특히 데이터 처리나 GameObject 관리할 때 정말 유용하니까 꼭 익혀두시길 추천합니다!

AsyncOperation란?

• 유니티에서 비동기 작업을 처리하는 클래스
• 시간이 오래 걸리는 작업(씬 로딩, 에셋 로딩 등)을 백그라운드에서 처리
• 메인 스레드를 막지 않고 진행상황을 추적할 수 있음

주요 속성들

AsyncOperation asyncLoad = SceneManager.LadSceneAsync("MainScene");

// 진행률 (0.0 ~ 1.0, 단 씬 로딩은 0.9까지만)
float progress = asyncLoad.progress;

// 작업 완료 여부
bool isFinished = asyncLoad.isDone;

// 씬 자동 활성화 여부
asyncLoad.allowSceneActivation = false;

// 우선순위 설정 (높을수록 빠름)
asyncLoad.priority = ThreadPriority.High;

다른 유용한 함수들

1. 에셋 비동기 로딩:

ResourceRequest request = Resources.LoadAsync<GameObject>("PlayerPrefab");
while (!request.isDone)
{
    Debug.Log($"에셋 로딩: {request.progress * 100}%");
    yield return null;
}
GameObject player = request.asset as GameObject;

2. 씬 언로드:

AsyncOperation unloadOp = SceneManager.UnloadSceneAsync("OldScene");

3. 에셋번들 로딩:

AssetBundleCreateRequest bundleRequest = AssetBundle.LoadFromFileAsync(path);

실제 활용 예시

IEnumerator LoadWithControl()
{
    AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("MainScene");
    asyncLoad.allowSceneActivation = false; // 수동 제어

    while (asyncLoad.progress < 0.9f) // 0.9까지만 로딩
    {
        loadingText.text = $"로딩: {asyncLoad.progress * 100:F0}%";
        yield return null;
    }

    loadingText.text = "완료! 클릭하세요";

    // 사용자 입력 대기
    while (!Input.GetMouseButtonDown(0))
        yield return null;

    asyncLoad.allowSceneActivation = true; // 씬 활성화
}

이 클래스는 비동기 작업의 상태를 추적하고 제어하는 핵심 클래스입니다!

1. 신호기 시스템
2. SemaphoreSystem
3. 이펙트 추가
4. 중간 결과
5. 신호기 미션 완료
6. 최종 결과
7. 오늘의 배운 점
8. 다음 계획

📡 신호기 시스템

제작하고 있는 게임 SignalHome은 외계에 고립된 플레이어가 신호기를 발동시켜 지구에 도움을 요청하고, 탈출하는 게임 입니다. 그렇다면 맵에 신호기가 존재하고, 플레이어는 그것을 찾아 발동시켜야겠죠? 스토리 흐름은 다음과 같습니다.

1. 신호기 존재 사실의 발견

불탄 연구실과 홀로 생존한 플레이어. 곧 외계에서 지구로 돌아가야 하지만, 신호기가 박살난 상태. 신호기에 응축되어있던 에너지는 모두 빠져나갔으며, 여분도 없어져버렸다. 고민하던 찰나 연구실에서 신호기의 존재에 대한 pdf를 발견한다.

2. 외계 신호기

이곳에서 처음 발견한 외계 문서에는 이 행성에 엄청난 에너지를 품고 있는 곳이 5곳이 있다고 한다. 우리는 외계 문서에 따라 그것을 '신호기'라고 부른다. 흡사 재단같이 생겼으며, 에너지가 농축된 특정 외계 보석을 넣으면 신호기가 발동된다.

3. 신호기 위치

신호기 위치에 대한 설명은 단 한 곳밖에 존재하지 않는다. 신호기에 보석을 넣으면 다음 신호기의 위치가 드러난다. 보석을 돌린 순간, 외계 에너지가 급증하는 곳을 찾아가면 된다.

4. 에너지 보석 위치

해당 신호기 주변에 여러개 존재한다.

5. 발동 전과 발동 후

📄 SemaphoreSystem

이제 스토리에서 중요한 신호기 스크립트를 짜봅시다. SemaphoreSytstem 스크립트를 생성합니다.

1. 현재 번호 저장

신호기는 순번대로 진행됩니다. 그러니 현재 게임 진행상태에 어디까지의 신호기까지 진행했는지 저장해야만 합니다.

// GameState.cs

// 첫번째 신호기는 이미 열려있음
public static int currentSemaphoreNumber = 0;

2. 활성화 코드

미리 맵에 신호기 다섯개를 배치합니다. 그리고 GameManager의 Inspector에 넣습니다.

// GameManager.cs

[Header("Semaphore")]
public SemaphoreSystem[] semaphores;

private void Start()
{
    for (int i = 0; i < GameState.currentSemaphoreNumber + 1; i++)
    {
        SetActiveSemaphore(i);
    }
}

public void SetActiveSemaphore(int num)
{
    if (num < 0 || num >= semaphores.Length) return;
    semaphores[num].gameObject.SetActive(true);
    if (num < GameState.currentSemaphoreNumber)
    {
        semaphores[num].isUnlocked = true;
    }
}

3. 신호기 기본 코드

// SemaphoreSystem.cs

[Header("Semaphore Settings")]
public int number;
public Transform keyCrystalPoint;
public GameObject keyCrystalPrefab;

private bool isUnlocked = false;

private void Start()
{
    if (isUnlocked)
    {
        SpawnKeyCrystal();
    }
}

private void SpawnKeyCrystal()
{
    if (keyCrystalPrefab && keyCrystalPoint)
    {
        GameObject keyCrystal = Instantiate(keyCrystalPrefab, keyCrystalPoint.position, keyCrystalPoint.rotation);
        keyCrystal.transform.SetParent(keyCrystalPoint);
        keyCrystal.transform.localPosition = Vector3.zero;
        keyCrystal.transform.localRotation = Quaternion.identity;
    }
}

4. 키 상호작용

F를 누르면 KeyCrystal이 삽입되게 합시다.

// InteractionDetector.cs

private void CheckInteraction()
{
    // 기존 코드...
    else if (hit.collider.CompareTag("Semaphore"))
    {
        AddCrystalKey(hit.collider.gameObject);
    }
}

private void AddCrystalKey(GameObject hitObject)
{
    if (playerItemHandler.currentItem)
    {
        if (playerItemHandler.currentItem.itemData.itemID == 31)
        {
            SemaphoreSystem semaphore = hitObject.GetComponent<SemaphoreSystem>();
            if (semaphore)
            {
                semaphore.SpawnKeyCrystal();
                GameState.currentSemaphoreNumber++;
                gameManager.SetActiveSemaphore(GameState.currentSemaphoreNumber);
                inventory.RemoveItemFromInstance(playerItemHandler.currentItem);
            }
        }
    }
}

✨ 이펙트 추가

보석을 넣은 후 2초 후, 이펙트가 활성화되게 해봅시다. 먼저 넣고 싶은 이펙트를 보석이 아닌 신호기에 붙여주세요!

// SemaphoreSystem.cs

[Header("Particle Settings")]
public ParticleSystem particleSystem1;
public ParticleSystem particleSystem2;

private void Start()
{
    if (!isUnlocked)
    {
        particleSystem1.Stop();
        particleSystem2.Stop();
    }
    else
    {
        SpawnKeyCrystal();
    }
}

public void SpawnKeyCrystal()
{
    if (keyCrystalPrefab && keyCrystalPoint)
    {
        // 기존 코드...

        Invoke("ShowPartical", 2f);   
    }
}

void ShowPartical()
{
    particleSystem1.Play();
    particleSystem2.Play();
}

🎮 중간 결과

첫 번째 신호기에 보석을 넣으면 2초 후에 이펙트가 일어납니다. 또한, 다음 신호기의 모습이 보이는 것 또한 확인할 수 있습니다.

📡 신호기 미션 완료

모든 신호기에 보석을 놓게 되면 차례대로 빛이 나오더니 위를 향해 빛줄기를 발사하게 됩니다. 해당 빛줄기 파티클을 직접 만들어볼까요? 일단 신호기 프리팹으로 이동합니다. Hierarchy에서 우클릭 후 Effects -> Line 으로 라인 렌더를 생성해주세요.

1. Line Renderer

// SemaphoreSystem.cs

[Header("Line Setting")]
public LineRenderer lineRenderer;

private void Awake()
{
    lineRenderer.useWorldSpace = false;
    lineRenderer.positionCount = 2;
    lineRenderer.SetPosition(0, Vector3.zero);      // 오브젝트 중심
    lineRenderer.SetPosition(1, Vector3.up * 50f);  // 위로 50m
}

2. 머티리얼 적용

Project에서 Create -> Material 를 생성합니다.

• Shader : Standard
• Albedo : 배경색
• Emission 체크 후 Color : 그라데이션 시작할 색

설정을 한 후 SemaphoreSystem 스크립트에서 Awake에 lineRenderer.material = beamMaterial 이라고 타이핑 해주세요.

3. 신호기 빔 발사 시점

모든 신호기가 가동되면 동시에 빔이 쏘아올려집니다. 그렇다면 게임 상태에서 현재 신호기가 모두 발동됐다는 신호를 보내야겠죠?

// GameState.cs

public static bool IsOperate = false;

// GameManager.cs

public void SetOperateSemaphore()
{
    if (!GameState.IsOperate) return;
    foreach (SemaphoreSystem semaphore in semaphores)
    {
        semaphore.lineRenderer.enabled = true;
    }
}

// SemaphoreSystem.cs

void ShowPartical()
{
    particleSystem1.Play();
    particleSystem2.Play();

    // 마지막 신호기에 보석을 넣었을때만 실행됨
    if (number >= 4)
    {
        GameState.IsOperate = true;
        gameManager.SetOperateSemaphore();
    }
}

🎮 최종 결과

이제 파티클이 생성된 후, 모든 신호기에서 빔이 나오는 것을 확인할 수 있습니다.

📚 오늘의 배운 점

• 파티클 제작
• 머티리얼 제작

🎯 다음 계획

다음 글에서는:

1. 세이브 & 로드
2. 빌드 후 실행파일 테스트

1. 공속 모듈
2. 중간 결과
3. 체력 자동 회복 모듈
4. 투명화 모듈
5. 최종 결과
6. 오늘의 배운 점
7. 다음 계획

⚔️ 공속 모듈

1. 함수 셋팅

공속을 올리려면 ItemData에서 attackSpeed를 들고 와야겠죠? 쿨타임일 경우에는 시행하지 않는단 코드를 일단 짜봅니다.

 // ItemData.cs

 public float GetAttackSpeed(float amount)
{
    if (itemType != ItemType.Weapon) return 0f;
    return attackSpeed * amount;
}

// UseItem.cs

private float attackCooldown = 0f;
private bool useWeapon = false;

private void Update()
{
    if (playerItemHandler.currentItem)
    {
        ReloadCharge(playerItemHandler.currentItem);
        if (useWeapon)
        {
            WeaponAttackCooldown();
        }   
    }
    // 기존 코드...
}

private void UseKnife(float damage)
{
    useWeapon = true;
    if (attackCooldown > 0f)
    {
        Debug.Log("쿰타임이 돌아오지 않았습니다!");
    }
    // 기존 코드...
}

private void WeaponAttackCooldown()
{
    if (playerItemHandler.currentItem.itemData.itemType == ItemType.Weapon)
    {
        if (attackCooldown <= playerItemHandler.currentItem.itemData.attackSpeed)
        {
            attackCooldown += Time.deltaTime;
        }
        else
        {
            Debug.Log("쿨타임이 돌아왔습니다!");
            attackCooldown = 0f;
            useWeapon = false;
        }
    }
}

2. 공속 변경

만약 공속 증가 모듈이 있을 경우, 공속이 빨라지게 합니다.

// PlayerItemHandler.cs

public void UseItem()
{
    if (!currentItem) return;

    if (useItem)
    {
        if (currentItem.itemData.itemType == ItemType.Weapon)
        {
            SetMaxAttackCooldown(useItem);
        }
        useItem.UseItems(currentItem);
    }
}

private void SetMaxAttackCooldown()
{
    ItemInstance armor = playerState.equipmentItems[1];
    if (armor)
    {
        ItemInstance attackSpeedModule = armor.Get<ItemInstance[]>("armorModules")[2];
        if (attackSpeedModule)
        {
            ArmorSkill armorSkill = attackSpeedModule.GetComponent<ArmorSkill>();
            useItem.maxAttackCooldown = currentItem.itemData.attackSpeed * (1 - armorSkill.attackSpeed);
        }
        else
        {
            useItem.maxAttackCooldown = currentItem.itemData.attackSpeed;
        }
    }
}

// UseItem.cs

[HideInInspector] public float maxAttackCooldown;
private bool useWeapon = false;

// 쿨타임 변수를 maxAttackCooldown으로 변경
private void WeaponAttackCooldown()
{
    if (playerItemHandler.currentItem.itemData.itemType == ItemType.Weapon)
    {
        if (attackCooldown <= maxAttackCooldown)
        {
            attackCooldown += Time.deltaTime;
        }
        else
        {
            Debug.Log("쿨타임이 돌아왔습니다!");
            attackCooldown = 0f;
            useWeapon = false;
        }
    }
}

3. 리셋

방어구를 중간에 벗게 되면 공속 또한 원래대로 돌아와야 합니다.

// PlayerItemHandler.cs

public void ResetWeapon()
{
    useItem.maxAttackCooldown = currentItem.itemData.attackSpeed;
}

// PlayerState.cs

public void ResetModuleEffect()
{
    if (isInHotZone)
    {
        ExitFromHotZone();
        EnterInHotZone();
    }
    playerController.SetMoveSpeed(5f); 
    if (playerItemHandler.currentItem)
    {
        if (playerItemHandler.currentItem.itemData.itemType == ItemType.Weapon)
        {
            playerItemHandler.ResetWeapon();
        }
    }
}

🎮 중간 결과

1. 이속 모듈 적용
2. 공속 모듈 적용
3. 모듈이 없는 상태

❤️ 체력 자동 회복 모듈

체력이 일정 피 이하가 되면 자동으로 차게끔 하는 모듈을 구현해보겠습니다.

1. 체력 감지

PlayerState에서 체력을 처리하는 함수에 현재 체력이 얼마인지 검사하는 로직을 짜면 되겠죠?

// PlayerState.cs

private bool isAutoHeal;

public void ModifyHealth(float amount)
{
    // 기존 로직...
    isAutoHeal = SetIsAutoHeal();
    // 기존 로직...
}

private bool SetIsAutoHeal()
{
    if (!equipmentItems[1]) return false;

    ItemInstance skillModule = equipmentItems[1].Get<ItemInstance[]>("armorModules")[2];
    if (!skillModule) return false;

    ArmorSkill armorSkill = skillModule.GetComponent<ArmorSkill>();
    if (ArmorSkillType.AutoHeal != armorSkill.skillType) return false;

    // 마지막에 한 번 더 AutoHeal하는 것을 막기 위해 현재 체력 + 힐량과 비교함
    return stats.health + autoHealAmount < GameConstants.MAX_HEALTH * armorSkill.healthRatio;
}

2. 체력 회복

// PlayerState.cs

private float autoHealAmount = 0f;
private float autoHealTime = 5f;

private void Update()
{
    if (isAutoHeal)
    {
        autoHealTime -= Time.deltaTime;
        if (autoHealTime <= 0f)
        {
            autoHealTime = 5f;
            ModifyHealth(autoHealAmount);
        }
    }
}

public void ResetModuleEffect()
{
    // 기존 로직...
    isAutoHeal = false;
    autoHealTime = 5f;
}

private void SetSkillModule(ItemInstance item)
{
    // 기존 로직...
    isAutoHeal = SetIsAutoHeal();
}

👻 투명화 모듈

투명화는 패시브가 아니라 액티브 스킬로 Q를 누르면 스킬을 쓸 수 있게 할겁니다. 투명화는 지속시간이 있고, 쿨타임도 존재합니다.

1. Q키 누를때 활성화

// ArmorSkill.cs

[Header("Skill Properties")]
public float skillCooldown;
public float skillDuration; 

[HideInInspector] public float skillCooldownTimer;
[HideInInspector] public float skillDurationTimer;
[HideInInspector] public bool isSkill = false;
[HideInInspector] public bool isCooldown = false;

private PlayerController cachedController;

public void SetSkill(PlayerController playerController)
{
    if (isCooldown) return;

    if (!cachedController)
    {
        cachedController = playerController;
    }
    isSkill = true;
    switch(skillType)
    {
        // 기존 로직...
        case ArmorSkillType.Invisibility:
            ApplyInvisibility();
            break;
        // 기존 로직...
    }
}

public void ResetSkill()
{
    if (!cachedController) return;
    switch (skillType)
    {
        case ArmorSkillType.SpeedBoost:
            cachedController.SetMoveSpeed(5f);
            break;
        case ArmorSkillType.Invisibility:
            cachedController.SetPlayerInvisibility(false);
            break;
        default:
            break;
    }
}

private void ApplyInvisibility()
{
    cachedController.SetPlayerInvisibility(true);
}

// PlayerController.cs

void Update()
{
    // 기존 로직...
    if (!GameState.IsUIOpen)
    {
        HandleModuleSkill();
    }
    SkillTimerController();
}

void SkillTimerController()
{
    if (!currentSkill) return;
    if (currentSkill.isSkill)
    {
        currentSkill.skillDurationTimer -= Time.deltaTime;
        if (currentSkill.skillDurationTimer <= 0)
        {
            currentSkill.isSkill = false;
            currentSkill.isCooldown = true;
            currentSkill.ResetSkill();
            currentSkill.skillDurationTimer = currentSkill.skillDuration;
        }
    }

    if (currentSkill.isCooldown)
    {
        currentSkill.skillCooldownTimer -= Time.deltaTime;
        if (currentSkill.skillCooldownTimer <= 0)
        {
            currentSkill.isCooldown = false;
            currentSkill.skillCooldownTimer = currentSkill.skillCooldown;
        }
    }
}

void HandleModuleSkill()
{
    if (!playerState.equipmentItems[1]) return;
    ItemInstance moduleManager = playerState.equipmentItems[1];
    ItemInstance skillModule = moduleManager.Get<ItemInstance[]>("armorModules")[2];
    ArmorSkill skill = skillModule.GetComponent<ArmorSkill>();

    if (Input.GetKeyDown(KeyCode.Q))
    {
        skill.SetSkill(this);
        currentSkill = skill;
        skill.isSkill = true;
    }
}

public void SetPlayerInvisibility(bool invisible)
{
    playerRenderer.enabled = !invisible;
}

2. 제작 후 초기화

비활성화일땐 Start함수가 실행되지 않습니다. 하지만 제작대에서 생성하게 되면 비활성화로 들어오죠. 그러기 위해 초기화를 합시다.

// ArmorSkill.cs

public void Initialize()
{
    if (skillCooldownTimer == 0f) skillCooldownTimer = skillCooldown;
    if (skillDurationTimer == 0f) skillDurationTimer = skillDuration;
}

public void SetSkill(PlayerController playerController)
{
    Initialize();
    // 기존 로직...
}

🎮 최종 결과

체력 자동 회복, 투명화 모두 되는 모습입니다. 체력 회복은 현재 모듈 설정을 0.8로 했기 때문에 체력이 80%이상이라면 더이상 회복하지 않습니다.

📚 오늘의 배운 점

• Mesh 비활성화로 투명화

🎯 다음 계획

다음 글에서는:

1. 신호기 시스템 구현

1. 대미지 감소 모듈
2. 중간 결과 1
3. 환경 적응 모듈
4. UI에 적용
5. 모듈 적용
6. 중간 결과 2
7. 스킬 모듈
8. 최종 결과
9. 오늘의 배운 점
10. 다음 계획

🔑 대미지 감소 모듈

방어구의 기본 효과, 대미지 감소 효과를 구현하겠습니다. ModuleEffect 스크립트를 생성합니다.

1. 대미지 감소 로직

// ModuleEffect.cs

using UnityEngine;

public class ModuleEffect : MonoBehaviour
{
    public ArmorModuleType moduleType;

    [ShowIf("moduleType", ArmorModuleType.Defense)]
    public float defensePower;

    [ShowIf("moduleType", ArmorModuleType.Resistance)]
    public EnvironmentType environmentType;

    [ShowIf("moduleType", ArmorModuleType.Skill)]
    public ArmorSkillType skillType;

    private void Start()
    {

    }

    public void ApplyArmorModule()
    {

    }
    public float ApplyDefenseEffect(float damage)
    {
        float reducedDamage = damage * (1 - defensePower);
        Debug.Log(defensePower * 100 + "%의 대미지를 감소시켜 " + reducedDamage + "의 대미지를 입었습니다.");
        return reducedDamage;
    }
}

2. 체력 감소 로직에 적용

// PlayerState.cs

public void ModifyHealth(float amout)
{
    if (isGameOver) return;

    if (amount < 0f && equipmentItems[1] != null)
    {
        ItemInstance defenseModule = equipmentItems[1].Get<ItemInstance[]>("armorModules")[0];
        if (defenseModule)
        {
            ModuleEffect moduleEffect = defenseModule.GetComponent<ModuleEffect>();
            if (moduleEffect)
            {
                amount = moduleEffect.ApplyDefenseEffect(amount);
            }
        }
    }

    // 기존 로직...
}

🎮 중간 결과 1

기존 10 대미지였던 것이 방어구 모듈 효과를 얻어 5만 감소하는 것을 볼 수 있습니다.

🔑 환경 적응 모듈

이곳에는 다양한 환경이 있습니다. 물지형, 사막지형, 눈지형 등이 있죠. 각각 산소, 더움, 추움을 넣으면 좋겠죠? 먼저 플레이어가 해당 지형에 있다면 각 스텟이 감소하는 로직을 짜보겠습니다.

1. UI 생성

일단은 산소와 더움만 추가해보겠습니다. HUD_Panel에 HotBar와 BreathingBar를 넣어주세요. 다른 Bar와 같이 Image Type을 Filled로 하여 게이지를 표현합니다.

2. 플레이어의 현재 장소 인식

더움은 더운 지역에 있을 때 증가하고, 산소는 물 안에 들어가 있을 때 감소해야만 합니다. 그러니 플레이어가 현재 있는 장소에 대해 알 수 있어야겠죠? 현재 Zone중에 Desert가 있으니 더움은 해당 지역에 있을 때 증가하는 것으로 합시다. 일단 Desert 오브젝트에 그 지역의 범위만큼 Collision을 넣습니다. 그리고 IsTrigger를 체크해주세요.

그리고 아래 코드를 작성하여 Zone안에 들어갔을시 로그가 뜨면 감지 성공입니다.

// ZoneController.cs

private void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        switch(environmentType)
        {
            case EnvironmentType.Desert:
                Debug.Log("Player가 Desert Zone에 들어왔습니다.");
                break;
            default:
                break;
        }
    }
}

3. 게이지 증감

들어가면 Hot이 증가하고, 나가면 서서히 감소하는 로직을 구성해야만 합니다.

// ZoneController.cs

private void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        PlayerState playerState = other.GetComponent<PlayerState>();
        switch(environmentType)
        {
            case EnvironmentType.Desert:
                playerState.EnterInHotZone();
                Debug.Log("Player가 Desert Zone에 들어왔습니다.");
                break;
            default:
                break;
        }
    }
}

private void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Player"))
    {
        PlayerState playerState = other.GetComponent<PlayerState>();
        switch (environmentType)
        {
            case EnvironmentType.Desert:
                playerState.ExitFromHotZone();
                Debug.Log("Player가 Desert Zone을 나갔습니다.");
                break;
            default:
                break;
        }
    }
}

// PlayerState.cs

// PlayerState의 생성자도 변경해줍시다!
public static class GameConstants
{
    public const float MAX_HEALTH = 100f;
    public const float MAX_SATIETY = 100f;
    public const float MAX_HYDRATION = 100f;
    public const float MAX_HOT_GAUGE = 100f;
    public const float MAX_BREATHING_GAUGE = 100f;
}

public class PlayerState : MonoBeHaviour
{
    private float hotGaugeTime = 1f;
    private float breathingGaugeTime = 1f;

    private void Update()
    {
        Debug.Log($"Hot:{stats.hotGauge}, Breathing:{stats.breathingGauge}");
    }
    public void EnterInHotZone()
    {
        CancelInvoke("DecreaseHotGaugeByTime"); 
        InvokeRepeating("IncreaseHotGaugeByTime", hotGaugeTime, hotGaugeTime); 
    }

    public void ExitFromHotZone()
    {
        CancelInvoke("IncreaseHotGaugeByTime");
        CancelInvoke("DecreaseHealthByHotGauge");
        InvokeRepeating("DecreaseHotGaugeByTime", hotGaugeTime + 1f, hotGaugeTime + 1f); // 온도 게이지 감소 함수 호출
    }

    public void EnterInWaterZone()
    {
        CancelInvoke("IncreaseHotGaugeByTime");
        InvokeRepeating("DecreaseBreathingGaugeByTime", breathingGaugeTime, breathingGaugeTime); // 호흡 게이지 감소 함수 호출
    }

    public void ExitFromWaterZone()
    {
        CancelInvoke("DecreaseBreathingGaugeByTime");
        CancelInvoke("DecreaseHealthByBreathingGauge");
        InvokeRepeating("IncreaseBreathingGaugeByTime", breathingGaugeTime + 1f, breathingGaugeTime + 1f); // 호흡 게이지 증가 함수 호출
    }

    // 온도 게이지 증가 함수
    private void IncreaseHotGaugeByTime()
    {
        ModifyHotGauge(1f);
        if (stats.hotGauge >= GameConstants.MAX_HOT_GAUGE)
        {
            InvokeRepeating("DecreaseHealthByHotGauge", 1f, 1f);
            CancelInvoke("IncreaseHotGaugeByTime");
        }
    }

    // 온도 게이지 감소 함수
    private void DecreaseHotGaugeByTime()
    {
        ModifyHotGauge(-1f);
        if (stats.hotGauge <= 0f)
        {
            CancelInvoke("DecreaseHealthByHotGauge");
            CancelInvoke("DecreaseHotGaugeByTime");
        }
    }

    // 호흡 게이지 증가 함수
    private void IncreaseBreathingGaugeByTime()
    {
        ModifyBreathingGauge(1f);
        if (stats.breathingGauge >= GameConstants.MAX_BREATHING_GAUGE)
        {
            CancelInvoke("DecreaseBreathingGaugeByTime");
            CancelInvoke("DecreaseHealthByBreathingGauge");
        }
    }

    // 호흡 게이지 감소 함수
    private void DecreaseBreathingGaugeByTime()
    {
        ModifyBreathingGauge(-1f);
        if (stats.breathingGauge <= 0f)
        {
            InvokeRepeating("DecreaseHealthByBreathingGauge", 1f, 1f);
            CancelInvoke("DecreaseBreathingGaugeByTime");
        }
    }

    // 온도 게이지 수정 함수
    public void ModifyHotGauge(float amount)
    {
        stats.hotGauge += amount;

        if (stats.hotGauge > GameConstants.MAX_HOT_GAUGE)
        {
            stats.hotGauge = GameConstants.MAX_HOT_GAUGE;
        }
        else if (stats.hotGauge < 0f)
        {
            stats.hotGauge = 0f;
        }

        OnStatsChanged?.Invoke(stats);
    }

    // 호흡 게이지 수정 함수
    public void ModifyBreathingGauge(float amount)
    {
        stats.breathingGauge += amount;

        if (stats.breathingGauge > GameConstants.MAX_BREATHING_GAUGE)
        {
            stats.breathingGauge = GameConstants.MAX_BREATHING_GAUGE;
        }

        else if (stats.breathingGauge < 0f)
        {
            stats.breathingGauge = 0f;
        }

        OnStatsChanged?.Invoke(stats);
    }
}

코드가 길어보이지만 로직 구조는 거의 같은 편입니다. 어차피 PlayerState는 Player의 현재상태 변화와 같은 코드만 넣을 것이기 때문에, 보기 쉽게 세분화하는 것이 좋습니다. 이제 ZoneController에서 Invoke실행과 종료를 하게끔 함수를 넣습니다.

// ZoneController.cs

private void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        PlayerState playerState = other.GetComponent<PlayerState>();
        switch(environmentType)
        {
            case EnvironmentType.Desert:
                playerState.EnterInHotZone();
                Debug.Log("Player가 Desert Zone에 들어왔습니다.");
                break;
            default:
                break;
        }
    }
}

private void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Player"))
    {
        PlayerState playerState = other.GetComponent<PlayerState>();
        switch (environmentType)
        {
            case EnvironmentType.Desert:
                playerState.ExitFromHotZone();
                Debug.Log("Player가 Desert Zone을 나갔습니다.");
                break;
            default:
                break;
        }
    }
}

4. 결과 확인

영역 안에 들어가면 Hot 게이지가 오르고, 나가면 올라가는 속도 보다 1초 느리게 감소합니다.

🎨 UI에 적용

이제 시각화 해봅시다! 본래 있던 함수에 넣기만 하면 끝입니다.

1. HUD Update

// UIManager.cs

[Header("Bar")]
public Image hotGaugeBar;
public Image breathingGaugeBar;

private void UpdateUI(PlayerStats stats)
{
    if (healthBar && satietyBar && hydrationBar)
    {
        healthBar.fillAmount = stats.health / GameConstants.MAX_HEALTH;
        satietyBar.fillAmount = stats.satiety / GameConstants.MAX_SATIETY;
        hydrationBar.fillAmount = stats.hydration / GameConstants.MAX_HYDRATION;
        hotGaugeBar.fillAmount = stats.hotGauge / GameConstants.MAX_HOT_GAUGE;
        breathingGaugeBar.fillAmount = stats.breathingGauge / GameConstants.MAX_BREATHING_GAUGE;
    }

    if (healthText && satietyText && hydrationText)
    {
        healthText.text = stats.health.ToString("F0");  
        satietyText.text = stats.satiety.ToString("F0");
        hydrationText.text = stats.hydration.ToString("F0");
    }
}

2. 결과 확인

Desert Zone안에 있으면 게이지가 오르고, 100이 된다면 체력도 줄어드는 모습입니다. (빠른 결과를 보여주기 위해 time을 0.1로 대폭 줄인 상태입니다)

🔑 모듈 적용

이제 모듈을 적용합시다! 더운 곳에 있을 경우, 해당 게이지가 천천히 오르게 하는 모듈입니다.

// ModuleEffect.cs

[ShowIf("moduleType", ArmorModuleType.Resistance)]
public EnvironmentType environmentType;
[ShowIf("moduleType", ArmorModuleType.Resistance)]
public float resistancePower;

public float ApplyResistanceEffect(float time)
{
    float reducedTime = time + time * resistancePower;
    Debug.Log($"time:{reducedTime}");
    return reducedTime;
}

// PlayerState.cs

[HideInInspector] public bool isInHotZone;

public void EnterInHotZone()
{
    CancelInvoke("DecreaseHotGaugeByTime");
    float resultTime = hotGaugeTime;
    if (equipmentItems[1] != null)
    {
        ItemInstance resistanceModule = equipmentItems[1].Get<ItemInstance[]>("armorModules")[1];
        if (resistanceModule)
        {
            ModuleEffect moduleEffect = resistanceModule.GetComponent<ModuleEffect>();
            if (moduleEffect && moduleEffect.environmentType == EnvironmentType.Desert)
            {
                resultTime = moduleEffect.ApplyResistanceEffect(resultTime);
            }
        }
    }
    isInHotZone = true;
    InvokeRepeating("IncreaseHotGaugeByTime", resultTime, resultTime); 
}

// ExitFromHotZone 함수에는 isInHotZone을 False로 바꿉시다

만약 구역 안에서 방어구를 벗거나 입었을때, 감소 시간의 수치가 그대로면 안되니 그때의 경우에도 로직을 넣어줍시다.

// EquipmentSlots.cs

private void RemoveItem(EquipmentType type)
{
    // 기존 로직...
    if (index == 1)
    {
        if (playerState.isInHotZone)
        {
            playerState.ExitFromHotZone();
            playerState.EnterInHotZone();
        }
    }
    // 기존 로직...
}

// UIManager.cs

private void UpdateEquipmentUI(EquipmentType type, ItemInstance item)
{
    switch(type)
    {
        // 기존 로직...
        case EquipmentType.Body:
            equipmentSlots[1].SetEquipmentSlot(item);
            if (playerState.isInHotZone)
            {
                playerState.ExitFromHotZone();    
                playerState.EnterInHotZone();
            }
            break;
        // 기존 로직...
}

🎮 중간 결과 2

기본 감소 시간은 0.5초로 했고, 각 방어구가 가진 power는 0.5와 1인 상태입니다. 그러니 0.5인 모듈은 0.75초마다 게이지가 오르고, 1인 모듈은 1초마다 게이지가 오르죠.

🔑 스킬 모듈

현재 스킬은 이속, 공속, 체력 자동 회복, 투명화가 있는데 여기선 이속만 구현하겠습니다. 이속은 간단합니다! PlayerController에 있는 moveSpeed만 조절하면 돼요.

1. 속도 변경

// PlayerController.cs

public void SetMoveSpeed(float speed)
{
    moveSpeed = speed;
}

// ArmorSkill.cs

public class ArmorSkill : MonoBehaviour
{
    public ArmorSkillType skillType;

    [ShowIf("skillType", ArmorSkillType.SpeedBoost)]
    public float speed;

    public void SetSkill(PlayerController playerController)
    {
        switch(skillType)
        {
            case ArmorSkillType.SpeedBoost:
                ApplySpeedBoost(playerController);
                break;
            case ArmorSkillType.Invisibility:
                ApplyInvisibility();
                break;
            default:
                Debug.LogWarning("No skill type set.");
                break;
        }
    }

    private void ApplySpeedBoost(PlayerController controller)
    {
        controller.SetMoveSpeed(speed);
    }

    private void ApplyInvisibility()
    {
        Debug.Log("투명화!");
    }
}

public enum ArmorSkillType
{
    None,
    SpeedBoost,
    Invisibility
}

2. 장착시 적용

스킬이 적용되면 플레이어의 현재 상태가 변경되어야하죠. 그것을 담당하는 PlayerState 스크립트를 수정합시다.

//PlayerState.cs

private void SetEquipmentItems(int index, ItemInstance item)
{
    if (equipmentItems[index])
    {
        inventory.AddItem(equipmentItems[index]);
        uiManager.UpdateItemUI();
    }
    equipmentItems[index] = item;

    SetSkillModule(item);
}

private void SetSkillModule(ItemInstance item)
{
    ItemInstance skillModule = item.Get<ItemInstance[]>("armorModules")[2];
    if (!skillModule) return;

    skillModule.GetComponent<ArmorSkill>().SetSkill(playerController);
}

// 방어구가 바뀔시 이전에 착용했던 모든 효과를 초기화
public void ResetModuleEffect()
{
    if (isInHotZone)
    {
        ExitFromHotZone();
        EnterInHotZone();
    }
    playerController.SetMoveSpeed(5f); 
}

🎮 최종 결과

대미지 감소, 열 저항력 증가, 이속 증가 모듈을 모두 장착한 장면입니다. 대미지 감소 모듈은 업그레이드가 가능한 형태로 해야겠습니다. 하나만 있으면 재미가 없으니까요! 일단 그건 나중에...

📚 오늘의 배운 점

• 받는 대미지 감소
• Trigger로 지역 나누기
• 이속 조정

🎯 다음 계획

다음 글에서는:

1. 방어구 스킬 구현
   • 공속 증가
   • 체력 자동 회복
   • 투명화

1. 모듈형 방어구
2. 모듈 적용
3. 최종 결과
4. 오늘의 배운 점
5. 다음 계획

🛡️ 모듈형 방어구

이 게임에서는 단순히 방어구를 입는 것이 아니라, 기존 방어구에서 모듈을 추가하는 형식으로 할겁니다. 슬롯이 3개인 방어구 모듈판이 있고, 각각 방어력, 환경 저항, 스킬로 구성되어 있습니다. 먼저 모듈 타입을 만들까요?

1. 모듈 아이템 생성

아래 코드를 작성하고, Defense, Resistance, Skill이란 Module 데이터를 만든 후, Prefab도 생성해주세요.

// ItemInstance.cs

void IntializeProperties()
{
    // 기존 코드...

    switch (itemdata.itemType)
    {
        case ItemType.Armor:
            properties["durability"] = 100f;
            properties["armorModules"] = new ItemInstance[3];
            break;
        default:
            break;
    }
}

// ItemData.cs

[ShowIf("itemType", ItemType.ArmorMoudle)]
public ArmorModuleType armorModuleType;

[ShowIf("armorModuleType", ArmorModuleType.Defense)]
public float defensePower;

[ShowIf("armorModuleType", ArmorModuleType.Resistance)]
public EnvironmentType environmentType;

[ShowIf("armorModuleType", ArmorModuleType.Skill)]
public ArmorSkill armorSkill;

public enum ArmorModuletype
{
    Defense,
    Resistance,
    Skill
}

2. UI생성

기존에 있던 슬롯 아무거나 하나를 복제해서, 모듈 교체시 나오는 UI를 제작합니다.

3. 슬롯 우클릭

인벤토리 슬롯안에서 갑옷을 우클릭하면 위에 Module UI가 나오게 할겁니다.

// InventorySlot.cs

public void OnPointerClick(PointerEventData eventData)
{
    if (!inventory.items[slotIndex]) return;

    if (eventData.button == PointerEventData.InputButton.Left && eventData.clickCount == 2)
    {
        uiManager.OnInventorySlotDoubleClick(slotIndex);
    }

    if (eventData.button == PointerEventData.InputButton.Right)
    {
        uiManager.OnInventorySlotRightClick(slotIndex);
    }
}

// UIManager.cs

// moduleSlotPanel은 InventoryPanel의 자식에 놓음
public GameObject moduleSlotPanel;
private ItemInstance currentArmor;

public void OnInventorySlotRightClick(int slotIndex)
{
    currentArmor = inventory.items[slotIndex];
    if (!currentArmor) return;

    ItemType type = currentArmor.itemData.itemType;
    if (type != ItemType.Armor) return;

    moduleSlotPanel.SetActive(true);

    ModuleSlot[] moduleSlots = moduleSlotPanel.GetComponentsInChildren<ModuleSlot>();
    ItemInstance[] armorModules = currentArmor.Get<ItemInstance[]>("armorModules");

    if (moduleSlots.Length <= 0 || armorModules.Length <= 0) return;
    for (int i = 0; i < moduleSlots.Length; i++)
    {
        moduleSlots[i].SetModuleSlots(armorModules[i], currentArmor);
    }
}

🔑 모듈 적용

이제 UI를 생성하는 것까진 됐죠? 그렇다면 ModuleSlot 스크립트를 생성해서 슬롯 프리팹에 적용하고 방어구에 모듈이 들어가게끔 해봅시다.

1. 현재 모듈 세팅

// ModuleSlot.cs

public void SetModuleSlots(ItemInstance module, ItemInstance armor)
{
    int index = -1;
    switch(moduleType)
    {
        case ArmorModuleType.Defense:
            index = 0;
            break;
        case ArmorModuleType.Resistance:
            index = 1;
            break;
        case ArmorModuleType.Skill:
            index = 2;
            break;
        default:
            return;
    }

    if (module)
    {
        itemIcon.sprite = module.itemData.icon;
        itemIcon.color = Color.white;
    }
    else
    {
        itemIcon.sprite = slotImage;
        itemIcon.color = new Color(1, 1, 1, 0.5f);
    }
}

인벤토리를 열어 갑옷을 우클릭하면 상단에 모듈창이 뜨는 모습입니다.

2. 모듈장착하기

인벤토리창에서 모듈을 더블클릭하면 해당 방어구의 모듈로 들어가고, 모듈창에서 더블클릭 한다면 인벤토리 창으로 해당 모듈이 들어가는 것을 구현하겠습니다.

// ArmorModuleManager.cs

// 현재 모듈이 바뀔때마다 부름
public static event System.Action<int, ItemInstance, ItemInstance> OnModuleChanged;

public void AddModule(Inventory inventory, ItemInstance module, ItemInstance armor)
{
    if (!inventory || !module) return;

    if (module.itemData.itemType != ItemType.ArmorMoudle) return;

    int index = -1;
    switch(module.itemData.armorModuleType)
    {
        case ArmorModuleType.Defense:
            index = 0;
            break;
        case ArmorModuleType.Resistance:
            index = 1;
            break;
        case ArmorModuleType.Skill:
            index = 2;
            break;
        default:
            return;
    }
    AddModuleInIndex(inventory, module, armor, index);
}

private void AddModuleInIndex(Inventory inventory, ItemInstance module, ItemInstance armor, int index)
{
    OnModuleChanged?.Invoke(index, module, armor);
    ItemInstance[] armorModules = armor.Get<ItemInstance[]>("armorModules");
    if (!armorModules[index])
    {
        armorModules[index] = module;
        inventory.RemoveItemFromInstance(module);
    }
    else
    {
        inventory.AddItem(armorModules[index]);
        armorModules[index] = module;
        inventory.RemoveItemFromInstance(module);
    }
}

// ModuleSlot.cs

void OnEnable()
{
    ArmorModuleManager.OnModuleChanged += OnModuleUpdated;
}

void OnDisable()
{
    ArmorModuleManager.OnModuleChanged -= OnModuleUpdated;
}

public void SetModuleSlots(ItemInstance module, ItemInstance armor)
{
    if (module)
    {
        itemIcon.sprite = module.itemData.icon;
        itemIcon.color = Color.white;
    }
    else
    {
        itemIcon.sprite = slotImage;
        itemIcon.color = new Color(1, 1, 1, 0.5f);
    }
}

3. 모듈해제하기

이번엔 모듈창에서 더블클릭하면 모듈이 해제되게 할겁니다. 먼저 currentArmor라는 변수를 생성하고 setModuleSlots함수에서 currentArmor = armor를 작성해주세요.

// ModuleSlot.cs

public void OnPointerClick(PointerEventData eventData)
{
    if (eventData.clickCount == 2)
    {
        RemoveItem(moduleType);
    }
}

private void RemoveItem(ArmorModuleType type)
{

    int index = -1;
    if (type == ArmorModuleType.Defense) index = 0;
    else if (type == ArmorModuleType.Resistance) index = 1;
    else if (type == ArmorModuleType.Skill) index = 2;
    else return;

    ItemInstance[] armorModules = currentArmor.Get<ItemInstance[]>("armorModules");
    if (!armorModules[index]) return;

    inventory.AddItem(armorModules[index]);
    armorModules[index] = null;

    currentArmor.Set("armorModules", armorModules);
    SetModuleSlots(null, currentArmor);

    uiManager.UpdateItemUI();
}

4. 그 외 예외처리

항상 그렇듯... 한 시스템을 만들면 엄청난 예외처리가 필요합니다. 그건 이곳에서 따로 코드를 보여드리진 않겠습니다. 대략적으로 말씀드리자면,

1. 인벤토리 창을 닫을 때 모듈 창이 꺼지게 함
2. 인벤토리의 다른 슬롯을 건들면 모듈 창이 꺼지게 함
3. 다른 방어구를 우클릭했을 경우, 해당 방어구의 모듈을 보여줌

등등이 있겠죠?

🎮 최종 결과

각 모듈이 탈부착 가능하며, 각각 방어구마다 다른 모듈을 보여주는 모습입니다. 인벤토리 슬롯 인덱스가 바껴도 창은 그대로 입니다.

📚 오늘의 배운 점

• 모듈 탈부착 구현

🎯 다음 계획

다음 글에서는:

1. 방어구 효과 적용
   • 받는 대미지 감소
   • 환경에 따른 영향 감소
   • 스킬 적용
2. 스킬 구현
   • 이속 증가
   • 공속 증가
   • 체력 자동 회복

1. 손전등 구현
2. 중간 결과
3. 애니메이션
4. 스크립트에서 애니메이션 제어
5. 오브젝트 맞추기
6. 최종 결과
7. 오늘의 배운 점
8. 다음 계획

🔦 손전등 구현

1. 빛 추가

손전등 구현은 이미 Scanner에서 대부분 구현했기 때문에, 간단하게 하고 넘어가겠습니다. 먼저 손전등 프리팹에서 PointLight를 자식으로 추가하고, 설정을 맞춰주세요.

2. 입력으로 끄고 켜기

지금 현재 손전등이 켜져있는지 꺼져있는지의 변수를 추가하고, 빛을 끄고 켜고를 표현합시다.

// ItemInstance.cs

 void IntializeProperties()
 {
     // 기존 코드...

    if (itemData.itemName = "손전등")
    {
        properties["IsFlashlightOn"] = false;
    }
}

public void SetFlashLightOn(bool isOn)
{
    if (itemData.itemName != "손전등") return;
    properties["isFlashlightOn"] = isOn;
    GetComponentInChildren<Light>().enabled = isOn;
}

// UseItem.cs

private void Update()
{
    if (playerItemHandler.currentItem)
    {
        ReloadCharge(playerItemHandler.currentItem);
    }
    UseScannerInUpdate();
    UseFlashlightInUpdate();
}

public void UseItems(ItemInstance item)
{
    switch(item.itemData.itemName)
    {
        case "스캐너":
            if (Input.GetMouseButtonDown(1)) UseScanner();
            break;
        case "나이프":
            if (Input.GetMouseButtonDown(0)) UseKnife(item.itemData.attackPower);
            break;
        case "손전등":
            if (Input.GetMouseButtonDown(1)) UseFlashlight(item);
            break;
        default:
            return;
    }
}

private void UseFlashlightInUpdate()
{
    if (!playerItemHandler.currentItem) return;
    if (playerItemHandler.currentItem.itemData.itemName != "손전등") return;

    bool isBattery = CanUseBatteryProduct();

    // 켜져있는중 배터리가 모두 소모하면 자동으로 꺼
    if (!isBattery)
    {
        playerItemHandler.currentItem.gameObject.GetComponentInChildren<Light>().enabled = false;
        return;
    }

    if (playerItemHandler.currentItem.Get<bool>("isFlashlightOn"))
    {
        UseBattery();
    }
}
private void UseFlashlight(ItemInstance item)
{
    if (!inventory || !item || chargeUIOpen || GameState.IsUIOpen || !CanUseBatteryProduct()) return;
    if (item.gameObject.GetComponentInChildren<Light>().enabled)
    {
        Debug.Log("손전등을 끕니다.");

    }
    else
    {
        Debug.Log("손전등을 켭니다.");
    }
    item.gameObject.GetComponentInChildren<Light>().enabled = !item.gameObject.GetComponentInChildren<Light>().enabled;
    item.Set<bool>("isFlashlightOn", item.gameObject.GetComponentInChildren<Light>().enabled);
}

3. UI 업데이트

R키로 배터리 교체창을 만들었었는데, 실시간으로 몇%인지 업데이트 하는 로직도 넣습니다.

// UseItem.cs

private void UseBattery()
{
    ItemInstance battery = playerItemHandler.currentItem.Get<ItemInstance>("Battery");
    float rate = battery.Get<float>("batteryUsageRate");
    rate -= Time.deltaTime;
    battery.Set<float>("batteryUsageRate", rate);
    uiManager.SetChargeText();
}

// UIManager.cs

public void SetChargeText()
{
    ItemInstance item = playerItemHandler.currentItem.GetComponent<ItemInstance>();
    ItemInstance charge = null;
    switch (item.itemData.productType)
    {
        case ProductType.BatteryUsing:
            charge = item.Get<ItemInstance>("Battery");
            break;
        case ProductType.FuelUsing:
            charge = item.Get<ItemInstance>("Fuel");
            break;
        default:
            return;
    }

    int displayCharge = Mathf.Max(0, (int)charge.Get<float>("batteryUsageRate"));

    if (!chargeSlotPanel) return;
    // 현재 쓰고 있는 배터리는 무조건 0 인덱스로 처음 것만 값이 변하도록 함
    if (!chargeSlotPanel.GetComponentInChildren<TextMeshProUGUI>()) return;
    chargeSlotPanel.GetComponentInChildren<TextMeshProUGUI>().text = displayCharge.ToString() + "%";
}

🎮 중간 결과

우클릭으로 껐다 켰다 할 수 있으며 배터리 교체도 가능합니다.

🎞️ 애니메이션

물건을 사용하고 쥐고 있을때의 애니메이션을 넣겠습니다. 전 이미 만들어진 애니메이션 에셋을 수정하여 사용했습니다.

1. 만들기

Window -> Animation -> Animation을 들어가면 Animation창이 뜹니다. 거기서 드롭다운을 선택, Create New Clip으로 새로운 Anim파일을 만듭니다. 왼족 상단에 녹화버튼이 있죠? 그 버튼을 누르면 이제 편집할 수가 있게 됩니다.

2. 편집

편집은 간단하지만 매우 번거롭습니다. 만들고 싶은 애니메이션을 직접 제작하는 것인데요. 무언가를 쥐고 있는 애니메이션을 만들기 위해 Player의 스켈레톤을 직접 조작합니다. 원하는 프레임에서 스켈레톤을 바꾸면 Key가 생겨 해당 지점에서는 그 위치로 옮겨가는 애니메이션을 진행합니다. 먼저 칼을 들고, 칼을 쓰는 애니메이션을 보여드리겠습니다.

3. Animator Controller

Project창에서 Create -> Animator Controller을 하고 이름을 PlayerAnimator로 합시다. 들어가면 그래프같은 창이 뜰겁니다. 이 각 노드들은 현재 캐릭터가 취하고 있는 행동을 말합니다. 지금은 아무것도 없으니, 캐릭터가 아무것도 하지 않는 가만히 있는 상태를 뜻하는 Idle를 추가합시다. 해당 창에서 create State -> Empty를 선택해주세요. 생성된 New State의 이름을 Idle로 바꾸고, Motion에는 가만히 서 있는 포즈 애니메이션을 넣습니다.

물건을 드는 것과 쓰고 있는 것 또한 HoldingItem과 OnUseKnife로 이름을 설정하여 Empty 두 개를 생성합니다. 그리고 똑같이 Motion에 만든 애니메이션을 넣습니다.

4. 노드 연결하기

이젠 여기선 다음을 연결하기 위한 조건이 필요합니다. 물건을 들게 되면 Idle에서 HoldingItem으로 바뀌고, 나이프를 쓰면 HoldingItem에서 OnUseKnife로 행동이 바뀌겠죠? 그 반대로도 행동이 바껴야하니 노드에서 우클릭을 하고 Make Transition을 선택하여 나온 화살표를 다음에 행동할 노드에 연결합시다.

5. 조건 걸기

이제 조건을 추가합시다. Idle에서 HodingItem을 가려면 현재 아이템을 들고 있다는 Bool값이 필요하고, HodingItem에서 OnUseKnife를 하려면 나이프를 들고 있으며 현재 쓰는 중 이라는 Trigger가 필요합니다. Trigger는 단발성 행동에 좋습니다. 한 번만 하고 끝내거든요.

왼쪽의 Parameters창에서 +버튼을 눌러 Bool과 Trigger 파라미터를 추가합시다.

그 다음 Idle->HoldingItem 화살표를 클릭하여 Conditions에 Holding을 True로 설정하여 추가합니다. HoldingItem->OnUseKnife는 DoUseKnife를 추가해주세요. HoldingItem->Idle은 Holding을 False로 설정하여 추가합니다.

각 화살표의 Inspector에 Has Exit Time이 있는데요. 이것은 애니메이션 전환 타이밍을 결정하는 중요한 설정입니다.

• 체크 시: 애니메이션이 일정 시간 재생된 후에 전환하고 Exit Time까지 기다린 후 조건 확인함. 애니메이션이 자연스럽게 끝나고 전환. 공격, 스킬, 점프 등 완료되어야 하는 애니메이션에 사용.
• 체크 해제 시: 조건이 맞으면 즉시 전환하며 애니메이션 중간에도 바로 전환 가능. 이동, 방향 전환 등 즉시 반응해야 하는 애니메이션에 사용.

OnUseKnife -> HoldingItem 의 Has Exit Time만 체크하고 나머지는 해제해주세요.

🎞️ 스크립트에서 애니메이션 제어

이제 우리에겐 아이템을 들었다와 아이템을 쓴다라는 코드를 찾아가는 일만 남았습니다.

// PlayerItemHandler.cs

private Animator animator;

private void Start()
{
    animator = GetComponent<Animator>();
}

public void ClearHolding()
{
    // 기존 코드...
    animator.SetBool("Holding", false);
}

private void SetHoldingItem(ItemInstance item, Transform transform)
{
    // 기존 코드...
    animator.SetBool("Holding", true);
    // 기존 코드...
}

// UseItem.cs

private void UseKnife(float damage)
{
    playerController.animator.SetTrigger("DoUseKnife");
    // 기존 코드...
}

🛠️ 오브젝트 맞추기

이대로 그냥 실행하게 되면 물건이 어색하게 손에 쥐어집니다. 그러니 물건을 쥐고 있는 Player를 Scene창에서 자연스럽게 쥐게끔 해당 오브젝트를 조정해줍니다. 그리고 조정 후, Inspector에 있는 Transform정보를 Prefab에 적용하면 자연스럽게 쥐게 됩니다.

다른 방법이 있기는 하나...!! 전 이게 더 자연스러워서 이 방법으로 했습니다.

🎮 최종 결과

이제 물건을 쥐고 사용해보세요! 다른 물건들도 만들어 보세요.

📚 오늘의 배운 점

• 손전등 구현
• Animation 및 Animator Controller 활용

🎯 다음 계획

다음 글에서는:

1. 모듈형 방어구 구현

1. 날아다니는 AI
2. 중간 결과
3. 유도 미사일
4. 최종 결과
5. 오늘의 배운 점
6. 다음 계획

🪽 날아다니는 AI

지상을 다니는 AI는 NavMesh를 이용했지만 공중 AI는 보통 NavMesh를 쓰지 않습니다. 이 게시글처럼 Transform을 직접 조작하는 것으로 AI를 구현하게 됩니다.

1. 타입 구분

//Enemy.cs

public AIType aiType;

public enum AIType
{
    None,
    Ground,
    Flying,
    Swimming
}

2. 이동 구현

// Enemy.cs

public void PerformPatrol()
{
    switch(aiType)
    {
        case AIType.Ground:
            patrolCoroutine = StartCoroutine(WaitForPatrolCoroutine());
            break;
        case AIType.Flying:
            patrolCoroutine = StartCoroutine(WaitForPatrolCoroutineFlying());
            break;
        case AIType.Swimming:
            break;
        default:
            break;
    }
}

IEnumerator WaitForPatrolCoroutineFlying()
{
    while (true)
    {
        // 현재 목표 위치
        Vector3 targetPosition = SetNewRandomPosition();

        while (Vector3.Distance(transform.position, targetPosition) > 0.5f)
        {
            // 목표 위치와 현재 위치를 연결하는 방향
            Vector3 direction = (targetPosition - transform.position).normalized;
            if (direction != Vector3.zero)
            {
                // 해당 방향을 바라보게됨
                Quaternion targetRotation = Quaternion.LookRotation(direction);
                // Slerp로 부드럽게 바라봄
                transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, enemyData.rotationSpeed * Time.deltaTime);
            }

            // MoveTowards는 (a,b,c)일때, a부터 b까지 c의 속도로 이동해주는 함수
            transform.position = Vector3.MoveTowards(transform.position, targetPosition, enemyData.moveSpeed * Time.deltaTime);
            yield return null;
        }

        // 도착할 경우 2초 대기
        yield return new WaitForSeconds(2f);
    }
}

private Vector3 SetNewRandomPosition()
{
    Vector3 randomDirection = UnityRandom.insideUnitSphere * patrolRadius;
    randomDirection += centerPoint;
    return randomDirection;
}

3. ChaseState 수정

// ChaseState.cs

private void Moving()
{
    if (enemy.IsInCenter(enemy.transform))
    {
        switch(enemy.aiType)
        {
            case AIType.Ground:
                enemy.agent.destination = enemy.target.transform.position;
                break;
            case AIType.Flying:
                FlyingTypeMoving();
                break;
            case AIType.Swimming:
                break;
            default:
                break;
        }
    }
}

private void FlyingTypeMoving()
{
    Vector3 direction = (enemy.target.transform.position - enemy.transform.position).normalized;
    if (direction != Vector3.zero)
    {
        Quaternion targetRotation = Quaternion.LookRotation(direction);
        enemy.transform.rotation = Quaternion.Slerp(enemy.transform.rotation, targetRotation, enemy.enemyData.rotationSpeed * Time.deltaTime);
        enemy.transform.position = Vector3.MoveTowards(enemy.transform.position, enemy.target.transform.position, enemy.enemyData.moveSpeed * Time.deltaTime);
    }
}

4. AttackState 수정

Attackstate에선 agent.isStopped를 GroundType만 적용하게 바꿔주세요. 그리고 EnemyAttackSystem도 수정합시다.

// EnemyAttackSystem.cs

public void PerformAttackByName(string name)
{
    switch(name)
    {
        case "Spitter":
            ThrowProjectile(enemy.attackTransform);
            break;
        case "Bomber":
            DropBomb(enemy.attackTransform);
            break;
        default:
            break;
    }
}

private void DropBomb(Transform attackTransform)
{
    Debug.Log("폭탄 투하!!!");
}

public void LookAtPlayer()
{
    Vector3 direction = (enemy.target.transform.position - transform.position).normalized;
    direction.y = 0; 
    Quaternion lookRotation = Quaternion.LookRotation(direction);
    switch(enemy.aiType)
    {
        case AIType.Ground:
            transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, enemy.agent.angularSpeed * Time.deltaTime);
            break;
        case AIType.Flying:
            transform.rotation = Quaternion.Slerp(enemy.transform.rotation, lookRotation, enemy.enemyData.rotationSpeed * Time.deltaTime);
            break;
        case AIType.Swimming:
            break;
        default:
            break;
    }
}

🎮 중간 결과

순찰 중일때 공중에서 자유롭게 다닙니다.

공격 범위내에 있으면 폭탄을 투하하고, 범위에서 벗어날땐 ChaseState인 것을 볼 수 있습니다.

💣 유도 미사일

게임에 자주 나오는 유도 기능입니다. 탄환이 플레이어를 쫓아가고, 일정 시간이 지나면 공중에서 터지거나 플레이어에 닿으면 데미지를 입고 터지죠. 구현해볼까요? 다른 오브젝트에도 쓰일 수도 있으니, 함수명을 ThrowGuidedMissile로 바꿉시다.

// EnemyAttackSystem.cs

public void PerformAttackByName(string name)
{
    switch(name)
    {
        case "Spitter":
            ThrowProjectile(enemy.attackTransform);
            break;
        case "Bomber":
            // 이미 발사한 미사일이 있다면 사라질때까지 스폰하지 않음
            if (!bomberMissile)
            {
                ThrowGuidedMissile(enemy.attackTransform);
            }
            break;
        default:
            break;
    }
}

private void ThrowGuidedMissile(Transform attackTransform)
{
    Debug.Log("폭탄 투하!!!");

    bomberMissile = Instantiate(enemy.projectilePrefab, attackTransform.position, attackTransform.rotation);
    ProjectileManager projectileManager = bomberMissile.GetComponent<ProjectileManager>();
    if (projectileManager)
    {
        projectileManager.damage = enemy.enemyData.damage;
        projectileManager.startFollow = true;
        projectileManager.enemy = enemy; 
    }
}

// ProjectileManager.cs

// 총알 유지 시간
public float lifeTime;

[HideInInspector] public float damage = 10f;
[HideInInspector] public bool startFollow = false;
[HideInInspector] public Enemy enemy;

private float currentTime = 0f;
private void Update()
{
    if (startFollow)
    {
        currentTime += Time.deltaTime;
        if (currentTime >= lifeTime)
        {
            Destroy(gameObject);
            return;
        }
        FollowTarget();
    }
}

public void FollowTarget()
{
    Vector3 direction = (enemy.target.transform.position - transform.position).normalized;

    if (direction != Vector3.zero && enemy)
    {
        Quaternion targetRotation = Quaternion.LookRotation(direction);
        transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, enemy.projectileSpeed * Time.deltaTime);
        // 유도탄이 발밑으로 가지 않기 위해  + Vector3.up * 1.5f 를 해줌
        transform.position = Vector3.MoveTowards(transform.position, enemy.target.transform.position + Vector3.up * 1.5f, enemy.projectileSpeed * Time.deltaTime);
    }
}

🎮 최종 결과

공격 범위내에 들어오면 비교적 느린 속도로 유도탄이 날아오고, 일정 시간이 지나면 제자리에서 터지게끔 사라집니다. 나중에 에셋을 적용시키고 더 느리게 한 후, 비틀거리는 애니메이션을 추가한다면 더 보기좋을것 같네요!

📚 오늘의 배운 점

• MoveTowards를 이용한 공중 이동
• 유도탄 구현

🎯 다음 계획

다음 글에서는:

1. 손전등 구현
2. 아이템을 든 모션 구현
   • 손전등
   • 나이프

1. 투사체 발사
2. 표적을 향해 발사
3. 데미지 주기
4. 최종 결과
5. 오늘의 배운 점
6. 다음 계획

🔫 투사체 발사

이번에는 적의 공격특성과 능력을 본격적으로 만들어보도록 합니다. 만들기로 계획한 몹 중 투사체 발사가 있는데요. 해당 로직을 따로 따로 만들어 세분화하고, 나중에 재활용하기 쉽게 합시다.

투사체는 본래 있던 Attack Point에서 공격 탄환을 발사하게 할 겁니다. 먼저 Spitter의 능력을 살펴봅시다. 해당 몹은 산성 탄환 발사를 하므로 마치 대포처럼 쏘는 게 좋겠죠?

적의 공격 시스템을 담당할 EnemyAttackSystem 스크립트를 생성합니다.

1. 물체를 앞으로 던지기

// EnemyAttackSystem

private Enemy enemy;
private void Awake()
{
    enemy = GetComponent<Enemy>();
}

// 적이 공격을 수행하는 로직
public void PerformAttackByName(string name)
{
    switch(name)
    {
        case "Spitter":
            ThrowProjectile(enemy.attackTransform);
            break;
        default:
            break;
    }
}    
// AttackTransform를 기점으로 투사체를 던지는 로직
private void ThrowProjectile(Transform attackTransform)
{
    // 투사체를 생성하고 초기화하는 로직
    GameObject projectile = Instantiate(enemy.projectilePrefab, attackTransform.position, attackTransform.rotation);
    Rigidbody rb = projectile.GetComponent<Rigidbody>();
    if (rb != null)
    {
        rb.AddForce(attackTransform.forward * enemy.projectileSpeed, ForceMode.VelocityChange);
    }
}

2. 쿨타임마다 공격 시행

[Header("Projectile Settings")] 
public GameObject projectilePrefab;
public float projectileSpeed = 10f;

private EnemyAttackSystem attackSystem;

protected override void Start()
{
    attackSystem = GetComponent<EnemyAttackSystem>();
}

public void PerformAttack()
{
    if (!attackSystem) return;
    StartCoroutine(AttackWithCooldown());
}
IEnumerator AttackWithCooldown()
{
    Debug.Log("공격합니다~");
    if (attackSystem)
    {
        attackSystem.PerformAttackByName(enemyData.enemyName);
    }
    yield return new WaitForSeconds(enemyData.attackCooldown);
}

3. 실행

🎯 표적을 향해 발사

1. 방향 설정

현재 forward를 이용하므로, 적이 바라보는 방향으로만 구체가 날아갑니다. 공격을 시행했을때는 플레이어를 보는 것으로 계속 고정시킵시다.

//EnemyAttackSystem.cs

private void Update()
{
    if (enemy.currentState.CurrentStateType == StateType.Attack)
    {
        LookAtPlayer();
    }
}

public void LookAtPlayer()
{
    Vector3 direction = (enemy.target.transform.position - transform.position).normalized;
    direction.y = 0; // Y축 회전을 방지하기 위해 Y값을 0으로 설정
    Quaternion lookRotation = Quaternion.LookRotation(direction);
    transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, Time.deltaTime * enemy.agent.angularSpeed);
}

2. State 조건 수정

계속해서 따라오는 것을 고치기 위해 ChaseState일때 자신의 위치가 추적범위 이상에서 멀어지면 움직이지 못하는 것으로 합니다. 이렇게 하면 공격 범위내에 플레이어가 있을시, 공격은 하나 더이상 쫓아오진 않습니다.

// ChaseState.cs

public override void Update()
{

    if (!enemy.IsInDistance(enemy.target.transform))
    {
        enemy.ChangeState(new PatrolState(enemy));
    }
    else if (enemy.IsInAttackRange(enemy.target.transform))
    {
        enemy.ChangeState(new AttackState(enemy));
    }
    Moving();
}

private void Moving()
{
    if (enemy.IsInCenter(enemy.transform))
    {
        enemy.agent.destination = enemy.target.transform.position;
    }
}

3. 실행

플레이어 포착하면 몸을 바로 돌려 플레이어를 바라보고, 쫓아옵니다. 또한 공격범위내에 들어오면 공격합니다.

💔 데미지 주기

부딪히면 사라지고 플레이어의 생명력을 깎는 로직을 짜봅시다. ProjectileManager 스크립트를 생성해주세요.

// ProjectileManager.cs

public class ProjectileManager : MonoBehaviour
{
    [HideInInspector] public float damage = 10f;

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.CompareTag("Player"))
        {
            PlayerState playerState = other.gameObject.GetComponent<PlayerState>();
            if (playerState != null)
            {
                playerState.ModifyHealth(-damage);
            }
            Destroy(gameObject); 
        }
        else if (other.gameObject.CompareTag("Ground"))
        {
            Destroy(gameObject);
        }
    }
}

// EnemyAttackSystem.cs

private void ThrowProjectile(Transform attackTransform)
{
    GameObject projectile = Instantiate(enemy.projectilePrefab, attackTransform.position, attackTransform.rotation);
    Rigidbody rb = projectile.GetComponent<Rigidbody>();
    ProjectileManager projectileManager = projectile.GetComponent<ProjectileManager>();
    if (rb && projectileManager)
    {
        projectileManager.damage = enemy.enemyData.damage;
        rb.AddForce(attackTransform.forward * enemy.projectileSpeed, ForceMode.VelocityChange);
    }
}

🎮 최종 결과

데미지를 입으며 탄환이 플레이어의 몸이나 땅에 닿으면 사라지는 모습입니다.

📚 오늘의 배운 점

• 투사체 생성 및 발사
• TriggetEnter시 투사체 삭제

🎯 다음 계획

다음 글에서는:

1. 날아다니는 적 구현
2. 위에서 떨어지는 투사체 공격

1. 몹 데이터 설정
2. 적 생성
3. Enemy 설정
4. 중간 결과
5. 여러 적 스폰
6. 최종 결과
7. 오늘의 배운 점
8. 다음 계획

👾 몹 데이터 설정

EnemyData를 담아두는 Resources -> Enemys에 특성에 따른 폴더를 제작할겁니다. 전 Aerial(비행), Ground(대지), Special(특이) 로 구분할겁니다. 일단 예시로 몇개만 생성해볼까요?

Aerial

Ground

공격력 및 체력 등 자세한 것은 임의로 설정했으므로 생략합니다. Special은 나중에 다루겠습니다!

👾 적 생성

이전에 계속 시험했던 Enemy는 Brute로 설정하고 진행하겠습니다. 이 몹은 Forest(숲지형) 타입으로 숲에서만 스폰하게 할 겁니다. 그렇다면 만들었던 ZoneManager에서 숲지형의 Transform을 넣고 그곳에서만 생성되게 해야겠죠?

// ZoneManager.cs

[Header("Forest Zone")]
public Transform[] forestTransforms;

숲 지형이며 몹이 스폰되는 곳은 여러곳일테니 Transform형식의 배열로 선언합니다. 그리고 Hierarchy에서 Map의 자식에 빈 오브젝트의 Forest를 넣고 스폰을 원하는 위치로 옮겨주세요. 그리고 ZoneManager의 Inspector에 집어넣습니다.

이제 영역은 지정했으니 스폰 로직이 필요합니다. LivingSpawner 스크립트를 생성해주세요.

// LivingSpawner.cs

using UnityEngine;
using UnityEngine.AI;
using UnityRandom = UnityEngine.Random;

public class LivingSpawner : MonoBehaviour
{
    [Header("Spawner Zone")]
    public ZoneManager zoneManager;

    [Header("Spawn Settings")]
    private float spawnRadius = 10f;

    public void SpawnEnemy(Enemy enemy)
    {
        if (!zoneManager || !enemy) return;
        GameObject enemyObject = Instantiate(enemy.enemyData.enemyPrefab);
        Vector3 randomDirection = UnityRandom.insideUnitSphere * spawnRadius;
        randomDirection += enemy.centerPoint;
        NavMeshHit hit;
        NavMesh.SamplePosition(randomDirection, out hit, spawnRadius, NavMesh.AllAreas
    }
}

// GameManager.cs

[Header("Scripts")]
public LivingSpawner livingSpawner;

// 테스트용으로 Inspector에서 Enemy를 하나만 추가합시다
public EnemyData[] allEnemies;

private void Start()
{
    if (allEnemies.Length > 0 && livingSpawner)
    {
        Enemy enemy = Enemy.Create(allEnemies[0]);
        livingSpawner.SpawnEnemy(enemy);
    }
}

// Enemy.cs

// 스폰된 후 Inspector에서 넣은 AttackPoint Collider가 None일 경우를 대비함
private void Awake()
{
    if (!attackPoint)
    {
        attackPoint = GetComponentInChildren<Collider>();
        if (attackPoint)
        {
            attackPoint.enabled = false; // 공격 콜라이더 비활성화
        }
        else
        {
            Debug.LogError("Attack Point Collider가 설정되지 않았습니다!");
        }
    }
}

⚙️ Enemy 설정

전에 맵을 설치하면서 Enemy AI가 약간씩 고장나는 것을 확인할 수 있죠. 그 이유는 플레이어의 벽 오르기 버그를 해결하기 위해 임시 벽 Collider를 설치했는데, Enemy가 그곳을 지나려고 할때 발생하는 문제입니다.

1. Layer 설정

Enemy는 NavMesh의 영역에서만 이동하는데, 그것을 Collider가 막아버리면 Enemy는 지나가지 못합니다. 그러니 Enemy Prefab의 Inspector -> Layer에 들어가 Add Layer를 합니다. 그 안에 Enemy와 Wall을 추가합니다.

2. Layer Collision Matrix 설정

Edit -> Project Settings -> Physics -> Layer Collision Matrix에 들어갑니다. 그렇다면 Layer들이 있는 체크박스를 볼 수가 있습니다. 거기서 Wall / Enemy 체크박스를 해제해주세요.

3. 충돌 제거

Enemy는 AI이기 때문에 물리 판정이 대체로 필요가 없습니다. 그러니 해당 프리팹의 Inspector에서 Rigidbody의 Is Kinematic을 true로 변경합시다.

🎮 중간 결과

확인을 위해 코드를 약간 변경하여 적들이 여러개 스폰되게 했습니다. 특정 지역을 중심으로 랜덤한 곳에서 스폰되고, 각자 이동하는 것을 확인할 수 있습니다.

👾 여러 적 스폰

게임에는 한가지의 적만 있지는 않죠. 여러 적들이 있을 겁니다. 이전에 아이템 정보를 배열에 담았듯이 적도 그럴 필요가 있습니다. 그래서 GameManager에서 enemyData 배열을 만들었죠!! EnemyData에서도 environmentType이라는 해당 적이 사는 지역에 대한 정보도 담았습니다. 그것을 기반으로 해볼까요?

1. GameManager에 Enemy 종류 저장

// EnvironmentType.cs

public enum EnvironmentType
{
    None,    
    Forest,    // 숲
    Desert, // 사막
    Cave,    // 동굴
    Beach,    // 해변
}

// GameManager.cs

public ZoneManager zoneManager;

public EnemyData[] allEnemies;

private void Start()
{
    GetAllEnemies();
    zoneManager.SpawnEnemyByZone(allEnemies);
}

private void GetAllEnemies()
{
    allEnemies = Resources.LoadAll<EnemyData>("Enemies");
    Array.Sort(allEnemies, (a, b) => a.enemyID - b.enemyID);
}

2. Zone별 Enemy 스폰

// zoneManager.cs

using UnityEngine;

public class ZoneManager : MonoBehaviour
{
    [Header("Scripts")]
    public LivingSpawner livingSpawner;

    [Header("Forest Zone")]
    public GameObject[] forestZones;

    [Header("Desert Zone")]
    public GameObject[] desertZones;

    [Header("Cave Zone")]
    public GameObject[] caveZones;

    [Header("Beach Zone")]
    public GameObject[] beachZones;


    public void SpawnEnemyByZone(EnemyData[] datas)
    {
        if (datas.Length <= 0 || !livingSpawner) return;

        int count = 0;
        Vector3 point = Vector3.zero;

        foreach (EnemyData data in datas)
        {
            if (data.environmentType == EnvironmentType.Forest)
            {
                foreach (GameObject zone in forestZones)
                {
                    count = zone.GetComponent<ZoneController>().SpawnCount(EnvironmentType.Forest);
                    for (int i = 0; i < count; i++)
                    {
                        Debug.Log("Forest 에서 생성!");
                        Enemy enemy = Enemy.Create(data);
                        point = zone.GetComponent<Transform>().position;
                        livingSpawner.SpawnEnemyRandomPosition(enemy, point);
                    }
                }
            }
            else if (data.environmentType == EnvironmentType.Desert)
            {
                foreach (GameObject zone in desertZones)
                {
                    count = zone.GetComponent<ZoneController>().SpawnCount(EnvironmentType.Desert);
                    for (int i = 0; i < count; i++)
                    {
                        Debug.Log("Desert 에서 생성!");
                        Enemy enemy = Enemy.Create(data);
                        point = zone.GetComponent<Transform>().position;
                        livingSpawner.SpawnEnemyRandomPosition(enemy, point);
                    }
                }
            }
            else if (data.environmentType == EnvironmentType.Cave)
            {
                foreach (GameObject zone in caveZones)
                {
                    count = zone.GetComponent<ZoneController>().SpawnCount(EnvironmentType.Cave);
                    for (int i = 0; i < count; i++)
                    {
                        Enemy enemy = Enemy.Create(data);
                        point = zone.GetComponent<Transform>().position;
                        livingSpawner.SpawnEnemyRandomPosition(enemy, point);
                    }
                }
            }
            else if (data.environmentType == EnvironmentType.Beach)
            {
                foreach (GameObject zone in beachZones)
                {
                    count = zone.GetComponent<ZoneController>().SpawnCount(EnvironmentType.Beach);
                    for (int i = 0; i < count; i++)
                    {
                        Enemy enemy = Enemy.Create(data);
                        point = zone.GetComponent<Transform>().position;
                        livingSpawner.SpawnEnemyRandomPosition(enemy, point);
                    }
                }
            }
        }
    }
}

4. Enemy 데이터 및 오브젝트 생성

// Enemy.cs

public static Enemy Create(EnemyData data)
{
    GameObject obj = Instantiate(data.enemyPrefab);
    Enemy enemy = obj.GetComponent<Enemy>();
    enemy.enemyData = data;
    return enemy;
}

// LivingSpawner.cs

[Header("Spawner Zone")]
public ZoneManager zoneManager;

[Header("Spawn Settings")]
private float spawnRadius = 10f;

public void SpawnEnemyRandomPosition(Enemy enemy, Vector3 centerPoint)
{
    if (!zoneManager || !enemy) return;

    Vector3 randomDirection = UnityRandom.insideUnitSphere * spawnRadius;
    randomDirection += centerPoint;
    enemy.centerPoint = centerPoint;
    NavMeshHit hit;

    if(NavMesh.SamplePosition(randomDirection, out hit, spawnRadius, NavMesh.AllAreas))
    {
        enemy.transform.position = hit.position;
    }
}

🎮 최종 결과

맵에 각 지형의 위치를 빈 오브젝트로 설정하고, EnemyData에 사는 지형을 지정했습니다. 그럼 해당 Enemy가 Min~Max까지의 수로, 해당 지역 주위에 랜덤으로 스폰되는 모습입니다.

📚 오늘의 배운 점

• Layer 활용
• 조건에 따른 랜덤 스폰

🎯 다음 계획

다음 글에서는:

1. 투사체 공격 구현

1. 맵설치
2. Physics Material
3. 벽과 바닥, 계단
4. 오브젝트 렌더링
5. 오늘의 배운 점
6. 다음 계획. 다음 계획

🧱 맵설치

1인 개발로 3D 모델링까지 하기에는 부담이 컸습니다. 그러니 Unity에서 제공하는 무료 에셋을 이용해봅시다. 이곳에서 다운받아 임포트 해주세요.

1. 지형 설치

아직 장황하게 맵을 설치할 필요는 없습니다. 해당 에셋을 다운받았나요? 그러면 빈 오브젝트를 설치하여 Mesh Renderer, Mesh Filter, Mesh Collider, DefaultGroundMaterial을 추가하여 기본 바닥을 생성합시다. 3DGameKit->Art->Models->Terrains에서 입맛대로 골라주세요. 어느정도의 장애물은 필요하니 Models->Environment->Rock에서 돌을 몇개 설치합시다.

2. NavMeshSurface

해당 Ground가 있는 오브젝트를 Ground라는 빈오브젝트의 자식들로 둡니다. 그리고 Ground에 NaveMeshSurface 컴포넌트를 추가한뒤 CollectObjects를 Children으로 하고 Bake합니다.

3. 테스트

🥎 Physics Material

맵과 플레이어가 충돌하면 빗겨가지 않고 그자리에서 버티는 경우가 있습니다. 예를 들면 점프하는 도중 벽에 충돌할때, W키를 누르면 공중에서 버티는 것이 있죠. 그것을 해결하기 위해 Physics Material을 Project창에서 생성합시다. 그리고 플레이어, 바닥, 벽에 적용할 해당 Physics Material의 값을 알맞게 설정해주세요.

1. Dynamic Friction (동적 마찰력)

• 움직이는 물체 간의 마찰력
• 값이 클수록 미끄러짐이 적음

2. Static Friction (정적 마찰력)

• 정지한 물체가 움직이기 시작할 때의 저항력
• 값이 클 수록 움직이기 어려움
• 보통 Dynamic Friction보다 높게 설정

3. Bounciness (탄성력)

• 물체가 튀어오르는 정도

4. Friction Combine (마찰력 결합 방식)

• 두 물체의 마찰력을 어떻게 계산할지
  • Average: 평균값 사용
  • Minimum: 더 낮은 값 사용
  • Maximum: 더 높은 값 사용
  • Multiply: 곱셈 사용

5. Bounce Combine (탄성력 결합 방식)

• 두 물체의 탄성력 계산 방식
• 설정은 위와 동일

🪨 벽과 바닥, 계단

플레이어가 자연스럽게 이동하도록 환경에서 벽모양대로 Collider를 생성해 Material에 WallPhysicsMat를 넣습니다. 계단에서는 미끄러지지 않게 하기 위해 마찰력이 높은 GroundPhysicsMat를 넣어주세요.

테스트

📦️ 오브젝트 렌더링

간혹가다 벽에 너무 가까이에 있으면 렌더링되지 않아 해당 오브젝트를 뚫고 바깥이 보이게 됩니다. 그때는 Player에 있는 Main Camera의 Inspector에서 Clipping Planes -> Near값을 0.1 또는 0.01 정도로 줄입시다. 그러면 정상적으로 렌더링 될겁니다!!

📚 오늘의 배운 점

• Physics Material
• Collider로 벽과 계단 판정 나누기

🎯 다음 계획

다음 글에서는:

1. EnemyData 여러개 생성
2. 구역에 따른 적 랜덤 스폰

1. NavMesh
2. 중간 결과
3. 순찰 상태
4. 랜덤으로 이동
5. 최종 결과
6. 오늘의 배운 점
7. 다음 계획

🧭 NavMesh

Unity에서는 AI 시스템이 존재합니다. 이것으로 간편하게 AI몹들이 움직이게 할 수 있습니다. 장애물을 알아서 피하게 할 수 있고, 속도나 회전을 모두 설정할 수 있습니다. 자세한 설명은 이 게시글을 확인해주세요!

1. 패키지 다운

Package Manager에서 Unity Registry -> AI Navigation을 설치합니다.

2. Inspector에 추가

자식이 아닌 최상위 부모. 즉 지형지물을 담은 Map에서 NavMeshSurface 컴포넌트를 추가합니다. 그리고 Bake 해주세요. 그러면 Nav Mesh Data에 데이터가 생길겁니다.

Bake를 하고 나면 이러한 파란색이 영역이 뜹니다. 뜨지 않을 경우 오른쪽 상단 gizmo를 클릭해주세요.

3. 몹에 적용

적 만들기 #1 에서 플레이어를 따라가는 코드를 작성했죠? 그것은 이제 모두 필요없습니다! 적 프리팹에 Nav Mesh Agent 컴포넌트를 추가합시다. 또 스크립트를 수정합시다.

// Enemy.cs

private NavMeshAgent agent;

protected override void Start()
{
    agent = GetComponent<NavMeshAgent>();
}

// ChaseState.cs

private void Moving()
{
    // 기존 이동, 회전 코드 모두 지움
    // 현재 이 AI의 목표는 enemy.target임
    enemy.agent.destination = enemy.target.transform.position;
}

그리고 AttackState와 IdleState에서 각각 Enter()에는 enemy.agent.isStoppend = true를 넣고, Exit()에는 enemy.agent.isStoppend = false를 넣어주시면 됩니다. true면 이동을 멈추고 false면 이동을 다시 시작합니다.

🎮 중간 결과

몹이 알아서 지형지물을 피하고 플레이어를 따라가는 모습입니다.

🔍 순찰 상태

이제 플레이어를 감지하지 않고 있을 때 가만히만 있으면 어색하잖아요? 그러니 Idle상태가 아니라 홀로 걸어다니는 PatrolSate를 만들 생각입니다.

1. 코루틴

각 적들은 순찰을 하는 Waypoint가 존재하며, 그 중 랜덤으로 이동하게 할 겁니다. 그렇다면 NavMesh를 이용해 목표지점으로 이동하고 다음 지점을 변경한뒤 기다리는 로직이 필요합니다.

//Enemy.cs

public Transform[] waypoints;

// PatrolState에서 코루틴을 종료시키기 위함
[HideInInspector] public Coroutine patrolCoroutine;

public void PerformPatrol()
{
    patrolCoroutine = StartCoroutine(WaitForPatrolCoroutine());
}

IEnumerator WaitForPatrolCoroutine()
{
    // 무한 반복
    while (true)
    {
        // 배열 중 랜덤으로 하나 선택
        int randomIndex = Range(0, waypoints.Length);
        // 해당 포지션으로 이동
        agent.SetDestination(waypoints[randomIndex].position);

        // 도착 전까지는 리턴
        while (agent.pathRending || agent.remainingDistance > 0.5f)
            yield return null;

        // 도착 후 2초 기다림
        yield return new WaitForSeconds(2f);
    }
}

// PatrolState.cs

public override void Enter()
{
    Debug.Log("적이 순찰 상태로 진입");
    enemy.PerformPatrol();
}

public override void Update()
{
    if (enemy.StartChase())
    {
        enemy.ChangeState(new ChaseState(enemy));
    }
}

public override void Exit()
{
    Debug.Log("적이 순찰 행동을 벗어남");
    enemy.StopCoroutine(enemy.patrolCoroutine);
}

2. Transform 적용

임시로 Empty 오브젝트를 맵에 설치하여 적 오브젝트에 적용시킵니다.

3. 적용 후 확인

이때 적이 생성되면 PatrolState로 시작됩니다. 돌아다니다가 플레이어를 만나면 ChaseState로 바뀌고 플레이어가 일정 거리를 벗어나면 다시 PatrolState로 바뀝니다.

🎲 랜덤으로 이동

제가 설계한 게임은 오픈월드이기에 AI몹의 포인트를 맵에 지정해주는 것이 힘들뿐더러, 이미 정해져 있으면 부자연스러워 보입니다. 그렇기 때문에 Random함수를 이용하여 AI가 이동하게 할 겁니다.

1. 순찰 함수 변경

// Enemy.cs

// 하지 않으면 오류가 떠서 명시적 선언을 함
using UnityRandom = UnityEngine.Random;

private Vector3 centerPoint;

protected override void start()
{
    // 처음 스폰된 위치를 이동 반경의 중심으로 설정
    centerPoint = transform.position;
}

IEnumerator WaitForPatrolCoroutine()
{
    while (true)
    {
        Debug.Log("코루틴 실행");

        SetNewRandomDestination();

        while (agent.pathPending || agent.remainingDistance > 0.5f)
            yield return null;

        yield return new WaitForSeconds(2f);
    }
}

void SetNewRandomDestination()
{
    // 구형식의 랜덤 좌표
    Vector3 randomDirection = UnityRandom.insideUnitSphere * patrolRadius;

    // 처음 스폰된 위치에 랜덤 좌표를 더함
    randomDirection += centerPoint;

    NavMeshHit hit;

    // 갈 수 있는 근처 NavMesh 좌표로 이동
    if (NavMesh.SamplePosition(randomDirection, out hit, patrolRadius, NavMesh.AllAreas))
    {
        agent.SetDestination(hit.position);
    }
}

2. 추적 함수 변경

만약 중심점에서 플레이어가 일정 반경 이상 멀어지면 더이상 쫓아가지 않게 해야 합니다.

// Enemy.cs

public bool IsInCenter(Transform target)
{
    return Vector3.Distance(centerPoint, target.position) <= patrolRadius;
}

// ChaseState.cs

public override void Update()
{
    if (enemy.IsInAttackRange(enemy.target.transform))
    {
        enemy.ChangeState(new AttackState(enemy));
    }
    else if (!enemy.IsInDistance(enemy.target.transform) || !enemy.IsInCenter(enemy.target.transform))
    {
        enemy.ChangeState(new PatrolState(enemy));
    }
    Moving();
}

🎮 최종 결과

순찰을 하다가 플레이어를 감지하면 추적을 하나, 플레이어가 일정 영역을 벗어나면 더이상 쫓지 않습니다.

📚 오늘의 배운 점

• NavMesh 활용
• 랜덤을 이용한 순찰 이동
• 일정 반경 인식

🎯 다음 계획

다음 글에서는:

1. 맵세팅

NavMesh

Unity에서는 별도의 AI 시스템이 존재합니다. 이것으로 간편하게 AI몹들이 움직이게 할 수 있습니다. 장애물을 알아서 피하게 할 수 있고, 속도나 회전을 모두 설정할 수 있습니다.

1. 패키지 다운

Package Manager에서 Unity Registry -> AI Navigation을 설치합니다.

2. NavMeshSurface 컴포넌트 추가

자식이 아닌 최상위 부모. 즉 지형지물을 담은 Map에서 NavMeshSurface 컴포넌트를 추가합니다. 그리고 Bake 해주세요. 그러면 Nav Mesh Data에 데이터가 생길겁니다.

Bake를 하고 나면 이러한 파란색이 영역이 뜹니다. 뜨지 않을 경우 오른쪽 상단 gizmo를 클릭해주세요.

3. NavMesh Agent 컴포넌트 추가

움직일 AI 캐릭터에 NavMesh Agent 컴포넌트를 추가합니다.

Navigation 설정

각 Agent Type마다 AI 행동반경을 조정할 수 있는데요. 에디터 상단바에서 Window->AI->Navigation을 들어가줍니다. 여러가지가 뜨겠죠? 이것들을 설명해봅시다.

- Name (이름) Agent 타입의 이름으로 여러 타입의 AI가 있을 때 구분용입니다. 코드에서 특정 Agent 타입을 지정할 때 사용됩니다.

- Radius (반지름) AI 캐릭터의 두께로 측면 충돌 범위를 지정합니다. 좁은 통로를 지날 수 있는지 결정합니다. 작을수록 좁은 곳을 통과 가능하지만, 벽에 파묻힐 위험이 있습니다. 클수록 안전하지만 좁은 곳을 통과하는 것이 불가능합니다.

- Height (높이) AI 캐릭터의 키로 수직 충돌 범위를 지정합니다. 낮은 천장 아래 지날 수 있는지 결정합니다. 작을수록 낮은 곳을 통과 가능하고, 클수록 높은 장애물을 감지합니다.

- Step Height (계단 높이) 한 번에 올라갈 수 있는 계단/단차 높이입니다. 이 값 이하의 단차는 부드럽게 올라가고 이 값을 초과하면 장애물로 인식합니다.

- Max Slope (최대 경사) 올라갈 수 있는 최대 경사각 (도 단위)입니다. 이 각도 이하의 경사는 걸어 올라가고 이 각도를 초과하면 벽으로 인식합니다.

- Drop Height (낙하 높이) 떨어져도 괜찮은 최대 높이입니다. 이 높이 이하면 뛰어내려서 이동하고 이 높이를 초과하면 다른 경로를 찾습니다.

- Jump Distance (점프 거리) 수평으로 뛸 수 있는 최대 거리입니다. 작은 틈을 뛰어넘을 수 있는 거리를 알려줍니다. 0이면 점프가 불가능합니다.재시도Claude는 실수를 할 수 있습니다. 응답을 반드시 다시 확인해 주세요.

NavMeshSurface 설정

Map의 컴포넌트인 NavMeshSurface 설명입니다.

- Agent Type (에이전트 타입) 어떤 크기/특성의 AI가 사용할 NavMesh인지 지정합니다. Navigation → Agents에서 정의한 타입들 중 선택하며, 서로 다른 크기의 AI가 다른 경로를 가질 수 있게 합니다.

- Default Area (기본 영역) NavMesh의 기본 영역 타입을 설정합니다. AI가 이동할 때의 비용을 결정하며, 여러 영역이 있을 때 AI는 비용이 낮은 곳을 선호합니다. Walkable, Not Walkable, Jump 등이 있습니다.

- Generate Links (링크 생성) 떨어진 NavMesh 영역들을 자동으로 연결할지 결정합니다. 체크하면 작은 틈이나 낙하지점을 자동으로 점프 연결하고, 체크 해제하면 수동으로 NavMesh Link를 추가해야 합니다.

- Use Geometry (지오메트리 사용) NavMesh 생성 시 어떤 지오메트리를 사용할지 선택합니다. Render Meshes는 보이는 모든 지형/건물을 포함하고, Physics Colliders는 Collider가 있는 오브젝트들만 사용합니다.

- Collect Objects (오브젝트 수집) NavMesh 생성 시 어떤 범위의 오브젝트를 포함할지 설정합니다. All Game Objects는 Scene의 모든 오브젝트를 검사하고, Children은 현재 오브젝트의 자식들만, Volume은 특정 범위 안의 오브젝트만 검사합니다.

- Include Layers (포함 레이어) 어떤 레이어의 오브젝트들을 NavMesh에 포함할지 레이어 마스크로 선택합니다. Default, Ground는 지형만 포함하고, Everything은 모든 레이어를 포함합니다.

- NavMesh Data (NavMesh 데이터) 생성된 NavMesh 정보가 저장되는 곳입니다. 여러 Scene에서 같은 NavMesh를 공유하거나, NavMesh 데이터를 에셋으로 저장할 때 사용합니다.

NavMesh Agent 설정

AI캐릭터에 있을 NavMesh Agent 설명입니다.

- Agent Type (에이전트 타입) 사용할 Agent 타입을 지정합니다. Navigation → Agents에서 정의한 타입 중 선택하며, 각 타입은 서로 다른 이동 특성(크기, 속도, 점프능력 등)을 가집니다.

- Base Offset (기본 오프셋) Agent의 기준점에서 실제 바닥까지의 거리를 설정합니다. 캐릭터가 바닥에 정확히 서있도록 조정하는 값으로, 양수는 위로, 음수는 아래로 이동시킵니다.

- Speed (속도) Agent가 이동할 때의 최대 속도입니다. 목적지까지 이동하는 기본 속력을 결정하며, 코드에서 동적으로 변경 가능합니다.

- Angular Speed (회전 속도) Agent가 방향을 바꿀 때의 회전 속도 (도/초)입니다. 값이 클수록 빠르게 회전하고, 값이 작으면 천천히 부드럽게 회전합니다.

- Acceleration (가속도) Agent가 속도를 변경할 때의 가속도입니다. 정지 상태에서 최대 속도까지 도달하는 시간과 급정거 시 멈추는 시간을 결정합니다.

- Stopping Distance (정지 거리) 목적지에 도달했다고 판단하는 거리입니다. 이 거리 내에 들어오면 Agent가 목적지에 도착한 것으로 간주하고 이동을 멈춥니다.

- Auto Braking (자동 제동) 목적지 근처에서 자동으로 감속할지 결정합니다. 체크하면 목적지 근처에서 부드럽게 멈추고, 체크 해제하면 일정 속도로 이동합니다.

- Radius (반지름) Agent의 충돌 반지름을 설정합니다. 다른 Agent나 장애물과의 거리를 유지하며, 값이 클수록 다른 객체들과 멀리 떨어져서 이동합니다.

- Height (높이) Agent의 충돌 높이를 설정합니다. 낮은 천장이나 장애물 아래를 지날 수 있는지 판단하는 기준이 됩니다.

- Quality (품질) 경로 계산의 정밀도를 설정합니다. High Quality는 정확하지만 무겁고, Low Quality는 빠르지만 부정확할 수 있습니다.

- Priority (우선순위) 다른 Agent들과 충돌 회피 시의 우선순위입니다. 낮은 값일수록 높은 우선순위를 가지며, 다른 Agent들이 이 Agent를 피해서 이동합니다.

- Obstacle Avoidance (장애물 회피) 동적 장애물 회피 기능을 사용할지 결정합니다. 체크하면 움직이는 장애물이나 다른 Agent들을 실시간으로 피해서 이동합니다.

- Auto Traverse Off Mesh Link (자동 오프메시 링크 횡단) NavMesh 간의 연결고리를 자동으로 건드릴지 결정합니다. 체크하면 점프나 낙하 지점을 자동으로 통과하고, 체크 해제하면 Off Mesh Link에 도달했을 때 수동으로 처리해야 합니다.

- Auto Repath (자동 경로 재계산) 경로가 무효화되었을 때 자동으로 새 경로를 계산할지 결정합니다. 체크하면 장애물이 생기거나 목적지가 변경될 때 자동으로 경로를 다시 찾고, 체크 해제하면 수동으로 경로를 재계산해야 합니다.

- Area Mask (영역 마스크) Agent가 이동 가능한 NavMesh 영역을 제한합니다. 선택된 영역에만 경로를 생성하며, 특정 영역을 금지구역으로 설정하거나 특별한 경로만 사용하도록 제한할 수 있습니다.

Unity NavMesh 주요 함수 가이드

NavMeshAgent 기본 함수

이동 관련

// 목표 지점으로 이동
NavMeshAgent agent = GetComponent<NavMeshAgent>();
agent.SetDestination(targetPosition);

// 이동 중인지 확인
if (agent.pathPending || agent.remainingDistance > 0.1f)
{
    // 아직 이동 중
}

// 목표 지점에 도달했는지 확인
if (!agent.pathPending && agent.remainingDistance < 0.1f)
{
    // 목표 지점 도달
}

// 이동 중지
agent.Stop();
agent.isStopped = true;

// 이동 재개
agent.isStopped = false;
agent.Resume();

속도 및 회전 제어

// 이동 속도 설정
agent.speed = 5f;

// 회전 속도 설정
agent.angularSpeed = 120f;

// 가속도 설정
agent.acceleration = 8f;

// 정지 거리 설정
agent.stoppingDistance = 2f;

// 자동 회전 끄기/켜기
agent.updateRotation = false;
agent.updateRotation = true;

경로 관련

// 경로 계산
NavMeshPath path = new NavMeshPath();
agent.CalculatePath(targetPosition, path);

// 경로 상태 확인
if (path.status == NavMeshPathStatus.PathComplete)
{
    // 경로 완성됨
}

// 경로 설정
agent.SetPath(path);

// 현재 경로 정보
Vector3[] pathCorners = agent.path.corners;
float pathLength = agent.path.GetCornersNonAlloc(pathCorners);

NavMesh 유틸리티 함수

위치 검색

// 가장 가까운 NavMesh 포인트 찾기
NavMeshHit hit;
if (NavMesh.SamplePosition(transform.position, out hit, 10f, NavMesh.AllAreas))
{
    Vector3 closestPoint = hit.position;
}

// 특정 영역에서 랜덤 포인트 찾기
Vector3 randomPoint = Random.insideUnitSphere * 10f;
randomPoint += transform.position;
if (NavMesh.SamplePosition(randomPoint, out hit, 10f, NavMesh.AllAreas))
{
    Vector3 validRandomPoint = hit.position;
}

경로 찾기

// 두 점 사이의 경로 계산
NavMeshPath path = new NavMeshPath();
bool pathFound = NavMesh.CalculatePath(startPos, endPos, NavMesh.AllAreas, path);

if (pathFound && path.status == NavMeshPathStatus.PathComplete)
{
    // 유효한 경로 존재
    Vector3[] corners = path.corners;
}

레이캐스트

// NavMesh 레이캐스트 (장애물 확인)
NavMeshHit hit;
bool blocked = NavMesh.Raycast(transform.position, targetPosition, out hit, NavMesh.AllAreas);

if (blocked)
{
    // 장애물 있음
    Vector3 hitPoint = hit.position;
}

NavMesh 영역 관리

영역 설정

// 특정 영역만 사용
int walkableArea = 1 << NavMesh.GetAreaFromName("Walkable");
int jumpArea = 1 << NavMesh.GetAreaFromName("Jump");
int combinedAreas = walkableArea | jumpArea;

agent.areaMask = combinedAreas;

// 모든 영역 사용
agent.areaMask = NavMesh.AllAreas;

영역 비용 설정

// 영역별 이동 비용 설정
NavMeshAgent agent = GetComponent<NavMeshAgent>();
agent.SetAreaCost(NavMesh.GetAreaFromName("Water"), 3f);
agent.SetAreaCost(NavMesh.GetAreaFromName("Mud"), 2f);

고급 기능

Off-Mesh Link 처리

// Off-Mesh Link 사용 중인지 확인
if (agent.isOnOffMeshLink)
{
    // 수동으로 Off-Mesh Link 완료
    agent.CompleteOffMeshLink();
}

// Off-Mesh Link 자동 처리 끄기
agent.autoTraverseOffMeshLink = false;

장애물 회피

// 장애물 회피 설정
agent.obstacleAvoidanceType = ObstacleAvoidanceType.HighQualityObstacleAvoidance;
agent.avoidancePriority = 50; // 0(높음) ~ 99(낮음)
agent.radius = 0.5f;
agent.height = 2f;

동적 NavMesh 업데이트

// NavMesh 베이킹 (런타임)
NavMeshBuilder.BuildNavMesh();

// NavMesh 데이터 업데이트
NavMeshHit hit;
if (NavMesh.SamplePosition(transform.position, out hit, 1f, NavMesh.AllAreas))
{
    // 새로운 NavMesh 데이터 사용
}

유용한 속성들

상태 확인

// 현재 상태 확인
bool isMoving = agent.velocity.magnitude > 0.1f;
bool hasPath = agent.hasPath;
bool isOnNavMesh = agent.isOnNavMesh;
bool pathPending = agent.pathPending;

// 거리 정보
float remainingDistance = agent.remainingDistance;
float stoppingDistance = agent.stoppingDistance;

위치 정보

// 현재 위치 정보
Vector3 currentPosition = agent.transform.position;
Vector3 destination = agent.destination;
Vector3 nextPosition = agent.nextPosition;
Vector3 velocity = agent.velocity;

실전 예제

기본 적 AI 이동

public class EnemyAI : MonoBehaviour
{
    private NavMeshAgent agent;
    private Transform target;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        target = GameObject.FindGameObjectWithTag("Player").transform;
    }

    void Update()
    {
        if (target != null)
        {
            agent.SetDestination(target.position);
        }
    }
}

순찰 AI

public class PatrolAI : MonoBehaviour
{
    private NavMeshAgent agent;
    public Transform[] waypoints;
    private int currentWaypoint = 0;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        if (waypoints.Length > 0)
        {
            agent.SetDestination(waypoints[0].position);
        }
    }

    void Update()
    {
        if (!agent.pathPending && agent.remainingDistance < 0.5f)
        {
            currentWaypoint = (currentWaypoint + 1) % waypoints.Length;
            agent.SetDestination(waypoints[currentWaypoint].position);
        }
    }
}

랜덤 이동

public class RandomMovement : MonoBehaviour
{
    private NavMeshAgent agent;
    public float wanderRadius = 10f;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        SetRandomDestination();
    }

    void Update()
    {
        if (!agent.pathPending && agent.remainingDistance < 0.5f)
        {
            SetRandomDestination();
        }
    }

    void SetRandomDestination()
    {
        Vector3 randomDirection = Random.insideUnitSphere * wanderRadius;
        randomDirection += transform.position;

        NavMeshHit hit;
        if (NavMesh.SamplePosition(randomDirection, out hit, wanderRadius, NavMesh.AllAreas))
        {
            agent.SetDestination(hit.position);
        }
    }
}

1. AI 상태 분류
2. 플레이어 감지
3. 중간 결과 1
4. 추적 상태
5. 중간 결과 2
6. 공격 판정
7. 최종 결과

🤖 AI 상태 분류

AI에게는 여러 행동들이 있습니다. 일단 행동들의 부모가 될 추상 클래스 EnemyState스크립트와 IdleState(대기), PatrolState(순찰), ChaseState(추적), AttackState(공격)스크립트를 생성합니다.

// EnemyState.cs

public abstract class EnemyState
{
    protected Enemy enemy;

    public EnemyState(Enemy enemy)
    {
        this.enemy = enemy;
    }

    public abstract void Enter();
    public abstract void Update();
    public abstract void Exit();
}

// IdleState.cs

public class IdleState : EnemyState
{
    // 생성자 문법
    // public 생성자(매개변수) : 부모생성자호출 {생성자 내용}
    // 생성자 내용이 빈 이유는 부모 생성자가 이미 다 해줘서
    public IdleState(Enemy enemy) : base(enemy) { }
    public override void Enter()
    {
        Debug.Log("적이 대기 상태로 진입");
    }

    public override void Update()
    {
        Debug.Log("적이 대기 행동을 하는 중");
    }

    public override void Exit()
    {
        Debug.Log("적이 대기 행동을 벗어남");
    }
}

// PatrolState.cs

public class PatrolState : EnemyState
{
    public PatrolState(Enemy enemy) : base(enemy) { }
    public override void Enter()
    {
        Debug.Log("적이 순찰 상태로 진입");
    }

    public override void Update()
    {
        Debug.Log("적이 순찰 행동을 하는 중");
    }

    public override void Exit()
    {
        Debug.Log("적이 순찰 행동을 벗어남");
    }
}

// ChaseState.cs

public class ChaseState : EnemyState
{
    public ChaseState(Enemy enemy) : base(enemy) { }
    public override void Enter()
    {
        Debug.Log("적이 추적 상태로 진입");
    }

    public override void Update()
    {
        Debug.Log("적이 추적 행동을 하는 중");
    }

    public override void Exit()
    {
        Debug.Log("적이 추적 행동을 벗어남");
    }
}

// AttackState.cs

public class AttackState : EnemyState
{
    public AttackState(Enemy enemy) : base(enemy) { }
    public override void Enter()
    {
        Debug.Log("적이 공격 상태로 진입");
    }

    public override void Update()
    {
        Debug.Log("적이 공격 행동을 하는 중");
    }

    public override void Exit()
    {
        Debug.Log("적이 공격 행동을 벗어남");
    }
}

// Enemy.cs

private EnemyState currentState;

protected override void Start()
{
    // 처음은 대기상태
    ChangeState(new IdleState(this));
    base.Start();
}

private void Update()
{
    currentState?.Update();
}

// EnemyState를 바꿔주는 함수
public void ChangeState(EnemyState newState)
{
    currentState?.Exit();        // 현재 상태에서 벗어나고
    currentState = newState;    // 새로운 상태를 할당
    currentState?.Enter();        // 새로운 상태에 진입
}

처음 생성될땐 대기 상태로 진입했다는 로그를 볼 수 있습니다.

임의로 2초 이상이 흐를 경우 대기 행동을 벗어나도록 했습니다. 그러면 2초간 Update함수가 호출되다가 Exit하게 됩니다.

👾 플레이어 감지

플레이어가 일정범위안에 들어가고, 적이 볼 수 있는 시야(각도)내에 들어와야 합니다. 또한, 장애물이 있을 경우 감지하지 않은 것으로 처리될겁니다.

// Enemy.cs

private GameObject player;

private float fieldOfViewAngle = 120f;
public float sightRange = 10f;    
public float attackRange = 2f;

protected override void Start()
{
    player = GameObject.Find("Player");
    maxHealth = enemyData.maxHealth;
    ChangeState(new IdleState(this));
    base.Start();
}
private void Update()
{
    if (CanSeePosition(player.transform) && !IsObstacleBetween(player.transform) && IsInDistance(player.transform))
    {
        Debug.Log("플레이어 발견!!");
    }
    else
    {
        Debug.Log("찾는 중.....");
    }
}

// 플레이어를 볼 수 있는 각도인지
public bool CanSeeAngle(Transform target)
{
    Vector3 directionToTarget = (target.position - transform.position).normalized;
    float angleToTarget = Vector3.Angle(transform.forward, directionToTarget);
    // 각도는 좌우 대칭이므로 나누기 2
    return angleToTarget <= fieldOfViewAngle / 2f;
}

// Raycast에 닿은 것이 플레이어인지 사물인지 (벽이나 다른 사물이라면 true)
public bool IsObstacleBetween(Transform target)
{
    Vector3 direction = (target.position - transform.position).normalized;
    float distance = Vector3.Distance(transform.position, target.position); 

    if (Physics.Raycast(transform.position, direction, out RaycastHit hit, distance))
    {
        return hit.transform != target;
    }
    return false;
}

// 감지 가능 거리 안에 있는지
public bool IsInDistance(Transform target)
{
    return Vector3.Distance(transform.position, target.position) <= sightRange; 
}

🎮 중간 결과 1

각도, 거리, 충돌에 따라 감지하는 로그가 띄워집니다.

🏃 추적 상태

적의 시야내에 플레이어가 온다면 추적 상태로 바꾸는 로직을 짜겠습니다.

1. ChangeState

// Enemy.cs

private bool isChase = false;

private void Update()
{
    if (CanSeeAngle(player.transform) && !IsObstacleBetween(player.transform) && IsInDistance(player.transform))
    {
        if (!isChase)
        {
            // 시야내에 있다면 ChaseState로 변경
            ChangeState(new ChaseState(this));
            isChase = true;
        }
    }
    else
    {
        // 추적 중 사라진다면 IdleState로 변경
        if (isChase)
        {
            ChangeState(new IdleState(this));
            isChase = false;
        }
    }

    // isChase가 true일때 isChase의 Update를 실행함
    if (isChase)
    {
        currentState.Update();
    }
}

2. 이동

플레이어를 향해 회전하고 이동하는 코드를 짜봅시다.

// ChaseState.cs

private void Moving()
{
    Vector3 direction = (enemy.target.transform.position - enemy.transform.position).normalized;
    // y는 0으로 해서 수직상승을 하지 않게 함
    enemy.rb.MovePosition(enemy.transform.position + new Vector3(direction.x, 0, direction.z) * enemy.enemyData.moveSpeed);
    if (direction != Vector3.zero)
    {
        // y는 0으로 하여 돌아가지 않게 함
        Quaternion targetRotation = Quaternion.LookRotation(new Vector3(direction.x, 0, direction.z));
        enemy.transform.rotation = Quaternion.Slerp(enemy.transform.rotation, targetRotation, enemy.enemyData.rotationSpeed * Time.deltaTime);
    }
}

// Enemy.cs

// 중간에 Enemy가 회전하지 않기 위한 설정
protected override void Start()
{
    rb = GetComponent<Rigidbody>();
    // 질량 증가 - 다른 물체에게 밀리지 않도록 무겁게 만듦
    rb.mass = 10f;                    
    // 공기 저항 - 이동 시 점점 느려지게 해서 부드러운 정지
    rb.drag = 10f;                    
    // 회전 저항 - 회전 시 빠르게 멈추게 해서 흔들림 방지
    rb.angularDrag = 20f;             
    // X, Z축 회전 고정 - 앞뒤/좌우로 넘어지지 않게 (Y축 회전만 허용)
    rb.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ;  
    // 무게중심을 아래쪽으로 이동 - 바닥에 가깝게 해서 안정성 증가                 
    rb.centerOfMass = new Vector3(0, -0.5f, 0);                   
}

3. 상태 전환

적 상태를 효율적으로 관리하기 위해 StateType을 생성합시다.

// StateType.cs

public enum StateType
{
    Idle,
    Chase,
    Attack,
    Patrol,
    Dead
}

// EnemyState.cs

public abstract StateType CurrentStateType { get; }

// IdleState.cs

public override StateType CurrentStateType => StateType.Idle;

// PatrolState.cs

public override StateType CurrentStateType => StateType.Patrol;

// ChaseState.cs

public override StateType CurrentStateType => StateType.Chase;

// AttackState.cs

public override StateType CurrentStateType => StateType.Attack;

// Enemy.cs

private void Update()
{
    switch(currentState.CurrentStateType)
    {
        case StateType.Idle:
            DoIdle();
            break;
        case StateType.Patrol:
            DoPatrol();
            break;
        case StateType.Chase:
            DoChase();
            break;
        case StateType.Attack:
            DoAttack();
            break;
        case StateType.Dead:
            break;
        default:
            break;
    }
    currentState.Update();
}

// Idle일때 목표를 포착하면 Chase로
private void DoIdle()
{
    if (CanSeeAngle(target.transform) && !IsObstacleBetween(target.transform) && IsInDistance(target.transform))
    {
        ChangeState(new ChaseState(this));
    }
}

// Patrol일때 목표를 포착하면 chase로
private void DoPatrol()
{
    if (CanSeeAngle(target.transform) && !IsObstacleBetween(target.transform) && IsInDistance(target.transform))
    {
        ChangeState(new ChaseState(this));
    }
}

// Chase일때 공격범위 내에 들어오면 Attack으로, 나간다면 Idle로
private void DoChase()
{
    if (IsInAttackRange(target.transform))
    {
        ChangeState(new AttackState(this));
    }
    else if (!IsInDistance(target.transform))
    {
        ChangeState(new IdleState(this));
    }

}

// Attack일때 공격범위에서 나간다면 Idle로
private void DoAttack()
{
    if (!IsInAttackRange(target.transform))
    {
        ChangeState(new IdleState(this));
    }
}

🎮 중간 결과 2

플레이어를 포착하면 따라오고, 공격범위 내에 들어온다면 멈춰서 공격하는 모습입니다.

🗡️ 공격 판정

실제로 공격을 하고 데미지를 받는 것을 처리해봅시다. 여러가지 방법이 있지만, 전 OnTriggerEnter을 이용했습니다.

1. AttackPoint

적이 공격하는 범위를 설정합니다. AttackPoint라는 빈 오브젝트를 만들어 Collider를 넣고 IsTrigger를 체크합니다.

2. AttackCollider

충돌을 관리할 AttackCollider 스크립트를 생성합시다.

// AttackCollider.cs

public class AttackCollider : MonoBehaviour
{
    private Enemy enemy;

    void Start()
    {
        enemy = GetComponentInParent<Enemy>();

        // 시작할 때는 콜라이더 비활성화
        GetComponent<Collider>().enabled = false;
    }

    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            other.gameObject.GetComponent<PlayerState>().ModifyHealth(-enemy.enemyData.damage);
            Debug.Log($"플레이어 체력 {enemy.enemyData.damage} 감소!");
        }
    }
}

2. 쿨타임을 적용한 공격

만약 공격범위내에 있다면 적은 공격을 시도하게 됩니다. 그 시도는 Collider를 활성화 하는 것으로 적용됩니다.

// AttackState.cs

private float currentCooldown;

public override void Enter()
{
    currentCooldown = enemy.enemyData.attackCooldown;
}

public override void Update()
{
    if (CanAttack())
    {
        enemy.PerformAttack();
    }
}

private bool CanAttack()
{
    currentCooldown -= Time.deltaTime;
    if (currentCooldown <= 0)
    {
        Debug.Log("공격!");
        currentCooldown = enemy.enemyData.attackCooldown;
        return true;
    }
    return false;
}

🎮 최종 결과

투명한 원 부분이 적의 공격 범위 입니다.

📚 오늘의 배운 점

• State 변환으로 몹 상태 변경
• AI 추격 시스템
• Collider를 이용한 공격 판정

🎯 다음 계획

다음 글에서는:

1. 다양한 몹 제작
2. AI시스템 추가 및 구체화, 수정

1. UI 생성
2. 데이터 옮기기
3. Equipment 슬롯 설정
4. 최종 결과
5. 오늘의 배운 점
6. 다음 계획

🎨 UI 생성

일단 탈착을 위해서는 별도의 UI창이 필요합니다. Inventory_Panel에서 EquipmentSlots라는 빈 오브젝트를 생성합시다. 그리고 본래 있는 Slot Prefab을 복사하여 EquipmentSlot이란 프리팹을 만듭시다. UI예시는 다음과 같습니다.

🚗 데이터 옮기기

1. ItemData변경

현재 아이템이 탈착이 가능한 아이템인지 아닌지를 판별해야합니다.

// ItemData.cs

public EquipmentType equipmentType;

public enum EquipmentType
{
    None,
    Face,
    Body,
    Back
}

2. 배열에 추가

인벤토리 창에서 탈착이 가능한 아이템을 더블클릭하면 아이템이 옮겨지게 할 겁니다. PlayerState에 새 배열 변수가 필요할 겁니다.

// PlayerState.cs

// 에디터의 Inspector에서 배열 3개 추가
public ItemInstance[] equipmentItems;

public void AddEquipmentItem(ItemInstance item)
{
    switch (item.itemData.equipmentType)
    {
        case EquipmentType.Face:
            SetEquipmentItems(0, item);
            break;
        case EquipmentType.Body:
            SetEquipmentItems(1, item);
            break;
        case EquipmentType.Back:
            SetEquipmentItems(2, item);
            break;
        default:
            break;
    }
}

private void SetEquipmentItems(int index, ItemInstance item)
{
    if (equipmentItems[index])
    {
        inventory.AddItem(equipmentItems[index]);
        uiManager.UpdateItemUI();
    }
    equipmentItems[index] = item;
}

3. 더블클릭 처리

기존 함수에 추가합니다.

// UIManager.cs

public void OnInventorySlotDoubleClick(int slotIndex)
{
    if (!inventory.items[slotIndex]) return;

    // 장착 아이템
    if (inventory.items[slotIndex].itemData.equipmentType != EquipmentType.None)
    {
        playerState.AddEquipmentItem(inventory.items[slotIndex]);
        inventory.RemoveItem(slotIndex);
        UpdateItemUI();
        return;
    }

    // 물, 식량, 힐팩 아이템
    if (inventory.items[slotIndex].itemData.itemType == ItemType.BioState && inventory.UseItem(slotIndex))
    {
        Destroy(inventory.items[slotIndex].gameObject);
        inventory.RemoveItem(slotIndex);
        UpdateItemUI();
        return;
    }
}

🔁 Equipment 슬롯 설정

1. 스크립트 제작

EquipmentSlot 스크립트를 추가하여 관리합시다.

// EquipmentSlot.cs

using UnityEngine;
using UnityEngine.UI;

public class EquipmentSlot : MonoBehaviour
{
    // 비어있을때 아이콘
    [SerializeField] private Sprite slotImage;

    // 현재 슬롯의 타입 (얼굴, 몸, 등)
    public EquipmentType equipmentType;

    // 변경할 아이템 이미지 위치
    private Image itemIcon;

    private void Start()
    {
        itemIcon = transform.Find("ItemIcon").GetComponent<Image>();
    }

    public void SetEquipmentSlot(ItemInstance item)
    {
        if (item)
        {
            itemIcon.sprite = item.itemData.icon;
            itemIcon.color = Color.white;
        }
        else
        {
            itemIcon.sprite = slotImage;
            itemIcon.color = new Color(255, 255, 255, 100);
        }
    }
}

2. 장착할때

인벤토리에서 더블클릭하면 이동한 것이 보이게 합시다.

// UIManager.cs

public GameObject equipmentSlotPanel;

private EquipmentSlot[] equipmentSlots;

void Start()
{    
    if (equipmentSlotPanel != null)
    {
        equipmentSlots = equipmentSlotPanel.GetComponentsInChildren<EquipmentSlot>();
    }
}

// 이 함수를 OnInventorySlotDoubleClick 함수에 추가!
private void UpdateEquipmentUI(EquipmentType type, ItemInstance item)
{
    switch(type)
    {
        case EquipmentType.Face:
            equipmentSlots[0].SetEquipmentSlot(item);
            break;
        case EquipmentType.Body:
            equipmentSlots[1].SetEquipmentSlot(item);
            break;
        case EquipmentType.Back:
            equipmentSlots[2].SetEquipmentSlot(item);
            playerItemHandler.SetBackSocket(item);
            break;
        default:
            break;
    }
}

// PlayerItemHandler.cs

public void SetBackSocket(ItemInstance item)
{
    if (!item || item == backSocketItem) return;
    backSocketItem = item;
    SetHoldingItem(backSocketItem, backSocket);
    // 더블클릭한 아이템이 현재 들고 있는 아이템일 경우에만 null로 할당!
    if (item == currentItem)
    {
        currentItem = null;
    }
}

3. 떼어낼때

탈착형 아이템은 착용을 하고 떼어내는 것도 필요합니다. 그것은 EquipmentSlot에서 더블클릭 이벤트로 합시다.

// EquipmentSlot.cs

public void OnPointerClick(PointerEventData eventData)
{
    if (eventData.clickCount == 2)
    {
        RemoveItem(equipmentType);
    }
}

public void SetEquipmentSlot(ItemInstance item)
{
    if (item)
    {
        itemIcon.sprite = item.itemData.icon;
        itemIcon.color = Color.white;
    }
    else
    {
        itemIcon.sprite = slotImage;
        itemIcon.color = new Color(1, 1, 1, 0.5f);
    }
}

private void RemoveItem(EquipmentType type)
{
    int index = -1;
    if (type == EquipmentType.Face) index = 0;
    else if (type == EquipmentType.Body) index = 1;
    else if (type == EquipmentType.Back) index = 2;
    else return;

    if (!inventory.AddItem(playerState.equipmentItems[index]) || !playerItemHandler) return;

    if (index == 0) return;
    else if (index == 1) return;
    else if (index == 2) playerItemHandler.ClearBackSocketHolding();

    playerState.equipmentItems[index] = null;
    SetEquipmentSlot(null);

    uiManager.UpdateItemUI();
}

// PlayerItemHandler.cs

public void ClearBackSocketHolding()
{
    if (!backSocketItem) return;
    backSocketItem.gameObject.SetActive(false);
    backSocketItem = null;
}

🎮 최종 결과

인벤토리를 열고 장착하면 UI가 뜨며 아이템을 사용할 수 있는 모습입니다. 만약에 연료가 0%가 된다면 아이템은 사용할 수 없으며, 충전이 되어 있는 연료통으로 갈아끼울시 다시 사용 가능합니다. (모듈형)

📚 오늘의 배운 점

• 더블클릭으로 아이템 탈착

🎯 다음 계획

다음 글에서는:

1. 몹 (Enemy) 제작
   • AI 행동 패턴 설계

1. 제트팩 장착
2. 날아오르기
3. 중간 결과
4. UI 표시
5. 최종 결과
6. 오늘의 배운 점
7. 다음 계획

🚀 제트팩 장착

제트팩은 등 뒤에 장착하겠습니다. Player에게 BackSocket이라는 빈 오브젝트를 등에 달아줍니다. 그리고 PlayerItemHandler에서 관리합시다.

// PlayerItemHandler.cs

[HideInInspector] public ItemInstance backSocketItem;

[Header("Socket")]
public Transform backSocket;

public void SetBackSocket(ItemInstance item)
{
    if (!item || item == backSocketItem) return;
    backSocketItem = item;
    SetActiveCurrentItem(backSocketItem, backSocket);
}

// 본래 있던 함수를 변형함
// 다른 Bone에도 붙일 수 있게끔 item과 해당 위치의 transform을 인수에 둠
private void SetHoldingItem(ItemInstance item, Transform transform)
{
    if (!item) return;

    item.transform.position = transform.position;
    item.transform.rotation = transform.rotation;

    item.transform.SetParent(transform);
    item.transform.localPosition = Vector3.zero;
    item.transform.localRotation = Quaternion.identity;

    Rigidbody rb = item.GetComponent<Rigidbody>();
    if (rb) rb.isKinematic = true;

    Collider[] colliders = item.GetComponents<Collider>();
    foreach (Collider collider in colliders)
    {
        collider.enabled = false;
    }

    item.gameObject.SetActive(true);
}

// UseItem.cs

public void UseItems(ItemInstance item)
{
    switch(item.itemData.itemName)
    {
        case "스캐너":
            if (Input.GetMouseButtonDown(1)) UseScanner();
            break;
        case "나이프":
            if (Input.GetMouseButtonDown(0)) UseKnife(item.itemData.attackPower);
            break;
        case "제트팩":
            if (Input.GetMouseButtonDown(1)) UseJetPack(item);
            break;
        default:
            return;
    }
}

private void UseJetPack(ItemInstance item)
{
    if (chargeUIOpen) return;
    playerItemHandler.SetBackSocket(item);
}

우클릭을 누르면 플레이어의 등에 장착하게 됩니다.

🚀 날아오르기

이 게임에서 제트팩의 효과는 점프가 더 높이되며, 내려올때 천천히 내려와 낙하데미지를 입지 않는 것입니다. JetpackController 스크립트를 생성합시다.

// JetpackController.cs

using UnityEngine;

public class JetpackController : MonoBehaviour
{
    [Header("Jetpack Settings")]
    public float jetpackForce = 15f;        // 제트팩 추진력
    public float maxAltitude = 50f;         // 최대 고도
    public float gravityScale = 1f;         // 중력 영향

    private ItemInstance jetPack;
    private Rigidbody rb;
    private float groundLevel;              // 지면 높이
    private bool isUsingJetpack;
    private GameObject player;

    private float foolPowerTime = 5f;        // 허공에 머물러 있을 수 있는 시간
    private float currentPowerTime;

    void Start()
    {
        player = GameObject.Find("Player");
        jetPack = GetComponent<ItemInstance>(); 
        rb = player.GetComponent<Rigidbody>();
        groundLevel = player.transform.position.y;  // 시작 지점을 지면으로 설정
        currentPowerTime = foolPowerTime;
    }

    void Update()
    {
        Debug.Log($"현재 제트팩 가능 게이지 : {currentPowerTime}");
        bool isCan = false;
        if (Input.GetKey(KeyCode.Space))
        {
            // 허공에 있을 수 있는 게이지가 모두 닳아버릴 경우 천천히 떨어짐
            if (currentPowerTime > 0)
            {
                currentPowerTime -= Time.deltaTime; // 누르고 있을 때는 게이지가 줄어듬
                isCan = CanUseFuelProduct(jetPack);
            }
            isUsingJetpack = isCan;
        }
        else // 누르고 있지 않을 때는 게이지가 느리게 채워짐
        {
            if (currentPowerTime <= foolPowerTime)
            {
                currentPowerTime += Time.deltaTime / 3;
            }
            isUsingJetpack = false;
        }
    }

    private void FixedUpdate()
    {
        if (isUsingJetpack)
        {
            UseJetpack();
        }
    }

    private bool CanUseFuelProduct(ItemInstance jetPack)
    {
        ItemInstance fuel = jetPack.Get<ItemInstance>("Fuel");
        if (!fuel)
        {
            Debug.Log("현재 연료통이 존재하지 않습니다!");
            return false;
        }
        float rate = fuel.Get<float>("fuelUsageRate");
        if (rate <= 0)
        {
            Debug.Log("연료가 모두 소진되었습니다!");
            return false;
        }
        rate -= Time.deltaTime;
        fuel.Set<float>("fuelUsageRate", rate);
        return true;
    }

    void UseJetpack()
    {
        // 현재 고도
        float currentAltitude = player.transform.position.y - groundLevel;

        if (currentAltitude < maxAltitude)
        {
            // 만약 있을 수 있는 고도면 위로 날 수 있게
            rb.AddForce(Vector3.up * jetpackForce, ForceMode.Force);
        }
        else
        {
            // 아니라면 더이상 올라가지 못함
            rb.AddForce(Vector3.up * (jetpackForce * 0.3f), ForceMode.Acceleration);
        }
    }
}

🎮 중간 결과

플레이어가 공중에서 잠시 뜰 수 있게 됩니다. 고도 제한과 시간 등의 설정은 나중에 밸런스를 맞추도록 합시다.

🎨 UI표시

제트팩은 현재 연료량과 날 수 있는 제한 시간에 대한 UI 표시가 필요합니다. HUD_Panel에서 JetpackBar의 빈 오브젝트를 생성하고, 다른 HUD와 비슷하게 설정할겁니다. Background_Bar(Image), Fill_Bar(Image, FuelRate(Text)란 자식 오브젝트를 생성합시다.

UIManager에서 편집하도록 합시다.

// UIManager.cs

[Header("Bar")]
public GameObject jetpackBar;
public Image jetpackGaugeBar;

[Header("Text")]
public Text jetPackRateText;

private UseItem useItem;

void Start()
{
    // 기존 코드...
    if (player)
    {
        useItem = player.GetComponent<UseItem>();
    }
    // 기존 코드...
}

public void UpdateJetpackUI(ItemInstance jetpack, float time, float foolTime)
{
    if (!jetpackBar || !jetpackGaugeBar || !jetpackRateText || !jetpack) return;

    JetpackController jetpackController = jetpack.GetComponent<JetpackController>();
    jetpackBar.SetActive(true);

    jetpackGaugeBar.fillAmount = time / foolTime;

    ItemInstance fuel = jetpack.Get<ItemInstance>("Fuel");
    int displayRate = 0;

    if (fuel)
    {
        displayRate = Mathf.Max(0, (int)fuel.Get<float>("fuelUsageRate"));
        Debug.Log(jetpack.Get<float>("fuelUsageRate"));
        jetpackRateText.text = displayRate.ToString() + "%";
    }
    else
    {
        jetpackRateText.text = "None";
    }
}

// JetpackController.cs

void Update()
{
    // 기존 코드...
    if (uiManager)
    {
        uiManager.UpdateJetpackUI(jetPack, currentPowerTime, foolPowerTime);
    }
    // 기존 코드...
}

🎮 최종 결과

📚 오늘의 배운 점

• Rigidbody를 이용한 비행
• 플레이어의 몸에 아이템 장착

🎯 다음 계획

다음 글에서는:

1. 현재 장착 아이템을 인벤토리에 표시
2. 더블클릭으로 탈착 구현

1. 배터리 교체 UI
2. 배터리 관리
3. 배터리 사용 아이템 조건 추가
4. 중간 결과
5. 연료 교체 및 관리
6. 연료 사용
7. 최종 결과
8. 오늘의 배운 점
9. 다음 계획

🔋 배터리 교체 UI

배터리를 넣거나 바꾸려면 UI가 필요합니다. HUD_Panel에 BatterySlots로 칸을 관리해줍니다.

// UIManager.cs

public GameObject batterySlotPrefab;
public GameObject batterySlotPanel;

// 현재 인벤토리에 있는 배터리 아이템을 보여줌
public void ShowBatterySlots(ItemInstance[] batterys, ItemInstance currentBattery)
{
    batterySlotPanel.SetActive(true);
    for (int i = 0; i < batterys.Length; i++)
    {
        GameObject slot = Instantiate(batterySlotPrefab, batterySlotPanel.transform);
        Image itemImage = slot.transform.Find("ItemIcon").GetComponent<Image>();
        TextMeshProUGUI batteryRate = slot.transform.Find("BatteryRate").GetComponent<TextMeshProUGUI>();

        // 배터리가 없다면 None이라는 빈칸을 띄움
        if (!batterys[i])
        {
            itemImage.color = Color.clear;
            batteryRate.text = "None";
            continue;
        }

        itemImage.sprite = batterys[i].itemData.icon;
        int displayBattery = Mathf.Max(0, (int)batterys[i].Get<float>("batteryUsageRate"));
        // 현재 남은 배터리량 표시
        batteryRate.text = displayBattery.ToString() + "%";

        // 현재 들어있는 배터리는 불투명하게 표시
        if (currentBattery == batterys[i])
        {
            itemImage.color = Color.white;
            continue;
        }

        // 현재 선택되어 있지 않은 배터리들은 반투명하게 표시
        itemImage.color = new Color (1, 1, 1, 0.5f);
    }
}

// 배터리 교체 창 닫기 전 초기화
public void ClearBatterySlots()
{
    for (int i = batterySlotPanel.transform.childCount - 1; i >= 0; i--)
    {
        Destroy(batterySlotPanel.transform.GetChild(i).gameObject);
    }
}

public void SwitchBatterySlot(int index)
{
    for (int i = 0; i < batterySlotPanel.transform.childCount; i++)
    {
        GameObject slot = batterySlotPanel.transform.GetChild(i).gameObject;
        Image itemImage = slot.transform.Find("ItemIcon").GetComponent<Image>();

        // 현재 선택되어 있는 배터리
        if (index == i)
        {
            itemImage.color = Color.white;
        }
        // 그 외
        else
        {
            itemImage.color = new Color(1, 1, 1, 0.5f);
        }
    }
}

🔋 배터리 관리

배터리를 전담할 스크립트로 BatteryManager 스크립트를 생성합시다.

// BatteryManager.cs

public class BatteryManager : MonoBehaviour
{
    // 현재 들고 있는 아이템 (스캐너 등)
    private ItemInstance thisItem;
    // 아이템에 들어있는 배터리
    private ItemInstance currentBattery;

    // 현재 선택하고 있는 배터리 선택 창 인덱스
    private int currentIndex;
    private UIManager uiManager;
    private Inventory inventory;

    private void Start()
    {
        thisItem = GetComponent<ItemInstance>();
        currentBattery = thisItem.Get<ItemInstance>("Battery");
        uiManager = GameObject.Find("UIManager").GetComponent<UIManager>();
        inventory = GameObject.Find("Player").GetComponent<Inventory>();
    }

    public void SetBatterySlots()
    {
        currentBattery = thisItem.Get<ItemInstance>("Battery");
        uiManager.ShowBatterySlots(BatteryArray(inventory.items), currentBattery);
        uiManager.SwitchBatterySlot(currentIndex);
    }

    // 현재 보여줄 배터리 창의 인스턴스 배열
    public ItemInstance[] BatteryArray(ItemInstance[] items)
    {
        List<ItemInstance> list = new List<ItemInstance>();

        // 만약 현재 장착하고 있는 배터리가 있다면, 현재 배터리도 표시하기 위해 list에 추가함
        // 왜냐하면 장착한 배터리는 인벤토리에서 삭제할 것이기 때문
        if (currentBattery) list.Add(currentBattery);

        // 없다면 현재 배터리는 null상태임을 표시하기 위해 null을 추가함
        else list.Add(null);

        // 인벤토리에서 순차적으로 배터리만 꺼내 list에 넣음
        for (int i = 0; i < items.Length; i++)
        {
            if (!items[i]) continue;
            if (items[i].itemData.productType == ProductType.Battery)
            {
                list.Add(items[i]);
            }
        }
        // 배터리를 아예 빼내는 선택창도 필요하기 때문에 현재 배터리가 있다면 마지막에 null도 추가함
        if (currentBattery) list.Add(null);

        return list.ToArray();
    }

    // 현재 배터리를 설정함
    public void SetCurrentBattery(ItemInstance[] items)
    {
        // 설정 전 본래 배터리를 저장
        ItemInstance defaultBattery = currentBattery;
        currentBattery = BatteryArray(items)[currentIndex];
        // 현재 장착된 배터리를 선택한 배터리로 변경
        thisItem.Set<ItemInstance>("Battery", currentBattery);
        // 장착한 배터리를 인벤토리에서 삭제
        inventory.RemoveItemFromInstance(currentBattery);
        if (defaultBattery)
        {
            // 새로 장착한 배터리라면
            if (defaultBattery != currentBattery)
            {    
                // 본래 배터리는 인벤토리에 추가하고 UI 업데이트
                inventory.AddItem(defaultBattery);
                uiManager.UpdateItemUI();
            }
        }
        currentIndex = 0;
    }

    // 마우스의 왼클릭 우클릭으로 배터리를 선택함
    public void SetCurrentBatteryIndex(string button)
    {
        switch(button)
        {
            case "left":
                if (currentIndex > 0) currentIndex--;
                break;
            case "right":
                if (currentIndex < BatteryArray(inventory.items).Length - 1) currentIndex++;
                break;
            default:
                break;
        }
        uiManager.SwitchBatterySlot(currentIndex);
    }
}

🔋 배터리 사용 아이템 조건 추가

현재까지 만든 기능에는 Scanner가 배터리를 사용하고 있습니다. 그곳에 배터리가 있으며, 0% 가 초과할 때만 사용할 수 있게 조건을 추가합니다.

// UseItem.cs

private bool batteryUIOpen = false;

private void UseScannerInUpdate()
{
    if (!playerItemHandler.currentItem)
    {
        scanTime = 0f;
        isScan = false;
        uiManager.scanBar.SetActive(false);
        return;
    }

    ReloadBattery(playerItemHandler.currentItem);

    bool isCan = false;
    if (isScan && Input.GetMouseButton(1) && !batteryUIOpen)
    {
        // 현재 장착한 배터리가 있거나, 쓸 수 있는지 판별
        isCan = CanUseBatteryProduct();
        if (isCan)
        {
            scanTime += Time.deltaTime;

            if (scanTime >= 2f)
            {
                isScan = false;
                scanTime = 0f;
                playerState.AddUnlockedItems(scanItem.itemData);
                uiManager.scanBar.SetActive(false);
            }
            else
            {
                if (uiManager)
                {
                    uiManager.UpdateScanUI(scanTime);
                }
            }
        }
    }

    if ((isScan && Input.GetMouseButtonUp(1) && scanTime > 0f) || !interactionDetector.GetCurrentTarget() || 
        playerItemHandler.currentItem.itemData.itemName != "스캐너" || !isCan)
    {
        scanTime = 0f;
        isScan = false;
        uiManager.scanBar.SetActive(false);
    }
}

// 배터리 사용 아이템을 들고 있는 채로 R키를 누른다면 배터리 선택창이 뜸
private void ReloadBattery(ItemInstance item)
{
    if (!inventory) return;
    BatteryManager batteryManager = item.GetComponent<BatteryManager>();

    if (Input.GetKeyDown(KeyCode.R) && batteryManager)
    {
        if (!batteryUIOpen)
        { 
            batteryManager.SetBatterySlots();
            batteryUIOpen = true;
        }
        else
        {
            batteryManager.SetCurrentBattery(inventory.items);
            uiManager.ClearBatterySlots();
            uiManager.batterySlotPanel.SetActive(false);
            batteryUIOpen = false;
        }
    }
    // 열려있는 채로 마우스를 누르면 배터리를 선택할 수 있음
    if (batteryUIOpen)
    {
        if (Input.GetMouseButtonDown(0))
        {
            batteryManager.SetCurrentBatteryIndex("left");
        }
        else if (Input.GetMouseButtonDown(1))
        {
            batteryManager.SetCurrentBatteryIndex("right");
        }
    }
}

private bool CanUseBatteryProduct()
{
    ItemInstance battery = playerItemHandler.currentItem.Get<ItemInstance>("Battery");
    // 배터리가 없을 경우
    if (!battery)
    {
        Debug.Log("배터리를 장착하세요!");
        return false;
    }
    float rate = battery.Get<float>("batteryUsageRate");
    // 현재 배터리 충전량이 0이하일 경우
    if (rate <= 0)
    {
        Debug.Log("배터리가 모두 소진되었습니다.");
        return false;
    }
    // Update에서 배터리의 batteryUsageRate가 아이템을 사용하는 동안 점차 줄어듬
    rate -= Time.deltaTime;
    battery.Set<float>("batteryUsageRate", rate);
    Debug.Log(rate);
    return true;
}

🎮 중간 결과

R키를 이용해 배터리 선택 창을 열고, 마우스 왼클릭, 우클릭으로 장착할 배터리를 고릅니다.

현재 장착한 배터리가 없다면 쓰지 못하고, 장착한 배터리가 있으며 해당 배터리에 충전량이 있을 때만 사용할 수 있습니다.

🛢️ 연료 교체 및 관리

연료는 배터리와 같은 형식으로 관리됩니다. 그러니 쓰는 UI도 로직도 모두 같습니다. 이럴 경우에는 다른 함수를 만드는 것이 아닌, 같은 함수에서 조건만 나누어 관리하는 것이 훨씬 효율적입니다. BatteryManager를 ChargeManager로 바꾸어 진행합시다.

// 제트팩과 스캐너에 넣어 에디어의 인스펙터에서 설정합니다
public Charge Type chargeType;

public enum ChargeType
{
    None,
    Battery,
    Fuel
}

위의 타입을 추가하고, Batter를 관리했던 모든 함수에 chargeType에 따른 조건부를 추가합니다.

🛢️ 연료 사용

아직 제트팩 로직은 완성되지 않았으나, 시험용으로 UseItem에 코드를 추가합시다.

public void UseItems(ItemInstance item)
{
    switch(item.itemData.itemName)
    {
        case "스캐너":
            if (Input.GetMouseButtonDown(1)) UseScanner();
            break;
        case "나이프":
            if (Input.GetMouseButtonDown(0)) UseKnife(item.itemData.attackPower);
            break;
        case "제트팩":
            if (Input.GetMouseButtonDown(1)) UseJetPack();
            break;
        default:
            return;
    }
}

private void UseJetPack()
{
    if (chargeUIOpen) return;
    bool isCan = CanUseFuelProduct();
}

private bool CanUseFuelProduct()
{
    ItemInstance fuel = playerItemHandler.currentItem.Get<ItemInstance>("Fuel");
    if (!fuel)
    {
        Debug.Log("현재 연료통이 존재하지 않습니다!");
        return false;
    }
    float rate = fuel.Get<float>("fuelUsageRate");
    if (rate <= 0)
    {
        Debug.Log("연료가 모두 소진되었습니다!");
        return false;
    }
    rate -= Time.deltaTime;
    fuel.Set<float>("fuelUsageRate", rate);
    Debug.Log("연료가 소진되는 중입니다...");
    return true;
}

🎮 최종 결과

배터리와 연료통 모두 교체 및 사용이 가능해집니다.

📚 오늘의 배운 점

• 제네릭을 이용한 Get, Set 활용
• 오브젝트 교체

🎯 다음 계획

다음 글에서는:

1. 제트팩 구현