yj_621.log

유니티로 만드는 3D 농사게임 - 2일차

Tue, 27 Jan 2026 05:47:59 GMT

1월 19일에 개발한걸 이제야 씀니다..

1. 초기 설정

오늘은 밭을 내마음대로 배치했다면 그 위에 씨앗을 심을 예정입니다

씨앗 - 새싹 - 열매 - 성체 순으로 점점 커지는 느낌으로 아래 에셋을 다운 받아요

https://assetstore.unity.com/packages/3d/environments/industrial/lite-farm-pack-low-poly-3d-art-by-gridness-243315

일단 버튼으로 밭-토마토 중 하나를 골라서 심어야하니까 TmpText 먼저 만들어주기

32-126,44032-55203,12593-12643,8200-9900

저번에 한 밭을 투명하게 한 것 처럼 씨앗도 이렇게 해줌

2. 결과

씬뷰 확대하니까 도트같아서 귀여운데 ㅋ 일단 요런식으로 밭 - 토마토 버튼이 있어서 무조건 밭 위에 심을 수 있게 하려고 함

3. 작물 설정

Crop이라는 빈 오브젝트를 만들어주고

using UnityEngine;

public class Crop : MonoBehaviour
{
    private CropData data;
    private int currentState = 0;
    private GameObject currentModel;

    public void Initialize(CropData cropData)
    {
        data = cropData;
        currentState = 0; // 0단계부터 시작 보장

        // 데이터가 정상인지 검사
        if (data == null || data.growthStagePrefabs == null || data.growthStagePrefabs.Length == 0)
        {
            Debug.LogError("CropData 또는 성장 프리팹 배열이 비어있습니다.");
            return;
        }

        UpdateModel();

        // Invoke 지연 시간 재확인 (0이면 실행 안됨)
        float interval = data.timeBetweenStages;
        if (interval <= 0) interval = 2.0f; // 기본값 방어 코드

        // 기존 예약된 Grow가 있다면 취소 후 재등록
        CancelInvoke(nameof(Grow));
        InvokeRepeating(nameof(Grow), interval, interval);

        Debug.Log($"{data.cropName} 성장 시작. 주기: {interval}초");
    }

    void Grow()
    {
        if (currentState < data.growthStagePrefabs.Length - 1)
        {
            currentState++;
            UpdateModel();
            Debug.Log($"{gameObject.name}가 {currentState}단계로 성장했습니다.");
        }
        else
        {
            CancelInvoke("Grow");
        }
    }

    void UpdateModel()
    {
        if(currentModel != null) Destroy(currentModel);

        // 자식으로 생성하되, 생성된 모델의 Local Position을 0으로 맞춤
        currentModel = Instantiate(data.growthStagePrefabs[currentState], transform);
        currentModel.transform.localPosition = Vector3.zero;
        currentModel.transform.localRotation = Quaternion.identity;
    }
}

using UnityEngine;

[CreateAssetMenu(fileName = "CropData", menuName = "Scriptable Objects/CropData")]
public class CropData : ScriptableObject
{
    public string cropName;
    public GameObject[] growthStagePrefabs; // 4단계 프리팹(씨앗-새싹-성장-수확)
    public float timeBetweenStages; //단계별 성장 시간
}

Scriptable Objects로 CropData도 만들어줌 GridManager 스크립트 수정

using UnityEngine;

public enum TileType { Empty, Mud, Crop };

/// 
/// 농장의 물리적인 공간 데이터를 관리하는 클래스
/// 어떤 타일이 비어있고, 어떤 타일이 점유되었는지를 2차원 배열로 저장함
/// 
public class GridManager : MonoBehaviour
{
    [Header("농장 크기 설정")]
    public int width = 10;  // 가로 타일 개수
    public int height = 10; // 세로 타일 개수

    private TileType[,] tileTypes; // bool 대신 TileType 사용

    /// 
    /// 게임 시작 시 설정된 크기에 맞춰 배열 메모리를 할당
    /// 
    private void Awake()
    {
        tileTypes = new TileType[width, height];
    }

    /// 
    /// 특정 좌표(x, z)에 오브젝트를 설치할 수 있는지 검사
    /// 
    /// 검사할 그리드 X 인덱스
    /// 검사할 그리드 Z 인덱스
    /// 해당 칸이 Empty일때만 true, 불가능하면 false
    public bool CanPlace(int x, int z)
    {
        // 맵 범위 체크
        if (x < 0 || x >= width || z < 0 || z >= height)
        {
            return false;
        }

        // 해당 칸이 Empty 상태일 때만 true 반환
        // (isOccupied 배열을 삭제했으므로 tileTypes만 확인하면 됩니다)
        return tileTypes[x, z] == TileType.Empty;
    }

    /// 
    /// 오브젝트 설치가 확정되었을 때 데이터 갱신
    /// 
    public void PlaceObject(int x, int z, TileType type)
    {
        // 맵 범위 안일 때만 실행
        if (x >= 0 && x < width && z >= 0 && z < height)
        {
            tileTypes[x, z] = type;
            Debug.Log($"데이터 갱신: [{x},{z}] 번지 타일이 {type} 상태가 되었습니다.");
        }
    }

    /// 
    /// 현재 타일의 타입을 반환하는 함수
    /// 
    public TileType GetTileType(int x, int z)
    {
        if(x < 0 || x >= width || z < 0 || z>=height) return TileType.Empty;
        return tileTypes[x, z];
    }
}

GridSystem 수정

using System;
using UnityEditor.ShaderGraph;
using UnityEngine;

/// 
/// 마우스 입력을 받아 그리드 상에 오브젝트를 배치하고 
/// 배치 가능 여부를 시각적으로 보여주는 클래스
/// 
public class GridSystem : MonoBehaviour
{
    [Header("설정")]
    [SerializeField] private float cellSize = 10f;       // 그리드 한 칸의 크기 (기본 Plane 10x10에 맞춤)
    [SerializeField] private LayerMask groundLayer;      // 레이캐스트가 감지할 바닥 레이어

    [Header("밭 설정")]
    [SerializeField] private GameObject mudPreviewPrefab;   // 설치 전 보여줄 투명한 미리보기용 프리팹
    [SerializeField] private GameObject mudPrefab;      // 실제로 설치될 완성된 오브젝트 프리팹

    [Header("작물 설정")]
    [SerializeField] private GameObject previewCropPrefab;
    [SerializeField] private GameObject cropPrefab;    // Crop 스크립트가 붙어있는 빈 오브젝트 프리팹

    [Header("선택된 상태")]
    [SerializeField] private bool isMudSelect = false; // 기본적으로 아무것도 선택X
    [SerializeField] private CropData currentSelectedCrop; // 선택된 씨앗 데이터

    private GridManager gridManager;   // 설치 데이터를 관리하는 GridManager 참조
    private GameObject previewInstance; // 씬에 생성되어 따라다닐 미리보기 인스턴스

    void Start()
    {
       /* // 미리보기 인스턴스를 생성하고 초기 설정 진행
        if (mudPreviewPrefab != null)
        {
            previewInstance = Instantiate(mudPreviewPrefab);
            mudPreviewPrefab.SetActive(false);

            // TryGetComponent: GameObject에 존재하는 경우 지정된 유형의 컴포넌트를 검색하려고 시도하고,
            // 발견되면 true, 발견되지 않으면 false를 반환한다.
            //public bool TryGetComponent(out T component) where T : Component;
            *//* T: 가져오려는 컴포넌트의 타입
            component: 컴포넌트를 가져올 때 사용되는 out 매개변수 *//*

            // 미리보기 오브젝트가 마우스 레이캐스트를 방해하지 않도록 콜라이더 비활성화
            if (previewInstance.TryGetComponent(out Collider col)) col.enabled = false;
        }*/
        // 씬에 존재하는 GridManager를 찾아 참조 연결
        if (gridManager == null) gridManager = FindAnyObjectByType();
    }
    void Update()
    {
        // 마우스 위치로부터 화면 안쪽으로 레이(광선)를 쏜다.
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;

        //Ray가 어떤 Collider에 맞으면 true를 반환하고, 그 충돌 정보는 hit에 담긴다.

        // 지정된 groundLayer(바닥)에 레이가 맞았을 때만 로직 실행
        if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
        {
            // [좌표 계산] 맞은 지점의 월드 좌표를 그리드 인덱스(0, 1, 2...)로 변환
            int xIdx = Mathf.FloorToInt(hit.point.x / cellSize);
            int zIdx = Mathf.FloorToInt(hit.point.z / cellSize);

            // [스냅 좌표] 바닥이 그리드 정중앙에 오도록 좌표 보정 (+cellSize/2)
            Vector3 snapPos = new Vector3(xIdx * cellSize + (cellSize / 2), 0, zIdx * cellSize + (cellSize / 2));

            // 모드에 따른 높이 결정
            // 밭 설치 모드면 0, 작물 설치 모드면 0.16f
            float targetY = isMudSelect ? 0f : 0.16f;

            // 프리뷰 처리 (targetY 반영)
            HandlePreview(snapPos, targetY, xIdx, zIdx);

            // 마우스 왼쪽 클릭 시 해당 위치에 실제 설치 시도
            if (Input.GetMouseButtonDown(0))
            {
                PlaceAt(snapPos, xIdx, targetY, zIdx);
            }
        }
        else
        {
            // 바닥을 벗어나면 미리보기를 숨김
            if (previewInstance != null)
            {
                previewInstance.SetActive(false);
            }
        }
    }

    /// 
    /// 선택된 모드에 맞춰 미리보기(Preview) 모델을 교체합니다.
    /// 
    void UpdatePreviewInstance(GameObject newPrefab)
    {
        // 기존 미리보기가 있다면 삭제
        if(previewInstance != null)
        {
            Destroy(previewInstance); 
        }
        //OnClickSelectCrop 새로운 프리팹으로 생성
        if (newPrefab != null)
        {
            // 원본 프리팹을 복제하여 previewInstance 변수에 할당
            previewInstance = Instantiate(newPrefab);
            previewInstance.SetActive(false);

            // 레이캐스트 방해 방지 (콜라이더 끄기)
            if (previewInstance.TryGetComponent(out Collider col))
                col.enabled = false;
        }
    }

    /// 
    /// 밭 선택 버튼
    /// 
    public void OnClickSelectMud()
    {
        isMudSelect = true;
        currentSelectedCrop = null;
        // 미리보기를 밭용으로 교체
        UpdatePreviewInstance(mudPreviewPrefab);
        Debug.Log("밭 선택 모드");
    }

    public void OnClickSelectCrop(CropData cropdata)
    {
        isMudSelect = false;
        currentSelectedCrop = cropdata;
        // 미리보기를 작물용으로 교체
        UpdatePreviewInstance(previewCropPrefab);
        Debug.Log($"{cropdata.cropName} 씨앗 선택");
    }

    /// 
    /// 미리보기 오브젝트를 마우스 위치로 이동시키고, 설치 가능 여부에 따라 색상을 변경하는 메서드
    /// 
    void HandlePreview(Vector3 pos, float y, int x, int z)
    {
        if (previewInstance == null)
        {
            return;
        }

        // 아무 모드도 선택되지 않았다면 프리뷰를 끄고 리턴
        if (!isMudSelect && currentSelectedCrop == null)
        {
            previewInstance.SetActive(false);
            return;
        }
        pos.y = y;
        previewInstance.SetActive(true);
        previewInstance.transform.position = pos;

        if (gridManager == null) return;

        bool canPlaceVisually = false;
        if (isMudSelect)
        {
            //밭 설치 모드 : 해당 칸이 Empty여야 초록색
            canPlaceVisually = gridManager.CanPlace(x, z);
        }
        else if (currentSelectedCrop != null)
        {
            //씨앗 심기 모드 : 해당 칸이 Mud 여야 초록색(이미 Crop인 곳은 false가 됨)
            canPlaceVisually = (gridManager.GetTileType(x, z) == TileType.Mud);
        }

        // 시각적 피드백: 가능하면 초록색(Green), 불가능하면 빨간색(Red) 반투명 처리
        MeshRenderer mr = previewInstance.GetComponentInChildren();
        if (mr != null)
        {
            mr.material.color = canPlaceVisually ? new Color(0, 1, 0, 0.5f) : new Color(1, 0, 0, 0.5f);
        }
    }

    /// 
    /// 최종적으로 GridManager의 승인을 받아 실제 오브젝트를 생성하고 점유 데이터를 기록하는 메서드
    /// 
    void PlaceAt(Vector3 pos, int x, float y, int z)
    {
        // 밭 설치 모드일 때
        if (isMudSelect && gridManager.CanPlace(x, z))
        {
            pos.y = 0f; // 밭은 무조건 바닥에 설치
            Instantiate(mudPrefab, pos, Quaternion.identity);
            gridManager.PlaceObject(x, z, TileType.Mud);
            Debug.Log($"[{x}, {z}] 위치에 밭 설치 성공");
        }
        // 작물 설치 모드 (현재 칸이 정확히 Mud 상태여야만 함)
        // 만약 이미 작물을 심어서 TileType.Crop으로 변했다면, GetTileType은 Mud가 아니게 됨
        else if (!isMudSelect && currentSelectedCrop != null)
        {
            TileType currentTile = gridManager.GetTileType(x, z);
            if (gridManager.GetTileType(x, z) == TileType.Mud)
            {
                pos.y = 0.16f;
                PlantCrop(pos, x, z);
            }
            else if (currentTile == TileType.Crop)
            {
                Debug.Log("여기는 이미 작물이 자라고 있습니다!"); // 이 로그가 찍히는지 확인하세요.
            }
            else
            {
                Debug.Log("밭이 아닌 곳에는 심을 수 없습니다.");
            }
        }
    }

    void PlantCrop(Vector3 pos, int x, int z)
    {
        // 작물 프리팹 생성
        GameObject newCrop = Instantiate(cropPrefab, pos, Quaternion.identity);

        gridManager.PlaceObject(x, z, TileType.Crop);

        // 생성된 작물에 Crop 스크립트를 가져와 데이터 전달
        if (newCrop.TryGetComponent(out Crop crop))
        {
            crop.Initialize(currentSelectedCrop);
            Debug.Log($"{currentSelectedCrop.cropName}을 심었습니다/");
        }

        else
        {
            Debug.LogError($"cropPrefab 루트에 Crop 컴포넌트가 없습니다! 프리팹을 확인하세요: {newCrop.name}");
            gridManager.PlaceObject(x, z, TileType.Mud);
            Destroy(newCrop);
        }
    }
}

4. 스크립트 역할 정리

① `GridSystem.cs` (입력 및 로직 제어기)

역할: 플레이어의 마우스 입력을 게임 내 좌표로 변환하고, 현재 무엇을 들고 있는지(밭 or 씨앗)에 따라 적절한 행동을 지시
핵심 기능:
- Raycasting: 3D 공간의 바닥을 감지하여 그리드 좌표를 산출
- State Management: isMudSelect와 currentSelectedCrop 변수를 통해 현재 모드를 관리함
- Preview Switching: 모드 변경 시 기존 미리보기를 삭제하고 새로운 모델을 생성하여 시각적 피드백을 제공

② `GridManager.cs` (데이터 관리자)

역할: 농장의 모든 타일 상태를 2차원 배열(TileType[,])로 저장하는 데이터 장부
핵심 기능:
- Data Integrity: PlaceObject를 통해 설치된 객체의 타입을 기록하여 중복 설치를 방지하고 작물 설치 조건을 검사
- Encapsulation: 데이터를 직접 수정하지 않고 CanPlace, GetTileType 등의 함수를 통해서만 접근하게 하여 버그를 최소화

③ `Crop.cs` & `CropData.cs` (객체 및 데이터 구조)

역할: CropData는 작물의 정보를 담는 설계도이며, Crop은 실제 월드에서 시간에 따라 자라나는 식물임
핵심 기능:
- Data-Driven Design: ScriptableObject를 사용하여 기획 데이터(성장 시간, 메쉬 등)를 코드와 분리
- Recursive Update: InvokeRepeating을 사용하여 정해진 주기마다 성장 단계를 갱신하고 모델을 교체

유니티로 만드는 3D 농사게임 - 1일차

Tue, 20 Jan 2026 07:41:45 GMT

안녕하신가요 오늘(사실 1월 16일)부터 시작한 3D 농사게임을 만들어보려고 해요

제미나이와 함께한 + 제 포트폴리오에 3D가 없기에 + 기술적 향상을 위한 의미있는 프로젝트인데 기록겸 남깁니당

1. 초기 설정

일단 아이소메트릭뷰로 만들거기 때문에 Camera를 자식으로 둔 Camera Pivot 오브젝트 생성 후 Rotation 30, 45, 0으로 설정해줘요

Main Camera는 Orthographic으로 설정 후 Size 및 Clipping Planes 조절

Plane 생성 후 Position(10, 0, 10) Scale(2, 2, 2)로 변경

농사게임에 일단 밭을 만들어야하니까 이 에셋 다운/임포트 후

https://assetstore.unity.com/packages/3d/environments/industrial/low-poly-farm-pack-lite-188100

그리드 크기에 맞춰서 작게 만들어줍니다(원본/투명 둘 다)

투명 오브젝트는 어케 만드냐? 메테리얼을 생성하고 - 인스펙터 창에서 Surface Type을 Transparent로 변경합니다 Blending Mode를 Alpha로 설정하고 만든 머티리얼을 Preview Prefab의 Mesh Renderer에 할당하면 끝!

2. 그리드 시스템의 데이터와 로직 분리

아이소메트릭뷰에 배치 시스템이 있으면 그리드 시스템이 기본으로 깔리겟져?

GridSystem 스크립트 생성 후 Plane에 부착해줘요

using System;
using UnityEngine;

/// 
/// 마우스 입력을 받아 그리드 상에 오브젝트를 배치하고 
/// 배치 가능 여부를 시각적으로 보여주는 클래스
/// 
public class GridSystem : MonoBehaviour
{
    [Header("설정")]
    public float cellSize = 10f;       // 그리드 한 칸의 크기 (기본 Plane 10x10에 맞춤)
    public LayerMask groundLayer;      // 레이캐스트가 감지할 바닥 레이어

    [Header("프리팹")]
    public GameObject previewPrefab;   // 설치 전 보여줄 투명한 미리보기용 프리팹
    public GameObject realPrefab;      // 실제로 설치될 완성된 오브젝트 프리팹

    private GridManager gridManager;   // 설치 데이터를 관리하는 GridManager 참조
    private GameObject previewInstance; // 씬에 생성되어 따라다닐 미리보기 인스턴스

    void Start()
    {
        // 미리보기 인스턴스를 생성하고 초기 설정 진행
        if (previewPrefab != null)
        {
            previewInstance = Instantiate(previewPrefab);
            previewPrefab.SetActive(false);

            // TryGetComponent: GameObject에 존재하는 경우 지정된 유형의 컴포넌트를 검색하려고 시도하고,
            // 발견되면 true, 발견되지 않으면 false를 반환한다.
            //public bool TryGetComponent(out T component) where T : Component;
            /* T: 가져오려는 컴포넌트의 타입
            component: 컴포넌트를 가져올 때 사용되는 out 매개변수 */

            // 미리보기 오브젝트가 마우스 레이캐스트를 방해하지 않도록 콜라이더 비활성화
            if (previewInstance.TryGetComponent(out Collider col)) col.enabled = false;
        }
        // 씬에 존재하는 GridManager를 찾아 참조 연결
        if (gridManager == null) gridManager = FindAnyObjectByType();
    }
    void Update()
    {
        // 마우스 위치로부터 화면 안쪽으로 레이(광선)를 쏜다.
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;

        //Ray가 어떤 Collider에 맞으면 true를 반환하고, 그 충돌 정보는 hit에 담긴다.

        // 지정된 groundLayer(바닥)에 레이가 맞았을 때만 로직 실행
        if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
        {
            // [좌표 계산] 맞은 지점의 월드 좌표를 그리드 인덱스(0, 1, 2...)로 변환
            int xIdx = Mathf.FloorToInt(hit.point.x / cellSize);
            int zIdx = Mathf.FloorToInt(hit.point.z / cellSize);

            // [스냅 좌표] 오브젝트가 그리드 정중앙에 오도록 좌표 보정 (+cellSize/2)
            Vector3 snapPos = new Vector3(xIdx * cellSize + (cellSize / 2), 0, zIdx * cellSize + (cellSize / 2));

            // 미리보기 위치 업데이트 및 색상 변경 함수 호출
            HandlePreview(snapPos, xIdx, zIdx);

            // 마우스 왼쪽 클릭 시 해당 위치에 실제 설치 시도
            if (Input.GetMouseButtonDown(0))
            {
                PlaceAt(snapPos, xIdx, zIdx);
            }
        }
        else
        {
            // 바닥을 벗어나면 미리보기를 숨김
            if (previewInstance != null)
            {
                previewInstance.SetActive(false);
            }
        }

        /// 
        /// 미리보기 오브젝트를 마우스 위치로 이동시키고, 설치 가능 여부에 따라 색상을 변경하는 메서드
        /// 
        void HandlePreview(Vector3 pos, int x, int z)
        {
            if (previewInstance == null)
            {
                return;
            }
            previewInstance.SetActive(true);
            previewInstance.transform.position = pos;

            // GridManager에게 현재 칸이 비어있는지 확인 요청
            bool canPlace = gridManager.CanPlace(x, z);

            // 시각적 피드백: 가능하면 초록색(Green), 불가능하면 빨간색(Red) 반투명 처리
            MeshRenderer mr = previewInstance.GetComponentInChildren();
            if(mr != null)
            {
                mr.material.color = canPlace ? new Color(0, 1, 0, 0.5f) : new Color(1, 0, 0, 0.5f);
            }
        }

        /// 
        /// 최종적으로 GridManager의 승인을 받아 실제 오브젝트를 생성하고 점유 데이터를 기록하는 메서드
        /// 
        void PlaceAt(Vector3 pos, int x, int z)
        {
            if (gridManager.CanPlace(x, z))
            {
                // 실제 오브젝트 생성
                Instantiate(realPrefab, pos, Quaternion.identity);

                // GridManager에 해당 좌표가 점유되었음을 기록 (중복 설치 방지)
                gridManager.PlaceObject(x, z);

                Debug.Log($"[{x}, {z}] 위치에 설치 성공");
            }
            else
            {
                Debug.Log("설치 불가 지역");
            }
        }
    }
}

GridManager 스크립트 생성 후 GridManager 오브젝트에 부착

using UnityEngine;

/// 
/// 농장의 물리적인 공간 데이터를 관리하는 클래스
/// 어떤 타일이 비어있고, 어떤 타일이 점유되었는지를 2차원 배열로 저장함
/// 
public class GridManager : MonoBehaviour
{
    [Header("농장 크기 설정")]
    public int width = 10;  // 가로 타일 개수
    public int height = 10; // 세로 타일 개수

    // 타일의 점유 상태를 저장하는 2차원 배열 데이터 구조
    // false : 비어있음 (설치 가능)
    // true  : 이미 무언가 설치됨 (설치 불가)
    private bool[,] isOccupied;

    /// 
    /// 게임 시작 시 설정된 크기에 맞춰 배열 메모리를 할당
    /// 
    private void Awake()
    {
        // width x height 크기의 바둑판 모양 데이터를 생성
        isOccupied = new bool[width, height];
    }

    /// 
    /// 특정 좌표(x, z)에 오브젝트를 설치할 수 있는지 검사
    /// 
    /// 검사할 그리드 X 인덱스
    /// 검사할 그리드 Z 인덱스
    /// 설치 가능하면 true, 불가능하면 false
    public bool CanPlace(int x, int z)
    {
        // 인덱스가 맵의 범위를 벗어났는지 먼저 체크 (배열 오류 방지)
        if (x < 0 || x >= width || z < 0 || z >= height)
        {
            return false; // 맵 밖은 설치 불가
        }

        // 해당 칸의 점유 상태를 반전시켜 반환
        // !isOccupied[x, z] 의 의미:
        // 점유(true)면 설치불가(false) 반환, 비었으면(false) 설치가능(true) 반환
        return !isOccupied[x, z];
    }

    /// 
    /// 오브젝트 설치가 확정되었을 때 해당 칸의 상태를 '점유됨'으로 변경
    /// 
    /// 점유할 그리드 X 인덱스
    /// 점유할 그리드 Z 인덱스
    public void PlaceObject(int x, int z)
    {
        // 맵 범위 안일 때만 실행
        if (x >= 0 && x < width && z >= 0 && z < height)
        {
            isOccupied[x, z] = true;
            Debug.Log($"데이터 업데이트: [{x}, {z}] 지점이 점유되었습니다.");
        }
    }
}

농장 크기는 Plane에 그리드 개수만큼 해줌(저는 2,2,2 크기로해서 20, 20이 나옴)

0,0,0 위치가 맨 아래가도록 배치해주고 Plane의 Layer를 Ground로 설정해주면 끝 왜 이럿케 하느냐 x,z 좌표가 양수인 부분만 배치가 가능하게 해둠

왜"???

가장 큰 이유는 배열(GridManager의 tileTypes)의 인덱스는 음수가 될 수 없기 때문입니다.

배열의 한계: GridManager에서 사용하는 new TileType[width, height]는 0부터 시작하는 '방 번호'를 가집니다. 컴퓨터 과학에서 배열 인덱스는 항상 0 또는 양수입니다. 좌표 변환 방식: 현재 GridSystem에서 인덱스를 계산할 때 아래 공식을 사용합니다. int xIdx = Mathf.FloorToInt(hit.point.x / cellSize);

만약 hit.point.x가 -5.0이고 cellSize가 10이라면, 결과는 -1이 됩니다. 코드의 방어막: GridManager의 CanPlace 함수에는 아래와 같은 조건문이 있습니다. if (x < 0 || x >= width ...) 여기서 음수 인덱스(-1)가 들어오면, 배열 오류(IndexOutOfRangeException)를 막기 위해 무조건 false(배치 불가)를 반환하도록 설계되어 있습니다.

라는 제미나이의 답변,, 요거는 좀 더 공부를 해바야겟음

3. 결과

클릭하면 밭이 배치되고, 배치할 수 없는(이미 점유된)곳에 배치하려고 하면 빨간색으로 표시,

가능한 곳은 초록색으로 표시되게 함

4. 지식 +

🔷 TryGetComponent?

💡 GameObject에 존재하는 경우 지정된 유형의 컴포넌트를 검색하려고 시도하고, 발견되면 true, 발견되지 않으면 false를 반환한다.

public bool TryGetComponent(out T component) where T : Component;

T: 가져오려는 컴포넌트의 타입 component: 컴포넌트를 가져올 때 사용되는 out 매개변수

🔷Physics.Raycast

💡 Ray가 어떤 Collider에 맞으면 true를 반환하고, 그 충돌 정보는 hit에 담긴다.

Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer)

: groundLayer에 맞으면 hit에 정보가 담기고 길이는 무한

💡 기술적 포인트

데이터 무결성 (Data Integrity):

시각적인 오브젝트(GameObject)는 파괴되거나 오류가 날 수 있지만, GridManager의 bool 배열은 현재 농장 상태의 절대적인 기준이 됨

연산 효율성:

이미 설치된 게 있나?를 알기 위해 Physics.OverlapBox 같은 무거운 물리 연산을 쓰지 않고, 단순한 배열 인덱스 참조(O(1))만으로 판별하기 때문에 매우 빠름

예외 처리 능력:

if (x < 0 || x >= width ...)와 같은 조건문을 통해 배열 인덱스 초과 에러(IndexOutOfRangeException)를 사전에 방지

UniTask를 이용한 비동기 처리

Wed, 14 Jan 2026 06:58:01 GMT

🔷 UniTask - 유니티 최적화 라이브러리

기존 C#의 Task는 무겁기도 하고 GC 할당이 계속 발생해서 UniTask를 사용했습니다.

구조체(struct) 기반이라 메모리 할당이 거의 없어요!

일단 패키지부터 설치해야겠죠?

Window -> Package Manager -> Add package from git URL 누르고 아래 주소 입력!

https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask

아래 링크 넣어서 다운로드

https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask

📄 1. 네트워크 통신 리팩토링 (Coroutine → UniTask)

원래 Coroutine이랑 Action(콜백) 써서 비동기 통신을 구현했었는데, 이게 가독성이 진짜 안 좋아서 UniTask로 싹 바꿔버렸습니다. 그리고 공부할겸! 활용해봤습니다~

① 통신 매니저 (PythonConnectManager.cs)

** [Before] 기존 코드: 코루틴 + 콜백 **

결과값을 바로 return 못하고 callback으로 넘겨줘야 하는게 제일 불편함 ㅠㅠ

// IEnumerator 반환, 결과는 Action 콜백으로 넘겨줌
public IEnumerator MostSimilarty(string inputWord, int num, Action> callback)
{
    // ... (중략) ...

    using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
    {
        // [기존 방식] 여기서 yield return으로 대기
        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            // ... 데이터 파싱 ...
            // [단점] 값을 직접 리턴 못하고 콜백 함수 호출해야 함
            callback(responseData.result);
        }
        else
        {
            callback(new List { "요청 실패" });
        }
    }
}

** [After] 개선된 코드: UniTask + Async/Await **

async 키워드 붙이고 결과값을 바로 return 받을 수 있어서 완전 직관적임!

using Cysharp.Threading.Tasks; // 필수!

// async 키워드 사용, List을 직접 반환!
public async UniTask> MostSimilarty(string inputWord, int num)
{
    // ... (중략) ...

    using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
    {
        // [개선] await로 기다림
        await request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
             // ... 데이터 파싱 ...
            // [장점] 그냥 바로 return 때리면 됨
            return responseData.result;
        }
        else
        {
            return new List { "요청 실패" };
        }
    }
}

② 호출하는 곳 (AlgorithmCall.cs)

[Before] 기존: 콜백 지옥 (계단식 코드)

StartCoroutine 안에 람다식 (result) => { ... } 들어가니까 들여쓰기가 계속 깊어짐;;

public void OnShowSimilarWord()
{
    // ... 생략 ...

    // [단점] StartCoroutine + 람다식 콜백 = 가독성 떨어짐
    StartCoroutine(pythonConnectManager.MostSimilarty(answerWord, 5, (result) =>
    {
        loading?.StopAnim();

        // --- 여기서부터 결과 처리 로직 ---
        if (result == null) { ... }

        // 로직이 길어질수록 계속 들여쓰기 해야함 ㅠㅠ
        resultText.text = $"관련 단어 : {result[idx]}";
    }));
}

[After] 개선: 선형적인 코드

// async void로 변경 (유니티 이벤트 함수용)
public async void OnShowSimilarWord()
{
    // ... 생략 ...

    // [장점] await로 결과값 바로 받아옴! (코루틴 삭제)
    List result = await pythonConnectManager.MostSimilarty(answerWord, 5);

    loading?.StopAnim();

    // --- 들여쓰기 없이 바로 로직 작성 가능 ---
    if (result == null) { ... }

    resultText.text = $"관련 단어 : {result[idx]}";
}

📄 2. 비동기 씬 로드

네트워크만 바꾸긴 아쉬워서 씬 로딩도 바꿨습니당. 보통 로딩바 구현할 때 StartCoroutine이랑 yield return null 쓰잖아요? 근데 yield return null이 미세하게 가비지를 만든다는 사실.. UniTask 쓰면 이것도 해결된다고 하더라구요

**[Before] **

IEnumerator LoadRoutine(string targetScene)
{
    AsyncOperation op = SceneManager.LoadSceneAsync(targetScene);
    op.allowSceneActivation = false;

    while (!op.isDone)
    {
        yield return null; // 매 프레임 가비지 생성 가능성 있음
        // ... 진행률 계산 로직 ...
    }
}

**[After] **

// Start에서 바로 비동기 함수 호출 가능!
async void Start()
{
    await LoadSceneAsync("TargetScene");
}

async UniTask LoadSceneAsync(string targetScene)
{
    await UniTask.Yield(); // 첫 프레임 대기

    AsyncOperation op = SceneManager.LoadSceneAsync(targetScene);
    op.allowSceneActivation = false;

    while (!op.isDone)
    {
        // [핵심] struct 기반이라 메모리 할당 없음 (Zero Allocation)
        await UniTask.Yield(); 

        // ... 진행률 계산 (기존과 동일) ...
        float raw = Mathf.Clamp01(op.progress / 0.9f);
        loadingUI?.SetProgress(raw);

        if (raw >= 1f)
        {
             op.allowSceneActivation = true;
             break;
        }
    }
}

Start()를 async void로 바꾸고 UniTask.Yield()를 쓰면 끗

💡 UniTask의 효과!

가독성 떡상: 콜백 지옥 탈출하고 코드가 깔끔해짐
메모리 절약: yield return null 대신 UniTask.Yield() 써서 GC 방어
예외 처리: 코루틴에선 안되던 try-catch가 먹힘

유니티 셰이더로 이미지 흑백 처리하기

Thu, 08 Jan 2026 06:51:52 GMT

오늘도 제미나이에게 도움을..

왼쪽 일반적인 스프라이트를 흑백처리하는 방법입니당

셰이더말고 답이 없더라고요,, 일단 이렇게 하면되는데 하나씩 차근차근 알려드릴게엽

UI Canvas Shader Graph 사용 (유니티 6 권장)

1. 셰이더 그래프 생성

Project 창 우클릭 -> Create -> Shader Graph -> UI -> Canvas Shader Graph를 선택

이름을 짓고 더블 클릭하여 열면

2. 필수 속성 만들기

좌측 Blackboard에서 다음 두 가지를 추가

Texture2D 추가 -> 이름을 반드시 _MainTex로 변경
- 주의: Reference 이름도 _MainTex여야 UI Image 컴포넌트의 소스 이미지를 자동으로 받아옴
Float 추가 -> 이름을 _GrayscaleAmount로 짓고 Default Value는 1로

_MainText는 아무것도 안 건드림


### 3. 노드 연결하기

빈 공간에 우클릭하여 노드를 추가(Create Node)하고 아래 순서대로 연결하면 되는데 좀 복잡함 ㅠㅠ

Sample Texture 2D 노드 생성

- Blackboard의 _MainTex를 끌어와서 Texture 슬롯에 연결
- RGBA 출력값을 사용

Saturation 노드 생성
- Sample Texture 2D의 출력을 In에 연결
- Saturation값에는 0을 입력 (흑백)

Lerp 노드 생성 (원본과 흑백을 섞기 위함)
- A: Sample Texture 2D의 출력 (원본 색)
  - B: Saturation 노드의 출력 (흑백 색)
  - T: Blackboard의 _GrayscaleAmount 연결
Vertex Color 노드 생성 (투명도 조절을 위해 필수)
Multiply 노드 생성 -A : Lerp의 결과 -B : Vertex Color 노드
최종 연결
- Multiply의 결과를 Master Stack의 Base Color와 Alpha에 연결

4. 머터리얼 적용

저장 후 만들어진 셰이더 파일 우클릭 -> Create -> Material

Material을 눌러보면 Grayscale Amount 속성을 1로 바꿔주면 됨니다(0 :원본, 1 :흑백)

만들어진 Matrial를 해당 Material 자리에 넣어주면 끝!

유니티에서 버튼을 선택했을때 스프라이트 교체

Thu, 08 Jan 2026 06:26:16 GMT

오늘은 유니티에서 버튼에 있는 Sprite Swap기능으로 스프라이트 교체가 되는것이 아닌 방법을 소개하겠습니다

이 방법을 사용하면 다른 곳을 누르면 바로 풀리는 문제가 있어서 제미나이한테 물어봐서 해결했습니당

일단 이 코드가 제일 중요한데 버튼의 interactable 기능을 이용했습니다!

private void Switch(JamoDefsType type)
    {
        _current = type;

        // 선택된 탭은 클릭이 안 되게(interactable = false) 만들어서
        // 인스펙터에서 설정한 'Disabled Sprite(흰 테두리)'가 보이도록 함
        if (btnConsonant != null) 
            btnConsonant.interactable = (type != JamoDefsType.Consonant);

        if (btnVowel != null) 
            btnVowel.interactable = (type != JamoDefsType.Vowel);

        RebuildGrid(type == JamoDefsType.Consonant ? JamoDefs.Consonants : JamoDefs.Vowels);
    }

interactable가 꺼져있으면 버튼 상호작용이 불가능하게 되고, 켜져있으면 버튼과 상호작용이 가능한 기능인데 버튼을 누르는 순간 interactable이 false가 되면서 Disabled Sprite를 보여주는 것임

Disabled Sprite : 버튼이 비활성화되었을때 보여줄 스프라이트

유니티에서 Google AdMob를 사용해서 광고 삽입하기

Fri, 19 Dec 2025 08:51:36 GMT

Unity - Google AdMob 광고 삽입하는 법(플러그인 다운로드, 광고 코드) 이 게시물을 참고했습니다 감사합니다(__)

https://github.com/googleads/googleads-mobile-unity/releases/tag/v10.5.0

이 링크에서

패키지 다운 후 드래그

Asset - Google ~ - Settings

Enable 선택 후

여기서 Android 에 ID 입력

Google AdMob: 모바일 앱 수익 창출

뭔진 모르겠지만 있어야하는듯함

using GoogleMobileAds;
using GoogleMobileAds.Api;
using UnityEngine;

public class GoogleMobileAdsDemoScript : MonoBehaviour
{
    public void Awake()
    {
        // Initialize Google Mobile Ads SDK.
        MobileAds.Initialize((InitializationStatus initStatus) =>
        {
            // This callback is called once the MobileAds SDK is initialized.
        });
    }

}

겜매에 두개를 넣어줌

인스펙터의 저 아이디는 광고 단위에서 추가한 아이디임

AdsManager.cs

using System;
using GoogleMobileAds;
using GoogleMobileAds.Api;
using UnityEngine;

public class AdsManager : MonoBehaviour
{
    public static AdsManager I { get; private set; }

#if UNITY_ANDROID
    [SerializeField] private string rewardedAdRevivalId = "ca-app-pub-1881501262849586/3221896109"; // 테스트용
#elif UNITY_IOS
    [SerializeField] private string rewardedAdUnitId = "ca-app-pub-3940256099942544/1712485313"; // 테스트용
#else
    [SerializeField] private string rewardedAdUnitId = "unused";
#endif

    private RewardedAd _rewardedAd;
    private bool _initializing;

    private void Awake()
    {
        if (I != null) { Destroy(gameObject); return; }
        I = this;
        DontDestroyOnLoad(gameObject);
    }

    private void Start()
    {
        InitializeSdkIfNeeded(() => PreloadRewarded());
    }

    public void InitializeSdkIfNeeded(Action onDone = null)
    {
        if (_initializing) return;
        _initializing = true;

        MobileAds.Initialize((InitializationStatus status) =>
        {
            _initializing = false;
            onDone?.Invoke();
        });
    }

    // 미리 로드
    public void PreloadRewarded()
    {
        if (string.IsNullOrEmpty(rewardedAdRevivalId)) return;

        if (_rewardedAd != null)
        {
            _rewardedAd.Destroy();
            _rewardedAd = null;
        }

        var request = new AdRequest();
        RewardedAd.Load(rewardedAdRevivalId, request, (RewardedAd ad, LoadAdError error) =>
        {
            if (error != null)
            {
                Debug.LogWarning($"[Ads] Rewarded load failed: {error.GetMessage()}");
                return;
            }

            _rewardedAd = ad;
            HookRewardedEvents(_rewardedAd);
            Debug.Log("[Ads] Rewarded loaded.");
        });
    }

    private void HookRewardedEvents(RewardedAd ad)
    {
        ad.OnAdFullScreenContentOpened += () =>
        {
            Debug.Log("[Ads] Rewarded opened.");
        };
        ad.OnAdFullScreenContentClosed += () =>
        {
            Debug.Log("[Ads] Rewarded closed.");
            // 닫히면 다음 광고 미리 로드
            PreloadRewarded();
        };
        ad.OnAdFullScreenContentFailed += (AdError err) =>
        {
            Debug.LogWarning($"[Ads] Rewarded open failed: {err.GetMessage()}");
            PreloadRewarded();
        };
    }

    /// 
    /// 공용: 리워드 광고 표시 (보상 콜백/미준비 콜백)
    /// 
    public void ShowRewarded(Action onRewardEarned, Action onUnavailable = null)
    {
        if (_rewardedAd != null && _rewardedAd.CanShowAd())
        {
            _rewardedAd.Show((Reward reward) =>
            {
                onRewardEarned?.Invoke();
            });
        }
        else
        {
            Debug.LogWarning("[Ads] Rewarded not ready.");
            onUnavailable?.Invoke();
            PreloadRewarded();
        }
    }

    /// 
    /// 부활 전용 진입점
    /// 
    public void ShowReviveAd(Action onRevive, Action onFail = null)
    {
        ShowRewarded(
            onRewardEarned: onRevive,
            onUnavailable: onFail
        );
    }
}

GameReviveSystem.cs

using System;
using UnityEngine;
using WordEater.Core;

[Serializable]
public class WordEaterCheckpoint
{
    public Vector3 Position;
    public int BatteryPercent;
    public int TurnsLeft;
    public int MistakesLeft;
    public GrowthStage Stage;
    public string CurrentAnswer;
}

public class GameReviveSystem : MonoBehaviour
{
    public static GameReviveSystem I { get; private set; }
    [SerializeField] private RevivePopup revivePopup;

    private WordEaterCheckpoint _cp;
    private bool _reviveOffered;

    void Awake() => I = this;

    public void SaveCheckpoint(WordEater.Core.WordEater we, int batteryPercent)
    {
        _cp = new WordEaterCheckpoint
        {
            Position = we.transform.position,
            BatteryPercent = Mathf.Clamp(batteryPercent, 0, 100),
            TurnsLeft = we.GetTurnsLeft(),         //
            MistakesLeft = we.GetMistakesLeft(),
            Stage = we.ReturnStage(),
            CurrentAnswer = we.CurrentAnswer
        };
    }
    public void OnPlayerDied(Action onGiveUp)
    {
        if (_reviveOffered) return;
        _reviveOffered = true;

        if (revivePopup == null)
        {
            Debug.LogWarning("[Revive] revivePopup 미할당");
            _reviveOffered = false;
            onGiveUp?.Invoke();
            return;
        }

        // ▶ 게임 정지: UI는 Unscaled로 뜨게
        Time.timeScale = 0f;

        revivePopup.Show(
            onAccept: () =>
            {
                ReviveFromCheckpoint();
                Debug.Log("[WordEater] 턴 고갈 → 사망 처리");
                _reviveOffered = false;
                Time.timeScale = 1f;  // ▶ 재개
            },
            onDecline: () =>
            {
                _reviveOffered = false;
                Time.timeScale = 1f;  // ▶ 재개
                onGiveUp?.Invoke();   // ▶ EndingController(1) 호출됨
            }
        );
    }

    public void ReviveFromCheckpoint()
    {
        var player = FindFirstObjectByType();
        if (player == null) { Debug.LogWarning("[Revive] WordEater 없음"); return; }
        if (_cp == null) { Debug.LogWarning("[Revive] 체크포인트 없음"); return; }

        // 위치/배터리 복원
        player.transform.position = _cp.Position;
        var battery = player.GetComponent()
                     ?? FindFirstObjectByType();
        if (battery != null) battery.SetBatteryPercent(Mathf.Max(_cp.BatteryPercent, 50));

        // 턴/오답/정답/단계 복원
        player.RestoreTurns(_cp.TurnsLeft, _cp.MistakesLeft);
        player.RestoreAnswer(_cp.CurrentAnswer, _cp.Stage);

        // 최종 활성화
        player.Reactivate();

        Debug.Log("[Revive] 체크포인트로 완전 복원 완료");
    }
}

얘는 초기 알파값을 0으로 일단 해두고

RevivePopup.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class RevivePopup : MonoBehaviour
{
    [Header("Refs")]
    [SerializeField] private CanvasGroup canvasGroup;
    [SerializeField] private Button watchAdButton;
    [SerializeField] private Button noThanksButton;
    [SerializeField] private GameObject spinner; // 로딩 표시용

    private Action _onAccept;
    private Action _onDecline;
    private bool _visible;

    private void Awake()
    {
        if (watchAdButton != null) watchAdButton.onClick.AddListener(OnClickWatchAd);
        if (noThanksButton != null) noThanksButton.onClick.AddListener(OnClickNoThanks);
        HideImmediate();
    }

    public void Show(Action onAccept, Action onDecline)
    {
        _onAccept = onAccept;
        _onDecline = onDecline;
        _visible = true;

        if (spinner != null) spinner.SetActive(false);

        // 팝업은 UnscaledTime 기반으로 동작 (애니메이션/타이머 쓴다면)
        var cg = canvasGroup;
        if (cg != null)
        {
            cg.ignoreParentGroups = true;
            cg.blocksRaycasts = true;
            cg.interactable = true;
        }

        // 최상단 보장(없다면 추가)
        var canvas = GetComponentInParent

워드이터가 죽었을때 띄우게 하려고 일단 전체 코드

using System;
using System.IO;
using UnityEngine;
using WordEater.Data;
using WordEater.Services;
using WordEater.Systems;
using static UnityEngine.EventSystems.EventTrigger;

namespace WordEater.Core
{
    /// 
    /// 한 마리 워드 이터의 생애 주기를 관리하는 상태 머신
    /// 
    public class WordEater : MonoBehaviour
    {
        [Header("할당")]
        [SerializeField] private GrowthConfig growthConfig;          // 단계 규칙 SO
        [SerializeField] private WordAssignmentService wordService;  // 단어 배정 
        [SerializeField] private BatterySystem battery;
        [SerializeField] private SubmitManager submitmanager;
        [SerializeField] private GameManager gamemanager;
        [SerializeField] private GalleryUIManager galleryUIManager;

        [SerializeField] private Sprite BitImg;
        [SerializeField] private Sprite ByteImg;
        [SerializeField] private Sprite WordImg;
        [SerializeField] private bool isDead = false;

        [Header("Runtime (read-only)")]
        [SerializeField] private GrowthStage stage = GrowthStage.Bit; // 현재 단계
        [SerializeField] private string currentAnswer;                // 현재 정답(프로토타입용 노출)

        private TurnController turn;   // 턴/오답 관리자
        private WordEntry currentEntry; // 현재 단어 데이터(주제/연관어 포함)

        private string pendingEvoId; // Bit/Byte 동안 쓸 임시 키=

        private void Awake()
        {
            turn = new TurnController(growthConfig);
        }

        /// 
        /// 단계 시작(턴/오답 초기화 + 단어 배정)
        /// 
        public void BeginStage(GrowthStage s, bool initial = false)
        {

            turn.StartStage(s);

            //처음 (다시시작이나 게임 클리어 포함)
            if (initial)
            {
                //BIT상태로 변경
                stage = GrowthStage.Bit;
                var sr = GetComponent();
                if (sr != null)
                {
                    sr.sprite = BitImg;
                }

                // 현재 단어 선택
                currentEntry = wordService.PickInitialWord();

                // ✅ 임시 키 생성 (한 생애 내내 고정)
                pendingEvoId = $"evo_{System.DateTime.UtcNow.Ticks}";

                // ✅ Bit 썸네일을 임시 키로 저장
                if (sr != null)
                    GalleryCapture.SaveSpriteThumb(sr, $"thumb_{pendingEvoId}_s0", 256);

                submitmanager.OnRelevantButton();
            }
            else
            {
                var sr = GetComponent();
                if (s == GrowthStage.Byte)
                {
                    if (sr != null) sr.sprite = ByteImg;
                    // ✅ Byte 썸네일을 임시 키로 저장
                    if (sr != null)
                        GalleryCapture.SaveSpriteThumb(sr, $"thumb_{pendingEvoId}_s1", 256);
                }
                else if (s == GrowthStage.Word)
                {
                    if (sr != null) sr.sprite = WordImg;
                }
            }

            // BeginStage 끝부분(초기 진입 포함)
            if (GameReviveSystem.I != null && battery != null)
            {
                GameReviveSystem.I.SaveCheckpoint(this, battery.CurrentPercent);
            }

            // EvolveOrFinish에서 다음 단계 단어 배정 직후
            if (GameReviveSystem.I != null && battery != null)
            {
                GameReviveSystem.I.SaveCheckpoint(this, battery.CurrentPercent);
            }

            currentAnswer = currentEntry.word;
            GameEvents.OnNewWordAssigned?.Invoke(currentAnswer); // UI: "새 단어 등장" (정답 직접 노출 대신 디버그/프로토타입용)
        }

        /// 
        /// 데이터 주입(정답/오답 판정, 다음 문제 배정, 진화 체크)
        /// 
        public void DoFeedData(string userInput)
        {

            if (!battery.TryConsume(ActionType.FeedData))
                return; // OnActionBlockedLowBattery 이벤트로 HUD/토스트 띄우기

            // 턴 소모(FeedData는 1턴)
            if (!turn.ConsumeTurn(ActionType.FeedData))
            {
                WordEaterDie();
                return;
            }

            if (turn.TurnsLeft <= 0) { WordEaterDie(); return; }
            // 정답 판정(v1 : 완전 일치, v2 : 오타/의미 유사도 확정 예정)
            bool ok = IsCorrect(userInput, currentAnswer);
            GameEvents.OnFeedResult?.Invoke(userInput, ok);

            if (ok)
            {
                EvolveOrFinish();
            }
            else
            {
                if (!turn.RegisterMistake()) { WordEaterDie(); return; }
            }

            // 턴 바닥나면 사망
            if (turn.TurnsLeft <= 0) { WordEaterDie(); return; }
        }

        /// 
        /// 미니게임/힌트(턴 1 소모)
        /// 
        public void DoOptimizeAlgo() // 미니게임 자리(힌트/버프 지급)
        {
            if (isDead) return;
            if (!turn.ConsumeTurn(ActionType.OptimizeAlgo))
            {
                WordEaterDie(); return;
            }
            // TODO: 힌트 토큰 +1, 상성 버프 스택 등
        }

        /// 
        /// 노이즈 제거(턴 2 소모, 배율/버프 예정)
        /// 
        public void DoCleanNoise() // 2턴 소모, 배율/보상 증가 버프
        {
            if (isDead) return;
            if (!turn.ConsumeTurn(ActionType.CleanNoise))
            {
                WordEaterDie(); return;
            }
            // TODO: 배율 스택 += 1
        }

        // === 내부 로직 =======================================================

        private bool IsCorrect(string input, string answer)
        {
            // v1: 완전 일치. v2: 유사도(레벤슈타인/임베딩) 도입.
            return string.Equals(input.Trim(), answer.Trim(), System.StringComparison.Ordinal);
        }

        /// 
        /// 단계 종료 처리(다음 단계 or 성체)
        /// - 현재 단계가 최종 단계(Word)이면: 도감에 등록하고 엔딩 처리
        /// - 아니면: 다음 단계로 진화
        /// 
        private void EvolveOrFinish()
        {
            if (stage == GrowthStage.Word)
            {
                // 성체 달성 → UI/연출 등 외부 구독자에게 알림
                GameEvents.OnEvolved?.Invoke(stage);

                // 성체가 되었으므로 "도감"에 현재 개체를 등록
                RegisterToGallery();

                // 게임 클리어 처리(엔딩 등)
                gamemanager.EndingController(2);
                galleryUIManager.Refresh();
                return;
            }

            // (성체가 아니라면) 다음 단계 단어 배정 및 진화
            currentEntry = wordService.PickNextLinkedWord(currentEntry, stage);
            currentAnswer = currentEntry.word;
            GameEvents.OnNewWordAssigned?.Invoke(currentAnswer);

            stage = (GrowthStage)((int)stage + 1);
            GameEvents.OnEvolved?.Invoke(stage);

            BeginStage(stage);
        }

        /// 
        /// 사망 처리(휴지통/광고 보상 등 훅)
        /// 
        private void WordEaterDie()
        {
            if (isDead) return; 
            isDead = true;
            GameEvents.OnDied?.Invoke();

            enabled = false;

            // 광고 팝업 띄우고, 거절하면 그때 엔딩
            if (GameReviveSystem.I != null)
            {
                Debug.Log("광고 팝업 띄울겨");
                GameReviveSystem.I.OnPlayerDied(onGiveUp: () =>
                {
                    // 정말 포기한 경우에만 게임오버 연출로 이동
                    gamemanager.EndingController(1);
                });
            }
            else
            {
                // 시스템이 없으면 안전하게 기존 흐름 유지
                gamemanager.EndingController(1);
            }

        }

        // 부활시
        public void Reactivate()
        {
            isDead = false;       // 죽은 상태 해제
            enabled = true;       // 다시 동작
                                  // 필요하면 무적 타이머/상태 초기화/입력언락 등을 여기서 처리
        }

        public int GetTurnsLeft() => turn.TurnsLeft;
        public int GetMistakesLeft() => turn.MistakesLeft; // TurnController에 프로퍼티 노출 필요

        public void RestoreTurns(int turnsLeft, int mistakesLeft)
        {
            turn.ForceRestore(turnsLeft, mistakesLeft); // TurnController에 강제 복원 API 추가
        }

        public void RestoreAnswer(string answer, GrowthStage s)
        {
            stage = s;
            currentAnswer = answer;
            GameEvents.OnNewWordAssigned?.Invoke(currentAnswer);

            // 스프라이트 동기화
            var sr = GetComponent();
            if (sr != null)
            {
                if (stage == GrowthStage.Bit) sr.sprite = BitImg;
                if (stage == GrowthStage.Byte) sr.sprite = ByteImg;
                if (stage == GrowthStage.Word) sr.sprite = WordImg;
            }
        }

        public WordEntry returnCurrentEnrty()
        {
            return currentEntry;
        }

        public string CurrentAnswer => currentAnswer;

        public GrowthStage ReturnStage()
        {
            return stage;
        }

        /// 
        /// [도감 등록] 성체 달성 시 현재 워드이터를 도감 JSON에 등록한다.
        /// 동작 순서:
        /// 1) 현재 단어/단계를 이용해 "고유 ID" 생성 (충돌 방지용)
        /// 2) UI에 표시할 제목/카테고리(설명) 텍스트 구성
        /// 3) 현재 SpriteRenderer의 스프라이트를 썸네일 PNG로 저장
        /// 4) GalleryStore(싱글톤)로 Upsert → gallery.json에 반영
        /// 
        private void RegisterToGallery()
        {
            var entry = currentEntry;

            // ✅ 최종 키: Word 단계의 MakeStableId (예: "2-수학")
            string finalId = MakeStableId(entry);

            // 임시 경로/최종 경로
            string baseDir = Application.persistentDataPath;
            string tmpS0 = Path.Combine(baseDir, $"thumb_{pendingEvoId}_s0.png");
            string tmpS1 = Path.Combine(baseDir, $"thumb_{pendingEvoId}_s1.png");
            string finS0 = Path.Combine(baseDir, $"thumb_{finalId}_s0.png");
            string finS1 = Path.Combine(baseDir, $"thumb_{finalId}_s1.png");

            // ✅ Bit/Byte 파일을 최종 키 이름으로 이동(있을 때만)
            MoveIfExists(tmpS0, finS0);
            MoveIfExists(tmpS1, finS1);

            // ✅ Word 썸네일은 최종 키로 저장
            var sr = GetComponent();
            string finS2 = Path.Combine(baseDir, $"thumb_{finalId}_s2.png");
            GalleryCapture.SaveSpriteThumb(sr, $"thumb_{finalId}_s2", 256);

            // 도감 등록: 대표 썸네일은 Word
            var item = new GalleryItem
            {
                id = finalId,
                displayName = entry.word,
                desc = GetTopicForDisplay(entry),
                thumbPath = finS2,
                dateCaught = System.DateTime.Now.ToString("yyyy-MM-dd")
            };
            GalleryStore.Instance.Upsert(item);
        }

        static void MoveIfExists(string src, string dst)
        {
            try
            {
                if (File.Exists(src))
                {
                    // 덮어쓰기 방지: 기존 있으면 삭제
                    if (File.Exists(dst)) File.Delete(dst);
                    File.Move(src, dst);
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogWarning($"[Gallery] Move fail {src} -> {dst} : {ex.Message}");
            }
        }
        /// 
        /// [도감 고유키 생성] 단어가 중복될 수 있으므로 "단계-단어" 형태로 고정 키를 만든다.
        /// 예: stage=2, word="수학" → "2-수학"
        /// 
        static string MakeStableId(WordEntry e)
        {
            string slug = e.word.Trim().Replace(" ", ""); // 공백 제거 등 최소 정규화
            return $"{e.stage}-{slug}";
        }

        /// 
        /// [표시용 카테고리 텍스트] 데이터 구조상 topic 필드는 없으므로 다음 규칙 적용:
        /// - Word(2단계)는 상위 개념이므로 "자기 자신"을 카테고리로 사용
        /// - Bit/Byte는 related[] 첫 번째 항목을 대표 카테고리로 사용
        /// - 없을 경우 "기타"
        /// 
        static string GetTopicForDisplay(WordEntry e)
        {
            if (e.stage == 2) return e.word;                     // 최상위 카테고리
            if (e.related != null && e.related.Length > 0)
                return e.related[0];                              // 대표 카테고리 하나만 표시
            return "기타";
        }

    }
}

길다 길어

여기만 보면됨


        /// 
        /// 사망 처리(휴지통/광고 보상 등 훅)
        /// 
        private void WordEaterDie()
        {
            if (isDead) return; 
            isDead = true;
            GameEvents.OnDied?.Invoke();

            enabled = false;

            // 광고 팝업 띄우고, 거절하면 그때 엔딩
            if (GameReviveSystem.I != null)
            {
                Debug.Log("광고 팝업 띄울겨");
                GameReviveSystem.I.OnPlayerDied(onGiveUp: () =>
                {
                    // 정말 포기한 경우에만 게임오버 연출로 이동
                    gamemanager.EndingController(1);
                });
            }
            else
            {
                // 시스템이 없으면 안전하게 기존 흐름 유지
                gamemanager.EndingController(1);
            }

        }

        // 부활시
        public void Reactivate()
        {
            isDead = false;       // 죽은 상태 해제
            enabled = true;       // 다시 동작
                                  // 필요하면 무적 타이머/상태 초기화/입력언락 등을 여기서 처리
        }

        public int GetTurnsLeft() => turn.TurnsLeft;
        public int GetMistakesLeft() => turn.MistakesLeft; // TurnController에 프로퍼티 노출 필요

        public void RestoreTurns(int turnsLeft, int mistakesLeft)
        {
            turn.ForceRestore(turnsLeft, mistakesLeft); // TurnController에 강제 복원 API 추가
        }

        public void RestoreAnswer(string answer, GrowthStage s)
        {
            stage = s;
            currentAnswer = answer;
            GameEvents.OnNewWordAssigned?.Invoke(currentAnswer);

            // 스프라이트 동기화
            var sr = GetComponent();
            if (sr != null)
            {
                if (stage == GrowthStage.Bit) sr.sprite = BitImg;
                if (stage == GrowthStage.Byte) sr.sprite = ByteImg;
                if (stage == GrowthStage.Word) sr.sprite = WordImg;
            }
        }

TurnController.cs 변경점 (강제 복원 API 추가)

using UnityEngine;
using WordEater.Core;
using WordEater.Data;

namespace WordEater.Core
{
    /// 
    /// 현재 단계(StageConfig)에 따라 '턴/오답' 수를 관리하는 컨트롤러
    /// 

    public class TurnController
    {
        private readonly GrowthConfig _growth;
        public int TurnsLeft { get; private set; }
        public int MistakesLeft { get; private set; }

        public TurnController(GrowthConfig growth) => _growth = growth;

        /// 
        /// 단계 시작 시 규칙 초기화
        /// 
        public void StartStage(GrowthStage stage)
        {
            var cfg = _growth.Get(stage);
            TurnsLeft = cfg.turnsPerStage;
            MistakesLeft = cfg.maxMistakes;
            GameEvents.OnStageStarted?.Invoke(stage, TurnsLeft, MistakesLeft);
        }

        /// 
        /// 액션 수행 시 턴 차감 (Clean은 2턴)
        /// 
        public bool ConsumeTurn(ActionType action)
        {
            int cost = action == ActionType.CleanNoise ? 2 : 1;
            TurnsLeft -= cost;

            // (OnTurnsChanged는 기존대로 두되, 필요시 RaiseTurnsChanged로 교체 가능)
            GameEvents.OnTurnsChanged?.Invoke(TurnsLeft);
            return TurnsLeft > 0;
        }

        /// 
        /// 오답 1회 등록
        /// 
        public bool RegisterMistake()
        {
            MistakesLeft -= 1;
            // 래퍼로 호출
            GameEvents.RaiseMistakesChanged(MistakesLeft);
            return MistakesLeft >= 0;
        }

        /// 
        /// ✅ 부활 복원을 위한 강제 복원 API (권장: stage 넘겨서 룰에 맞게 Clamp)
        /// 
        public void ForceRestore(int turnsLeft, int mistakesLeft, GrowthStage stage)
        {
            var cfg = _growth.Get(stage);
            TurnsLeft = Mathf.Clamp(turnsLeft, 0, cfg.turnsPerStage);
            MistakesLeft = Mathf.Clamp(mistakesLeft, 0, cfg.maxMistakes);

            GameEvents.OnStageStarted?.Invoke(stage, TurnsLeft, MistakesLeft);
            GameEvents.OnTurnsChanged?.Invoke(TurnsLeft);
            GameEvents.RaiseMistakesChanged(MistakesLeft);
        }

        /// 
        /// (옵션) stage 없이 그대로 복원 – 기존 호출부 호환용
        /// 
        public void ForceRestore(int turnsLeft, int mistakesLeft)
        {
            TurnsLeft = turnsLeft;
            MistakesLeft = mistakesLeft;

            GameEvents.OnTurnsChanged?.Invoke(TurnsLeft);
            GameEvents.RaiseMistakesChanged(MistakesLeft);
        }
    }

}

유니티 모바일 키보드가 인풋필드를 가리는 문제

Fri, 19 Dec 2025 08:46:32 GMT

문제 영상

인풋필드에 타자를 치려하면 키보드가 가리는 문제가 생김

KeyboardAvoider 라는 스크립트를 생성하고

using UnityEngine;

/// 
/// 모바일(안드로이드/IOS)에서 소프트 키보드가 올라올 때,
/// 화면 하단에 위치한 Input_Group(입력창 + 전송 버튼)을
/// 키보드 높이에 맞춰 위로 올려주는 스크립트
///
/// 목적:
/// - 키보드가 InputField를 가리는 현상을 방지
/// 
/// 원리:
/// 1) 네이티브 키보드 높이를 픽셀 단위로 가져온다
/// 2) Canvas Scaler의 scaleFactor로 나눠 'UI 좌표'로 변환
/// 3) 입력창의 anchoredPosition.y 를 그만큼 위로 올린다
/// 
/// 이 스크립트는 오직 target(Input_Group)만 움직이며,
/// 메시지 스크롤뷰 등 다른 UI는 그대로 둔다
/// (채팅 앱에서 하단 입력창만 올라가는 방식)
/// 
public class KeyboardAvoider : MonoBehaviour
{
    [Header("키보드에 맞춰 올릴 RectTransform (Input_Group)")]
    [SerializeField] private RectTransform target;

    [Header("키보드 높이에 곱해줄 값 (1.0 = 그대로, 0.9 = 살짝 덜 올리기)")]
    [SerializeField] private float heightMultiplier = 1.05f;

    [Header("추가로 미세하게 조절할 오프셋 (UI px 단위, 음수면 아래로)")]
    [SerializeField] private float extraOffset = -50f;

    // 현재 캔버스 (CanvasScaler의 scaleFactor 읽기 위함)
    private Canvas rootCanvas;

    // target의 원래 anchoredPosition 값 (키보드 닫으면 원래 위치로 복귀)
    private Vector2 originalAnchoredPos;

    // 이전 프레임 키보드 높이 (같은 값일 경우 연산 안 하려고 저장)
    private float currentKeyboardHeight;

    void Awake()
    {
        // 타겟이 비어 있으면 자기 자신 RectTransform 참조
        if (target == null)
            target = GetComponent();

        // 가장 가까운 부모 Canvas 찾기
        rootCanvas = target.GetComponentInParent

이 스크립트가 하는 일

모바일에서 키보드가 올라올 때
Input_Group(InputField + 전송 버튼 포함한 UI)을
키보드 높이만큼 위로 들어 올려서

키보드가 입력창을 가리지 않게 만드는 기능

target : 키보드와 함께 올라갈 오브젝트

extraOffset : 너무 내려감 → 양수 너무 올라감 → 음수로 조절하는 변수

동작 원리

모바일에서 키보드가 올라오면 OS가 “키보드 영역” 만큼 화면을 가린다.
Android/iOS 네이티브 API를 사용하여 키보드의 실제 높이(px) 를 가져온다.
Canvas Scaler 값에 따라 UI 좌표계로 변환한다.
Input_Group에 anchoredPosition.y 만큼 값을 더해준다.
키보드가 내려가면 originalAnchoredPos로 원위치.

유니티에서 AWS를 사용해 파이썬 프로그램 실행하기

Fri, 19 Dec 2025 08:41:37 GMT

1단계 : AWS EC2 인스턴스 생성 (서버 만들기)

일단 로긘을 해야겠지?

난 아이디도 없어서 회원가입부터함

쭉 진행하다 보면 카드 정보 입력하고 어디사는지 입력하라고 뜨는데 그거까지 다 해주고 로그인 ㄱㄱ

https://aws.amazon.com/ko/

다음에 이 사이트를 들어가서 EC2를 검색(로그인 돼있으면 사진처럼)

인스턴스를 누르고

오른쪽 위 인스턴스 시작 ㄱㄱ

이름 : 프로젝트 이름으로 암거나하고
OS 이미지(AMI): Ubuntu Server 22.04 LTS (프리 티어 사용 가능 확인)

첫번째 프리티어 사용 가능이니까 그거 선택

인스턴스 유형: t2.micro 또는 t3.micro (지역에 따라 '프리 티어 사용 가능'이라고 표시된 것 선택)
키 페어: '새 키 페어 생성'을 눌러 .pem 파일을 다운로드 (중요: 이 파일은 서버 접속 시 꼭 필요하며 다시 받을 수 없으니 안전한 곳에 보관해야댐)

키 페어 이름도 프로젝트 이름으로 해줬음 여기서 ppk로 하는게 좋을듯 어차피 나중에 ppk도 필요해서(근데 난 pem으로 함)

인스턴스 시작하면 만들어집니당

2단계: 서버 보안 설정 (포트 5000 열기)

다시 대시보드로 돌아와서 인스턴스ID를 클릭하면(사진에서 가려놔서 안 보이는거지 클릭할 수 있게 돼있음)

가릴거 참 많다,, 여기서 보안 들어가면

보안 그룹이라는게 보이는데 이걸 누르삼

인바운드 규칙 편집을 클릭

원래 있던 두가지 유형을 이렇게 편집하면 됨
- 유형: 사용자 지정 TCP
- 포트 범위: 5000
- 소스: Anywhere-IPv4 (0.0.0.0/0) — 테스트용
규칙 저장을 누르면 됨

3단계: 서버에 파일 업로드 및 환경 구축

얘가 귀찮음

https://winscp.net/eng/download.php

여기서 얘 다운 받고 키면 로그인하라는 창이 뜨는데 여기다 파이썬 모듈을 옮겨줄거임

호스트 이름(Host Name): 아까 확인한 AWS의 퍼블릭 IPv4 주소 (예: 3.34.xxx.xxx)

아까 그 대시보드에서 이 부분을 복사해오면 됨

사용자 이름(User Name): ubuntu (반드시 소문자)
비밀번호: 입력X

여기서 냅다 로그인하면 안되고 고급에서

로그인 창의 [고급(D)] 버튼을 클릭
왼쪽 목록에서 SSH → 인증을 클릭

개인 키 파일(Private key file) 칸의 ... 버튼을 눌러 내 컴퓨터에 있는 .pem 파일을 선택
- 파일 탐색기 창이 뜨면 오른쪽 하단 파일 형식을 모든 파일 (.)로 바꿔야 .pem 파일이 보임

만약에 ppk로 했으면 그거 넣고 pem으로 했으면 이렇게 넣어줌

그럼 이런 창이 뜨면서 확인 누르면 됨

만약 안 뜬다!! 하면 공개 키 표시 버튼을 눌러보세요(난 이렇게 해결함 왜인진 모름)

이제 내 컴퓨터에 있는 아래 4개 파일을 마우스로 잡아서 오른쪽 칸으로 드래그하면 끝

4단계: 서버 실행

일단 내가 만든 서버에 접속해야되니까 이거부터 해줌

서버 접속 (SSH): 터미널이나 PuTTY를 통해 서버에 접속

ssh -i "키파일이름.pem" ubuntu@내-EC2-IP주소

키파일이름은 아까 만든 이름으로 하면 되고

내 EC2 IP 주소는 아래 사진에 보이는 퍼블릭 IPv4 주소를 쓰면댐

파이썬 환경 설치

sudo apt update sudo apt install python3-pip -y pip3 install flask gensim

패키지 목록 업데이트

`sudo apt update`

파이썬 설치 확인 및 pip(설치 도구) 설치

`sudo apt install python3-pip -y`

필요한 라이브러리 설치

`pip3 install flask gensim`

실행 테스트

`python3 run.py`

(에러 없이 `Complety Loading Model`이 뜨는지 확인!!)

백그라운드 실행

nohup python3 run.py > output.log 2>&1 &
- 이제 터미널을 종료해도 서버는 계속 작동함
- 서버를 끄고 싶을 때는 ps -ef | grep run.py로 프로세스 ID를 찾아 kill 명령어를 사용

⚠️ 오류 모음

만약

Loading FastText...

Killed

라는 오류가 떴다면 메모리 부족으로 뜨는 오류로 다음과 같이 순서대로 진행

1. 2GB 크기의 스왑 파일 생성

sudo fallocate -l 2G /swapfile

2. 파일 권한 설정 (보안)

sudo chmod 600 /swapfile

3. 파일을 스왑 공간으로 포맷

sudo mkswap /swapfile

4. 스왑 공간 활성화

sudo swapon /swapfile

5. 설정이 잘 되었는지 확인

free -h

결과 확인: Swap: 부분에 2.0Gi라고 나오면 성공입니다!

이후에 다시 python3 [run.py](http://run.py) 를 입력해서 실행

5단계: 유니티 코드 수정

이제 유니티의 PythonConnectManager.cs 파일에서 URL만 변경하면 끝!

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Text;
using Newtonsoft.Json;
using System.Collections.Generic;
using System;

[System.Serializable]
public class ResultData
{
    public List result;
}

public class ResultData2
{
    public float? result;
}

public class PythonConnectManager : MonoBehaviour
{
    private string serverIP = "본인 퍼블릭 IPv4 주소";

    }

    //단어와 몇개의 유사한 단어를 가져올 것인지 입력
    public IEnumerator MostSimilarty(string inputWord, int num, Action> callback)
    {
        string url = $"http://{serverIP}:5000/most_similarty";

        var data = new { word = inputWord, num = num };
        string jsonData = JsonConvert.SerializeObject(data);

        using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
        {
            byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);
            request.uploadHandler = new UploadHandlerRaw(bodyRaw);
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SetRequestHeader("Content-Type", "application/json");

            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.Success)
            {
                string jsonResponse = request.downloadHandler.text;
                Debug.Log("서버 응답: " + jsonResponse);
                ResultData responseData = JsonConvert.DeserializeObject(jsonResponse);

                if (responseData.result != null && responseData.result.Count > 0)
                {
                    callback(responseData.result);
                }
                else
                {
                    callback(new List { "부정확한 단어" });
                }
            }
            else
            {
                Debug.LogError("요청 실패: " + request.error);
                callback(new List { "요청 실패" });
            }
        }
    }

    //두 단어 사이의 유사도
    public IEnumerator SimilartyTwoWord(string inputWord, string inputWord2, Action callback)
    {
        string url = $"http://{serverIP}:5000/similarity";

        var data = new { word1 = inputWord, word2 = inputWord2 };
        string jsonData = JsonConvert.SerializeObject(data);

        using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
        {
            byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);
            request.uploadHandler = new UploadHandlerRaw(bodyRaw);
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SetRequestHeader("Content-Type", "application/json");

            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.Success)
            {
                string jsonResponse = request.downloadHandler.text;
                ResultData2 responseData = JsonConvert.DeserializeObject(jsonResponse);

                if (responseData != null && responseData.result.HasValue)
                {
                    callback?.Invoke(responseData.result.Value);
                }
                else
                {
                    Debug.Log("부정확한 단어");
                    callback?.Invoke(null);
                }
            }
            else
            {
                Debug.LogError("요청 실패: " + request.error);
                callback?.Invoke(null);
            }
        }
    }
}

💡 만약 서버를 끄고 싶다면?

나중에 서버를 업데이트하거나 끄고 싶을 때는 아래 명령어를 터미널에 입력하면 됩니당~

pkill -f run.py

유니티 ait 파일 생성, 앱인토스 ait 파일 빌드, 유니티에서 만든 게임을 앱인토스에 올리기

Fri, 01 Aug 2025 08:06:00 GMT

앱인토스 개발자센터

이 글은 앱인토스 ait 빌드, 리더보드,, 어쩌고 기능을 어떻게 써!! 하시는 분들에게 바칩니다.

앱인토스로 게임을 만드는 분들께 도움이 되길 바랍니다 … ⭐

일단 제일 중요한 ❗사업자 등록❗이 필요합니다.

이게 없으면 앱인토스에 올릴 수가 없어요

있다고 가정하고, 게임까지 다 만들었다(아예 완성X, 80%?)라고 가정한 후 이 단계를 따라오시면 됩니다.

먼저, 게임을 다 만든후 WebGL로 빌드해주세요

앱인토스 시작하기

앱인토스 콘솔

여기 들어가서 회원가입 후 - 워크스페이스에 초대를(본인이 사업자 등록자라면 본인이 만들기) 받은 후 들어갑니다.

워크스페이스(회사명)을 입력한 후, 안에 여러 게임을 동시에 등록할 수 있습니다.

만들게되면 이런 화면이 뜨는데 “앱 등록하기” 버튼을 누르면

앱 정보(이름, 한국어, 영어,,,, ,, 등등)를 쓸 수 있는 칸이 나오는데 다 채워주시면 됩니다.

여기서 미리 준비해야할 것이

⭐ 앱 로고(600px * 600px)

⭐ 정방형 썸네일(1000px * 1000px)

⭐ 가로형 썸네일(1932px * 828px)

이 세가지입니다!!

이런식으로 들어갈 거고, 저는 미리캔버스 사용해서 만들었습니다

다 만들었다면 카테고리를 작성해야하는데 앱 설명은

이런식으로 옆에 뜨는 문구입니다.

리더보드의 점수는 이렇게 뜬다고 예시보기 누르면 이 사진이 뜨게됩니다~!

저는 아래 등급정보에 스토어 링크가 없으니 itch.io에 WebGL로 빌드한 후, 업로드하고 그 링크를 넣어줬어요

자 이제 50%는 준비가 완료됐습니다. 검토 요청 후 토스내에서 검토가 완료되면 워크스페이스가 만들어질 것이고, 저희가 이제부터 할 것은 ait 파일을 빌드하는 방법이에요

AIT 파일 빌드하기

Node.js — Run JavaScript Everywhere

먼저, node js를 다운받아줍니다. 다운 받는 방법은 여러 게시물이 있으니 생략하겠습니다.

⚠️ WebGL로 빌드한 폴더와 경로가 같아야합니다. (ex. desktop - Build - 빌드한 폴더 라면, Build에서 진행)

npm create vite@latest 폴더명

이렇게 한 후** 프레임워크는 Vanilla** 배리언트는 JavaScript

만들어진 폴더로 이동한 후

npm install

후에 ! 아래부터 차근차근 따라가주세요

npm install @apps-in-toss/web-framework

npx ait init

여기까지 했다면 아래 이것저것 입력하라고 할텐데 사진대로 하면 됩니당

React Native로 해주고, app-name(본인 게임 이름 소문자로)를 입력해줍니다.

이때 빌드한 폴더의 index.html파일을 만들어진 unity-web-wrapper에 덮어씌우기 한 후

유니티 빌드 폴더의 "Build"폴더를 public 폴더 안에 복사

복사를 다 한 후에 ait파일을

npm run build

여기까지하면 ait파일이 빌드가 됩니다.

그 전에, bedrock파일에

import { defineConfig } from '@apps-in-toss/web-framework/config';

export default defineConfig({
  appName: 'crayonfish',
  brand: {
    displayName: '크레용 피쉬', // 화면에 노출될 앱의 한글 이름으로 바꿔주세요.
    primaryColor: '#3182F6', // 화면에 노출될 앱의 기본 색상으로 바꿔주세요.
    icon: "이미지주소링크(위에서 말한것)", // 화면에 노출될 앱의 아이콘 이미지 주소로 바꿔주세요.
    bridgeColorMode: 'inverted',
  },
  web: {
    host: 'localhost',
    port: 5173,
    commands: {
      dev: 'vite',
      build: 'vite build',
    },
  },
  permissions: [],
  outdir: 'dist',
  webViewProps: {
    type: 'game',
  },
});

bridgeColorMode 는 inverted로,

type은 game으로 바꿔주셔야합니다!

여기서 icon은 아까 만든 워크스페이스에 개발 - 앱정보 들어가서 “수정하기”버튼을 누릅니다. 여기서 앱로고 링크를 복사해 bedrock의 icon : null 에 null대신 넣어주면 됩니다.

리더보드 기능은 index.html과 toss.js파일을 만들고 유니티 에디터에서 연결할 버튼 스크립트 짜주고 bedrock 수정해주고 등등 다시 파일을 바꾸고 그 버전으로 ait파일을 빌드하려면

npm run build 를 해주셔야합니다.

AIT 파일 업로드하기

ait 빌드 후 오른쪽 위에 버전 등록을 누르고 아까 만든 ait파일과 출시노트(~수정, ~추가 버전)을 작성하고 등록해주면 목록에 버전, 상태, 출시노트, 생성일, 테스트하기 / 검토요청하기 버튼이 뜹니다

테스트하기 버튼을 누르면 이런 화면이 뜨고, 큐알을 찍거나 링크를 복사해 모바일로 실행하면 토스앱 내에서 테스트할 수 있게 됩니다.

푸시발송하기 누르면 워크스페이스 내 멤버 모두가 토스 알람을 받게됩니다.

검토 요청을 누르게되면 체크리스트 체크 후 검토 요청하기를 누르면 반려사유보기 or 출시하기 버튼이 활성화되며 검토가 완료된 버전은 출시가 가능합니다. (토스 내 게임 앱에서 바로 출시가 됩니다!)

중간에 까먹은 명령어와 리더보드는 빠른 시일내에 올리도록 하겠습니다 ㅠ,ㅠ

유니티 Photon Voice2 보이스 채팅 기능

Tue, 25 Mar 2025 07:12:41 GMT

이 글을,,, 보이스를 구현하려는 모든 사람에게 바칩니다. 유니티 6버전 기준으로 만들어졌습니다@@!

포톤 보이스에 대한 기본적인 기능은 있는데 음소거 ON/OFF, 말하는 사람 아이콘 활성화 등의 기능을 다룬 게시물이 없어서 씀

근데 나도 야매로 한거라 약간의 하자가 있습니다.

먼저, Photon Voice2를 임포트하고 기본 세팅은 다른 곳에서 찾아보면 알 수 있듯이, Voice Manager라는 오브젝트를 만들어줌

아래처럼 Recorder 오브젝트와 Pun Voice Client를 부착

플레이어에 Speaker와 Photon Voice View 컴포넌트를 부착해주면 준비 끝

이때, Recorder에 Debug Echo를 체크하면 내 목소리가 들려서 테스트가 가능하다

조금 복잡하게 생겼지만 내 게임의 구조는 PlayerGroup이라는 오브젝트 아래 Player1,2,3,4 자식으로 각각 플레이어가 생성될 것이고

VoicePanel은이렇게 생겼따.

내 코드인것,,. 정말정말 길고 복잡하고 막 짠거(아님 ㅠㅠ 열심히 한거야)같지만 최선이였따.

using Photon.Pun;
using Photon.Realtime;
using Photon.Voice.Unity;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using static TotalMultiManager;
using System.Collections;

public class VoiceManager : MonoBehaviourPunCallbacks
{
    public static VoiceManager Instance { get; private set; } // Singleton 인스턴스

    [SerializeField] private Transform playerGroup; // PlayerGroup의 Transform

    [SerializeField] private GameObject[] players;  // 각 플레이어 GameObject
    [SerializeField] private TextMeshProUGUI[] playerTexts;  // 각 플레이어의 TextMeshProUGUI 배열

    [SerializeField] private Sprite speakImage;  // 말하는 이미지
    [SerializeField] private Sprite defaultImage;  // 기본 이미지
    [SerializeField] private Sprite muteImage;  // 기본 이미지

    [SerializeField] private GameObject speakerPanel;

    private Speaker[] speakers;  // Speaker 컴포넌트를 담을 배열
    private bool[] isMuted = new bool[4];  // 각 플레이어의 음소거 상태

    private Recorder recorder;
    // 로컬 플레이어의 자체 음소거 상태 변수
    private bool selfMuted = false;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(Instance.gameObject);
            Instance = this;
        }
    }

    private void Start()
    {
        StartCoroutine(UpdatePlayerText());
    }

    /// 
    /// 매 프레임의 후반부에 호출되는 함수
    /// 스피커 목록을 최신 상태로 유지하기 위해 업데이트 호출
    /// 
    private void LateUpdate()
    {
        StartCoroutine(UpdatePlayerText());
        CheckIsPlaying();
    }


    public void OnClickSpeakerPanel()
    {
        speakerPanel.SetActive(!speakerPanel.activeSelf);
    }

    /// 
    /// 각 스피커의 재생 상태에 따라 플레이어 UI를 업데이트하는 함수
    /// 
    private void CheckIsPlaying()
    {
        // 모든 플레이어 UI를 비활성화
        for (int i = 0; i < players.Length; i++)
        {
            players[i].SetActive(false);
        }

        speakers = playerGroup.GetComponentsInChildren(true);

        foreach (var speaker in speakers)
        {
            PhotonView pv = speaker.GetComponent();
            if (pv == null) continue;

            int index = pv.OwnerActorNr - 1;
            if (index < 0 || index >= players.Length) continue;

            players[index].SetActive(true);

            Image img = playerTexts[index].GetComponentInChildren();


            // 로컬 플레이어 처리
            if (pv.IsMine)
            {
                // 로컬 플레이어의 AudioSource 가져오기
                AudioSource audioSource = speaker.GetComponent();
                if (audioSource != null)
                {
                    // 본인이 말할 때는 볼륨을 0, 그렇지 않을 때는 1로 설정
                    audioSource.volume = speaker.IsPlaying ? 0f : 1f;
                }
                // 로컬 플레이어의 음소거 여부 및 말하는 상태에 따른 이미지 설정
                img.sprite = selfMuted ? muteImage : (speaker.IsPlaying ? speakImage : defaultImage);
            }
            else
            {
                // 원격 플레이어 처리: 음소거 상태 및 말하는 상태에 따른 이미지 설정
                img.sprite = isMuted[index]
                    ? muteImage
                    : (speaker.IsPlaying ? speakImage : defaultImage);
            }
            // 플레이어 닉네임 업데이트
            playerTexts[index].text = pv.Owner.NickName;
        }
    }

    /// 
    /// 모든 Speaker 컴포넌트를 가진 플레이어를 확인하고 playerTexts를 업데이트
    /// 
    private IEnumerator UpdatePlayerText()
    {
        while (!AllhasTag("HasInfo"))
        {
            yield return null; // 모든 플레이어의 CustomProperties가 준비될 때까지 대기
        }

        speakers = playerGroup.GetComponentsInChildren(true);

        foreach (var speaker in speakers)
        {
            PhotonView pv = speaker.GetComponent();
            if (pv == null) continue;

            int index = pv.OwnerActorNr - 1;
            if (index < 0 || index >= playerTexts.Length) continue;

            players[index].SetActive(true);
            playerTexts[index].text = pv.Owner.NickName;
        }
    }

    /// 
    /// 방에 입장했을 때 호출되는 콜백 함수
    /// 로컬 플레이어의 CustomProperties에 "HasInfo"를 설정
    /// 
    public override void OnJoinedRoom()
    {
        base.OnJoinedRoom();

        // 로컬 플레이어의 정보가 준비되었음을 표시하는 프로퍼티 설정
        ExitGames.Client.Photon.Hashtable props = new ExitGames.Client.Photon.Hashtable
        {
            { "HasInfo", true }
        };

        PhotonNetwork.LocalPlayer.SetCustomProperties(props);
    }

    // 방에 들어왔을때
    public override void OnPlayerEnteredRoom(Player newPlayer)
    {
        // 입장한 플레이어의 ActorNumber를 인덱스로 사용
        int index = newPlayer.ActorNumber - 1;

        // 인덱스가 유효하면 UI를 활성화하고 닉네임을 업데이트
        if (index >= 0 && index < players.Length)
        {
            players[index].SetActive(true);
            playerTexts[index].text = newPlayer.NickName;
        }
    }

    /// 
    /// 플레이어가 방을 떠났을 때 호출되는 콜백 함수
    /// 해당 플레이어의 UI를 비활성화(또는 닉네임 삭제)하고 스피커 목록을 업데이트
    /// 
    public override void OnPlayerLeftRoom(Player otherPlayer)
    {
        // 나간 플레이어의 ActorNumber를 인덱스로 사용
        int index = otherPlayer.ActorNumber - 1;

        // 인덱스가 유효하면 UI를 비활성화(또는 닉네임을 지움)하여 표시하지 않음
        if (index >= 0 && index < players.Length)
        {
            players[index].SetActive(true);
            playerTexts[index].text = "";
        }
    }


    /// 
    /// 특정 ActorNumber에 해당하는 플레이어의 음소거 상태를 토글하는 함수
    /// - 로컬 플레이어인 경우 Recorder를 토글하여 자신의 목소리 전송 여부 제어
    /// - 원격 플레이어인 경우 해당 Speaker 컴포넌트의 활성화를 토글하여 클라이언트에서만 음소거 처리
    /// 
    /// 음소거할 플레이어의 ActorNumber
    public void ToggleSpeaker(int actorNumber)
    {
        if (actorNumber == PhotonNetwork.LocalPlayer.ActorNumber)
        {
            ToggleSelfMute();
            return;
        }

        // ActorNumber를 인덱스로 변환 (배열은 0부터 시작)
        int index = actorNumber - 1;
        foreach (var speaker in speakers)
        {
            PhotonView pv = speaker.GetComponent();
            // 해당 Speaker의 소유자와 전달된 ActorNumber가 일치하면 음소거 상태를 토글
            if (pv != null && pv.OwnerActorNr == actorNumber)
            {
                // Speaker 컴포넌트의 활성화 여부를 반전시킴 (비활성화되면 음소거)
                speaker.enabled = !speaker.enabled;
                // isMuted 배열에도 반영 (speaker가 비활성화이면 음소거 상태)
                isMuted[index] = !speaker.enabled;

                // UI의 이미지도 즉시 업데이트하여 음소거 상태를 표시
                Image img = playerTexts[index].GetComponentInChildren();
                img.sprite = isMuted[index] ? muteImage : (speaker.IsPlaying ? speakImage : defaultImage);
                return;
            }
        }
    }
    /// 
    /// 로컬 플레이어의 음소거를 토글
    /// 
    private void ToggleSelfMute()
    {
        if (recorder == null)
        {
            Debug.LogWarning("Recorder is not assigned!");
            return;
        }

        // selfMuted 상태 반전
        selfMuted = !selfMuted;
        // 음소거 상태이면 전송하지 않음, 아니면 전송
        // TransmitEnabled : 시작하자마자 말하기가 가능함(눌러서 말하기 제어 가능)
        recorder.TransmitEnabled = !selfMuted;

        // UI 업데이트: 로컬 플레이어 인덱스에 해당하는 이미지 변경
        int index = PhotonNetwork.LocalPlayer.ActorNumber - 1;
        Image img = playerTexts[index].GetComponentInChildren();

        img.sprite = selfMuted ? muteImage : defaultImage;
        Debug.Log(img);
        Debug.Log("Self mute toggled: " + (selfMuted ? "Muted" : "Unmuted"));
    }
}

자, 하나씩 살펴보면 전체적인 구조는 Player가 Speaker 컴포넌트를 가지고 있으니 PlayerGroup에서 speaker컴포넌트를 가진 애가 들어올때마다 위의 VoicePanel에 닉네임과 아이콘을 활성화시켜주는것임

여기서 ActorNumber란 무엇인가!! 플레이어를 구분할때 사용하는 고유한 넘버인데, 내 코드에서는 닉네임 배열의 인덱스로 활용함

그리고 누군가가 말하고 있으면 CheckIsPlaying 함수를 사용해 말하는 아이콘을 활성화해줌 이때 Recorder에 Debug Echo를 체크를 한 상태로 진행했는데, 어째서인지 체크를 해제하면 상대방에게도 내 목소리가 들리지 않은 버그가 생겼었음

그래서 아래의 코드로 내 목소리는 들리지 않도록 처리를 해줬음

// 본인이 말할 때는 볼륨을 0, 그렇지 않을 때는 1로 설정
audioSource.volume = speaker.IsPlaying ? 0f : 1f;

on/off는 ToggleSelfMute함수로 해줄건데 내가 상대방의 목소리를 끌 수도 있고, 내 목소리를 끌 수도 있음

내 코드에서 로컬과 원격을 분리한 이유는 자신의 음성 전송과 관련된 직접적인 제어가 필요하고, 원격 플레이어는 단순히 해당 클라이언트에서 음성이 재생되는지 여부에 따라 UI와 음소거 상태를 관리해야하기 때문에 두가지를 나눠 구현했다.

객체지향 5대 원칙/인터페이스 분리 원칙(ISP)

Sun, 17 Nov 2024 05:40:28 GMT

인터페이스 분리 원칙(ISP)

인터페이스 분리 원칙이란, 객체는 자신이 호출하지 않는 메소드에 의존하지 않아야한다는 원칙이다.

5가지 SOLID 원칙

객체지향 설계에서 지켜줘야 할 5개의 소프트웨어 개발 원칙

단일 책임 (SRP)
개방 폐쇄 (OCP)
리스코프 치환 (LSP)
인터페이스 분리 (ISP)
종속성 역전 (DIP)

이 5가지를 SOLID원칙이라고 한다.

단일 책임 원칙(Single Responsibility)

컴포넌트도 클래스도 함수도 하나만 책임진다.
클래스가 너무 많은 일을 책임진다면 일을 나눈다.

*단일 책임을 무시한다면 * 이런식으로 클래스를 분할한다.

개방 폐쇄 원칙(Open- losed)

확장에는 개방적이되, 수정에는 폐쇄적일 것
새로운 요소를 추가할 때마다 기존의 코드도 수정되는 상황을 피할 것

각각 도형이 추가될때마다 추가한 클래스에 기능을 추가(기존 클래스를 수정하는 방식X)

리스코프 치환 원칙(Liskov Substitution)

자식 클래스는 부모 클래스로 완전히 대체할 수 있다.
자식은 부모의 기능을 제거하지 않도록, 부모는 너무 많은 로직을 가지지 않도록
자식 클래스가 기능을 추가할땐 가능한한 인터페이스를 사용한다.

인터페이스 분리 원칙(Interface Scgregation)

객체는 자신이 호출하지 않는 메서드에 의존하지 않아야한다는 원칙
특정 클래스가 사용하지도 않을 약속에 얽매여서는 안된다.
하나의 인터페이스에 너무 많은 약속이 있으면 곤란

규모가 너무 큰 객체를 상속했을 때 방생하는 문제와 이를 인터페이스로 분리하여 해결하는 방법이다.

의존 역전 원칙(Dependency Inversion)

클래스 간 종속성을 최소화한다.
상위 모듈이 하위 모듈의 정보나 기능에 의존하면 안된다.
구제촤된 클래스에 의존하기보다는 추상 클래스나 인터페이스에 의존해야 한다는 의미.

C# 백준 1120 문자열 (나는 이제 실버다 ㅋㅋ)

Thu, 24 Oct 2024 07:38:58 GMT

❓문제

길이가 N으로 같은 문자열 X와 Y가 있을 때, 두 문자열 X와 Y의 차이는 X[i] ≠ Y[i]인 i의 개수이다. 예를 들어, X=”jimin”, Y=”minji”이면, 둘의 차이는 4이다.

두 문자열 A와 B가 주어진다. 이때, A의 길이는 B의 길이보다 작거나 같다. 이제 A의 길이가 B의 길이와 같아질 때 까지 다음과 같은 연산을 할 수 있다.

A의 앞에 아무 알파벳이나 추가한다. A의 뒤에 아무 알파벳이나 추가한다. 이때, A와 B의 길이가 같으면서, A와 B의 차이를 최소로 하는 프로그램을 작성하시오.

✏️입력

첫째 줄에 A와 B가 주어진다. A와 B의 길이는 최대 50이고, A의 길이는 B의 길이보다 작거나 같고, 알파벳 소문자로만 이루어져 있다.

⌨️출력

A와 B의 길이가 같으면서, A와 B의 차이를 최소가 되도록 했을 때, 그 차이를 출력하시오.

예제 입력1

adaabc aababbc

예제 출력1

예제 입력2

hello xello

예제 출력2

💻코드

using System;

namespace Baekjoon
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();
            string A = input[0];
            string B = input[1];
            int min = 50;

            for (int i = 0; i <= B.Length - A.Length ; i++)
            {
                int count = 0;
                for (int j= 0; j < A.Length ; j++)
                {
                    if (A[j] != B[i+j])
                    {
                        count++;
                    }
                }
                min = Math.Min(min, count);
            }
            Console.WriteLine(min);
        }
    }
}

✍️풀이

input에 띄어쓰기로 입력을 두 개 받고, input[0]은 문자열 A, input[0]은 문자열 B로 선언해준다. 여기서 *A 길이 <= B길이 * 이므로 B-A만큼 반복문을 돌려준다. A와 B의 차이를 최소화할 것이기 때문에 아래처럼 B문자열을 순회함. 이때 차이가 빈 곳을 제외하고 2개 차이가 나므로 2가 된다.

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 9일차

Mon, 14 Oct 2024 08:03:01 GMT

애니메이션

달리다가 바로 멈췄으면 좋겠다 → Has Exit Time 없애기

Nav Mesh Agent 컴포넌트의 Angular Speed : 초당 돌아볼 수 있는 각도

애니메이션에 따른 코드 추가

using UnityEngine;
using UnityEngine.AI;

public class Enemy : MonoBehaviour
{
    enum State
    {
        idle,
        Follow,
        Attack
    }

    GameObject player;
    NavMeshAgent agent;
    Animator animator;

    State state;
    float currentStateTime;

    public float timeForNextState = 2;

    void Start()
    {
        animator = GetComponent();
        player = GameObject.FindWithTag("Player");
        agent = GetComponent();

        state = State.idle;

        currentStateTime = timeForNextState;
    }

    void Update()
    {
        switch (state)
        {
            case State.idle:
                currentStateTime -= Time.deltaTime;
                if(currentStateTime < 0)
                {
                    float distance = (player.transform.position - transform.position).magnitude;
                    if(distance < 1.5f)
                    {
                        StartAttack();
                    }
                    else
                    {
                        StartFollow();
                    }
                }
                break;
            case State.Follow: 
                if(agent.remainingDistance < 1.5f || !agent.hasPath)
                //agent.hasPath : 갈 수 있는 길
                {
                    StartIdle();
                }
                break;
            case State.Attack:
                currentStateTime -= Time.deltaTime;
                if(currentStateTime < 0)
                {
                    StartIdle();
                }
                break;
        }
    }
    void StartIdle()
    {
        state = State.idle;
        currentStateTime = timeForNextState;
        agent.isStopped = true;
        animator.SetTrigger("Idle");
    }

    void StartFollow()
    {
        state = State.Follow;
        agent.destination = player.transform.position;
        agent.isStopped = false;
        animator.SetTrigger("Run");
    }

    void StartAttack()
    {
        state = State.Attack;
        currentStateTime = timeForNextState;
        animator.SetTrigger("Attack");

    }    
    public void OnDie()
    {
        Debug.Log("주금");
    }
}

인터페이스

using UnityEngine;
using UnityEngine.AI;

public class Enemy : MonoBehaviour, Health.IHealthListener
//Enemy 클래스는 Health.IHealthListener인터페이스를 구현해야한다.
//C#은 상속을 1개밖에 받지 못해 그 단점을 인터페이스로 보완
{

public class Health : MonoBehaviour
{
    public float hp = 10;
    public float maxHp = 10;
    public IHealthListener healthListener;

    void Start()
    {
        healthListener = GetComponent();
    }
    public void Damage(float damage)
    {
        if(hp>0)
        {
            hp -= damage;
            if(hp <= 0 )
            {
                //죽음
                Debug.Log("Dead");
               if(healthListener !=null)
                {
                    healthListener.OnDie();
                }
            }
            else
            {
                //다침
                Debug.Log("다침");
            }
        }
    }

    public interface IHealthListener
    {
        void OnDie();
    }
}

interface : 여러 클래스가 공통된 기능을 제공하면서도 서로 다른 방식으로 그 기능을 구현할 수 있도록 하기 위해서

// 1. 인터페이스 정의
public interface IAnimal
{
    void Speak();  // 동물들이 소리를 낼 수 있는 능력을 정의
}

// 2. Dog 클래스에서 IAnimal 인터페이스 구현
public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("멍멍");
    }
}

// 3. Cat 클래스에서 IAnimal 인터페이스 구현
public class Cat : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("야옹");
    }
}

// 4. 인터페이스를 사용하는 코드
public class Program
{
    public static void Main()
    {
        IAnimal dog = new Dog();
        IAnimal cat = new Cat();

        dog.Speak();  // 출력: 멍멍
        cat.Speak();  // 출력: 야옹
    }
}

죽고나서 없어지기

    public void OnDie()
    {
        state = State.Die;
        agent.isStopped = true;
        animator.SetTrigger("Die");
        Invoke("DestroyThis", 2);
    }
    void DestroyThis()
    {
        Destroy(gameObject);
    }

펀치 콜라이더 설정

손 쪽에 콜라이더를 넣어준 후, 펀치 애니메이션이 나갈때쯤 콜라이더를 켜주고, 끝날때 쯤 콜라이더를 꺼준다.

무적시간

using UnityEngine;

public class Health : MonoBehaviour
{
    public float hp = 10;
    public float maxHp = 10;
    public float invincibleTime; //무적시간

    public IHealthListener healthListener;
    float lastDamageTime;

    void Start()
    {
        healthListener = GetComponent();
    }
    public void Damage(float damage)
    {
        //마지막으로 얻어 맞은 시간 + 무적 시간이 현재 시간보다 적으면
        if(hp>0 && lastDamageTime+invincibleTime < Time.time)
        {
            hp -= damage;
            lastDamageTime = Time.time;

            if (hp <= 0 )
            {
                //죽음
                Debug.Log("Dead");
               if(healthListener !=null)
                {
                    healthListener.OnDie();
                }
            }
            else
            {
                //다침
                Debug.Log("다침");
            }
        }
    }

    public interface IHealthListener
    {
        void OnDie();
    }
    void Update()
    {

    }
}

Hp 구현

filed → Horizontal

맞으면 피가 줄어들게

public class Health : MonoBehaviour
{

    public void Damage(float damage)
    {
        //마지막으로 얻어 맞은 시간 + 무적 시간이 현재 시간보다 적으면
        if (hp > 0 && lastDamageTime + invincibleTime < Time.time)
        {
            hp -= damage;

            if (hpGauge != null)
            {
                hpGauge.fillAmount = hp / maxHp;
            }
            //마지막으로 피해를 입은 시간을 기록
            lastDamageTime = Time.time;

            if (hp <= 0)
            {
                //죽음
                Debug.Log("Dead");
                if (healthListener != null)
                {
                    healthListener.OnDie();
                }
            }
            else
            {
                //다침
                Debug.Log("다침");
            }
        }
    }
}

HP 게이지의 Amount값에 따라 색 바뀌도록

using UnityEngine;
using UnityEngine.UI;

public class GaugeColor : MonoBehaviour
{
    void Update()
    {
        Image image = GetComponent();

        image.color = Color.HSVToRGB(image.fillAmount / 3, 1.0f, 1.0f);
    }
}

무서워 아저씨. ..

Render Mode

Screen Space - Camera 일때

거리를 설정하면 거리에 따라 캔버스가 뒤로 가보이게 됨 World Space 일때

Enemy HP 구현

Enemy아래 캔버스를 달아주고, Hp를 똑같이 해준다.

여기서 Canvas는 world space로 해줌

using UnityEngine;
using UnityEngine.UI;

public class Health : MonoBehaviour
{
    public float hp = 10;
    public float maxHp = 10;
    public float invincibleTime; //무적시간

    public Image hpGauge;

    public IHealthListener healthListener;
    float lastDamageTime;

    void Start()
    {
        healthListener = GetComponent();
    }
    public void Damage(float damage)
    {
        //마지막으로 얻어 맞은 시간 + 무적 시간이 현재 시간보다 적으면
        if (hp > 0 && lastDamageTime + invincibleTime < Time.time)
        {
            hp -= damage;

            if (hpGauge != null)
            {
                hpGauge.fillAmount = hp / maxHp;
            }

            //마지막으로 피해를 입은 시간을 기록
            lastDamageTime = Time.time;

            if (hp <= 0)
            {
                //죽음
                Debug.Log("Dead");
                if (healthListener != null)
                {
                    healthListener.OnDie();
                }
            }
            else
            {
                //다침
                Debug.Log("다침");
            }
        }
    }

    public interface IHealthListener
    {
        void OnDie();
    }
    void Update()
    {

    }
}

저 게이지가 나를 보도록

using UnityEngine;

public class LookCamera : MonoBehaviour
{
    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {
        transform.LookAt(transform.position + Camera.main.transform.forward);
        //HP 게이지가 나를 보도록
    }
}

위 코드 사용X(게이지를 보세용)

사용

Player 죽음

플레이어가 쓰러지면서 화면이 어두워지도록 만들어줌

이렇게하면 Player가 안 움직이는데 Apply Root Motion을 켜주면 움직인다.

Apply Root Motion : 오브젝트의 위치와 회전을 애니메이션이 제어하도록 할 것이냐를 결정

죽었을때 조작 불가능하도록

public class PlayerController : MonoBehaviour, Health.IHealthListener
{
......
    void Update()
    {
        if (GameManager.Instance.isPlaying)
        {
            Vector3 moveVector = moveAction.ReadValue(); //move 입력 감지
            Vector3 move = new Vector3(moveVector.x, 0, moveVector.y);
........

    public void OnDie()
    {
        GetComponent().SetTrigger("Die");
        GameManager.Instance.PlayerDie();
    }
}

Sort Order가 2여야함

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 8일차

Mon, 14 Oct 2024 07:23:57 GMT

조퇴로 인한 지금 업로드 ,, 크흠 ^_^

코루틴으로 총알 흔적 없애기

void RayCastFire()
{
    ...

    GameObject go = Instantiate(trailPrefab);
    Vector3[] pos = new Vector3[] { firingPosition.position, hitPosition };
    go.GetComponent().SetPositions(pos);

    //방법 1 Invoke()
    //방법 2
    StartCoroutine(DestroyTrail(go));        
    //방법 3
    Destroy(go, 0.1f);
}
IEnumerator DestroyTrail(GameObject obj)
    {
    yield return new WaitForSeconds(0.5f);        
    Destroy(obj);
   }
}

사용 이유

비동기 작업을 처리하면서도 게임 루프의 제어를 유지할 수 있기 때문에 사용한다.

사용 방법

IEnumerator 메소드이름() { yield return new WaitForSeconds(초); } StartCoroutine(메소드이름());

총알이 맞은 지점 나타내기

파티클이 끝난 후 어떤걸 불러올지 정할 수 있음(None, Disable, Destroy, Callback(함수 불러오기))

총알이 맞은 방향 수직으로 파티클이 튀도록

    void RayCastFire()
    {
        Camera cam = Camera.main;

        RaycastHit hit;
        Ray r = cam.ViewportPointToRay(Vector3.one / 2); //카메라 정 중앙으로 발사

        Vector3 hitPosition = r.origin + r.direction * 200; //아무곳에도 부딪히지 않았다면 카메라 방향에서 200정도 떨어져있는 곳

        if (Physics.Raycast(r, out hit, 1000)) //어딘가에 빛이 부딪혔으면 true
        { //레이 r의 정보를 가지고 1000의 최대거리 만큼 레이를 쏜다. out : 변수를 넣었을때 변수가 변할 수 있다는 것(out을 안 쓰면 오류남)
            hitPosition = hit.point; //빛이 부딪힌 부분이 총알의 종착점

            //총알이 부딪힌 지점의 수직으로 파티클이 튀도록
            GameObject particle = Instantiate(particlePrefab);
            particle.transform.position = hitPosition;
            particle.transform.forward = hit.point;
        }

수류탄

총과 같은 위치에 수류탄 에셋을 가져와서 두기

상속

0,0,0에 수류탄을 하나 만들어서 콜라이더를 넣어줌

얘가 projectilePrefab이 될 예정

상속되어서 인스펙터창에 다 나옴

각각 알맞은 곳에 넣어준다

using UnityEngine;

public class ProjectileWeapon : Weapon
{
    public GameObject projectilePrefab;
    public float projectileAngle = 30;
    public float projectileForce = 10;
    public float projectileTime = 5;

    protected override void Fire()
    {
        ProjectileFire();
    }
    public void ProjectileFire()
    {
        //30도 올린 각도 만들기
        Camera cam =Camera.main;

        Vector3 forward = cam.transform.forward; //카메라가 주시하는 방향 벡터
        Vector3 up = cam.transform.up; //y축 벡터

        Vector3 direction = forward + up * Mathf.Tan(projectileAngle * Mathf.Deg2Rad);
        //주시방향+(y축 * 라디안으로 치환한 발사각의 탄젠트값)

        direction.Normalize(); //벡터값 정규화
        direction *= projectileForce; //발사 방향에 발사 힘 곱해서

        GameObject go = Instantiate(projectilePrefab); //수류탄 인스턴스 생성
        go.transform.position = firingPosition.position; //생성한 수류탄 초기 위치 지정
        go.GetComponent().AddForce(direction, ForceMode.Impulse); //생성한 수류탄을 지정한 벡터로 투척
    }
}

public class Weapon : MonoBehaviour
{
    public void FireWeapon()
    {
        if (animator != null)
        {
            if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
            {
                animator.SetTrigger("Fire");
                Fire();
            }
        }
        else
        {
            Fire();
        }

    }

    protected virtual void Fire()
    {
        RayCastFire();
    }

폭발

폭발하는 애니메이션 생성

using UnityEngine;

public class Bomb : MonoBehaviour
{
    public float time;

    private void Update()
    {
        time -= Time.deltaTime;
        if (time < 0)
        {
            GetComponent().SetTrigger("Explode");
            Destroy(gameObject, 2f);
        }
    }
}

using UnityEngine;

public class Bomb : MonoBehaviour
{
    public float time;

    private void Update()
    {
        time -= Time.deltaTime;
        if (time < 0)
        {
            GetComponent().SetTrigger("Explode");
            Destroy(gameObject, 2f);
        }
    }
}

수류탄 프리팹에 추가

public class ProjectileWeapon : Weapon
{
    public float projectileTime = 5;

    public void ProjectileFire()
    {  
        go.GetComponent().time = projectileTime;
    }
}

무기 변경

인풋 추가

Listen누르고 원하는 버튼 누르면 쉽게 가능

PlayerController 스크립트 수정

public List weapons;
int currentWeaponIndex;

    void OnChangeWeapon()
    {
        weapons[currentWeaponIndex].gameObject.SetActive(false);

        currentWeaponIndex++;
        if(currentWeaponIndex > weapons.Count-1)
        {
            currentWeaponIndex = 0;
        }
        weapons[currentWeaponIndex].gameObject.SetActive(true);
    }

public class Weapon : MonoBehaviour
{
    public GameObject trailPrefab;
    public Transform firingPosition;
    public GameObject particlePrefab;
    public TextMeshProUGUI bulletText;

    public int currentBullet = 8;
    public int totalBullet = 32;
    public int maxBulletMagazine = 8;

    Animator animator;
    void Start()
    {
        animator = GetComponent();
    }

    void Update()
    {
        bulletText.text = currentBullet + "/" + totalBullet;
    }
    public void FireWeapon()
    {
        if (currentBullet > 0) //현재 잔탄이 남아있을때
        {
            if (animator != null)
            {
                if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
                {
                    animator.SetTrigger("Fire");
                    currentBullet--;
                    Fire();
                }
            }
            else
            {
                currentBullet--;
                Fire();
            }
        }

    }

    protected virtual void Fire()
    {
        RayCastFire();
    }

    public void ReloadWeapon()
    {
        if (totalBullet > 0) //탄약이 있으면
        {
            if (animator != null)
            {
                if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
                {
                    animator.SetTrigger("Reload");
                    Reload();
                }
            }
            else
            {
                Reload();
            }

        }
    }
    void Reload()
    {
        if (totalBullet >= maxBulletMagazine - currentBullet)
            //탄약수가 (탄창 탄약 - 잔탄)보다 같거나 많으면
        {
            //꽉 채우기
            totalBullet -= maxBulletMagazine - currentBullet;
            currentBullet = maxBulletMagazine;
            //잔탄을 탄창 탄약으로 설정
        }
        else
            //탄약수가 (탄창 탄약 - 잔탄)보다 적으면
        {
            //남은 탄창 + 채울거
            currentBullet += totalBullet;
            totalBullet = 0; //탄약을 비움
        }
    }

적 Ai 만들기

적으로 지정해줘서 콜라이더 넣어주기

Nav Mesh Surface 추가후 Bake Enemy에 Nav Mesh Agent를 추가

using UnityEngine;
using UnityEngine.AI;

public class Enemy : MonoBehaviour
{
    GameObject player;
    NavMeshAgent agent;

    void Start()
    {
        player = GameObject.FindWithTag("Player");
        agent = GetComponent(); 
    }

    void Update()
    {
        agent.destination = player.transform.position;
    }
}

내가 가있던 자리로 쫓기

using UnityEngine;
using UnityEngine.AI;

public class Enemy : MonoBehaviour
{
    GameObject player;
    NavMeshAgent agent;

    void Start()
    {
        player = GameObject.FindWithTag("Player");
        agent = GetComponent(); 
    }

    void Update()
    {
        //destination까지 남은 거리(흔적쫓기)
        if (agent.remainingDistance<1f)
        {
            agent.destination = player.transform.position;
        }
    }
}

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 7일차

Thu, 10 Oct 2024 08:51:22 GMT

Slope Limit : 올라갈수 있는 경사로의 한계

Step Offset : 올라갈 수 있는 계단의 단차 등을 설정할 수 있다

중력

public class PlayerController : MonoBehaviour
{
    public float WalkSpeed = 7;
    public float mouseSens = 1;
    public Transform cameraTransform; 

    public float gravity = 10;
    public float terminalSpeed = 20; //떨어지는 물체가 최대 속도를 유지하게

    float horizontalAngle;
    float verticalAngle;
    float verticalSpeed; //낙하 속력

    InputAction moveAction;
    InputAction lookAction;

    CharacterController characterController;

    ...생략
    void Update(){
        //중력
        verticalSpeed -=  gravity * Time.deltaTime; 
        //gravity값에 타임을 곱해 verticalSpeed를 뺴주면 점점 더 빠르게 아래로 떨어짐

        if(verticalSpeed < -terminalSpeed) 
        //verticalSpeed가 최대 낙하속도(terminalSpeed)를 넘어가면 **-**최대 낙하속도로 고정
        {
            verticalSpeed = -terminalSpeed;
        }
        Vector3 verticalMove = new Vector3(0, verticalSpeed, 0); //떨어지는 Vector 생성 
        verticalMove *= Time.deltaTime; //Vector에 deltaTime 적용

        CollisionFlags flag = characterController.Move(verticalMove); //캐릭터에게 중력속도 적용

        if ((flag & (CollisionFlags.Below | CollisionFlags.Above)) !=0) 
        //flag중에 Bellow 비트가 없으면 / 떨어지는 상태가 아니면(바닥에 땅을 디딛고 있냐)
        {
            verticalSpeed = 0; //하강속도를 0으로 초기화
        }
     }

땅에 붙어있는지 0.5초 뒤에 인지하도록

public class PlayerController : MonoBehaviour
{
    public float WalkSpeed = 7;
    public float mouseSens = 1;
    public Transform cameraTransform;

    public float gravity = 10;
    public float terminalSpeed = 20; //떨어지는 물체가 최대 속도를 유지하게

    float horizontalAngle;
    float verticalAngle;
    float verticalSpeed; //낙하 속력
    bool isGrounded;
    float groundedTimer;

    InputAction moveAction;
    InputAction lookAction;

    CharacterController characterController;

    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked; //게임화면 내 커서 잠금       
        Cursor.visible = false; //커서 숨기기

        InputActionAsset inputActions = GetComponent().actions;
        moveAction = inputActions.FindAction("Move"); //Move에 해당하는 입력값 가져오기
        lookAction = inputActions.FindAction("Look");

        characterController = GetComponent();

        horizontalAngle = transform.localEulerAngles.y; //바라보는 각도에 얼마나 돌아야하는지 세팅
        verticalAngle = 0;
        verticalSpeed = 0;
        isGrounded = true;
        groundedTimer = 0;
    }

   void Update()
   {  
        Vector3 verticalMove = new Vector3(0, verticalSpeed, 0); //떨어지는 Vector 생성 
        verticalMove *= Time.deltaTime; //Vector에 deltaTime 적용

        CollisionFlags flag = characterController.Move(verticalMove); //캐릭터에게 중력속도 적용

        if ((flag & CollisionFlags.Below) !=0)
         //flag중에 Bellow 비트가 없으면 / 떨어지는 상태가 아니면(바닥에 땅을 디딛고 있냐)
        {
            verticalSpeed = 0; //하강속도를 0으로 초기화
        }
        if(!characterController.isGrounded) //characterController가 땅에 안 붙어있다고함
        { 
            if(isGrounded) //안 붙어있다면
            {
                groundedTimer += Time.deltaTime; //timer를 움직이게하고
                if(groundedTimer > 0.3f) //0.5초뒤에
                {
                    isGrounded = false; //false로
                }
            }
        }
        else //땅에 붙어있다면
        { 
            isGrounded = true; //true
            groundedTimer = 0;
        }
   }

점프

뉴인풋시스템에 있는 Jump를 사용하기 위해 OnJump()함수 사용

void OnJump()
{
    if(isGrounded)
    {
        verticalSpeed = jumpSpeed;
        isGrounded = false; //무한점프 방지
    }
}

총만들기

총 에셋 가져오기

애니메이션 생성

재장전 애니메이션은 Mag와 Mag_Full을 사용

애니메이션 연결

저 이름으로 할거면 스크립트도 저 이름으로 해야댐

발사할땐 Has Exit TIme없이(바로 애니메이션이 실행될 수 있도록)

Trigger 설정

Idle로 돌아올땐(애니메이션이 다 끝나고) Has Exit TIme 체크

인풋 이름 바꿔서

InputAction fireAction;

    void Start()
    {

        fireAction = inputActions.FindAction("Fire");
    }
    void Updat()
    {

        if (fireAction.WasPressedThisFrame())
        {

            weapon.FireWeapon();
        }
    }

이렇게 갖다 쓸 수 있다.

public class Weapon : MonoBehaviour
{
    }
    public void FireWeapon()
    {
        Debug.Log("Fire");
    }
    public void ReloadWeapon()
    {

    }
}

Player Input 컴포넌트를 보면 아래 저 함수들을 사용할 수 있다고 보여줌

public class PlayerController : MonoBehaviour
{
   void Update()
        {
        if (fireAction.WasPressedThisFrame())
        {
            weapon.FireWeapon();
        }
        if (reloadAction.WasPressedThisFrame()) //이번 프레임에 눌렸는가
        {
            weapon.ReloadWeapon();
        }
    } 
 }

public class Weapon : MonoBehaviour
{
    Animator animator;
    void Start()
    {
        animator = GetComponent();
    }
    public void FireWeapon()
    {
        if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
        {
            animator.SetTrigger("Fire");
        }
    }
    public void ReloadWeapon()
    {
        if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
        {
            animator.SetTrigger("Reload");
        }
    }
}

인풋시스템 수동 추가

없는건 이렇게 만들 수 있음

조준선

이렇게 추가 된 모습

총구 위치 추가

빈 오브젝트를 총구 앞으로 설정

Effect - Line 추가

TrailPrefab으로 이름을 바꿔주고 프리팹으로 만들어줌

0,0,0으로 설정

using UnityEngine;

public class Weapon : MonoBehaviour
{
    public GameObject trailPrefab;
    public Transform firingPosition;

    Animator animator;
    void Start()
    {
        animator = GetComponent();
    }

    void Update()
    {

    }
    public void FireWeapon()
    {
        if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
        {
            animator.SetTrigger("Fire");
            RayCastFire();
        }
    }
    public void ReloadWeapon()
    {
        if (animator.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
        {
            animator.SetTrigger("Reload");
        }
    }

    void RayCastFire()
    {
        Camera cam = Camera.main;

        RaycastHit hit;
        Ray r = cam.ViewportPointToRay(Vector3.one / 2); //카메라 정 중앙으로 발사

        Vector3 hitPosition = r.origin + r.direction * 200; //아무곳에도 부딪히지 않았다면 카메라 방향에서 200정도 떨어져있는 곳

        if(Physics.Raycast(r, out hit, 1000)) //어딘가에 빛이 부딪혔으면 true
        { //레이 r의 정보를 가지고 1000의 최대거리 만큼 레이를 쏜다. out : 변수를 넣었을때 변수가 변할 수 있다는 것(out을 안 쓰면 오류남)
            hitPosition = hit.point; //빛이 부딪힌 부분이 총알의 종착점
        }

        GameObject go = Instantiate(trailPrefab);
        Vector3[] pos = new Vector3[] { firingPosition.position, hitPosition };
        go.GetComponent().SetPositions(pos);
    }
}

Physics.Raycast(Vector3 origin, Vector3 direction, out RaycastHit hitInfo, float maxDistance) : 시작점(Origin)과 방향(Direction)으로 최대거리(maxDistance)만큼 레이를 쏘는 함수입니다. 최대거리 안에서 충돌이 되면 true를 반환하고 RaycastHit로 충돌정보를 넘겨줍니다.

Physics.Raycast(r, out hit, 1000) : 레이 r의 정보를 가지고 1000의 최대거리 만큼 레이를 쏜다. out : 변수를 넣었을때 변수가 변할 수 있다는 것(out을 안 쓰면 오류남)

쏘면 이렇게 됨

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 6일차 - 3D 프로젝트 시작

Tue, 08 Oct 2024 08:25:38 GMT

사용 에셋

Survival city lowpoly pack

PSX Misc. Gun Pack

3D 오브젝트가 마젠타 색으로 변했을때 전부다 체크하고 컨벌트

Window - Rendering - Render Pipeline Convert로 들어가서 싹다 선택후 and Convert버튼 누르기

Player 자식에 카메라를두고 Character Controller 컴포넌트 부착(1인칭 효과)

Player에 아래 컴포넌트들 부착

옛날 입력 시스템+최근거 다 쓸 수 있음(Both)

[최근거]

마우스 커서 조절

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked;        
        Cursor.visible = false; //그냥 추가
    }
}

이렇게하면 마우스 커서가 안 보이게 된다

플레이어 input

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
    public float WalkSpeed = 7;
    InputAction moveAction;

    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked;        
        Cursor.visible = false;

        InputActionAsset inputActions = GetComponent().actions;

        moveAction = inputActions.FindAction("Move");

    }
 }

뉴 인풋 시스템 사용

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
    public float WalkSpeed = 7; //움직이는 속도
    public float mouseSens = 1; //마우스 민감도
    public Transform cameraTransform; //카메라가 바라보고 있는 방향

    float horizontalAngle; //가로 각도(마우스 움직일때 돌아가는거)
    float verticalAngle;  //세로 각도

    InputAction moveAction; //움직일때 input
    InputAction lookAction; //마우스 움직일때 보이는거

    CharacterController characterController; //계속 인스턴스로 갖고오기 귀찮아서

    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked; //게임화면 내 커서 잠금       
        Cursor.visible = false; //커서 숨기기

        InputActionAsset inputActions = GetComponent().actions; 
        //인풋시스템에서 할당
        moveAction = inputActions.FindAction("Move"); //Move에 해당하는 입력값 가져오기
        lookAction = inputActions.FindAction("Look"); //Look "

        characterController = GetComponent();

        horizontalAngle = transform.localEulerAngles.y; //바라보는 각도에 얼마나 돌아야하는지 세팅
        verticalAngle = 0; //초기값 설정(상하 각도)

    }

    void Update()
    {
        Vector3 moveVector = moveAction.ReadValue(); //move 입력 감지
        Vector3 move = new Vector3(moveVector.x, 0, moveVector.y);

        //이동벡터가 1보다 크다면 1로
        if(move.magnitude >1) //Vector크기 감지(대각선 그거 어쩌구)
        {
            move.Normalize(); //아래 그림으로 설명함
        }
        move = move * WalkSpeed * Time.deltaTime;
        move = transform.TransformDirection(move); //현재 gameObjct의 방향으로 벡터를 돌린다.
        characterController.Move(move); //characterController컴포넌트에 접근해 움직여준다.

        Vector2 look = lookAction.ReadValue(); //look 액션 벡터를 가져오고

        float turnPlayer = look.x * mouseSens; //마우스 감도를 적용하고

        horizontalAngle += turnPlayer; //현재 각도에 더한다

        if (horizontalAngle >= 360) horizontalAngle -= 360; //변화된 각도를 넣는다.
        if (horizontalAngle <0) horizontalAngle += 360;

        Vector3 currentAngle = transform.localEulerAngles; //currentAngle 는 현재 y회전값
        currentAngle.y = horizontalAngle; 
        transform.localEulerAngles = currentAngle;

        //마우스 상하
        float turnCam = look.y * mouseSens;
        verticalAngle -= turnCam; //상하이동은 카메라에서 얻어온 verticalAngle에 더함
        verticalAngle = Mathf.Clamp(verticalAngle, -89f, 89f); //90도 이상 꺾이지 않도록 구간 지정
        currentAngle = cameraTransform.localEulerAngles; //카메라의 EulerAngles의 x값을 회전량을 적용한 verticalAngle로 바꿈
        currentAngle.x = verticalAngle;
        cameraTransform.localEulerAngles = currentAngle;
    }
}

eulerAngles : 오일러앵글이라고 하며 x,y,z축 중심으로 회전한다는 의미 eulerAngles .x 라고하면 x축 회전

localEulerAngles : 부모에 대한 상대좌표로 부모가 없다면 월드좌표 공간이 기준(부모의 상대적인 회전값을 Vector3으로 접근)

//이동벡터가 1보다 크다면 1로 :

아래 대각선을 1로 맞춰주는거

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 6일차

Tue, 08 Oct 2024 08:23:25 GMT

프리팹을 만들어서 중요 오브젝트를 한 번에 관리

Enemy와 Player를 프리팹으로 만든다.

Level Data라는 빈 오브젝트 하위에 다른 난이도의 맵을 만들때 사용할 프리팹으로 생성

프리팹으로 만들었기 때문에 프리팹을 지웠다 다시 올리면 Missing이 뜸 해결 방법! LevelLoader 스크립트에서 Missing이 뜨는 오브젝트를 다시 불러와준다

using UnityEngine;

public class LevelLoader : MonoBehaviour
{
    public PlayerController Player;
    public GameObject Cinemachine;
    private void Start()
    {
        GameManager.Instance.Player = Player; 
        GameManager.Instance.CinemaCamera = Cinemachine;
    }

}

Start가 아니라 Awake로 하려니까 GameManager에 Awake에서 Instance로 만들어주는게 우선순위가 더 높아서 오류가 뜸(인스턴스를 만들고 찾아야하는데 찾고 만들려니까 안 찾아짐)

다른 방법(Scripts Execution Order)

우선순위를 정해주는 설정창으로

[ Project Settings - Scripts Execution Order - +버튼에서 내 스크립트 할당 ]하면 어떤 스크립트가 먼저 실행될지 정할 수 있다.

유니티는 기본적으로 아래와 같은 순서로 실행된다

Enemy를 새로 만들때마다 Terrain만 계속 추가해주어야해서 스크립트에서 할당해주자.

using UnityEngine;

public class EnemyController : MonoBehaviour
{
    public int Hp = 3;
    public float Speed = 3;
    public CompositeCollider2D TerrainCollider;
    public Collider2D FrontCollider;
    public Collider2D FrontBottomCollider;

    Vector2 vx;

    private void Awake()
    {
        GameObject.FindGameObjectWithTag("Terrain").GetComponent();
    }

FindGameObjectWithTag 를 사용해서 태그로 찾아 할당해주기

레벨 선택창 만들기

LevelSelect 씬을 만들고 캔버스를 만들어준다

이런식으로 Panel - Scroll View 순서로 만들어주고, 아래처럼 설정

가로로 스크롤할거기 때문에 Vertical 체크 해제

Level Manager를 싱글톤으로 작성

싱글톤 : 무조건 한번만 만들어야함 이런식으로 instance가 있으면(null이 아니면) 삭제해야함

LevelManager위에 class를 만들어주고 list를 만들어줌

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

[Serializable]
public class LevelInfo
{
    public string LevelName;
    public Sprite LevelThum;
    public GameObject LevelPrefab;

}

public class LevelManager : MonoBehaviour
{
    public List levels;

    private static LevelManager instance;  
    public static LevelManager Instance
    {
         get { return instance; }
        private set
        {
            instance = value;
        }
    }

    private void Awake()
    {
        if (instance == null)
        {
            instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

Class를 Serializable로 해주어서 인스펙터창에 나타나게 된다.

Serializable : 구조체나 클래스에서만 사용하는 인스펙터에서 접근할 수 있도록 하는 키워드

맵 프리팹을 다르게 두개 만들어서 각각에 할당해주면 된다.

public List levels;에는 Name, Thum, Prefab 각각 할당해준 것들이 들어가게 된다.

가로로 정렬하는 Horizontal Layout Group 생성 content size fitter : 컨텐츠의 크기에 따라 자동으로 컨텐트의 길이가 달라지도록(크기가 작으면 스크롤이 그 크기밖에 안됨)

LevelPanel 스크립트 생성

using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class LevelPanel : MonoBehaviour
{
    int StageIndex;
    public Image StageThum;
    public TextMeshProUGUI TextTitle;

    public void SetLevelInfomation(int stageIndex, Sprite thumnail, string title)
    {
        StageThum.sprite = thumnail;
        this.StageIndex = stageIndex;
        TextTitle.text = title;
    }

}

위에 LevelTitle + 사진 + 버튼 이 들어가있는 패널을 컨트롤하는 스크립트

패널들의 내용들을 넣어주는 스크립트

using UnityEngine;

public class LevelSelectManager : MonoBehaviour
{
    public GameObject LevelPanelPrefab;
    public GameObject ScrollViewContent;

    private void Start()
    {
        for(int i = 0;i().SetLevelInfomation(i, Info.LevelThum, Info.LevelName);
        }
    }
}

LevelSelectManager 설명

    for(int i = 0;i


▲ Name, Thum, Prefab 각각 할당해준 것들(몇개 지정해주었는지)의 수까지 반복문을 돌린다.
        LevelInfo Info = LevelManager.Instance.levels[i];
▲ class에 넣어준다.
         GameObject go = Instantiate(LevelPanelPrefab, ScrollViewContent.transform);
▲ LevelPanelPrefab을 ScrollViewContent 자식에 clone해준다.
         go.GetComponent().SetLevelInfomation(i, Info.LevelThum, Info.LevelName);
▲ LevelPanel스크립트의 SetLevelInfomation함수로 인자 전달 (LevelThum(이미지)와 Name)
LevelPanel.cs
public void SetLevelInfomation(int stageIndex, Sprite thumnail, string title)
{
    StageThum.sprite = thumnail;
    this.StageIndex = stageIndex;
    TextTitle.text = title;
}
각각 전달받은 인자들 대입
난이도에 따른 플레이 버튼 설정
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

[Serializable]
public class LevelInfo
{
    public string LevelName;
    public Sprite LevelThum;
    public GameObject LevelPrefab;
}

public class LevelManager : MonoBehaviour
{
    public List levels;

    private static LevelManager instance;
    public GameObject SelectedPrefab;
    public static LevelManager Instance
    {
         get { return instance; }
        private set
        {
            instance = value;
        }
    }
...생략

    public void StartLevel(int index)
    {
        SelectedPrefab = levels[index].LevelPrefab;
        SceneManager.LoadScene("GameScene");
    }

}

GameManager.cs
    void Start()
    {
        Instantiate(LevelManager.Instance.SelectedPrefab);
        life = 3;
        **LifeDisplayerInstance.SetLives(life);**
    }

using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class LevelPanel : MonoBehaviour
{
    int StageIndex;
    public Image StageThum;
    public TextMeshProUGUI TextTitle;

    public void SetLevelInfomation(int stageIndex, Sprite thumnail, string title)
    {
        StageThum.sprite = thumnail;
        this.StageIndex = stageIndex;
        TextTitle.text = title;
    }

    public void StageStart()
    {
        LevelManager.Instance.StartLevel(StageIndex);
    }
}

StageStart를 Level Prefab의 버튼에 할당!
  
그럼 이제 버튼을 누르면 다른 난이도의 맵들을 볼 수 있답니다~
빌드 세팅(아이콘, 이름, 회사이름, 등등)

게임 시작하자마자 나오는 화면


끝~



[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 5일차
Mon, 07 Oct 2024 08:47:57 GMT

[SerializeField] : private으로 선언했지만 인스펙터에서 접근할 수 있도록 함



    scoreLebel.text = GameManager.Instance.TimeLimit.ToString("#.##");
▲ 소수점 아래 자리 제한 (#.##은 두번째자리까지 표시하겠다는 의미)
    private void OnEnable()
    {
        Time.timeScale = 0f;
        if (GameManager.Instance.IsCleared)
        {
            resultTitle.text = "Clear!";
            scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
            SaveHighScore();
        }
        else
        {
            resultTitle.text = "Game Over";
            scoreLabel.text = "";
        }
        scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
    }

    public void TryAgainButton()
    {
        SceneManager.LoadScene("GameScene");
        Time.timeScale = 1f;
    }
OnEnable 함수는 오브젝트가 켜질때 호출됨

timeScale : 모든 것을 다 멈추게한다(애니메이션, 플레이어 등) deltatIme에도 영향을 받는다

게임 클리어
using TMPro;
using Unity.Cinemachine;
using UnityEngine;

public class GameManager : MonoBehaviour
{
..생략
    private bool isCleared;
    public bool IsCleared
    {
        get { return isCleared; }
    }

    void GameOver()
    {
        isCleared = false;
        popUpCanvas.SetActive(true);
    }
    public void GameClear()
    {
        isCleared = true;
        popUpCanvas.SetActive(true);
    }
}
GameClear 함수로 popup을 띄워주고 isCleared의 bool값에 따라 text를 다르게 출력해준다.
public class PopUpCanvas : MonoBehaviour
{
    [SerializeField]
    private TMP_Text resultTitle;
    [SerializeField]
    private TMP_Text scoreLabel;
    [SerializeField]
    GameObject highScoreObject;

    private void OnEnable()
    {
        Time.timeScale = 0f;
        if (GameManager.Instance.IsCleared)
        {
            resultTitle.text = "Clear!";
            scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
            SaveHighScore();
        }
        else
        {
            resultTitle.text = "Game Over";
            scoreLabel.text = "";
        }
        scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
    }

  }
클리어했을 경우

게임 오버시

최고기록
public class ResultCanvas : MonoBehaviour
{
 void SaveHighScore()
    {
        float highScore = PlayerPrefs.GetFloat("highscore", 0);

        if(GameManager.Instance.TimeLimit > highScore)
        {
            highScoreObject.SetActive(true);
            PlayerPrefs.SetFloat("highscore", GameManager.Instance.TimeLimit);
            PlayerPrefs.Save();
        }
    }
 }
highScoreObject가 활성화되면서 가장 높은 점수일때 표시된다

    string cureentScoreString = score.ToString("#.##");
    string savedScoreString = PlayerPrefs.GetString("HighScores", "");

    if (savedScoreString == "")
    {
        PlayerPrefs.SetString("HighScores", cureentScoreString);
    }
    else
    {
        string[] scoreArray = savedScoreString.Split(',');
    }

배열을 만들어서 , 로 분류한다.
점수 저장법
public class ResultCanvas : MonoBehaviour
{
    [SerializeField]
    private TMP_Text resultTitle;
    [SerializeField]
    private TMP_Text scoreLabel;
    [SerializeField]
    GameObject highScoreObject;
    [SerializeField]
    GameObject highScoreCanvas;

    private void OnEnable()
    {
        Time.timeScale = 0f;
        if (GameManager.Instance.IsCleared)
        {
            resultTitle.text = "Clear!";
            scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
            SaveHighScore();
        }
        else
        {
            resultTitle.text = "Game Over";
            scoreLabel.text = "";
        }
        scoreLabel.text = GameManager.Instance.TimeLimit.ToString("#.##");
    }

    void SaveHighScore()
    {
        float score = GameManager.Instance.TimeLimit;
        float highScore = PlayerPrefs.GetFloat("highscore", 0);

        if (GameManager.Instance.TimeLimit > highScore)
        {
            highScoreObject.SetActive(true);
            PlayerPrefs.SetFloat("highscore", score);
            PlayerPrefs.Save();
        }
        else
        {
            highScoreObject.SetActive(false);
        }

        string cureentScoreString = score.ToString("#.##");
        string savedScoreString = PlayerPrefs.GetString("HighScores", "");

        if (savedScoreString == "")
        {
            PlayerPrefs.SetString("HighScores", cureentScoreString);
        }
        else
        {
            string[] scoreArray = savedScoreString.Split(',');  
            List scoreList = new List(scoreArray);
            for(int i = 0; i< scoreList.Count; i++) //적절한 위치에 새 스코어 넣기
            { 
                float savedScore = float.Parse(scoreList[i]); 
                if(savedScore < score) // 나보다 낮은 점수가 들어온다면
                {
                    scoreList.Insert(i, cureentScoreString); // 뒤로 밀어버린다
                    break;
                }
            }
            if (scoreArray.Length == scoreList.Count) // 적절한 위치를 못 찾았다면 넌 꼴찌
            {
                scoreList.Add(cureentScoreString);
            }
            if(scoreList.Count>10) // 10개 넘으면 맨 끝 빼기
            {
                scoreList.RemoveAt(10);
            }

            string result = string.Join(",", scoreList); // 리스트를 하나의 스트링으로 합치기
            Debug.Log(result);
            PlayerPrefs.SetString("HighScores", result);

        }

    }
    public void TryAgainButton()
    {
        SceneManager.LoadScene("GameScene");
        Time.timeScale = 1f;
    }

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

    public void OnHighScoreCanvas()
    {
        highScoreCanvas.SetActive(true);
    }
}


score : 현재 남은 시간
highScore : 저장된 highscore (저장된게 없으면 0)
    void SaveHighScore()
    {
        float score = GameManager.Instance.TimeLimit;
        float highScore = PlayerPrefs.GetFloat("highscore", 0);

현재 TimeLimit (남은시간)이 저장된 highScore보다 크면 
=(최고기록을 세우면)
highscore을 다시 저장함
 if (GameManager.Instance.TimeLimit > highScore)
        {
            highScoreObject.SetActive(true);
            PlayerPrefs.SetFloat("highscore", score);
            PlayerPrefs.Save();
        }
cureentScoreString  : 현재 점수 
savedScoreString  : 저장된 점수(처음에는 빈 스트링)
        string cureentScoreString = score.ToString("#.##");
        string savedScoreString = PlayerPrefs.GetString("HighScores", "");
저장된 점수가 빈 스트링이면 현재 스코어를 저장함
if (savedScoreString == "")
        {
            PlayerPrefs.SetString("HighScores", cureentScoreString);
        }
scoreList(string)을 float로 형변환해서  savedScore 변수에 넣어준다
비교해서 낮은 점수가 들어오면 적절한 위치에 넣거나 맨 끝에 넣음
float savedScore = float.Parse(scoreList[i]); 
if(savedScore < score) // 나보다 낮은 점수가 들어온다면
 {
  scoreList.Insert(i, cureentScoreString); // 뒤로 밀어버린다
   break;
}  

if (scoreArray.Length == scoreList.Count) // 적절한 위치를 못 찾았다면 넌 꼴찌
  {
      scoreList.Add(cureentScoreString);
  }
10개가 넘으면 맨 끝을 제거하고, result를 하나로 합친 후 저장
if(scoreList.Count>10) // 10개 넘으면 맨 끝 빼기
{
    scoreList.RemoveAt(10);
}

string result = string.Join(",", scoreList); // 리스트를 하나의 스트링으로 합치기
Debug.Log(result);
PlayerPrefs.SetString("HighScores", result);

최고 기록 나열
using TMPro;
using UnityEngine;

public class HighscoreCanvas : MonoBehaviour
{
    public TMP_Text ScoreLabel;

    private void OnEnable()
    {
        string[] scores = PlayerPrefs.GetString("HighScores", "").Split(',');
        string result = "";

        for(int i=0; i

아래의 패널이 생기면 실행되는 함수로 저장된 최고기록들을 scores라는 배열에 저장한다.
최고기록들을 1. ~ 2. ~로 출력하게 해준다.

총알 만들기
using UnityEngine;

public class Bullet : MonoBehaviour
{
    public Vector2 Velocity = new Vector2(10, 0); 
    void Start()
    {

    }
    private void FixedUpdate()
    {
        transform.Translate(Velocity * Time.fixedDeltaTime);
    }

    void Update()
    {

    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.gameObject.tag == "Terrain")
        {
            Destroy(gameObject);
        }
        else if (collision.gameObject.tag == "Enemy")
        {
            Destroy(gameObject);
            collision.GetComponent().Hit(1);
        }
    }
}

프리팹으로 만들어주고 isTrigger, rigd2D를 Kinematic으로 설정

적 체력 + 죽게 만들기
using UnityEngine;

public class EnemyController : MonoBehaviour
{
    public int Hp = 3;
      ...생략

    private void FixedUpdate()
    {
       // GetComponent().MovePosition
        transform.Translate(vx*Time.fixedDeltaTime);
    }

    public void Hit(int damage)
    {
        Hp -= damage;
        if(Hp <= 0 )
        {
            GetComponent().constraints = RigidbodyConstraints2D.None; //Freeze OFF
            GetComponent().angularDamping = 720; //빙글빙글
            GetComponent().AddForce(new Vector2(0, 10), ForceMode2D.Impulse);//한번에 힘을 주기
            GetComponent().enabled = false;

            Invoke("DestroyThis", 2f);
        }
    }
    void DestroyThis()
    {
        Destroy(gameObject);
    }
}

플레이어가 Die하듯이 적도 똑같이 지정해준다.
제한시간이 넘어가면 게임 종료하기
using TMPro;
using Unity.Cinemachine;
using UnityEngine;

public class GameManager : MonoBehaviour
{
   ..생략
    void Update()
    {
        TimeLimit -= Time.deltaTime;
        TimeLimitLabel.text = "Time Left " + ((int)TimeLimit);
        if(TimeLimit<0)
        {
            GameOver();
        }
    }
if(TimeLimit<0)
간단하게 이 조건으로 완료!
instantiate 줄이기(오브젝트 풀링)
아래와 같이 게임 루프에 instantiate가 많으면 렉이 발생할 확률이 높아진다.

ObjectPool 스크립트 생성
public class ObjectPool : MonoBehaviour
{

    public GameObject Prefab;
    public int InitialObjectNumber = 30;

    List objs;

    private void Start()
    {
        objs = new List();

        for (int i = 0; i < InitialObjectNumber; i++)
        {
            GameObject go = Instantiate(Prefab, transform); //부모 지정
            go.SetActive(false);
            objs.Add(go);
        }
    }
    public GameObject GetObject()
    {
        foreach (GameObject go in objs)
        {
            if (!go.activeSelf)
            {
                go.SetActive(true);
                return go;
            }
        }
        //준비해둔 30개를 다 쓰면 인스턴스로 생성 
        GameObject obj = Instantiate(Prefab, transform);
        objs.Add(obj);
        return obj;
    }
}

Instantiate :
GameObject Object.InstantiateGameObject original, Vector3 position, Quaternion rotation
라고 사용

objs에 go(bullet : Prefab으로 지정한 오브젝트) 추가
using UnityEngine;

public class Bullet : MonoBehaviour
{
    public Vector2 Velocity = new Vector2(10, 0); 
    void Start()
    {

    }
    private void FixedUpdate()
    {
        transform.Translate(Velocity * Time.fixedDeltaTime);
    }

    void Update()
    {
        if(!GetComponent().isVisible)
        {
            gameObject.SetActive(false);
        }
    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.gameObject.tag == "Terrain")
        {
            gameObject.SetActive(false);
        }
        else if (collision.gameObject.tag == "Enemy")
        {
            gameObject.SetActive(false);
            collision.GetComponent().Hit(1);
        }
    }
}

gameObject.SetActive(false);으로 수정
화면 밖을 나가면 비활성화된다

    if(!GetComponent().isVisible)
    {
        gameObject.SetActive(false);
    }
isVisible : 화면에 보이는지의 여부



[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 4일차
Fri, 04 Oct 2024 07:52:12 GMT
EndPoint로 골인지점과 애니메이션, 콜라이더 추가


Collider - isTrigger
Animation 추가
스크립트 추가

public class EndPoint : MonoBehaviour
{

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.tag == "Player")
        {
            Debug.Log("End");
        }
    }
}
Item(Melon)과 애니메이션, 콜라이더 추가


Collider - isTrigger
Animation 추가 (+Eaten)
스크립트 추가

먹으면 먹는 애니메이션(Eaten)과 함께 과일이 사라지도록함

public class Fruits : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.tag == "Player")
        {
            GetComponent().SetTrigger("Eaten");
        }
    }
}
Gamemanger 생성
public class GameManager : MonoBehaviour
{
    private static GameManager instance;
    public static GameManager Instance
    {
        get { return instance; }
    }
    public TMP_Text timeLimitLabel;

    public float TimeLimit = 30;

    private void Awake()
    {
        instance = this;
    }

    void Update()
    {
        TimeLimit -= Time.deltaTime;
        timeLimitLabel.text = "Time Left" + ((int)TimeLimit);
    }
}


남은시간 표시



캔버스 추가
남은 시간 텍스트 추가

아이템 먹고 사라지게 하기
public class Fruits : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.tag == "Player")
        {
            GetComponent().SetTrigger("Eaten");
            GetComponent().enabled = false;
            Invoke("DestroyThis", 0.6f);
        }
    }
    void DestroyThis()
    {
        Destroy(gameObject);
    }
}

Invoke("DestroyThis", 0.6f); 없이도 원하는 시기에 함수 호출 가능

Add event로 이벤트 추가 후 


원하는 함수 입력 가능
시간 늘리기
public class GameManager : MonoBehaviour
{
    private static GameManager instance;
    public static GameManager Instance
    {
        get { return instance; }
    }
    public TMP_Text TimeLimitLabel;

    public float TimeLimit = 30;

    private void Awake()
    {
        instance = this;
    }

    void Start()
    {

    }


    void Update()
    {
        TimeLimit -= Time.deltaTime;
        TimeLimitLabel.text = "Time Left " + ((int)TimeLimit);
    }
    public void AddTime(float time)
    {
        TimeLimit += time;
    }
}

AddTime 함수를 통해 아이템을 먹으면 시간이 늘어나도록 설정
public class Fruits : MonoBehaviour
{
    public float TimeAdd = 5;
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.tag == "Player")
        {
            GameManager.Instance.AddTime(TimeAdd);
            GetComponent().SetTrigger("Eaten");
            GetComponent().enabled = false;
        }
    }
    void DestroyThis()
    {
        Destroy(gameObject);
    }
}
GameManager.Instance.AddTime(TimeAdd); Fruits 스크립트에서 함수 호출

아이템을 먹으면 5초씩 늘어남

프리팹 설정


Revert All : 리셋(프리팹대로 돌리겠다)
Apply All : 적용(이 설정대로 프리팹을 수정하겠다)

죽었을때
public class DeadZone : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.gameObject.tag == "Player")
        {
            GameManager.Instance.Die();
            Debug.Log("Dead");
        }
    }
}

죽었는데도 플레이어를 움직이면 카메라가 움직이는 것 방지하기
public class GameManager : MonoBehaviour
{
    public GameObject CinemaCamera;

    private static GameManager instance;
    public static GameManager Instance
    {
        get { return instance; }
    }
    public TMP_Text TimeLimitLabel;

    public float TimeLimit = 30;

    private void Awake()
    {
        instance = this;
    }

    void Update()
    {
        TimeLimit -= Time.deltaTime;
        TimeLimitLabel.text = "Time Left " + ((int)TimeLimit);
    }
    public void AddTime(float time)
    {
        TimeLimit += time;
    }

    public void Die()
    {
        CinemaCamera.SetActive(false);
    }
}
CinemaCamera.SetActive(false); 로 시네마 카메라를 비활성화 해준다.
콜라이더의 차이
public Collider2D BottomCollider;
public CompositeCollider2D TerrainCollder;

▲ 위에서 아래로 찾기 때문에 그냥 Collider2D 라고하면 Tilemap 콜라이더를 가져온다.

목숨 UI


horizontal layout group으로 가로로 정렬해준다

public class LifeDisplayer : MonoBehaviour
{
    public List lifeImage;

    public void SetLives(int life)
    {
        for(int i = 0; i


🚨 오류가 생겼던 부분
이 코드에서 false ↔ true를 바꿔버림


public class GameManager : MonoBehaviour
{
    public GameObject CinemaCamera;

    private static GameManager instance;
    public static GameManager Instance
    {
        get { return instance; }
    }
    public TMP_Text TimeLimitLabel;

    public float TimeLimit = 30;

    private void Awake()
    {
        instance = this;
    }

    void Start()
    {
        life = 3;
    }


    void Update()
    {
        TimeLimit -= Time.deltaTime;
        TimeLimitLabel.text = "Time Left " + ((int)TimeLimit);
    }
    public void AddTime(float time)
    {
        TimeLimit += time;
    }

    public LifeDisplayer LifeDisplayerInstance;
    int life = 3;

    public void Die()
    {
        CinemaCamera.SetActive(false);
        life--;
        LifeDisplayerInstance.SetLives(life);
    }
}
이제 떨어지면 dead존(아래 떨어지면 Collider)에 맞고 life가 하나 깎인다
죽었을때 위치 초기화
public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    public float JumpSpeed = 5;
    public Collider2D BottomCollider;
    public CompositeCollider2D TerrainCollder;

    float prevVx = 0;
    float vx = 0;
    bool isGround;

    Vector2 originalPosition;

    public void Restart()
    {
        transform.position = originalPosition;
        GetComponent().linearVelocity = Vector2.zero;//떨어지고 있을때의 속도 초기화
    }
...생략

}

GetComponent().linearVelocity = Vector2.zero
떨어지는 속도를 초기화해준다.
public class GameManager : MonoBehaviour
{
    public GameObject CinemaCamera;
    public PlayerController Player;

    private static GameManager instance;
    public static GameManager Instance
    {
        get { return instance; }
    }
    public TMP_Text TimeLimitLabel;

    public float TimeLimit = 30;

    ..생략

    public LifeDisplayer LifeDisplayerInstance;
    int life = 3;

    public void Die()
    {
        CinemaCamera.SetActive(false);
        life--;
        LifeDisplayerInstance.SetLives(life);

        Invoke("Restart", 2);
    }

    void Restart()
    {
        if(life > 0)
        {
            CinemaCamera.SetActive(true);
            Player.Restart();
        }
        else
        {
            GameOver();
        }
    }

    void GameOver()
    {
        Debug.Log("Game OVer");
    }
}
Die,  Restart, GameOver 함수를 추가해준다.
적 만들기



sorting layer는 player로
Collider 추가
Animation 추가
스크립트 추가

public class EnemyConteroller : MonoBehaviour
{
    public float Speed;
    Vector2 vx;

    void Start()
    {
        vx = Vector2.right * Speed;
    }

    private void FixedUpdate()
    {
       // GetComponent().MovePosition
        transform.Translate(vx*Time.fixedDeltaTime);
    }
}

transform.Translate(vx*Time.fixedDeltaTime);
이 방법은 추천하진 않지만 이런 방법이 있다.
❓ 이유는

순간이동하는 방식이라 속도가 빠르고 콜라이더가 얇으면 뚫을수도 있음
rigd로 사용하면 천천히 이동

벽과 절벽등을 감지하는 collider를 만들어줌


Front : 앞에 벽이 있는지
Front Bottom : 땅을 밟고 있는지

void Update()
{
        if(FrontCollider.IsTouching(TerrainCollider) || !FrontBottomCollider.IsTouching(TerrainCollider)) //벽이 있거나 || (절벽이 있는 경우) 바닥이 없는 경우
    {
        vx = -vx; //좌우반전
       transform.localScale = new Vector2(-transform.localScale.x, 1);

    }
}

좌우반전
        transform.localScale = new Vector2(-transform.localScale.x, 1);
적과 부딪히면 죽도록
    private void OnCollisionEnter2D(Collision2D collision)
    {
        if(collision.gameObject.tag == "Enemy")
        {
            Die();
        }
    }

    void Die()
    {
        GameManager.Instance.Die();
    }
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    enum State{
        Playing,
        Dead
    }

//생략

    Vector2 originalPosition;
    State state;

    void Start()
    {
        originalPosition = transform.position;
        State state = State.Playing;
    }

    public void Restart()
    {
        //원상복구
        GetComponent().constraints = RigidbodyConstraints2D.FreezeRotation; 
        GetComponent().angularVelocity = 0; 
        GetComponent().enabled = true;

        transform.position = originalPosition;
        GetComponent().linearVelocity = Vector2.zero;//떨어지고 있을때의 속도 초기화
        state = State.Playing;
    }

   //생략

    private void OnCollisionEnter2D(Collision2D collision)
    {
        if(collision.gameObject.tag == "Enemy")
        {
            Die();
        }
    }

    void Die()
    {
        state = State.Dead;
        GetComponent().constraints = RigidbodyConstraints2D.None; //Freeze OFF
        GetComponent().angularDamping = 720; //빙글빙글
        GetComponent().AddForce(new Vector2(0, 10), ForceMode2D.Impulse);//한번에 힘을 주기
        GetComponent().enabled = false;

        GameManager.Instance.Die();
    }
}

Rigidbody2D컴포넌트에서 여러 설정을 수정해서 

▲ 이런식으로 죽게 만들기
enum State{
    Playing,
    Dead
}
현재 상태를 나타내는 State를 만들어주고, 
State state;

void Start()
{
    originalPosition = transform.position;
    State state = State.Playing;
}
처음에는 Playing으로 초기화,
    void Die()
    {
        state = State.Dead;
        GetComponent().constraints = RigidbodyConstraints2D.None; //Freeze OFF
        GetComponent().angularDamping = 720; //빙글빙글
        GetComponent().AddForce(new Vector2(0, 10), ForceMode2D.Impulse);//한번에 힘을 주기
        GetComponent().enabled = false;

        GameManager.Instance.Die();
    }
죽었을때는 Dead로 설정해주고, 캐릭터가 움직이지 못하고 떨어지는 효과를 주기 위해 
Rigdbody의 여러 상태들을 바꿔준다.
    public void Restart()
    {
        //원상복구
        GetComponent().constraints = RigidbodyConstraints2D.FreezeRotation; 
        GetComponent().angularVelocity = 0; 
        GetComponent().enabled = true;

        transform.position = originalPosition;
        GetComponent().linearVelocity = Vector2.zero;//떨어지고 있을때의 속도 초기화
        state = State.Playing;
    }
Restart(재시작)이 될 경우에는 원상복구를 해준다.
게임 오버 팝업창을 만들어준다.

Sliced는 안 깨지고 크기가 늘어나게




[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼유니티게임스쿨 3일차
Mon, 30 Sep 2024 07:40:05 GMT
타일맵 만들기
사용 에셋
Pixel Adventure 1
Free - Adventure Pack - Grassland
TileMap 종류

rectangular : 사각형(기본)
hexagonal : 육각형
isometic : 2.5D? 메이플2 같은 뷰



▲ hexagonal

▲ isometic
TileMap 설정하기
가져온 타일맵의 pixel per unit을 25로 하고 grid크기를 0.64(16/25)로 해준다


pixel per unit을 16으로하고 grid크기를 1,1로 하는거랑 뭐가 다른지?
→ 한 영역에 담기는 그리드 개수가 달라짐. 25, 0.64로하면 더 많은 그리드가 생김
콜라이더 설정
만든 Tile Map이 생성된 자식 오브젝트 이름을 Terrain로 설정한 후, composite collider 컴포넌트(+rigd가 동시에 생김)를 달아준다.

*composite collider *
Tilemap Collider를 넣었을때 타일 하나하나가 Collider 적용이 되기 때문에 composite collider로 하나의 콜라이더로 통합해준다.




타일 맵의 땅이 떨어지는걸 막기 위해 static으로 바꿔줌



Player도 rigd와 collider추가


Player

GetAxis : 부드러운 중간값도 출력
GetAxisRaw : 키를 누르자마자 반응

Player 이동
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    float vx = 0;
    void Start()
    {

    }

    void Update()
    {
        vx = Input.GetAxisRaw("Horizontal")*Speed;
        GetComponent().linearVelocity = new Vector2(vx,0);
    }
}

linearVelocity랑 velocity랑 같은 것
버전이 바뀌면서 velocity → linearVelocity로 바뀜
Player를 바라보는 방향으로 보게하기
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    float vx = 0;
    void Start()
    {

    }

    void Update()
    {
        vx = Input.GetAxisRaw("Horizontal")*Speed;

        if(vx<0)
        {
            GetComponent().flipX = true;
        }
        if (vx > 0)
        {
            GetComponent().flipX = false;
        }

        GetComponent().linearVelocity = new Vector2(vx,0);
    }
}

Player 점프 구현
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    public float JumpSpeed = 5;

    float vx = 0;

    void Start()
    {

    }

    void Update()
    {
        vx = Input.GetAxisRaw("Horizontal")*Speed;
        float vy = GetComponent().linearVelocityY;

        if(vx<0)
        {
            GetComponent().flipX = true;
        }
        if (vx > 0)
        {
            GetComponent().flipX = false;
        }
        if(Input.GetButtonDown("Jump"))
        {
            vy = JumpSpeed;
        }

        GetComponent().linearVelocity = new Vector2(vx,vy);
    }
}
float vy = GetComponent().linearVelocityY;
위 Y 값을 주고 GetComponent().linearVelocity = new Vector2(vx,vy); 로 수정해준다


Discrete : 빠른 계산
Continuous : 정밀한 계산


Player가 벽타는 현상(마찰력 줄이기)

PhysicsMaterial 컴포넌트를 만들고 Player의 Rigidbody에 붙여주면 벽에 붙는 현상이 없어진다.

Discrete로 설정하면 높이 뛰었다가 내려올때 collider를 뚫고 내려갈 수 있기 때문에 Continuous로 바꿔준다

무한 점프 방지
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    public float JumpSpeed = 5;
    public Collider2D BottomCollider;
    public CompositeCollider2D TerrainCollder;

    float vx = 0;

    void Start()
    {

    }

    void Update()
    {
        if(BottomCollider.IsTouching(TerrainCollder))
        {
            Debug.Log("Grounded");
        }
        else
        {
            Debug.Log("NOT");
        }

        vx = Input.GetAxisRaw("Horizontal")*Speed;
        float vy = GetComponent().linearVelocityY;

        if(vx<0)
        {
            GetComponent().flipX = true;
        }
        if (vx > 0)
        {
            GetComponent().flipX = false;
        }
        if(Input.GetButtonDown("Jump"))
        {
            vy = JumpSpeed;
        }

        GetComponent().linearVelocity = new Vector2(vx,vy);
    }

}

   public Collider2D BottomCollider;
    public CompositeCollider2D TerrainCollder; 
콜라이더를 선언하고 넣어준 후,   if(BottomCollider.IsTouching(TerrainCollder))로 

IsTouching :  2D 물리 시스템에서 Collider2D 컴포넌트 간의 충돌 여부를 확인할 때 사용
나의 콜라이더.IsTouching(닿을 콜라이더)
로 사용한다.



        if (BottomCollider.IsTouching(TerrainCollder))
        {
            isGround = true;
        }
        else
        {
            isGround = false;
        }
이렇게 한줄로 요약 가능
isGround = BottomCollider.IsTouching(TerrainCollder);
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    public float JumpSpeed = 5;
    public Collider2D BottomCollider;
    public CompositeCollider2D TerrainCollder;

    float vx = 0;
    bool isGround;

    void Start()
    {

    }

    void Update()
    {
        vx = Input.GetAxisRaw("Horizontal")*Speed;
        float vy = GetComponent().linearVelocityY;

        if(vx<0)
        {
            GetComponent().flipX = true;
        }
        if (vx > 0)
        {
            GetComponent().flipX = false;
        }

        isGround = BottomCollider.IsTouching(TerrainCollder);

        if (Input.GetButtonDown("Jump") && isGround == true)
        {
            vy = JumpSpeed;
        }

        GetComponent().linearVelocity = new Vector2(vx,vy);
    }

}

카메라가 따라오도록 하기
시네머신 카메라의 활용 : 카트라이더에 뒤에서 비추는 카메라 구현도 가능
Unity Registry에서 시네머신 import
cinemachine camera 추가 후, follow 컴포넌트와 target을 player로 지정하면 따라오게 한다

Border(화면 밖으로 나가지 못하게하는 경계선)을 collider로 만들고, 시네마 카메라에 confiner 2D를 추가한 후 Border을 할당해준다

BoxCollider은 꼭짓점 정보를 안 줌 그래서 Edge Collider로 사용
🚨 보더 크기가 카메라보다 훨씬 커야 오류가 안 뜸(작으면 플레이어를 안 따라옴)
Player 애니메이션

2D에는 다 0,0 으로 세팅
다른 애들도 다 Can Transition To Self를 켜준다
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float Speed = 5;
    public float JumpSpeed = 5;
    public Collider2D BottomCollider;
    public CompositeCollider2D TerrainCollder;

    float prevVx = 0;
    float vx = 0;
    bool isGround;


    void Start()
    {

    }

    void Update()
    {
        vx = Input.GetAxisRaw("Horizontal")*Speed;
        float vy = GetComponent().linearVelocityY;

        if(vx<0)
        {
            GetComponent().flipX = true;
        }
        if (vx > 0)
        {
            GetComponent().flipX = false;
        }

        if (BottomCollider.IsTouching(TerrainCollder))
        {
            if (!isGround)
            {
                if(vx == 0) //속도가 0일때, 가만히 있는다면
                {
                    GetComponent().SetTrigger("Idle");
                }
                else
                {
                    GetComponent().SetTrigger("Run");
                }
            }
            else
            {
                if (vx != prevVx)
                {
                    if (vx == 0)
                    {
                        GetComponent().SetTrigger("Idle");
                    }
                    else
                    {
                        GetComponent().SetTrigger("Run");
                    }
                }
            }

        }
        else
        {
            if(isGround)
            {
                GetComponent().SetTrigger("Jump");
            }
        }

        isGround = BottomCollider.IsTouching(TerrainCollder); //콜라이더들이 부딪히면 true를 isGround에 

        if (Input.GetButtonDown("Jump") && isGround == true)
        {
            vy = JumpSpeed;
        }

        GetComponent().linearVelocity = new Vector2(vx,vy);
    }

}

각 조건마다 애니메이션을 다르게 실행하도록 해준다

yj_621.log

유니티로 만드는 3D 농사게임 - 2일차

1. 초기 설정

2. 결과

3. 작물 설정

4. 스크립트 역할 정리

① GridSystem.cs (입력 및 로직 제어기)

② GridManager.cs (데이터 관리자)

③ Crop.cs & CropData.cs (객체 및 데이터 구조)

유니티로 만드는 3D 농사게임 - 1일차

1. 초기 설정

2. 그리드 시스템의 데이터와 로직 분리

3. 결과

4. 지식 +

🔷 TryGetComponent?

🔷Physics.Raycast

💡 기술적 포인트

UniTask를 이용한 비동기 처리

🔷 UniTask - 유니티 최적화 라이브러리

📄 1. 네트워크 통신 리팩토링 (Coroutine → UniTask)

① 통신 매니저 (PythonConnectManager.cs)

② 호출하는 곳 (AlgorithmCall.cs)

📄 2. 비동기 씬 로드

유니티 셰이더로 이미지 흑백 처리하기

UI Canvas Shader Graph 사용 (유니티 6 권장)

1. 셰이더 그래프 생성

2. 필수 속성 만들기

4. 머터리얼 적용

유니티에서 버튼을 선택했을때 스프라이트 교체

유니티에서 Google AdMob를 사용해서 광고 삽입하기

유니티 모바일 키보드가 인풋필드를 가리는 문제

이 스크립트가 하는 일

동작 원리

유니티에서 AWS를 사용해 파이썬 프로그램 실행하기

1단계 : AWS EC2 인스턴스 생성 (서버 만들기)

2단계: 서버 보안 설정 (포트 5000 열기)

3단계: 서버에 파일 업로드 및 환경 구축

4단계: 서버 실행

⚠️ 오류 모음

5단계: 유니티 코드 수정

💡 만약 서버를 끄고 싶다면?

유니티 ait 파일 생성, 앱인토스 ait 파일 빌드, 유니티에서 만든 게임을 앱인토스에 올리기

앱인토스 시작하기

AIT 파일 빌드하기

AIT 파일 업로드하기

유니티 Photon Voice2 보이스 채팅 기능

객체지향 5대 원칙/인터페이스 분리 원칙(ISP)

인터페이스 분리 원칙(ISP)

5가지 SOLID 원칙

단일 책임 원칙(Single Responsibility)

개방 폐쇄 원칙(Open- losed)

리스코프 치환 원칙(Liskov Substitution)

인터페이스 분리 원칙(Interface Scgregation)

의존 역전 원칙(Dependency Inversion)

C# 백준 1120 문자열 (나는 이제 실버다 ㅋㅋ)

❓문제

✏️입력

⌨️출력

예제 입력1

예제 출력1

예제 입력2

예제 출력2

💻코드

✍️풀이

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 9일차

애니메이션

애니메이션에 따른 코드 추가

인터페이스

죽고나서 없어지기

펀치 콜라이더 설정

무적시간

Hp 구현

Render Mode

Enemy HP 구현

Player 죽음

[멋쟁이사자처럼 부트캠프 TIL] 멋쟁이사자처럼 유니티게임스쿨 8일차

코루틴으로 총알 흔적 없애기

총알이 맞은 지점 나타내기

수류탄

폭발

① `GridSystem.cs` (입력 및 로직 제어기)

② `GridManager.cs` (데이터 관리자)

③ `Crop.cs` & `CropData.cs` (객체 및 데이터 구조)