663 lines
29 KiB
C#
663 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine;
|
|
|
|
public class DialogPlayer : MonoBehaviour
|
|
{
|
|
// 대화 후보는 인스펙터가 아니라 StoryDatabase에서 온다 —
|
|
// 현재 장소(LocationManager.Current) + 이 캐릭터의 비트 중 조건을 만족하는 것들.
|
|
// 여럿이면 선택 메뉴가 뜨고, DB 목록에서 위에 있을수록 우선순위가 높다.
|
|
//
|
|
// CharacterVoiceObject는 선택이다:
|
|
// 있으면 → NPC 플레이어. 그 캐릭터의 비트(말을 걸어야 시작되는 대화)를 재생한다.
|
|
// 없으면 → 씬 플레이어. Character가 빈 "장소 비트"를 재생한다 (서술·진입 연출 등).
|
|
// LocationManager가 장소 입장 직후 자동으로 호출한다.
|
|
|
|
private CharacterVoiceObject _voice; // 이 NPC의 캐릭터 정보 (없으면 씬 플레이어)
|
|
private Animator _animator;
|
|
|
|
// 이 플레이어가 담당하는 캐릭터. 씬 플레이어는 null이고, 그게 곧 "장소 비트" 조회 키가 된다.
|
|
private CharacterData OwnerCharacter => _voice != null ? _voice.Character : null;
|
|
|
|
// 대화 중 제스처/표정을 재생한 Animator들의 원래 상태 — 대화 종료 시 전부 복원.
|
|
// (끼어든 다른 NPC의 Animator도 포함되므로 딕셔너리로 추적한다)
|
|
private readonly Dictionary<Animator, (int gestureHash, int expressionHash, bool hasExpression)> _touchedAnimators = new();
|
|
|
|
// 대화 중 포즈를 바꾼 캐릭터들의 원래 포즈 — 대화 종료 시 전부 복원.
|
|
// (끼어든 다른 NPC의 포즈도 포함되므로 Animator와 같은 방식으로 딕셔너리에 추적한다)
|
|
// 키가 인터페이스라 스프라이트 인물과 Live2D 인물이 한 딕셔너리에 섞여 들어간다.
|
|
private readonly Dictionary<ICharacterPoses, Pose> _touchedPoses = new();
|
|
public bool IsPlaying { get; private set; }
|
|
|
|
// 지금 실제 대사를 재생 중인 DialogPlayer (전역 1개) — 이때 다른 NPC의 Play()는 무시된다.
|
|
// 선택 메뉴만 떠 있는 단계는 여기 안 잡힌다 (그 경우는 새 NPC가 메뉴를 취소하고 시작).
|
|
private static DialogPlayer _entryInProgress;
|
|
|
|
// ── 전역 대화 진행 신호 (대화 중 월드 상호작용 차단용) ────────
|
|
// 선택 메뉴 단계부터 대사 종료까지, 어느 NPC든 대화가 진행 중이면 true.
|
|
// 이동 버튼·클릭 인터랙션 등이 AnyActiveChanged를 구독해 대화 중 입력을 잠그면 된다.
|
|
public static bool IsAnyActive => _activeCount > 0;
|
|
public static event Action<bool> AnyActiveChanged;
|
|
private static int _activeCount;
|
|
|
|
private static void PushActive()
|
|
{
|
|
if (++_activeCount == 1) AnyActiveChanged?.Invoke(true);
|
|
}
|
|
|
|
private static void PopActive()
|
|
{
|
|
if (_activeCount <= 0) return;
|
|
if (--_activeCount == 0) AnyActiveChanged?.Invoke(false);
|
|
}
|
|
|
|
// Enter Play Mode에서 도메인 리로드를 꺼도 이전 상태가 안 남게
|
|
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
|
|
private static void ResetStatics()
|
|
{
|
|
_entryInProgress = null;
|
|
_activeCount = 0;
|
|
AnyActiveChanged = null;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
_voice = GetComponent<CharacterVoiceObject>();
|
|
_animator = GetComponentInChildren<Animator>(); // 화자를 못 찾을 때의 폴백 Animator
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
// 재생 도중 파괴(씬 전환 등)돼도 전역 잠금이 남지 않도록
|
|
if (_entryInProgress == this) _entryInProgress = null;
|
|
}
|
|
|
|
// 장소 비트를 자동으로 시작한다 (LocationManager가 장소 입장 직후 호출).
|
|
// 선택 메뉴를 띄우지 않는다 — 메뉴는 플레이어가 "말을 건" 경우의 UI다.
|
|
public void PlayAuto() => _ = Play(autoSelect: true);
|
|
|
|
// 「이야기한다」 버튼용 — 선택 메뉴를 띄우고 대화를 시작한다.
|
|
// PlayAuto와 달리 후보가 여럿이면 DialogEnterHud로 고르게 한다. (UnityEvent 연결용 void)
|
|
public void Talk() => _ = Play();
|
|
|
|
// autoSelect가 true면 후보가 여럿이어도 메뉴 없이 최상단(우선순위 1위) 비트를 바로 재생한다.
|
|
public async Awaitable Play(bool autoSelect = false)
|
|
{
|
|
if (IsPlaying) return;
|
|
|
|
// 다른 NPC가 실제 대사를 재생 중이면 무시 — 대화 중 다른 NPC 상호작용 차단
|
|
if (_entryInProgress != null) return;
|
|
|
|
// 다른 NPC의 대화 선택 메뉴가 떠 있으면 먼저 취소한다.
|
|
// (취소된 쪽의 Play가 이 자리에서 HUD 숨김 등 정리를 마친 뒤에 이쪽이 시작된다)
|
|
if (DialogEnterHud.Instance != null)
|
|
DialogEnterHud.Instance.CancelPending();
|
|
|
|
// 선택 메뉴가 떠 있는 동안에도 재진입을 막아야 하므로 여기서 잠근다.
|
|
IsPlaying = true;
|
|
PushActive();
|
|
try
|
|
{
|
|
var playable = FindPlayableBeats();
|
|
if (playable.Count == 0)
|
|
{
|
|
Debug.Log($"[DialogPlayer] 조건에 맞는 대화가 없음: {name}");
|
|
return;
|
|
}
|
|
|
|
StoryBeat beat = playable.Count == 1 || autoSelect
|
|
? playable[0]
|
|
: await SelectBeat(playable);
|
|
if (beat == null) return; // 선택 대기 중 취소됨 (다른 NPC와 대화 시작, 씬 전환 등)
|
|
|
|
_entryInProgress = this; // 여기서부터 실제 대사 재생 — 끝날 때까지 다른 NPC 상호작용 무시
|
|
await PlayBeat(beat);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 대화 도중 선택지 대기가 취소됨 (씬 전환으로 ChoiceHud 비활성화 등) — PlayBeat의 finally에서 정리됨
|
|
}
|
|
finally
|
|
{
|
|
if (_entryInProgress == this) _entryInProgress = null;
|
|
IsPlaying = false;
|
|
PopActive();
|
|
}
|
|
}
|
|
|
|
// 조건/선택 메뉴를 건너뛰고 특정 대화 그룹을 강제로 시작한다 (버튼·컷신 등 UnityEvent 연결용).
|
|
// DB에 등록된 비트면 그 설정(진행도 보상 등)을 그대로 쓰고, 없으면 임시 비트로 재생한다.
|
|
// 완료 여부는 검사하지 않으므로(강제) 1회성이 필요하면 호출하는 쪽(존의 Trigger Once)에서 보장할 것.
|
|
public void PlayGroup(DialogGroup group)
|
|
{
|
|
_ = PlayGroupForced(group);
|
|
}
|
|
|
|
private async Awaitable PlayGroupForced(DialogGroup group)
|
|
{
|
|
if (group == null || IsPlaying) return;
|
|
if (_entryInProgress != null) return; // 다른 NPC가 대사 재생 중
|
|
|
|
// 다른 NPC의 대화 선택 메뉴가 떠 있으면 먼저 취소
|
|
if (DialogEnterHud.Instance != null)
|
|
DialogEnterHud.Instance.CancelPending();
|
|
|
|
IsPlaying = true;
|
|
PushActive();
|
|
try
|
|
{
|
|
// DB에 등록된 비트가 있으면 그 설정(진행도 보상 등)을 그대로 사용, 없으면 임시 비트로 재생
|
|
var lm = LocationManager.Instance;
|
|
StoryBeat beat = lm != null && lm.Database != null ? lm.Database.FindBeat(group) : null;
|
|
beat ??= new StoryBeat { Group = group };
|
|
|
|
_entryInProgress = this;
|
|
await PlayBeat(beat);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 씬 전환 등으로 취소됨 — PlayBeat의 finally에서 정리됨
|
|
}
|
|
finally
|
|
{
|
|
if (_entryInProgress == this) _entryInProgress = null;
|
|
IsPlaying = false;
|
|
PopActive();
|
|
}
|
|
}
|
|
|
|
// 현재 장소에서 이 캐릭터가 걸 수 있는 대화 비트들 (DB 목록 순서 = 우선순위)
|
|
private List<StoryBeat> FindPlayableBeats()
|
|
{
|
|
var lm = LocationManager.Instance;
|
|
if (lm == null || lm.Database == null)
|
|
{
|
|
Debug.LogWarning($"[DialogPlayer] LocationManager 또는 StoryDatabase가 없음: {name}");
|
|
return new List<StoryBeat>();
|
|
}
|
|
return lm.Database.GetPlayableBeats(lm.Current, OwnerCharacter);
|
|
}
|
|
|
|
// 재생 가능한 대화가 여럿일 때 DialogEnterHud로 플레이어에게 고르게 한다. 취소되면 null.
|
|
private async Awaitable<StoryBeat> SelectBeat(List<StoryBeat> playable)
|
|
{
|
|
if (DialogEnterHud.Instance == null)
|
|
return playable[0]; // 선택 UI가 없으면 기존처럼 최상단 우선
|
|
|
|
var options = new List<DialogChoice>(playable.Count);
|
|
foreach (var beat in playable)
|
|
{
|
|
string label = !string.IsNullOrWhiteSpace(beat.MenuLabel)
|
|
? beat.MenuLabel
|
|
: beat.Group.DialogGroupName;
|
|
options.Add(new DialogChoice { ChoiceText = label }); // Code 없음 → 선택 이력에 기록 안 됨
|
|
}
|
|
|
|
try
|
|
{
|
|
int picked = await DialogEnterHud.Instance.Show(options);
|
|
return playable[picked];
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 대기 중 DialogEnterHud가 비활성화됨(씬 전환 등) — 재생하지 않음
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async Awaitable PlayBeat(StoryBeat beat)
|
|
{
|
|
// 도달한 종료 노드가 정한다. 중간에 끊기면(씬 전환 등) false로 남아 장소 BGM으로 복귀한다.
|
|
bool keepBgmOnEnd = false;
|
|
|
|
try
|
|
{
|
|
var node = beat.Group.StartNode;
|
|
int routingHops = 0; // 연속 라우팅 횟수 — 라우팅 노드끼리 순환하면 대기 없는 무한 루프가 되므로 차단
|
|
while (node != null)
|
|
{
|
|
// 종료 노드 — 대화를 끝낸다. 분기마다 다른 종료 노드를 둘 수 있어서
|
|
// "이 루트는 BGM 유지, 저 루트는 복귀"가 각각 정해진다.
|
|
if (node.Kind == DialogNodeKind.End)
|
|
{
|
|
keepBgmOnEnd = node.KeepBgmOnEnd;
|
|
break;
|
|
}
|
|
|
|
// 호감도 라우팅 노드 — 대사 없이 즉시 분기 (플레이어에겐 분기 자체가 보이지 않는다)
|
|
if (node.Kind == DialogNodeKind.AffectionCheck)
|
|
{
|
|
if (++routingHops > 100)
|
|
{
|
|
Debug.LogError($"[DialogPlayer] 라우팅 노드가 순환합니다 — 대화 중단: {beat.Group.name}");
|
|
break;
|
|
}
|
|
node = IsAffectionMet(node) ? node.AffectionPassBranch : node.Next;
|
|
continue;
|
|
}
|
|
routingHops = 0; // 실제 대사 노드에 도달 — 카운터 리셋
|
|
|
|
// 이 노드가 히든 분기를 가지면, 노드가 재생되는 동안 발동 감시를 무장한다.
|
|
// (무장 안 된 노드는 아래 대기/선택이 기존과 완전히 동일하게 동작)
|
|
bool armed = node.HiddenBranches != null && node.HiddenBranches.Count > 0;
|
|
if (armed) HiddenBranchResolver.Arm(node.HiddenBranches);
|
|
try
|
|
{
|
|
bool diverted = await PlayNode(node); // 대사 표시 + 대기(무장 시 발동 감시 포함)
|
|
|
|
if (diverted)
|
|
{
|
|
node = TakeHiddenBranch(node); // 대사 도중 발동 → 몰래 분기
|
|
}
|
|
else if (node.Choices != null && node.Choices.Count > 0)
|
|
{
|
|
int picked = await WaitForChoice(node); // 메뉴(무장 시 발동 감시 포함)
|
|
if (picked == DivertIndex)
|
|
{
|
|
node = TakeHiddenBranch(node); // 메뉴 도중 발동 → 메뉴엔 없던 히든 분기
|
|
}
|
|
else
|
|
{
|
|
RecordChoice(node, picked);
|
|
node = node.Choices[picked].DestinationNode;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
node = node.Next;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (armed) HiddenBranchResolver.Disarm();
|
|
}
|
|
}
|
|
|
|
// 여기까지 왔으면 자연 종료(끝까지 재생) — 이때만 완료로 기록한다.
|
|
// (중간에 오브젝트 파괴 등으로 끊기면 예외로 빠져나가 기록되지 않음)
|
|
var story = StoryManager.Instance;
|
|
bool firstTime = story.MarkDialogCompleted(beat.Group.name);
|
|
if (firstTime && beat.ProgressOnComplete > 0)
|
|
story.MainProgress += beat.ProgressOnComplete;
|
|
story.Save();
|
|
|
|
Debug.Log($"[DialogPlayer] 대화 종료: {beat.Group.name}");
|
|
}
|
|
finally
|
|
{
|
|
if (DialogHud.Instance != null)
|
|
DialogHud.Instance.Hide();
|
|
|
|
// 대화 BGM 처리 — 도달한 종료 노드가 Keep BGM이면 마지막 곡을 그대로 유지하고,
|
|
// 아니면 장소 BGM으로 복귀한다.
|
|
if (SoundManager.Instance != null && !keepBgmOnEnd)
|
|
SoundManager.Instance.ClearOverrideBGM();
|
|
|
|
// 장면 그림과 앞/옆 그림은 대화 전용이라 대화가 끝나면 무조건 걷는다
|
|
if (SceneScreen.Instance != null) SceneScreen.Instance.Hide();
|
|
if (FrontSprite.Instance != null) FrontSprite.Instance.Hide();
|
|
if (SideSprite.Instance != null) SideSprite.Instance.Hide();
|
|
|
|
RestoreDefaultPoses();
|
|
RestoreDefaultAnimations();
|
|
}
|
|
}
|
|
|
|
// 대화 중 제스처/표정을 재생했던 모든 Animator(끼어든 NPC 포함)를 원래 상태로 복원
|
|
private void RestoreDefaultAnimations()
|
|
{
|
|
foreach (var kvp in _touchedAnimators)
|
|
{
|
|
var anim = kvp.Key;
|
|
if (anim == null) continue;
|
|
anim.CrossFade(kvp.Value.gestureHash, 0.3f, 0, normalizedTimeOffset: 0f);
|
|
if (kvp.Value.hasExpression)
|
|
anim.CrossFade(kvp.Value.expressionHash, 0.3f, 1, normalizedTimeOffset: 0f);
|
|
}
|
|
_touchedAnimators.Clear();
|
|
}
|
|
|
|
// 처음 건드리는 Animator면 현재 상태를 기억해 둔다 (대화 종료 시 복원 기준)
|
|
private void CaptureInitialAnimState(Animator anim)
|
|
{
|
|
if (_touchedAnimators.ContainsKey(anim)) return;
|
|
bool hasExpression = anim.layerCount > 1;
|
|
_touchedAnimators[anim] = (
|
|
anim.GetCurrentAnimatorStateInfo(0).fullPathHash,
|
|
hasExpression ? anim.GetCurrentAnimatorStateInfo(1).fullPathHash : 0,
|
|
hasExpression);
|
|
}
|
|
|
|
// 반환: true = 대기 도중 히든 제스처가 발동됨(→ HiddenBranch로 분기), false = 평범하게 진행
|
|
private async Awaitable<bool> PlayNode(DialogNode node)
|
|
{
|
|
// DialogHud에 대사 표시 (이름은 노드 오버라이드 우선, 타이핑 연출도 노드 지정이 우선)
|
|
if (DialogHud.Instance != null)
|
|
DialogHud.Instance.Show(node.Speaker, node.TalkText, node.SpeakerNameOverride, node.Typewriter);
|
|
|
|
// 호감도 증감 — 화자 기준, 화자가 비어 있으면 대화 주인 NPC
|
|
if (node.Affection != 0)
|
|
{
|
|
var affectionTarget = node.Speaker != null ? node.Speaker : OwnerCharacter;
|
|
StoryManager.Instance.AddAffection(affectionTarget, node.Affection);
|
|
}
|
|
|
|
// 메인 진행도 증가 — 분기 끝 노드마다 다른 값을 주면 선택지에 따라 진행도가 달라진다
|
|
if (node.Progress != 0)
|
|
StoryManager.Instance.MainProgress += node.Progress;
|
|
|
|
// BGM: 지정된 노드에서만 갈아타고, 다시 바꾸기 전까지 계속 이어진다.
|
|
// 비어 있으면 "변경 없음" — 모든 노드에 같은 곡을 넣어줄 필요가 없다.
|
|
if (node.Bgm != null && SoundManager.Instance != null)
|
|
SoundManager.Instance.PlayOverrideBGM(node.Bgm);
|
|
|
|
// 1회성 효과음 — 이 대사가 뜨는 순간 한 번 재생된다
|
|
if (node.Sfx != null && SoundManager.Instance != null)
|
|
SoundManager.Instance.PlaySFX(node.Sfx);
|
|
|
|
// 포즈 + 화면 그림
|
|
ApplyStageVisuals(node);
|
|
|
|
// 보이스 재생
|
|
if (node.Voice != null && node.Speaker != null)
|
|
{
|
|
var voiceObj = CharacterVoiceObject.Find(node.Speaker);
|
|
if (voiceObj != null && node.Voice.Clip != null)
|
|
voiceObj.Play(node.Voice.Clip);
|
|
}
|
|
|
|
// 제스처/표정은 화자(Target)의 Animator에 적용 — 끼어든 NPC의 대사/연출 노드도 그 캐릭터가 움직인다.
|
|
// 화자를 못 찾으면 대화 주인 NPC의 Animator로 폴백.
|
|
if (node.Gesture != null || node.Expression != null)
|
|
{
|
|
var gestureObj = node.Speaker != null ? CharacterVoiceObject.Find(node.Speaker) : null;
|
|
var anim = gestureObj != null ? gestureObj.GetComponentInChildren<Animator>() : _animator;
|
|
if (anim == null) anim = _animator;
|
|
|
|
if (anim != null)
|
|
{
|
|
CaptureInitialAnimState(anim); // 대화 종료 시 복원할 원래 상태 기억
|
|
if (node.Gesture != null)
|
|
anim.CrossFade(node.Gesture.StateName, node.Gesture.CrossFadeDuration, node.Gesture.AnimationLayer);
|
|
if (node.Expression != null)
|
|
anim.CrossFade(node.Expression.StateName, node.Expression.CrossFadeDuration, node.Expression.AnimationLayer);
|
|
}
|
|
}
|
|
|
|
// 진행은 항상 플레이어 입력 대기.
|
|
// 히든 분기가 무장된 노드는 대기 중 히든 발동을 함께 감시(레이스)한다.
|
|
if (HiddenBranchResolver.Armed)
|
|
return await WaitAdvanceOrDivert();
|
|
|
|
await WaitForAdvanceInput();
|
|
return false;
|
|
}
|
|
|
|
// 노드가 지정한 무대 연출을 반영한다. 넷의 수명 규칙이 각각 다르다:
|
|
// Pose — 지속. '변경 없음'이 기본이라 인물이 서 있는 동안 다시 꽂을 필요가 없다
|
|
// SceneScreen — 지정한 대사에서만. 비우면 사라진다 (배경 앞·캐릭터 뒤 장면 그림)
|
|
// FrontSprite — 1회성. 지정 안 한 노드에선 사라진다 ("이의있음!" 같은 번쩍 연출)
|
|
// SideSprite — 지정한 대사에서만. 비우면 사라진다
|
|
// Pose 말고 셋은 Show(null)이 곧 Hide라, 노드 값을 그대로 넘기면 두 경우가 한 줄로 처리된다.
|
|
private void ApplyStageVisuals(DialogNode node)
|
|
{
|
|
if (SceneScreen.Instance != null) SceneScreen.Instance.Show(node.SceneScreen);
|
|
if (FrontSprite.Instance != null) FrontSprite.Instance.Show(node.FrontSprite);
|
|
if (SideSprite.Instance != null) SideSprite.Instance.Show(node.SideSprite);
|
|
|
|
if (node.Pose == Pose.Keep) return; // 변경 없음 — 지금 포즈를 그대로 둔다
|
|
|
|
// 대상을 안 정했으면 아무 일도 하지 않는다.
|
|
// 화자나 장소 인물로 자동 유추할 수도 있지만, 그러면 "누가 바뀌는지"가 노드만 봐서는
|
|
// 보이지 않는다. 말하는 사람과 화면에 비치는 사람이 다를 수 있는 이상 명시를 요구하는 편이 낫다.
|
|
if (node.PoseTarget == null)
|
|
{
|
|
Debug.LogWarning($"[DialogPlayer] Pose({node.Pose})를 지정했으나 Pose Target이 비어 있음 — 무시");
|
|
return;
|
|
}
|
|
|
|
var poses = FindPoses(node.PoseTarget);
|
|
if (poses == null)
|
|
{
|
|
Debug.LogWarning($"[DialogPlayer] {node.PoseTarget.name}의 CharacterPoses를 찾지 못함 — 포즈 무시");
|
|
return;
|
|
}
|
|
|
|
// 대화 종료 시 복원할 원래 포즈를 처음 건드릴 때만 기억한다
|
|
if (!_touchedPoses.ContainsKey(poses)) _touchedPoses[poses] = poses.Current;
|
|
poses.Apply(node.Pose);
|
|
}
|
|
|
|
// 포즈를 적용할 대상의 포즈 구현. 그 캐릭터가 지금 씬에 없으면 null.
|
|
// 제스처/표정과 달리 화자를 전혀 보지 않는다 — 대상은 노드가 명시한 것 하나뿐이다.
|
|
// 스프라이트(CharacterPoses)든 Live2D(CubismCharacterPoses)든 인터페이스로 받으므로
|
|
// 대화 그래프는 그 인물이 어느 쪽인지 알 필요가 없다.
|
|
private static ICharacterPoses FindPoses(CharacterData target)
|
|
{
|
|
var obj = CharacterVoiceObject.Find(target);
|
|
return obj != null ? obj.GetComponentInChildren<ICharacterPoses>(includeInactive: true) : null;
|
|
}
|
|
|
|
// 대화 중 포즈를 바꾼 모든 캐릭터(끼어든 NPC 포함)를 원래 포즈로 복원
|
|
private void RestoreDefaultPoses()
|
|
{
|
|
foreach (var kvp in _touchedPoses)
|
|
{
|
|
// 인터페이스 참조로는 Unity의 "파괴됨" 검사가 안 걸린다(그냥 C# 널 비교가 된다).
|
|
// 씬 전환으로 오브젝트가 사라졌을 수 있으므로 Object로 보고 확인한다.
|
|
if (kvp.Key as UnityEngine.Object != null)
|
|
kvp.Key.Apply(kvp.Value);
|
|
}
|
|
_touchedPoses.Clear();
|
|
}
|
|
|
|
// 호감도 분기 노드의 조건식 평가.
|
|
// 각 조건의 JoinWithNext로 이어 붙이며, AND가 OR보다 우선순위가 높다:
|
|
// A and B or C → (A and B) or C
|
|
// 즉 "AND 그룹들을 OR로 합치는" 형태로 계산한다. 조건이 없으면 통과로 본다.
|
|
private bool IsAffectionMet(DialogNode node)
|
|
{
|
|
var requirements = node.AffectionRequirements;
|
|
if (requirements == null || requirements.Count == 0) return true;
|
|
|
|
var story = StoryManager.Instance;
|
|
bool result = false; // 지금까지 닫힌 AND 그룹들을 OR로 합친 값
|
|
bool group = true; // 현재 진행 중인 AND 그룹
|
|
|
|
for (int i = 0; i < requirements.Count; i++)
|
|
{
|
|
var req = requirements[i];
|
|
if (req == null) continue;
|
|
|
|
var target = req.Character != null ? req.Character : OwnerCharacter;
|
|
group &= req.IsMet(story.GetAffection(target));
|
|
|
|
// 다음 연결자가 OR이거나 마지막이면 AND 그룹을 닫고 OR로 합친다
|
|
bool isLast = i == requirements.Count - 1;
|
|
if (isLast || req.JoinWithNext == AffectionJoin.Or)
|
|
{
|
|
result |= group;
|
|
group = true;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// 선택 기록: 선택지 Code를 StoryState에 영구 기록 (대화 활성화 조건 판정에 사용)
|
|
private void RecordChoice(DialogNode node, int index)
|
|
{
|
|
string code = (node.Choices != null && index >= 0 && index < node.Choices.Count)
|
|
? node.Choices[index].Code : null;
|
|
code = DialogVariables.Format(code); // {token} 치환 → 동적으로 생성된 코드 반영
|
|
|
|
if (!string.IsNullOrEmpty(code))
|
|
StoryManager.Instance.RecordChoice(code);
|
|
}
|
|
|
|
// 발동한 히든 분기로 이동한다. 어느 분기가 발동했는지는 Resolver가 키를 보고 이미 골라 뒀다.
|
|
// (Disarm보다 먼저 불려야 하므로 반드시 무장 구간 안에서 호출할 것)
|
|
private DialogNode TakeHiddenBranch(DialogNode node)
|
|
{
|
|
int index = HiddenBranchResolver.FiredIndex;
|
|
if (node.HiddenBranches == null || index < 0 || index >= node.HiddenBranches.Count)
|
|
{
|
|
// 정상 흐름에선 올 수 없다(발동 = 매칭 성공). 와도 대화가 끊기지 않게 원래 흐름으로.
|
|
Debug.LogWarning($"[DialogPlayer] 히든 분기 인덱스가 범위를 벗어남: {index}");
|
|
return node.Next;
|
|
}
|
|
|
|
var branch = node.HiddenBranches[index];
|
|
|
|
// 선택지 Code와 동일하게 StoryState에 영구 기록
|
|
string code = DialogVariables.Format(branch.Code); // {token} 치환
|
|
if (!string.IsNullOrEmpty(code))
|
|
StoryManager.Instance.RecordChoice(code);
|
|
|
|
return branch.Destination;
|
|
}
|
|
|
|
// 히든 분기 신호값 — 선택지 인덱스(0..n-1)와 절대 겹치지 않는 값.
|
|
private const int DivertIndex = -1;
|
|
|
|
private async Awaitable<int> WaitForChoice(DialogNode node)
|
|
{
|
|
if (ChoiceHud.Instance == null)
|
|
{
|
|
Debug.LogWarning("[DialogPlayer] ChoiceHud 없음 — 0번 자동 선택");
|
|
return 0;
|
|
}
|
|
|
|
// 무장 안 된 노드는 기존과 동일 — 그냥 메뉴 선택을 기다린다.
|
|
if (!HiddenBranchResolver.Armed)
|
|
return await ChoiceHud.Instance.Show(node.ChoiceQuestion, node.Choices);
|
|
|
|
// 무장된 노드: 메뉴가 떠 있는 동안 발동이 들어오면 메뉴를 취소하고 히든으로 분기.
|
|
if (HiddenBranchResolver.Fired)
|
|
return DivertIndex; // 메뉴가 뜨기 전에 이미 발동한 경우
|
|
|
|
void OnFired() => ChoiceHud.Instance.CancelPending(); // 발동 → 메뉴 즉시 취소
|
|
HiddenBranchResolver.FiredEvent += OnFired;
|
|
try
|
|
{
|
|
return await ChoiceHud.Instance.Show(node.ChoiceQuestion, node.Choices);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 우리가 히든 발동으로 취소한 것이면 히든 분기, 아니면(씬 전환 등) 위로 전파
|
|
if (HiddenBranchResolver.Fired) return DivertIndex;
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
HiddenBranchResolver.FiredEvent -= OnFired;
|
|
}
|
|
}
|
|
|
|
// 노드 대기 + 히든 발동 감시(레이스). 무장된 노드에서만 호출된다.
|
|
// 반환: true = 대기 도중 히든 발동(→히든 분기), false = 평범하게 진행(입력)
|
|
private async Awaitable<bool> WaitAdvanceOrDivert()
|
|
{
|
|
var im = InputManager.Instance;
|
|
bool advance = false;
|
|
void OnAdvance() => advance = true;
|
|
if (im != null) im.OnDialogNext_Event += OnAdvance;
|
|
|
|
// InputManager가 없으면 기존 WaitForAdvanceInput처럼 1초 후 진행
|
|
float timeLeft = im == null ? 1f : -1f;
|
|
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (HiddenBranchResolver.Fired) return true; // 히든 발동 → 히든 분기
|
|
if (advance)
|
|
{
|
|
advance = false;
|
|
// 타이핑 중이었으면 이 입력은 "전체 표시"에 쓰고 계속 기다린다
|
|
if (!TrySkipReveal()) return false; // 이미 다 나옴 → 평범하게 진행
|
|
}
|
|
if (timeLeft >= 0f)
|
|
{
|
|
timeLeft -= Time.deltaTime;
|
|
if (timeLeft <= 0f) return false;
|
|
}
|
|
await Awaitable.NextFrameAsync(destroyCancellationToken);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return false; // 대기 중 파괴/씬 전환 — 기존과 동일하게 조용히 종료
|
|
}
|
|
finally
|
|
{
|
|
if (im != null) im.OnDialogNext_Event -= OnAdvance;
|
|
}
|
|
}
|
|
|
|
// 대사가 아직 드러나는 중이면 전체 표시로 건너뛰고 true.
|
|
// 이미 다 나와 있으면 false — 그 입력은 다음 노드로 넘어가는 데 쓰인다.
|
|
private static bool TrySkipReveal()
|
|
{
|
|
var hud = DialogHud.Instance;
|
|
if (hud == null || !hud.IsRevealing) return false;
|
|
hud.SkipReveal();
|
|
return true;
|
|
}
|
|
|
|
// 대화 진행 입력(OnDialogNext) 한 번을 대기 (타이핑 중이면 첫 입력은 전체 표시에 쓰인다)
|
|
private async Awaitable WaitForAdvanceInput()
|
|
{
|
|
var im = InputManager.Instance;
|
|
if (im == null)
|
|
{
|
|
// 입력 매니저 없으면 안전하게 잠깐 대기 후 진행
|
|
await Awaitable.WaitForSecondsAsync(1f);
|
|
return;
|
|
}
|
|
|
|
bool pressed = false;
|
|
void Handler() => pressed = true;
|
|
im.OnDialogNext_Event += Handler;
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (pressed)
|
|
{
|
|
pressed = false;
|
|
// 타이핑 중이었으면 이 입력은 "전체 표시"에 쓰고 계속 기다린다
|
|
if (!TrySkipReveal()) break; // 이미 다 나옴 → 다음 노드로
|
|
}
|
|
await Awaitable.NextFrameAsync(destroyCancellationToken);
|
|
}
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 대기 중 오브젝트 파괴 시 조용히 종료
|
|
}
|
|
finally
|
|
{
|
|
im.OnDialogNext_Event -= Handler;
|
|
}
|
|
}
|
|
|
|
//테스트용 — 캐릭터를 클릭하면 대화 시작 (Collider2D가 있어야 잡힌다)
|
|
private void Update()
|
|
{
|
|
if (_voice == null) return; //씬 플레이어(장소 비트 담당)는 클릭 대상이 아니다
|
|
if (Mouse.current == null) return;
|
|
if (!Mouse.current.leftButton.wasPressedThisFrame) return;
|
|
if (Camera.main == null) return;
|
|
|
|
var world = Camera.main.ScreenToWorldPoint(Mouse.current.position.ReadValue());
|
|
var hit = Physics2D.OverlapPoint(world);
|
|
if (hit != null && hit.transform.IsChildOf(transform))
|
|
{
|
|
Debug.Log("캐릭터 클릭");
|
|
_ = Play(); // 테스트용 fire-and-forget (Update는 await 불가)
|
|
}
|
|
}
|
|
}
|