SMN 블로그

Step of Love - 색 변경

SMNNMN — Sun, 31 May 2026 17:16:58 +0900

이번에 구현할 기능은 색 변경이다.

특정 상황에서 여러 오브젝트의 기본 색이 변경될수 있게 할 것이다.

그리고 이 기능을 만들고 나면 나머지 기획했던 기능들을 실제 게임을 구현하면서 차츰 만들어갈 예정이다.

ColorManager

색을 관리하는 매니저

using System;
using UnityEngine;

public class ColorManager : Singleton<ColorManager>
{
    public event Action<ColorEvent> C_ChangeEvent;
    public enum ColorEvent
    {
        NOON,
        NIGHT,
    }
    protected override void Awake()
    {
        base.Awake();
    }
    public void ChangeColor(ColorEvent colorEvent)
    {
        C_ChangeEvent?.Invoke(colorEvent);
    }
}

지금은 상황을 낮과 밤으로 만 만들어 주었다.

이후에 확장하려면 ColorEvent에다가 여러 상황을 넣어서 관리하면 될 것 같다.

ChangeColorObject

색이 변경되는 오브젝트 스크립트

using UnityEngine;

public class ChangeColorObject : MonoBehaviour
{
    private SpriteRenderer sprite;
    [SerializeField] Color[] colors;
    private void Awake()
    {
        sprite = GetComponent<SpriteRenderer>();
    }
    private void OnEnable()
    {
        ColorManager.Instance.C_ChangeEvent += ChangeColor;
    }
    private void OnDisable()
    {
        ColorManager.Instance.C_ChangeEvent -= ChangeColor;
    }
    // 색이 변경된다.
    void ChangeColor(ColorManager.ColorEvent colorEvent)
    {
        int index = (int)colorEvent;

        sprite.color = colors[index];
        Debug.Log("색 변경");
        Debug.Log("index : " + index);
    }
}

색이 변경되는 오브젝트는 이 스크립트를 가지고 있다.

먼저 각 상황에 따라서 자신이 지니는 색을 가지고 있고,

상황에 따른 이벤트가 호출되면 해당 색으로 sprite.color를 변경한다.

InputController

임의로 이벤트를 호출하는 코드

    void Update()
    {
        Mouse_Pos();
        Mouse_L();
        if (Input.GetMouseButtonDown(1))
        {
            CameraManager.Instance.EventCam(Vector2.zero);
            ColorManager.Instance.ChangeColor(ColorManager.ColorEvent.NOON);
        }
        else if(Input.GetMouseButtonDown(2))
        {
            CameraManager.Instance.FollowCam(player);
            ColorManager.Instance.ChangeColor(ColorManager.ColorEvent.NIGHT);
        }
    }

아키텍처

완성본

낮과 밤으로 스프라이트 색이 변경되는 것을 볼수 있다.

Step of Love 미니게임

SMNNMN — Sun, 31 May 2026 15:53:47 +0900

이번엔 구현할 것은 미니게임이다.

이벤트처럼 플레이어가 미니게임 존에 들어가거나 특정 상황이 되었을 때, 일단은 UI로 할수 있는 미니게임이 등장하고, 이 미니게임을 완료하면 다시 이동할 수 있는 상태가 되는 것을 구현해볼 것이다.

MiniGameManager

미니게임을 생성과 삭제등을 관리하는 스크립트

using UnityEngine;

public class MiniGameManager : Singleton<MiniGameManager>
{
    protected override void Awake()
    {
        base.Awake();
    }
    public void StartMiniGame(GameObject miniGame)
    {
        GameManager.Instance.SetEventState(GameManager.EventState.MINIGAME);
        Time.timeScale = 0;
        Instantiate(miniGame);
    }
    public void FinishMiniGame(GameObject miniGame)
    {
        GameManager.Instance.SetEventState(GameManager.EventState.NORMAL);
        Time.timeScale = 1f;
        Destroy(miniGame);
    }
}

미니게임이 시작되었을 때와 끝났을 때를 관리한다.

MiniGameZone

미니게임이 실행되는 트리거 역할

using UnityEngine;

public class MiniGameZone : MonoBehaviour
{
    [SerializeField] GameObject miniGame; // 발생하는 미니게임
    private void OnTriggerEnter2D(Collider2D collision)
    {
        FootPrint foot = collision.GetComponent<FootPrint>();
        if (foot != null)
        {
            Debug.Log("Start MiniGame");
            MiniGameManager.Instance.StartMiniGame(miniGame);
            gameObject.SetActive(false);
        }
    }
}

EventZone과 마찬가지로, 발자국과 닿았을 때, 미니게임을 실행한다. MiniGameManager를 거쳐 실행코드를 만든다.

miniGame이라는 자신이 실행할 미니게임 오브젝트를 가진다.

Minigame

모든 미니게임이 가지는 공통 부모 코드

using UnityEngine;

public class MiniGame : MonoBehaviour
{
    [SerializeField] GameObject myMiniGame;
    protected void GameFinish()
    {
        MiniGameManager.Instance.FinishMiniGame(myMiniGame);
    }
}

모든 미니게임은 현재기준으로 끝이 존재하기 때문에, 게임이 끝났을 때를 MiniGame 이라는 부모 클래스에 구현해준다.

A_MiniGameManager

임의로 만든 하나의 미니게임 시스템

using UnityEngine;
using UnityEngine.UI;

public class A_MiniGameManager : MiniGame
{
    [SerializeField] Text myText;
    [SerializeField] int clickNum;
    private void Awake()
    {
        myText.text = $"Click {clickNum}".ToString();
    }
    public void buttonClick()
    {
        clickNum--;
        if(clickNum <= 0)
        {
            GameFinish();
            return;
        }
        myText.text = $"Click {clickNum}".ToString();
    }
}

버튼을 클릭하는 미니게임을 임의로 만들었다.

아키텍처

완성본

Step of Love 카메라 제어

SMNNMN — Thu, 28 May 2026 02:15:13 +0900

이번엔 카메라를 제어할 것이다.

기본적으로, 카메라는 특정한 타겟을 따라가거나, 특정 위치에 고정되게끔 할 것이다.

CameraManager

여러 개의 카메라를 관리하는 스크립트를 만든다.

using Unity.Cinemachine;
using UnityEngine;

public class CameraManager : Singleton<CameraManager>
{
    [SerializeField] CinemachineCamera follow_Cam; // 플레이어를 따라다니는 카메라
    [SerializeField] CinemachineCamera event_Cam; // 이벤트 발동시 특정 위치에 존재하는 카메라

    private CinemachineCamera currentCam; // 현재 사용중인 카메라

    private void ChangeCamera(CinemachineCamera cam)
    {
        if(currentCam != null)
        {
            currentCam.Priority = 0;
        }
        cam.Priority = 10;
        currentCam = cam;
    }
    // 타켓을 따라다니는 카메라
    public void FollowCam(GameObject target)
    {
        ChangeCamera(follow_Cam);
        follow_Cam.Follow = target.transform;
        follow_Cam.LookAt = target.transform;
    }

    // 특정 위치를 비추는 카메라
    public void EventCam(Vector2 targetPos)
    {
        ChangeCamera(event_Cam);
        event_Cam.transform.position = new Vector3(targetPos.x, targetPos.y, -10f);
    }
}

현재 사용하는 카메라 형식은 총 2개로 특정 오브젝트를 따라가는 follow_Cam과 특정 위치를 촬영하는 event_Cam이 존재한다.

ChangeCamera로 전환할 카메라의 Priority값을 높여주어 전환을 한다.

FollowCam에서 따라갈 대상을 받아와 카메라가 그 오브젝트를 따라가게끔 하고, EventCam에서는 특정 위치를 받아와 해당 위치를 비추는 기능을 구현했다.

unity Editor 설정

가장 먼저 Cinemachine Brain이 될 mainCamera에 brain을 달아주고,

followCam과 eventCam을 만들어서 Cinemachine을 넣어주고 사용한다.

블렌딩 방식으로는 지금은 이렇게 사용하지만 원하는 연출이 있을때는 카메라를 전환하기 전에 블렌드 방식을 바꾸는 식으로 사용할 것 같다.

완성본

임의로 카메라 전환 입력기능을 만들었다.

Step of Love 달리기 시스템

SMNNMN — Wed, 27 May 2026 20:33:29 +0900

이번엔 달리기 시스템을 만들 것이다.

달리기 시스템은 플레이어가 마우스 좌클릭을 했을 때, 발걸음 속도가 빨라지고, 다시 뗐을때 원래 속도로 돌아오게끔 한다.

InputController

먼저 좌클릭을 클릭했을 때와 뗐을 때 입력을 만들어 줘야한다.

using System;
using UnityEngine;

public class InputController : Singleton<InputController>
{
    [SerializeField] Vector2 mousePos; // 마우스포인터 위치
    public Vector2 MousePos => mousePos;

    // 마우스 좌클릭 이벤트
    public event Action MouseLeftDown;
    public event Action MouseLeftUp;

    protected override void Awake()
    {
        base.Awake();
    }
    // Update is called once per frame
    void Update()
    {
        Mouse_Pos();
        Mouse_L();
    }
    // 마우스 좌클릭
    void Mouse_L()
    {
        if (Input.GetMouseButtonDown(0))
        {
            MouseLeftDown?.Invoke();
        }
        else if (Input.GetMouseButtonUp(0))
        {
            MouseLeftUp?.Invoke();
        }
    }
}

Update에서 if문으로 bool 값을 사용하여 현재 클릭상태인지 아닌지를 판단하는 코드를 사용하려 했지만 Event Driven 아키텍처에 맞게, 눌렀을 때와, 뗏을 때 각각 이벤트를 호출하는 식으로 만들어주었다.

만약 좌클릭을 클릭하면 MouseLeftDown 델리게이트를 호출하고, 좌클릭을 떼면 MouseLeftUp 델리게이트를 호출한다.

FPMovement

입력에 따라 발걸음을 제어하는 행동을 구현할 것이다.

using System.Collections;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.AI;

public class FPMovement : MonoBehaviour
{
    [SerializeField] InputController input_C; // 입력 컨트롤러
    private NavMeshAgent agent; // 발자국 Nav
    [SerializeField] float maxSpeed; // 최대 속도
    [SerializeField] float walkSpeed; // 걸음 속도

    private void Awake()
    {
        footPrintRb = footPrint.GetComponent<Rigidbody2D>();
        agent = footPrint.GetComponent<NavMeshAgent>();
    }
    void OnEnable()
    {
        InputController.Instance.MouseLeftDown += SpeedIncrease;
        InputController.Instance.MouseLeftUp += SpeedDecrease;

    }
    private void OnDisable()
    {
        InputController.Instance.MouseLeftDown -= SpeedIncrease;
        InputController.Instance.MouseLeftUp -= SpeedDecrease;
    }
    // 발자국 움직임
    void FootPrintMove()
    {
        agent.SetDestination(input_C.MousePos);
    }
    void SpeedIncrease()
    {
        agent.speed = 7;
        walkSpeed = 0.3f;
    }
    void SpeedDecrease()
    {
        agent.speed = 3.5f;
        walkSpeed = 0.5f;
    }
    ~~~~~~~~~~~~~~~~~생략~~~~~~~~~~~~
}

우선 간단하게, 속도가 빨라지는 함수와 느려지는 코드를 만들고 각각의 이벤트에 구독하여 사용해 주었다.

agent, 발걸음 속력이 변화하고, 이에 맞게, 발걸음 빠르기가 변화한다

Script Execution Order

위와 같이 사용했을 때, Awake와 OnEnable의 실행순서가 꼬여서 OnEnable에서 InputController를 가져오지 못하는 현상이 발생한다.

이를 해결하기 위해 Edit - Project Settings에서 Script Execution Order에 InputController를 추가하고, Default Time보다 더 빠르게 실행되게끔 잡아준다.

완성본

마우스를 클릭하면 FootPrint의 속력이 빨라져, 발걸음의 속력이 빨라지고 이에 맞춰 발걸음 빠르기가 빨라진다.

Step of Love 이벤트 상호작용

SMNNMN — Tue, 26 May 2026 23:55:52 +0900

이번엔 이벤트 상호작용을 만들 것이다.

발자국이 특정 이벤트 존에 도달하게 되면 이벤트가 진행된다.

우선 만들어본 이벤트는 애니메이션 이벤트로 만들어 봤다.

만들면서 배운 Timeline을 사용하여 만들어주었다.

EventZone

이벤트의 트리거 역할을 한다.

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

public class EventZone : MonoBehaviour
{
    private PlayableDirector myDirector;

    private void Awake()
    {
        myDirector = GetComponent<PlayableDirector>();
    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        FootPrint footPrint = collision.GetComponent<FootPrint>();

        if (footPrint != null)
        {
            Debug.Log("Foot in Event Area");
            EventManager.Instance.StartEvent(myDirector);
        }
    }
    // 자신의 이벤트 종료
    public void MyEventFinish()
    {
        EventManager.Instance.FinishEvent();
        Destroy(gameObject);
    }
}

발자국이라는 컴포넌트를 가진 오브젝트와 부딧혔을 때, 자신의 타임라인 이벤트를 이벤트 매니저에 넘겨준다.

MyEventFinish함수에서 이벤트 매니저에게 이벤트의 종료를 알리고, 삭제한다. (1회성 이벤트)

FootPrint

충돌 확인을 위해 넣은 스크립트

using UnityEngine;

public class FootPrint : MonoBehaviour
{

}

왼쪽,오른쪽의 발자국에 넣어준다.

GameManager

게임의 여러 상태를 관리하는 게임매니저를 미리 만들어준다.

using UnityEngine;

public class GameManager : Singleton<GameManager>
{
    // 이벤트 상태
    public enum EventState
    {
        NORMAL,
        EVENT,
    }
    public EventState eventState { get; private set; } = EventState.NORMAL;

    protected override void Awake()
    {
        base.Awake();
    }
    public void SetEventState(EventState state)
    {
        eventState = state;
    }
}

지금은 이벤트상태인지 아닌지만 확인하기 위해 EventState만 만들어 준다.

(싱글톤은 나중에 설명)

EventManager

이벤트를 관리하는 매니저 컴포넌트

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;
public class EventManager : Singleton<EventManager>
{
    
    protected override void Awake()
    {
        base.Awake();
        // director = GetComponent<PlayableDirector>();
    }

    // 이벤트 시작
    public void StartEvent(PlayableDirector director)
    {
        GameManager.Instance.SetEventState(GameManager.EventState.EVENT);
        director.Play();
    }

    // 이벤트 종료
    public void FinishEvent()
    {
        GameManager.Instance.SetEventState(GameManager.EventState.NORMAL);
        Debug.Log("이벤트 끝");
    }
}

타임라인을 실행하기 위해 자신의 PlayableDirector를 가져와 넣어준다.

StartEvent에서 이벤트를 실행한다. 먼저 게임의 상태를 이벤트중으로 변경해주고, 받아온 타임라인을 실행할 타임라인에 넣어준 이후 실행한다.

FinishEvent에서 게임의 상태를 다시 기본적인 상태로 바꿔준다.

타임라인 만들기

프로젝트에서 타임라인을 생성하거나, 타임라인을 생성할 오브젝트를 클릭후 Create를 눌러준다.

이후 Event Area 오브젝트를 만들어주고, Playable Director를 넣어준다.

Playable에는 생성한 타임라인을 넣어주고, 활성상태 재생은 해제한다.

이후 타임라인에서 여러 오브젝트를 변형해가며 애니메니션을 만들어준다. (Animation Track)

이때, 이동하는 오브젝트의 경우, Animator 컴포넌트가 필요하다.

이벤트가 끝이 날때는 Signal Track으로 종료를 알린다. 때문에 Event Area에는 Singal Receiver라는 컴포넌트가 필요한다.

이후

애니메이션의 특수환경

이 게임에서 발자국이 끊기면서 애니메이션이 되게끔, 노드사이의 자연스러운 이동을 없앨 것이다.

양쪽 탄젠트의 일정을 눌러 부드러운 움직임을 제거한다.

https://docs.unity3d.com/Packages/com.unity.timeline@1.8/manual/curves-tangents.html

테스트

빨간 발자국은 선형, 파란 발자국은 일정으로 애니메이션 무브가 되어있다.

완성본

이벤트 실행과 끝 상호작용을 만들었다.

시스템 아키텍처

이후 이벤트를 사용할 때, 프리팹에 이벤트 내용을 추가해서 사용하면 된다.

제네릭 싱글톤

이 게임에서는 제네릭 싱글톤을 만들것이다.

제네릭 싱글톤이란, 싱글톤을 사용하는 컴포넌트의 부모 클래스를 제네릭으로 만들어, 일일이 싱글톤을 만들지 않아도, 상속만 받게되면 싱글톤이 완성되는 패턴이다.

Singleton

using UnityEngine;

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T instance;
    public static T Instance
    {
        get { return instance; }
    }
    protected virtual void Awake()
    {
        if (instance == null)
        {
            instance = this as T;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

Singleton이라는 클래스를 만들고, 제네릭을 사용해준다. <T>

제네릭의 T는 아무 변수가 들어갈수 있지만 제약을 걸어주기위해 where이라는 예약어를 사용해준다.

where T : MonoBehaviour의 경우, 상속받는 컴포넌트는 유니티 컴포넌트(유니티 기능을 사용하는 컴포넌트)로 제약을 걸어준다.

이후 T라는 변수로 instance를 만들어 주고, 싱글톤과 똑같이 처리한다.

이렇게 제네릭 싱글톤을 작성하고 나면 싱글톤을 사용하는 다른 클래스에서 더 수월하게 사용할 수 있다.

기본적인 사용방법

using UnityEngine;

public class GameManager : Singleton<GameManager>
{
    protected override void Awake()
    {
        base.Awake();
    }
}

Singleton을 상속받고 제네릭에는 자신의 클래스를 넣어준다.

virtual 함수인 Awake를 재정의를 통해 부모클래스의 함수를 사용한다.