유니티 사화

private void Update()
{
    // 상태에 따른 행동 함수 호출 제어
    if (playerState.doNotAct || player.IsPerformingHitAction)
    {
        return;
    }

    if (Input.GetKeyDown(saveManager.InputKeys[KeyAction.ATTACK_NORMAL]))
    {
        // 행동 함수(스킬) 호출
        humanMaskSkill.NormalAttack();
    }
}

// CoFirstAttack()을 실행
public void NormalAttack() {}

public IEnumerator CoFirstAttack()
{
    while (isPerformingFirstAttack)
    {
        // bool 변수 'doNotAct'로 행동 함수 호출을 제어
        playerState.RestrictPlayer(humanData.firstNormalAttackRestrict, firstAttackStartTime);
    }
}

public void RestrictPlayer(RestrictStruct restrictStruct, float skillStartTime)
{
    // 일정 시간 동안 doNotAct를 true로 하여 다른 행동의 호출을 방지
    if (restrictStruct.actRestrictDuration != 0)
    {
        if (Time.time >= skillStartTime + restrictStruct.actRestrictWaitTime + restrictStruct.actRestrictDuration)
        {
            doNotAct = false;
        }
        else if (Time.time >= skillStartTime + restrictStruct.actRestrictWaitTime)
        {
            doNotAct = true;
        }
    }
}

private void Update()
{
    if (Input.GetKeyDown(saveManager.InputKeys[KeyAction.ATTACK_NORMAL]))
    {
        // 입력을 저장
        playerSkillInput.StoreInput(PlayerStateType.HUMAN_NORMALATTACK);

        // 스킬 실행 중이 아니라면 바로 실행
        if (!playerState.isPerfomingSklill) humanMaskSkill.NormalAttack();
    }
}

// CoFirstAttack()을 실행
public void NormalAttack() {}

public IEnumerator CoFirstAttack()
{
    // 지정된 시간 동안 입력된 스킬을 저장
    playerSkillInput.ProcessInput(humanData.firstNormalAttackInput, firstAttackStartTime);

    while (isPerformingFirstAttack)
    {
        playerState.RestrictPlayer(humanData.firstNormalAttackRestrict, firstAttackStartTime);
    }
}

public void StoreInput(PlayerStateType inputValue)
{
    // 저장 가능할 때만 Stack<PlayerStateType>에 저장
    if (canStoreInputValue)
    {
        playerSkillInputValue.Push(inputValue);
    }
}

// CoProcessInput() 실행
public void ProcessInput(PlayerSkillInputStruct skillInput, float startTime) {}

public IEnumerator CoProcessInput(PlayerSkillInputStruct skillInput, float startTime)
{
    while (!stopCoroutine)
    {
        // 지정된 타이밍 이후 마지막으로 저장된 스킬값 실행
        else if (Time.time >= startTime + skillInput.executeWaitTime)
        {
            if (playerSkillInputValue.Count > 0)
            {
                ExecuteStoredInput(playerSkillInputValue.Pop());
                yield break;
            }
        }

        // bool 제어로 지정된 시간 동안만 입력이 저장되도록
        if (Time.time >= startTime + skillInput.storeWaitTime + skillInput.storeDuration)
        {
            canStoreInputValue = false;
        }
        else if (Time.time >= startTime + skillInput.storeWaitTime)
        {
            canStoreInputValue = true;
        }
    }
}

public void MenuSwitch()
{
    if (loadingUI.LoadBG.activeSelf)
    {
        return;
    }
    else if (settingWindow.activeSelf)
    {
        if (soundWindow.activeSelf)
        {
            soundUI.SaveVolumeData();
        }
        else if (inputKeyWindow.activeSelf)
        {
            if (inputKeyUI.completeEditingKey)
            {
                inputKeyUI.CompleteEditingKey(false);
                return;
            }
            mouseUI.SaveMouseData();
        }
        settingWindow.SetActive(false);
    }
    else if (loadSlotWindow.activeSelf)
    {
        SaveManager.instance.SelectedIndex = null;

        if (loadWindow.activeSelf)
        {
            loadWindow.SetActive(false);
        }
        else
        {
            loadSlotWindow.SetActive(false);
        }
    }
    else if (quitWindow.activeSelf)
    {
        quitWindow.SetActive(false);
    }
    else if (pauseMenu.activeSelf)
    {
        if (goToMainMenuWindow.activeSelf)
        {
            goToMainMenuWindow.SetActive(false);
        }
        else
        {
            gameTimeScale.SetTimeScale(1);
            if (!timelineHelper.IsTimelinePlaying())
            {
                isPlayerControlDisabled = false;
                playerSound.TogglePlayingAudioPause(false);

                if (PlatformSwitcher.instance.IsPCPlatform)
                {
                    Cursor.visible = false;
                    Cursor.lockState = CursorLockMode.Locked;
                }
                else
                {
                    Cursor.visible = true;
                    Cursor.lockState = CursorLockMode.Confined;
                }
            }
            else
            {
                Cursor.visible = true;
                Cursor.lockState = CursorLockMode.Confined;
            }
            pauseMenu.SetActive(false);
            ActivateLetterBox(false);
        }
    }
    else if (mainMenu.activeSelf)
    {
        SaveManager.instance.SelectedIndex = null;

        if (settingWindow.activeSelf)
        {
            settingWindow.SetActive(false);
        }
        else if (newGameWindow.activeSelf)
        {
            newGameWindow.SetActive(false);
        }
    }
    else
    {
        if (!canShowPauseMenu)
        {
            return;
        }
        gameTimeScale.SetTimeScale(0);
        isPlayerControlDisabled = true;

        playerSound.TogglePlayingAudioPause(true);

        pauseMenu.SetActive(true);
        ActivateLetterBox(true);

        Cursor.visible = true;
        Cursor.lockState = CursorLockMode.Confined;
    }
}

public IReadOnlyCollection<IPopup> ActivePopupStack { get; }
public IReadOnlyDictionary<PopupTypeEnum, IPopup> PopupRegistry { get; }

public void RegisterPopup(PopupTypeEnum popupTypeEnum, IPopup popup);
public void UnRegisterPopup(PopupTypeEnum popupTypeEnum, IPopup popup);
public void OpenPopup(PopupTypeEnum popupTypeEnum);
public void ClosePopup();

activePopupStack은 popupRegistry에서 팝업을 가져와 활성화·비활성화하고, popupRegistry는 초기에 의존성 주입으로 팝업 구현체를 등록하면서 해당 팝업의 열기/닫기 이벤트를 구독합니다.

public IReadOnlyCollection<IPopup> ActivePopupStack
{
    get { return activePopupStack; }
}
private Stack<IPopup> activePopupStack = new Stack<IPopup>();
private bool hasMainMenu;

public IReadOnlyDictionary<PopupTypeEnum, IPopup> PopupRegistry
{
    get { return popupRegistry; }
}
private Dictionary<PopupTypeEnum, IPopup> popupRegistry = new Dictionary<PopupTypeEnum, IPopup>();

등록과 동시에 이벤트를 구독하고, 해제와 동시에 구독을 끊습니다.

public void RegisterPopup(PopupTypeEnum popupTypeEnum, IPopup popup)
{
    popupRegistry.Add(popup.PopupID, popup);
    popup.PopupOpened += OpenPopup;
    popup.PopupClosed += ClosePopup;
    if (popup.PopupID == PopupTypeEnum.MainMenu)
    {
        hasMainMenu = true;
    }
}

public void UnRegisterPopup(PopupTypeEnum popupTypeEnum, IPopup popup)
{
    popupRegistry.Remove(popupTypeEnum);
    popup.PopupOpened -= OpenPopup;
    popup.PopupClosed -= ClosePopup;
}

외부 요청 신호(사용자 입력, UI 버튼 등)로 팝업 메서드가 호출됩니다. OpenPopup()은 스택에 팝업을 추가하고 활성화 함수를 호출하며, ClosePopup()은 맨 위 팝업의 비활성화 함수를 호출하고 제거합니다.

public void OpenPopup(PopupTypeEnum popupTypeEnum)
{
    if (!popupRegistry.ContainsKey(popupTypeEnum))
    {
        Debug.LogWarning("팝업을 찾을 수 없습니다: " + popupTypeEnum);
        return;
    }

    activePopupStack.Push(popupRegistry[popupTypeEnum]);
    activePopupStack.Peek().ActivatePopup();
}

public void ClosePopup()
{
    if (activePopupStack.Count <= 0)
    {
        if (!hasMainMenu)
        {
            OpenPopup(PopupTypeEnum.PauseMenu);
        }
        return;
    }

    activePopupStack.Peek().DeactivatePopup();
    activePopupStack.Pop();
}

public PopupTypeEnum PopupID { get; }
public bool IsActive { get; }

public event Action<PopupTypeEnum> PopupOpened;
public event Action PopupClosed;

public void ActivatePopup();
public void DeactivatePopup();

public void SetTransform();

PopupOpened는 팝업을 열어달라는, PopupClosed는 닫아달라는 외부 신호로 작용하는 이벤트입니다.

public PopupTypeEnum PopupID
{
    get { return popupType; }
}
[SerializeField] PopupTypeEnum popupType;

public bool IsActive
{
    get { return isActive; }
}
private bool isActive;

public event Action<PopupTypeEnum> PopupOpened;
public event Action PopupClosed;

[SerializeField] Vector3 rectPosition = new Vector2(0, 0);
[SerializeField] Vector2 rectSize = new Vector2(0, 0);
[SerializeField] Vector2 minAnchors = new Vector2(0, 0);
[SerializeField] Vector2 maxAnchors = new Vector2(0, 0);
[SerializeField] Vector2 pivot = new Vector2(0, 0);

public void ActivatePopup()
{
    isActive = true;
    this.gameObject.SetActive(true);
    SetTransform();
}

public void DeactivatePopup()
{
    isActive = false;
    this.gameObject.SetActive(false);
}

public void SetTransform()
{
    var rectTR = this.transform.GetComponent<RectTransform>();

    rectTR.anchoredPosition = rectPosition;
    rectTR.sizeDelta = rectSize;
    rectTR.anchorMin = maxAnchors;
    rectTR.anchorMax = minAnchors;
    rectTR.pivot = pivot;
}

protected void OpenPopup(PopupTypeEnum popupTypeEnum)
{
    PopupOpened.Invoke(popupTypeEnum);
}

protected void ClosePopup()
{
    PopupClosed.Invoke();
}

PopupBase를 상속받은 자식 클래스로, 팝업 관련 UI 요소들의 이벤트를 연결합니다.

[SerializeField] Button openPopupA;
[SerializeField] Button openPopupB;
[SerializeField] Button openPopupC;
[SerializeField] Button closePopup;

private void Start()
{
    AddOpenPopupEvent(openPopupA, PopupTypeEnum.A);
    AddOpenPopupEvent(openPopupB, PopupTypeEnum.B);
    AddOpenPopupEvent(openPopupC, PopupTypeEnum.C);
    AddClosePopupEvent(closePopup);
}

private void AddOpenPopupEvent(Button btn, PopupTypeEnum popupTypeEnum)
{
    btn.onClick.AddListener(() =>
    {
        OpenPopup(popupTypeEnum);
    });
}

private void AddClosePopupEvent(Button btn)
{
    btn.onClick.AddListener(() =>
    {
        ClosePopup();
    });
}