439 lines
15 KiB
C#
439 lines
15 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
[DisallowMultipleComponent]
|
|
public class FootprintHintManager : MonoBehaviour
|
|
{
|
|
[Header("VR Player Reference")]
|
|
[Tooltip("XR Origin의 Main Camera Transform을 넣는 것을 추천합니다.")]
|
|
[SerializeField] private Transform playerTarget;
|
|
|
|
[Header("Footprint Prefabs")]
|
|
[SerializeField] private GameObject leftFootPrefab;
|
|
[SerializeField] private GameObject rightFootPrefab;
|
|
|
|
[Header("Footprint Settings")]
|
|
[SerializeField] private int footprintCount = 6;
|
|
[SerializeField] private float spacing = 0.5f;
|
|
[SerializeField] private float sideOffset = 0.13f;
|
|
[SerializeField] private float showTime = 3f;
|
|
[SerializeField] private float revealInterval = 0.08f;
|
|
[SerializeField] private bool startWithLeftFoot = true;
|
|
[SerializeField] private Transform footprintParent;
|
|
|
|
[Header("Effect Lifetime")]
|
|
[Tooltip("FootprintEffect처럼 발자국 프리팹이 스스로 페이드아웃 후 삭제되는 경우 체크하세요.")]
|
|
[SerializeField] private bool footprintsAutoDestroy = true;
|
|
[Tooltip("발자국이 스스로 삭제된 뒤 리스트에서 빈 참조를 정리하기 전까지 기다리는 시간입니다.")]
|
|
[SerializeField] private float autoDestroyCleanupDelay = 1.5f;
|
|
[Tooltip("Footprints Auto Destroy가 켜져 있는데 프리팹에 FootprintEffect가 없으면 안전하게 자동 삭제합니다.")]
|
|
[SerializeField] private bool destroyIfMissingFootprintEffect = true;
|
|
[Tooltip("FootprintEffect가 없는 프리팹을 강제 삭제할 때 추가로 기다릴 시간입니다.")]
|
|
[SerializeField] private float fallbackDestroyDelay = 1f;
|
|
|
|
[Header("Footprint Rotation Offset")]
|
|
[Tooltip("왼발 프리팹 방향이 살짝 어긋난 경우 여기서 보정합니다.")]
|
|
[SerializeField] private Vector3 leftFootRotationOffset = Vector3.zero;
|
|
[Tooltip("오른발 프리팹 방향이 살짝 어긋난 경우 여기서 보정합니다.")]
|
|
[SerializeField] private Vector3 rightFootRotationOffset = Vector3.zero;
|
|
|
|
[Header("Ground Settings")]
|
|
[SerializeField] private bool useGroundRaycast = true;
|
|
[Tooltip("가급적 Ground 레이어만 선택하세요. Everything이면 벽이나 다른 오브젝트를 바닥으로 착각할 수 있습니다.")]
|
|
[SerializeField] private LayerMask groundMask = ~0;
|
|
[SerializeField] private float raycastHeight = 2f;
|
|
[SerializeField] private float raycastDistance = 5f;
|
|
[SerializeField] private float groundOffset = 0.03f;
|
|
[SerializeField] private float fallbackGroundY = 0f;
|
|
|
|
[Header("Obstacle Settings")]
|
|
[Tooltip("체크하면 발자국이 Wall 레이어를 뚫고 생성되지 않도록 벽 앞에서 멈춥니다.")]
|
|
[SerializeField] private bool stopAtObstacle = true;
|
|
[Tooltip("벽/장애물 레이어만 선택하세요. 예: Wall")]
|
|
[SerializeField] private LayerMask obstacleMask;
|
|
[Tooltip("바닥에서 어느 높이에서 벽을 검사할지 정합니다.")]
|
|
[SerializeField] private float obstacleCheckHeight = 0.45f;
|
|
[Tooltip("벽 감지 SphereCast 반지름입니다. 발자국 폭보다 작게 두는 것을 추천합니다.")]
|
|
[SerializeField] private float obstacleCheckRadius = 0.08f;
|
|
[Tooltip("벽에 너무 붙어서 발자국이 생성되지 않도록 여유 거리를 둡니다.")]
|
|
[SerializeField] private float obstaclePadding = 0.12f;
|
|
|
|
[Header("Debug")]
|
|
[SerializeField] private bool showDebugLogs = false;
|
|
[SerializeField] private bool drawDebugPath = true;
|
|
[SerializeField] private Color debugPathColor = Color.cyan;
|
|
[SerializeField] private Color debugBlockedColor = Color.red;
|
|
|
|
private readonly List<GameObject> spawnedFootprints = new List<GameObject>();
|
|
private Coroutine footprintRoutine;
|
|
private Coroutine cleanupRoutine;
|
|
|
|
private void OnDisable()
|
|
{
|
|
ClearFootprints();
|
|
}
|
|
|
|
public void SetPlayerTarget(Transform target)
|
|
{
|
|
playerTarget = target;
|
|
}
|
|
|
|
public void ShowFootprints(MazeDirection direction)
|
|
{
|
|
ShowFootprints(direction, -1, -1f);
|
|
}
|
|
|
|
public void ShowFootprints(MazeDirection direction, int countOverride, float showTimeOverride)
|
|
{
|
|
if (playerTarget == null)
|
|
{
|
|
Debug.LogWarning("FootprintHintManager: Player Target is missing.", this);
|
|
return;
|
|
}
|
|
|
|
Vector3 moveDirection = GetWorldDirection(direction);
|
|
ShowFootprintsAlongWorldDirection(moveDirection, countOverride, showTimeOverride);
|
|
}
|
|
|
|
public void ShowFootprintsToTarget(Transform target)
|
|
{
|
|
ShowFootprintsToTarget(target, -1, -1f);
|
|
}
|
|
|
|
public void ShowFootprintsToTarget(Transform target, int countOverride, float showTimeOverride)
|
|
{
|
|
if (target == null)
|
|
{
|
|
Debug.LogWarning("FootprintHintManager: Target is missing.", this);
|
|
return;
|
|
}
|
|
|
|
ShowFootprintsToPosition(target.position, countOverride, showTimeOverride);
|
|
}
|
|
|
|
public void ShowFootprintsToPosition(Vector3 targetPosition)
|
|
{
|
|
ShowFootprintsToPosition(targetPosition, -1, -1f);
|
|
}
|
|
|
|
public void ShowFootprintsToPosition(Vector3 targetPosition, int countOverride, float showTimeOverride)
|
|
{
|
|
if (playerTarget == null)
|
|
{
|
|
Debug.LogWarning("FootprintHintManager: Player Target is missing.", this);
|
|
return;
|
|
}
|
|
|
|
Vector3 moveDirection = targetPosition - playerTarget.position;
|
|
moveDirection.y = 0f;
|
|
|
|
ShowFootprintsAlongWorldDirection(moveDirection, countOverride, showTimeOverride);
|
|
}
|
|
|
|
public void ShowFootprintsAlongWorldDirection(Vector3 worldDirection)
|
|
{
|
|
ShowFootprintsAlongWorldDirection(worldDirection, -1, -1f);
|
|
}
|
|
|
|
public void ShowFootprintsAlongWorldDirection(Vector3 worldDirection, int countOverride, float showTimeOverride)
|
|
{
|
|
worldDirection.y = 0f;
|
|
|
|
if (worldDirection.sqrMagnitude < 0.001f)
|
|
{
|
|
if (showDebugLogs)
|
|
Debug.Log("FootprintHintManager: Direction is too small. Hint skipped.", this);
|
|
|
|
return;
|
|
}
|
|
|
|
worldDirection.Normalize();
|
|
|
|
StopRunningRoutines();
|
|
footprintRoutine = StartCoroutine(
|
|
ShowFootprintRoutine(worldDirection, countOverride, showTimeOverride)
|
|
);
|
|
}
|
|
|
|
private IEnumerator ShowFootprintRoutine(Vector3 moveDirection, int countOverride, float showTimeOverride)
|
|
{
|
|
ClearSpawnedFootprintsOnly();
|
|
|
|
if (playerTarget == null)
|
|
{
|
|
Debug.LogWarning("FootprintHintManager: Player Target is missing.", this);
|
|
footprintRoutine = null;
|
|
yield break;
|
|
}
|
|
|
|
if (leftFootPrefab == null || rightFootPrefab == null)
|
|
{
|
|
Debug.LogWarning("FootprintHintManager: Left Foot Prefab or Right Foot Prefab is missing.", this);
|
|
footprintRoutine = null;
|
|
yield break;
|
|
}
|
|
|
|
int countToUse = countOverride > 0 ? countOverride : footprintCount;
|
|
float showTimeToUse = showTimeOverride > 0f ? showTimeOverride : showTime;
|
|
|
|
Vector3 origin = playerTarget.position;
|
|
Vector3 sideDirection = Vector3.Cross(Vector3.up, moveDirection).normalized;
|
|
Vector3 lastPathCenter = origin;
|
|
|
|
if (showDebugLogs)
|
|
Debug.Log($"FootprintHintManager: Show footprints. Count={countToUse}, Direction={moveDirection}", this);
|
|
|
|
for (int i = 0; i < countToUse; i++)
|
|
{
|
|
bool isLeftFoot = startWithLeftFoot ? i % 2 == 0 : i % 2 != 0;
|
|
GameObject prefabToUse = isLeftFoot ? leftFootPrefab : rightFootPrefab;
|
|
|
|
float forwardDistance = spacing * (i + 1);
|
|
float leftRightOffset = isLeftFoot ? -sideOffset : sideOffset;
|
|
|
|
Vector3 pathCenter = origin + moveDirection * forwardDistance;
|
|
|
|
bool blocked = stopAtObstacle && IsBlockedByObstacle(lastPathCenter, pathCenter);
|
|
|
|
if (drawDebugPath)
|
|
Debug.DrawLine(lastPathCenter + Vector3.up * 0.05f, pathCenter + Vector3.up * 0.05f, blocked ? debugBlockedColor : debugPathColor, 2f);
|
|
|
|
if (blocked)
|
|
{
|
|
if (showDebugLogs)
|
|
Debug.Log($"FootprintHintManager: Footprints stopped by obstacle at index {i}.", this);
|
|
|
|
break;
|
|
}
|
|
|
|
Vector3 spawnPosition = pathCenter + sideDirection * leftRightOffset;
|
|
Quaternion spawnRotation = Quaternion.LookRotation(moveDirection, Vector3.up);
|
|
|
|
PlaceOnGround(ref spawnPosition, ref spawnRotation, moveDirection);
|
|
|
|
Vector3 rotationOffset = isLeftFoot ? leftFootRotationOffset : rightFootRotationOffset;
|
|
Quaternion finalRotation = spawnRotation * Quaternion.Euler(rotationOffset);
|
|
|
|
GameObject footprint = footprintParent != null
|
|
? Instantiate(prefabToUse, spawnPosition, finalRotation, footprintParent)
|
|
: Instantiate(prefabToUse, spawnPosition, finalRotation);
|
|
|
|
spawnedFootprints.Add(footprint);
|
|
ScheduleFallbackDestroyIfNeeded(footprint, showTimeToUse);
|
|
lastPathCenter = pathCenter;
|
|
|
|
if (revealInterval > 0f)
|
|
yield return new WaitForSeconds(revealInterval);
|
|
}
|
|
|
|
if (showTimeToUse > 0f)
|
|
yield return new WaitForSeconds(showTimeToUse);
|
|
|
|
if (footprintsAutoDestroy)
|
|
{
|
|
cleanupRoutine = StartCoroutine(CleanupDestroyedFootprintsAfterDelay(autoDestroyCleanupDelay));
|
|
}
|
|
else
|
|
{
|
|
ClearSpawnedFootprintsOnly();
|
|
}
|
|
|
|
footprintRoutine = null;
|
|
}
|
|
|
|
private void ScheduleFallbackDestroyIfNeeded(GameObject footprint, float showTimeToUse)
|
|
{
|
|
if (!footprintsAutoDestroy || !destroyIfMissingFootprintEffect || footprint == null)
|
|
return;
|
|
|
|
FootprintEffect effect = footprint.GetComponentInChildren<FootprintEffect>(true);
|
|
|
|
if (effect != null)
|
|
return;
|
|
|
|
Destroy(footprint, Mathf.Max(0f, showTimeToUse + fallbackDestroyDelay));
|
|
}
|
|
|
|
private Vector3 GetWorldDirection(MazeDirection direction)
|
|
{
|
|
Vector3 forward = playerTarget.forward;
|
|
Vector3 right = playerTarget.right;
|
|
|
|
forward.y = 0f;
|
|
right.y = 0f;
|
|
|
|
if (forward.sqrMagnitude > 0.001f)
|
|
forward.Normalize();
|
|
|
|
if (right.sqrMagnitude > 0.001f)
|
|
right.Normalize();
|
|
|
|
switch (direction)
|
|
{
|
|
case MazeDirection.Forward:
|
|
return forward;
|
|
|
|
case MazeDirection.Backward:
|
|
return -forward;
|
|
|
|
case MazeDirection.Left:
|
|
return -right;
|
|
|
|
case MazeDirection.Right:
|
|
return right;
|
|
|
|
case MazeDirection.None:
|
|
default:
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
private void PlaceOnGround(ref Vector3 position, ref Quaternion rotation, Vector3 moveDirection)
|
|
{
|
|
if (!useGroundRaycast)
|
|
{
|
|
position.y = fallbackGroundY + groundOffset;
|
|
return;
|
|
}
|
|
|
|
Vector3 rayStart = position + Vector3.up * raycastHeight;
|
|
|
|
if (Physics.Raycast(rayStart, Vector3.down, out RaycastHit hit, raycastDistance, groundMask, QueryTriggerInteraction.Ignore))
|
|
{
|
|
position = hit.point + hit.normal * groundOffset;
|
|
|
|
Vector3 projectedForward = Vector3.ProjectOnPlane(moveDirection, hit.normal).normalized;
|
|
|
|
if (projectedForward.sqrMagnitude > 0.001f)
|
|
rotation = Quaternion.LookRotation(projectedForward, hit.normal);
|
|
}
|
|
else
|
|
{
|
|
position.y = fallbackGroundY + groundOffset;
|
|
}
|
|
}
|
|
|
|
private bool IsBlockedByObstacle(Vector3 from, Vector3 to)
|
|
{
|
|
if (!stopAtObstacle)
|
|
return false;
|
|
|
|
if (obstacleMask.value == 0)
|
|
return false;
|
|
|
|
Vector3 fromGround = GetGroundPointForObstacleCheck(from);
|
|
Vector3 toGround = GetGroundPointForObstacleCheck(to);
|
|
|
|
Vector3 start = fromGround + Vector3.up * obstacleCheckHeight;
|
|
Vector3 end = toGround + Vector3.up * obstacleCheckHeight;
|
|
|
|
Vector3 direction = end - start;
|
|
direction.y = 0f;
|
|
|
|
float distance = direction.magnitude;
|
|
|
|
if (distance <= 0.001f)
|
|
return false;
|
|
|
|
direction.Normalize();
|
|
|
|
float checkDistance = Mathf.Max(0f, distance + obstaclePadding);
|
|
|
|
return Physics.SphereCast(start, obstacleCheckRadius, direction, out RaycastHit hit, checkDistance, obstacleMask, QueryTriggerInteraction.Ignore);
|
|
}
|
|
|
|
private Vector3 GetGroundPointForObstacleCheck(Vector3 position)
|
|
{
|
|
if (!useGroundRaycast)
|
|
{
|
|
position.y = fallbackGroundY;
|
|
return position;
|
|
}
|
|
|
|
Vector3 rayStart = position + Vector3.up * raycastHeight;
|
|
|
|
if (Physics.Raycast(rayStart, Vector3.down, out RaycastHit hit, raycastDistance, groundMask, QueryTriggerInteraction.Ignore))
|
|
return hit.point;
|
|
|
|
position.y = fallbackGroundY;
|
|
return position;
|
|
}
|
|
|
|
private IEnumerator CleanupDestroyedFootprintsAfterDelay(float delay)
|
|
{
|
|
if (delay > 0f)
|
|
yield return new WaitForSeconds(delay);
|
|
|
|
spawnedFootprints.RemoveAll(footprint => footprint == null);
|
|
cleanupRoutine = null;
|
|
}
|
|
|
|
private void StopRunningRoutines()
|
|
{
|
|
if (footprintRoutine != null)
|
|
{
|
|
StopCoroutine(footprintRoutine);
|
|
footprintRoutine = null;
|
|
}
|
|
|
|
if (cleanupRoutine != null)
|
|
{
|
|
StopCoroutine(cleanupRoutine);
|
|
cleanupRoutine = null;
|
|
}
|
|
}
|
|
|
|
private void ClearSpawnedFootprintsOnly()
|
|
{
|
|
for (int i = 0; i < spawnedFootprints.Count; i++)
|
|
{
|
|
if (spawnedFootprints[i] != null)
|
|
Destroy(spawnedFootprints[i]);
|
|
}
|
|
|
|
spawnedFootprints.Clear();
|
|
}
|
|
|
|
public void ClearFootprints()
|
|
{
|
|
StopRunningRoutines();
|
|
ClearSpawnedFootprintsOnly();
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
private void OnValidate()
|
|
{
|
|
footprintCount = Mathf.Max(1, footprintCount);
|
|
spacing = Mathf.Max(0.01f, spacing);
|
|
sideOffset = Mathf.Max(0f, sideOffset);
|
|
showTime = Mathf.Max(0f, showTime);
|
|
revealInterval = Mathf.Max(0f, revealInterval);
|
|
autoDestroyCleanupDelay = Mathf.Max(0f, autoDestroyCleanupDelay);
|
|
fallbackDestroyDelay = Mathf.Max(0f, fallbackDestroyDelay);
|
|
raycastHeight = Mathf.Max(0.01f, raycastHeight);
|
|
raycastDistance = Mathf.Max(0.01f, raycastDistance);
|
|
groundOffset = Mathf.Max(0f, groundOffset);
|
|
obstacleCheckHeight = Mathf.Max(0f, obstacleCheckHeight);
|
|
obstacleCheckRadius = Mathf.Max(0.001f, obstacleCheckRadius);
|
|
obstaclePadding = Mathf.Max(0f, obstaclePadding);
|
|
|
|
if (stopAtObstacle && obstacleMask.value == 0)
|
|
{
|
|
Debug.LogWarning(
|
|
"FootprintHintManager: Stop At Obstacle이 켜져 있지만 Obstacle Mask가 비어 있습니다. Wall 레이어를 지정하세요.",
|
|
this
|
|
);
|
|
}
|
|
|
|
if (useGroundRaycast && groundMask.value == ~0)
|
|
{
|
|
Debug.LogWarning(
|
|
"FootprintHintManager: Ground Mask가 Everything입니다. 가능하면 Ground 레이어만 지정하세요.",
|
|
this
|
|
);
|
|
}
|
|
}
|
|
#endif
|
|
}
|