1127 lines
57 KiB
C#
1127 lines
57 KiB
C#
|
using UnityEngine;
|
||
|
|
using UnityEngine.InputSystem;
|
||
|
|
using WL.Combat;
|
||
|
|
|
||
|
|
namespace WL.Player
|
||
|
|
{
|
||
|
|
/// <summary>
|
||
|
|
/// 플레이어 컨트롤러 (Suriyun Kazuko / CombatGirls RifleGirl 공용).
|
||
|
|
///
|
||
|
|
/// 1) 씬 시작 시 쓰러진 자세(Down · 98_Damage LyingFront) → 기상(GetUp · LyingFront_WakeUp 정방향) → 조작 개방.
|
||
|
|
/// (구 Cry 1회 단계는 PD #705 ② 로 제거 — Cry 상태·클립은 남아 있고 시퀀스 호출만 끊었다)
|
||
|
|
/// 2) 조작 = 모바일 터치 드래그가 기본. 화면 좌측 하단 1/4 = 가상 패드, 그 밖 = 터치 지점 방향 자동 이동.
|
||
|
|
/// (에디터에서는 마우스가 같은 동작. 키보드 WASD/게임패드는 에디터 테스트용으로 병행 유지)
|
||
|
|
/// 3) 입력이 없으면 자동 탐색: 시야 안 적 → 공격 범위까지 이동 후 공격 / 적 없으면 Idle.
|
||
|
|
///
|
||
|
|
/// 모든 수치는 ScriptableObject 또는 [SerializeField] 로 외부화한다(코드 상수 금지 · C45).
|
||
|
|
/// </summary>
|
||
|
|
[RequireComponent(typeof(CharacterController))]
|
||
|
|
public class PlayerController : MonoBehaviour
|
||
|
|
{
|
||
|
|
public enum WakeState { Down, GetUp, Cry, Playable, Dead }
|
||
|
|
public enum ActState { Idle, Move, Chase, Attack, Swim }
|
||
|
|
|
||
|
|
[Header("수치 설정 (ScriptableObject)")]
|
||
|
|
[SerializeField] private PlayerMoveSettings settings;
|
||
|
|
[SerializeField] private PlayerTouchSettings touchSettings;
|
||
|
|
|
||
|
|
[Header("참조")]
|
||
|
|
[SerializeField] private Animator animator;
|
||
|
|
[SerializeField] private Transform cameraTransform;
|
||
|
|
[SerializeField] private InputActionAsset inputActions;
|
||
|
|
[SerializeField] private PlayerCombat combat;
|
||
|
|
[Tooltip("수영 판정기. 비어 있으면 같은 오브젝트에서 찾는다")]
|
||
|
|
[SerializeField] private WaterProbe waterProbe;
|
||
|
|
[Tooltip("검 궤적 슬래시 VFX 재생기 (PD #712 ②). 비어 있으면 같은 오브젝트에서 찾는다")]
|
||
|
|
[SerializeField] private SlashVfxPlayer slashVfx;
|
||
|
|
|
||
|
|
[Header("입력 액션 이름 (에디터 테스트용 키보드/게임패드)")]
|
||
|
|
[SerializeField] private string actionMapName = "Player";
|
||
|
|
[SerializeField] private string moveActionName = "Move";
|
||
|
|
[SerializeField] private string sprintActionName = "Sprint";
|
||
|
|
[SerializeField] private string jumpActionName = "Jump";
|
||
|
|
[Tooltip("끄면 터치/마우스 입력만 받는다")]
|
||
|
|
[SerializeField] private bool enableKeyboardGamepad = true;
|
||
|
|
|
||
|
|
[Header("애니메이터 상태 / 파라미터 이름 (Player_Base.controller 기준)")]
|
||
|
|
[Tooltip("공용 98_Damage · LyingFront (엎드려 쓰러진 정지 자세)")]
|
||
|
|
[SerializeField] private string downStateName = "Down";
|
||
|
|
[Tooltip("공용 98_Damage · LyingFront_WakeUp (일어나기 · 정방향 재생)")]
|
||
|
|
[SerializeField] private string getUpStateName = "GetUp";
|
||
|
|
[Tooltip("전투 세트 Idle/Walk/Run 블렌드 트리")]
|
||
|
|
[SerializeField] private string locomotionStateName = "Locomotion";
|
||
|
|
[Tooltip("캐릭터 고유 감정 모션. Kazuko = Cry_wing (Override 로 교체)")]
|
||
|
|
[SerializeField] private string cryStateName = "Cry";
|
||
|
|
[Tooltip("콤보 단계별 공격 상태 이름. 전투 세트에서 캐릭터(직업)마다 Override 로 교체된다")]
|
||
|
|
[SerializeField] private string[] attackStateNames = new string[] { "Attack1", "Attack2", "Attack3" };
|
||
|
|
[Tooltip("공용 98_Damage · Damage1 (피격)")]
|
||
|
|
[SerializeField] private string hitStateName = "Hit";
|
||
|
|
[Tooltip("공용 98_Damage · KnockDown_F_Light (사망)")]
|
||
|
|
[SerializeField] private string deathStateName = "Death";
|
||
|
|
[Tooltip("공용 50_Adventure · Swim 블렌드 트리")]
|
||
|
|
[SerializeField] private string swimStateName = "Swim";
|
||
|
|
[SerializeField] private string speedParamName = "Speed";
|
||
|
|
[SerializeField] private string groundedParamName = "Grounded";
|
||
|
|
|
||
|
|
[Header("조준/전투")]
|
||
|
|
[Tooltip("터치 지점 방향 계산에 쓰는 캐릭터 기준 높이(m)")]
|
||
|
|
[SerializeField] private float bodyScreenAnchorHeight = 1.0f;
|
||
|
|
[Tooltip("공격 중 적을 향해 도는 속도(도/초)")]
|
||
|
|
[SerializeField] private float aimTurnSpeed = 540f;
|
||
|
|
[Tooltip("공격 -> Locomotion 크로스페이드 시간(초)")]
|
||
|
|
[SerializeField] private float attackBlendTime = 0.08f;
|
||
|
|
|
||
|
|
[Header("시작 시퀀스 (PD #711 — 교체 투입 시 끈다)")]
|
||
|
|
[Tooltip("씬 시작 시 쓰러짐→기상 시퀀스를 재생한다. 캐릭터 교체로 투입될 때는 PlayerSwitcher 가 끈다")]
|
||
|
|
[SerializeField] private bool playIntroSequence = true;
|
||
|
|
|
||
|
|
[Header("디버그")]
|
||
|
|
[SerializeField] private bool logWakeSequence = true;
|
||
|
|
[Tooltip("체크 시 실제 입력 대신 아래 값을 이동 입력으로 사용한다(자동 검증용)")]
|
||
|
|
[SerializeField] private bool useDebugMoveInput = false;
|
||
|
|
[SerializeField] private Vector2 debugMoveInput = Vector2.zero;
|
||
|
|
|
||
|
|
private CharacterController _controller;
|
||
|
|
private InputActionMap _map;
|
||
|
|
private InputAction _moveAction, _sprintAction, _jumpAction;
|
||
|
|
private TouchInputProvider _touch;
|
||
|
|
private FollowCamera _followCam; // PD #713 ② — 입력 기준 요·요 추종 목표 보고 대상
|
||
|
|
private bool _followCamCached;
|
||
|
|
private float _inputLockTimer; // PD #711 — 캐릭터 교체 직후 입력 잠금 잔여 시간(초)
|
||
|
|
private float _idleTimer; // PD #715 ③ — 무입력·무전투 지속 시간(초)
|
||
|
|
private bool _idleVariationPlaying;
|
||
|
|
private float _idleVariationTimer;
|
||
|
|
|
||
|
|
private WakeState _wakeState = WakeState.Down;
|
||
|
|
private ActState _actState = ActState.Idle;
|
||
|
|
private float _stateTimer;
|
||
|
|
private float _getUpDuration;
|
||
|
|
|
||
|
|
private float _currentSpeed;
|
||
|
|
private float _speedDampVelocity;
|
||
|
|
private float _rotationDampVelocity;
|
||
|
|
private float _verticalVelocity;
|
||
|
|
private bool _suppressMoveRotation; // PD #733 — 공격 중 이동할 때는 이동 방향 회전을 끄고 대상 방향을 본다
|
||
|
|
private float _moveSpeedScale = 1f; // PD #734 — 공격 중 이동 속도 배율(설정 attackMoveSpeedRatio) · 평소 1
|
||
|
|
private bool _hurtLocked; // PD #735 — 피격 모션 중 이동 잠금 진행 여부(검증 로그용)
|
||
|
|
private Vector3 _hurtLockStartPos; // PD #735 — 잠금 시작 위치(피격 중 이동거리 실측용)
|
||
|
|
|
||
|
|
private float _attackTimer; // 현재 공격 클립 남은 시간
|
||
|
|
private float _attackClipLength; // 현재 공격 클립 전체 길이 (콤보 전이 시점 계산용)
|
||
|
|
private float _hitDelayTimer; // 피해 적용까지 남은 시간
|
||
|
|
private bool _hitPending;
|
||
|
|
private Enemy _target;
|
||
|
|
|
||
|
|
private int _comboStep; // 0 = 콤보 없음, 1~N = 현재 단계
|
||
|
|
private bool _comboAdvanceResolved; // 이번 단계의 전이 판정을 이미 했는가
|
||
|
|
private int _comboHitCount; // 이번 콤보에서 실제로 들어간 타격 수 (검증 로그용)
|
||
|
|
|
||
|
|
private bool _isSwimming;
|
||
|
|
private float _waterSurfaceY;
|
||
|
|
|
||
|
|
private float _deathTimer;
|
||
|
|
|
||
|
|
private float _hurtTimer; // 피격 모션 남은 시간
|
||
|
|
private float _hp = -1f; // 현재 체력 (첫 피격 때 최대치로 초기화)
|
||
|
|
|
||
|
|
private int _speedParamHash, _groundedParamHash;
|
||
|
|
private bool _hasSpeedParam, _hasGroundedParam;
|
||
|
|
|
||
|
|
private float _tDown = -1f, _tGetUp = -1f, _tCry = -1f, _tPlayable = -1f;
|
||
|
|
|
||
|
|
public bool IsPlayable { get { return _wakeState == WakeState.Playable; } }
|
||
|
|
public WakeState CurrentWakeState { get { return _wakeState; } }
|
||
|
|
public ActState CurrentActState { get { return _actState; } }
|
||
|
|
public float CurrentSpeed { get { return _currentSpeed; } }
|
||
|
|
public Enemy CurrentTarget { get { return _target; } }
|
||
|
|
public TouchInputProvider Touch { get { return _touch; } }
|
||
|
|
/// <summary>가상패드 UI 가 패드 영역·반경을 그릴 때 참조하는 설정 에셋.</summary>
|
||
|
|
public PlayerTouchSettings TouchSettings { get { return touchSettings; } }
|
||
|
|
|
||
|
|
/// <summary>현재 체력. 하한(기본 1) 아래로 내려가지 않는다 — 아직 사망은 구현하지 않는다(PD 지시 ⑥).</summary>
|
||
|
|
public float CurrentHp { get { return _hp < 0f ? MaxHp : _hp; } }
|
||
|
|
public float MaxHp { get { var s = CombatConfig; return s != null ? s.playerMaxHp : 100f; } }
|
||
|
|
/// <summary>공격 모션 재생 중인가. 피격 모션 생략 판정에 쓴다(PD 지시 ③).</summary>
|
||
|
|
public bool IsAttacking { get { return _attackTimer > 0f; } }
|
||
|
|
/// <summary>피격 모션 재생 중인가.</summary>
|
||
|
|
public bool IsHurt { get { return _hurtTimer > 0f; } }
|
||
|
|
/// <summary>수영 중인가 (PD #704 범위확정 1).</summary>
|
||
|
|
public bool IsSwimming { get { return _isSwimming; } }
|
||
|
|
/// <summary>사망 상태인가 (PD #704 범위확정 4).</summary>
|
||
|
|
public bool IsDead { get { return _wakeState == WakeState.Dead; } }
|
||
|
|
/// <summary>현재 콤보 단계. 0 = 진행 중 아님, 1~3 = Attack1~3.</summary>
|
||
|
|
public int CurrentComboStep { get { return _comboStep; } }
|
||
|
|
/// <summary>이번(또는 마지막) 콤보에서 실제로 들어간 타격 수. 검증용.</summary>
|
||
|
|
public int LastComboHitCount { get { return _comboHitCount; } }
|
||
|
|
|
||
|
|
/// <summary>자동 검증용 — 실제 터치 대신 화면 기준 입력(x=우, y=상)을 주입한다. 끄면 실제 입력으로 복귀.</summary>
|
||
|
|
public void SetDebugMoveInput(bool enabled, Vector2 screenInput)
|
||
|
|
{
|
||
|
|
useDebugMoveInput = enabled;
|
||
|
|
debugMoveInput = enabled ? screenInput : Vector2.zero;
|
||
|
|
}
|
||
|
|
/// <summary>주입 입력이 켜져 있는가.</summary>
|
||
|
|
public bool DebugMoveInputEnabled { get { return useDebugMoveInput; } }
|
||
|
|
/// <summary>전투 수치 에셋. PlayerCombat 이 들고 있는 것을 그대로 쓴다.</summary>
|
||
|
|
private CombatSettings CombatConfig { get { return combat != null ? combat.Settings : null; } }
|
||
|
|
|
||
|
|
/// <summary>각 단계 진입 시각(초, 씬 로드 기준). 아직 진입 전이면 -1.</summary>
|
||
|
|
public float DownEnterTime { get { return _tDown; } }
|
||
|
|
public float GetUpEnterTime { get { return _tGetUp; } }
|
||
|
|
public float CryEnterTime { get { return _tCry; } }
|
||
|
|
public float PlayableEnterTime { get { return _tPlayable; } }
|
||
|
|
public float MeasuredGetUpDuration { get { return _getUpDuration; } }
|
||
|
|
|
||
|
|
// ───────────────────────────────── 초기화
|
||
|
|
|
||
|
|
private void Awake()
|
||
|
|
{
|
||
|
|
_controller = GetComponent<CharacterController>();
|
||
|
|
if (animator == null) animator = GetComponentInChildren<Animator>();
|
||
|
|
if (combat == null) combat = GetComponent<PlayerCombat>();
|
||
|
|
if (waterProbe == null) waterProbe = GetComponent<WaterProbe>();
|
||
|
|
if (slashVfx == null) slashVfx = GetComponent<SlashVfxPlayer>();
|
||
|
|
if (cameraTransform == null && Camera.main != null) cameraTransform = Camera.main.transform;
|
||
|
|
|
||
|
|
if (animator != null)
|
||
|
|
{
|
||
|
|
animator.applyRootMotion = false;
|
||
|
|
foreach (var p in animator.parameters)
|
||
|
|
{
|
||
|
|
if (p.name == speedParamName) { _hasSpeedParam = true; _speedParamHash = p.nameHash; }
|
||
|
|
else if (p.name == groundedParamName) { _hasGroundedParam = true; _groundedParamHash = p.nameHash; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
_touch = new TouchInputProvider(touchSettings);
|
||
|
|
ResolveInput();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ResolveInput()
|
||
|
|
{
|
||
|
|
if (inputActions == null) return;
|
||
|
|
_map = inputActions.FindActionMap(actionMapName, false);
|
||
|
|
if (_map == null)
|
||
|
|
{
|
||
|
|
Debug.LogWarning("[PlayerController] 액션맵을 찾지 못했습니다: " + actionMapName, this);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_moveAction = _map.FindAction(moveActionName, false);
|
||
|
|
_sprintAction = _map.FindAction(sprintActionName, false);
|
||
|
|
_jumpAction = _map.FindAction(jumpActionName, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void OnEnable() { if (_map != null && !_map.enabled) _map.Enable(); }
|
||
|
|
private void OnDisable() { if (_map != null && _map.enabled) _map.Disable(); }
|
||
|
|
|
||
|
|
private void Start()
|
||
|
|
{
|
||
|
|
// PD #711 — 캐릭터 교체로 나중에 켜진 캐릭터는 시작 시퀀스를 다시 재생하지 않는다(최초 1회만).
|
||
|
|
if (playIntroSequence) EnterDown();
|
||
|
|
else EnterPlayable();
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>시작 시퀀스(쓰러짐→기상) 재생 여부. 교체로 투입되는 캐릭터는 끄고 켠다(PD #711).</summary>
|
||
|
|
public void SetPlayIntroSequence(bool v) { playIntroSequence = v; }
|
||
|
|
|
||
|
|
/// <summary>체력을 그대로 옮긴다(캐릭터 교체 시 유지 · PD #711).</summary>
|
||
|
|
public void SetHp(float value) { _hp = Mathf.Clamp(value, 0f, MaxHp); }
|
||
|
|
|
||
|
|
/// <summary>교체 직후 잠깐 입력을 막는다(초). 버튼을 뗄 때의 잔여 터치로 이동이 시작되는 것을 막는다.</summary>
|
||
|
|
public void LockInput(float seconds) { _inputLockTimer = Mathf.Max(_inputLockTimer, seconds); }
|
||
|
|
|
||
|
|
// ───────────────────────────────── 기상 시퀀스
|
||
|
|
|
||
|
|
private void EnterDown()
|
||
|
|
{
|
||
|
|
_wakeState = WakeState.Down;
|
||
|
|
_stateTimer = 0f;
|
||
|
|
_tDown = Time.timeSinceLevelLoad;
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null)
|
||
|
|
{
|
||
|
|
// 98_Damage · LyingFront = 전 구간이 엎드려 쓰러진 자세라 어느 시점에서 멈춰도 같다.
|
||
|
|
// Down 상태의 speed 는 0 이므로 아래 정규화 시각에서 정지한 채 유지된다.
|
||
|
|
animator.Play(downStateName, 0, settings != null ? settings.downFreezeNormalizedTime : 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
}
|
||
|
|
if (logWakeSequence)
|
||
|
|
Debug.Log("[PlayerController] WAKE t=" + Time.timeSinceLevelLoad.ToString("F2") + "s STATE=Down (쓰러진 자세 유지) pos=" + transform.position.ToString("F3"));
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EnterGetUp()
|
||
|
|
{
|
||
|
|
_wakeState = WakeState.GetUp;
|
||
|
|
_stateTimer = 0f;
|
||
|
|
_tGetUp = Time.timeSinceLevelLoad;
|
||
|
|
_getUpDuration = settings != null ? settings.getUpFallbackDuration : 1.7f;
|
||
|
|
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null)
|
||
|
|
{
|
||
|
|
// 98_Damage · LyingFront_WakeUp = 엎드린 자세에서 일어나는 전용 클립이므로 정방향(0 -> 1) 재생한다.
|
||
|
|
// (구 Kazuko DieA_wing 역재생 방식은 PD #704 추가지시 3 으로 폐기)
|
||
|
|
animator.Play(getUpStateName, 0, 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
if (info.length > 0f && !float.IsInfinity(info.length)) _getUpDuration = info.length;
|
||
|
|
}
|
||
|
|
if (logWakeSequence)
|
||
|
|
Debug.Log("[PlayerController] WAKE t=" + Time.timeSinceLevelLoad.ToString("F2") + "s STATE=GetUp 재생 시작 (길이 " + _getUpDuration.ToString("F2") + "s)");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 기상 직후 Cry 모션을 설정된 시간만큼 재생한다. crySeconds 0 이면 건너뛴다.
|
||
|
|
/// **PD #705 ② 로 현재 시퀀스에서는 호출하지 않는다** (미사용 · 복구용으로 보존).
|
||
|
|
/// </summary>
|
||
|
|
private void EnterCry()
|
||
|
|
{
|
||
|
|
float cry = settings != null ? settings.crySeconds : 0f;
|
||
|
|
if (cry <= 0f || string.IsNullOrEmpty(cryStateName)) { EnterPlayable(); return; }
|
||
|
|
|
||
|
|
_wakeState = WakeState.Cry;
|
||
|
|
_stateTimer = 0f;
|
||
|
|
_tCry = Time.timeSinceLevelLoad;
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null)
|
||
|
|
animator.CrossFade(cryStateName, settings != null ? settings.getUpToCryBlend : 0.12f, 0, 0f);
|
||
|
|
if (logWakeSequence)
|
||
|
|
Debug.Log("[PlayerController] WAKE t=" + Time.timeSinceLevelLoad.ToString("F2") + "s STATE=Cry 재생 (" + cry.ToString("F2") + "s)");
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EnterPlayable()
|
||
|
|
{
|
||
|
|
_wakeState = WakeState.Playable;
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
_stateTimer = 0f;
|
||
|
|
_tPlayable = Time.timeSinceLevelLoad;
|
||
|
|
CrossFadeLocomotion();
|
||
|
|
if (logWakeSequence)
|
||
|
|
Debug.Log("[PlayerController] WAKE t=" + Time.timeSinceLevelLoad.ToString("F2") + "s STATE=Playable — 조작 활성화 pos=" + transform.position.ToString("F3"));
|
||
|
|
}
|
||
|
|
|
||
|
|
private void CrossFadeLocomotion()
|
||
|
|
{
|
||
|
|
if (animator == null || animator.runtimeAnimatorController == null) return;
|
||
|
|
animator.CrossFade(locomotionStateName, settings != null ? settings.getUpToLocomotionBlend : 0.15f, 0, 0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 메인 루프
|
||
|
|
|
||
|
|
private void Update()
|
||
|
|
{
|
||
|
|
float dt = Time.deltaTime;
|
||
|
|
_stateTimer += dt;
|
||
|
|
if (_inputLockTimer > 0f) _inputLockTimer -= dt;
|
||
|
|
|
||
|
|
switch (_wakeState)
|
||
|
|
{
|
||
|
|
case WakeState.Down:
|
||
|
|
ApplyGravityOnly(dt);
|
||
|
|
if (settings == null || _stateTimer >= settings.downHoldSeconds) EnterGetUp();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WakeState.GetUp:
|
||
|
|
ApplyGravityOnly(dt);
|
||
|
|
// PD #705 ② — 기상 직후 Cry 를 거치지 않고 바로 조작을 연다.
|
||
|
|
if (IsGetUpFinished()) EnterPlayable();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WakeState.Cry:
|
||
|
|
// 현재 시퀀스는 이 단계로 들어오지 않는다(PD #705 ②).
|
||
|
|
// 되살릴 때는 위 GetUp 분기를 EnterCry() 로 되돌리기만 하면 된다.
|
||
|
|
ApplyGravityOnly(dt);
|
||
|
|
if (settings == null || _stateTimer >= settings.crySeconds) EnterPlayable();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WakeState.Playable:
|
||
|
|
PlayableUpdate(dt);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case WakeState.Dead:
|
||
|
|
// 사망 후에는 조작을 받지 않는다. 클립이 끝나면 그대로 쓰러진 자세로 남는다.
|
||
|
|
if (_deathTimer > 0f) _deathTimer -= dt;
|
||
|
|
ApplyGravityOnly(dt);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (animator != null && _hasGroundedParam) animator.SetBool(_groundedParamHash, _controller.isGrounded);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsGetUpFinished()
|
||
|
|
{
|
||
|
|
float timeout = settings != null ? settings.getUpTimeoutSeconds : 6f;
|
||
|
|
if (_stateTimer >= timeout) return true;
|
||
|
|
if (_stateTimer >= _getUpDuration) return true;
|
||
|
|
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null)
|
||
|
|
{
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
if (info.IsName(getUpStateName) && info.normalizedTime >= 1f) return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void PlayableUpdate(float dt)
|
||
|
|
{
|
||
|
|
// 1) 입력 수집 — 터치 최우선
|
||
|
|
Vector2 input = ReadCombinedInput();
|
||
|
|
bool hasInput = input.sqrMagnitude > 0.0000001f;
|
||
|
|
|
||
|
|
// 1-1) 물 판정 — 수영 중에는 전투를 멈추고 수면을 따라간다 (PD #704 범위확정 1)
|
||
|
|
UpdateSwimState();
|
||
|
|
if (_isSwimming)
|
||
|
|
{
|
||
|
|
if (_comboStep > 0 || _attackTimer > 0f) CancelCombo(false);
|
||
|
|
_hurtTimer = 0f;
|
||
|
|
_actState = ActState.Swim;
|
||
|
|
SwimUpdate(input, dt);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 1-2) 피격 모션 진행 — 시간이 지나면 이동/대기 상태로 되돌린다
|
||
|
|
if (_hurtTimer > 0f)
|
||
|
|
{
|
||
|
|
if (!_hurtLocked) { _hurtLocked = true; _hurtLockStartPos = transform.position; }
|
||
|
|
_hurtTimer -= dt;
|
||
|
|
if (_hurtTimer <= 0f)
|
||
|
|
{
|
||
|
|
CrossFadeLocomotion();
|
||
|
|
Vector3 moved = transform.position - _hurtLockStartPos; moved.y = 0f;
|
||
|
|
Debug.Log("[PlayerController] HURT 종료 — 피격 중 수평 이동거리=" + moved.magnitude.ToString("F3") + "m t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
_hurtLocked = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// PD #735 — 피격 모션이 재생되는 동안은 움직이지 않는다(중력만 적용 · 입력·공격 시작·자동 접근 전부 무시)
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
StopHorizontal(dt);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 2) 공격 진행 중 처리 (피해 적용 타이밍 + 콤보 전이)
|
||
|
|
if (_hitPending)
|
||
|
|
{
|
||
|
|
_hitDelayTimer -= dt;
|
||
|
|
if (_hitDelayTimer <= 0f)
|
||
|
|
{
|
||
|
|
_hitPending = false;
|
||
|
|
_comboHitCount++;
|
||
|
|
if (combat != null) combat.ApplyDamage(_target);
|
||
|
|
// PD #733 검증용 — 타격 시점의 시선 오차(전방 ↔ 대상 방향)와 이동 여부를 남긴다
|
||
|
|
if (_target != null)
|
||
|
|
{
|
||
|
|
Vector3 toT = _target.transform.position - transform.position; toT.y = 0f;
|
||
|
|
if (toT.sqrMagnitude > 0.0001f)
|
||
|
|
Debug.Log("[PlayerController] FACE 타격 시선오차=" + Vector3.Angle(transform.forward, toT).ToString("F1")
|
||
|
|
+ "° 이동중=" + (_currentSpeed > 0.05f) + " 속도=" + _currentSpeed.ToString("F2") + " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
}
|
||
|
|
// PD #718 — 검 궤적 이펙트는 여기(히트 시점)가 아니라 **스윙 시작 시점**에 연다(PlayAttackStep).
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_attackTimer > 0f)
|
||
|
|
{
|
||
|
|
_attackTimer -= dt;
|
||
|
|
// PD #737 — 이동 중 공격(#732)은 원래대로 되돌린다: 이동 입력이 들어오면 공격·콤보를 끊고 즉시 이동 우선.
|
||
|
|
// (#733 최근접 대상 조준은 제자리 공격에 그대로 적용 · #734 공격 중 이동 배율은 사용 경로가 없어져 보존만)
|
||
|
|
if (hasInput) { CancelCombo(true); }
|
||
|
|
else
|
||
|
|
{
|
||
|
|
FaceNearestTarget(dt); // PD #733 — 공격 중 가장 가까운 대상 방향 자동 조준
|
||
|
|
StopHorizontal(dt);
|
||
|
|
ComboAdvanceUpdate(); // 다음 단계로 이을지 판정 (PD #704 추가지시 1·2 · #732 대상 재탐색)
|
||
|
|
if (_attackTimer <= 0f) EndCombo("클립 종료");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hasInput)
|
||
|
|
{
|
||
|
|
_actState = ActState.Move;
|
||
|
|
_target = null;
|
||
|
|
CancelIdleVariation(); // PD #715 ③
|
||
|
|
MoveByInput(input, dt);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 3) 무입력 → 자동 탐색 패턴
|
||
|
|
AutoBehaviourUpdate(dt);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 입력
|
||
|
|
|
||
|
|
private Vector2 ReadCombinedInput()
|
||
|
|
{
|
||
|
|
// PD #711 — 캐릭터 교체 직후 잠금 구간. 버튼을 뗄 때의 잔여 터치가 이동으로 새는 것을 막는다.
|
||
|
|
if (_inputLockTimer > 0f) return Vector2.zero;
|
||
|
|
if (useDebugMoveInput) return Vector2.ClampMagnitude(debugMoveInput, 1f);
|
||
|
|
|
||
|
|
// 터치/마우스 (모바일 기본 조작)
|
||
|
|
if (_touch != null)
|
||
|
|
{
|
||
|
|
_touch.Tick(GetPlayerScreenPosition());
|
||
|
|
Vector2 t = _touch.ScreenMove;
|
||
|
|
if (t.sqrMagnitude > 0.0000001f) return Vector2.ClampMagnitude(t, 1f);
|
||
|
|
// 눌렀지만 데드존 안 → 정지(자동 패턴으로 넘기지 않음). UI 위에서 시작한 터치는 제외.
|
||
|
|
if (_touch.IsPressed && !_touch.IsBlockedByUI) return Vector2.zero;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (enableKeyboardGamepad && _moveAction != null)
|
||
|
|
return Vector2.ClampMagnitude(_moveAction.ReadValue<Vector2>(), 1f);
|
||
|
|
|
||
|
|
return Vector2.zero;
|
||
|
|
}
|
||
|
|
|
||
|
|
private Vector2 GetPlayerScreenPosition()
|
||
|
|
{
|
||
|
|
var cam = cameraTransform != null ? cameraTransform.GetComponent<Camera>() : Camera.main;
|
||
|
|
if (cam == null) return new Vector2(Screen.width * 0.5f, Screen.height * 0.5f);
|
||
|
|
Vector3 sp = cam.WorldToScreenPoint(transform.position + Vector3.up * bodyScreenAnchorHeight);
|
||
|
|
if (sp.z < 0f) { sp.x = Screen.width - sp.x; sp.y = Screen.height - sp.y; }
|
||
|
|
return new Vector2(sp.x, sp.y);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ReadSprint()
|
||
|
|
{
|
||
|
|
if (_touch != null && _touch.IsPressed && touchSettings != null)
|
||
|
|
{
|
||
|
|
// 패드 밖 터치(자동 이동)는 항상 달리기
|
||
|
|
if (_touch.CurrentMode == TouchInputProvider.Mode.PointAt) return touchSettings.autoMoveAlwaysRun;
|
||
|
|
return _touch.ScreenMove.magnitude >= touchSettings.sprintInputThreshold;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (enableKeyboardGamepad && _sprintAction != null) return _sprintAction.IsPressed();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 이동
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 드래그 크기 → 목표 속도. 임계값 미만은 걷기(미세 위치 조작 · 크기에 비례),
|
||
|
|
/// 임계값 이상은 걷기~달리기 구간을 선형 보간한다.
|
||
|
|
/// </summary>
|
||
|
|
private float ResolveTargetSpeed(float inputMag)
|
||
|
|
{
|
||
|
|
float walk = settings != null ? settings.walkSpeed : 2.2f;
|
||
|
|
float run = settings != null ? settings.runSpeed : 5.5f;
|
||
|
|
|
||
|
|
bool padDrag = _touch != null && _touch.IsPressed && _touch.CurrentMode == TouchInputProvider.Mode.VirtualPad;
|
||
|
|
if (!padDrag || touchSettings == null) return (ReadSprint() ? run : walk) * inputMag;
|
||
|
|
|
||
|
|
float thr = Mathf.Clamp(touchSettings.sprintInputThreshold, 0.01f, 0.99f);
|
||
|
|
if (inputMag < thr)
|
||
|
|
{
|
||
|
|
// 걷기 구간 — 짧은 드래그일수록 느리게(최소 비율까지)
|
||
|
|
if (!touchSettings.scaleWalkByDrag) return walk;
|
||
|
|
float t = inputMag / thr;
|
||
|
|
return walk * Mathf.Lerp(touchSettings.walkMinSpeedRatio, 1f, t);
|
||
|
|
}
|
||
|
|
// 달리기 구간 — 임계값에서 걷기 속도, 최대 드래그에서 달리기 속도
|
||
|
|
float u = Mathf.Clamp01((inputMag - thr) / Mathf.Max(1f - thr, 0.0001f));
|
||
|
|
return Mathf.Lerp(walk, run, u);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void MoveByInput(Vector2 input, float dt)
|
||
|
|
{
|
||
|
|
float targetSpeed = ResolveTargetSpeed(input.magnitude) * _moveSpeedScale; // PD #734 — 공격 중에는 배율 축소
|
||
|
|
var fc = FollowCam;
|
||
|
|
// PD #719 ⑤ — 방향 변환 **전에** 패드 원본 입력을 보고한다.
|
||
|
|
// 카메라가 이 보고로 기준 요를 래치해, 누르고 있는 동안 이동 벡터가 카메라와 함께 휘는 순환을 끊는다.
|
||
|
|
if (fc != null) fc.ReportPadInput(input);
|
||
|
|
Vector3 dir = ScreenToWorldDirection(input);
|
||
|
|
// PD #713 ② — 카메라 요 추종 목표를 캐릭터 facing 이 아니라 이 입력 방향으로 삼게 보고한다
|
||
|
|
if (fc != null) fc.ReportMoveDirection(dir);
|
||
|
|
MoveTowards(dir, targetSpeed, dt);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>추적 카메라. cameraTransform 에서 1회 찾아 캐시한다(없으면 null).</summary>
|
||
|
|
private FollowCamera FollowCam
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
if (_followCamCached) return _followCam;
|
||
|
|
_followCamCached = true;
|
||
|
|
if (cameraTransform != null) _followCam = cameraTransform.GetComponent<FollowCamera>();
|
||
|
|
if (_followCam == null) _followCam = Object.FindFirstObjectByType<FollowCamera>();
|
||
|
|
return _followCam;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 화면 기준 입력(x=우, y=상)을 월드 방향으로 변환.
|
||
|
|
/// 기준 방향은 카메라가 정한다(PD #713 ②) — 요 추종 모드는 모드의 고정 요를 기준으로 삼아야
|
||
|
|
/// "패드 방향 → 월드 방향 → 카메라 요 → 다시 패드 기준" 순환이 끊기고 추종이 수렴한다.
|
||
|
|
/// </summary>
|
||
|
|
private Vector3 ScreenToWorldDirection(Vector2 input)
|
||
|
|
{
|
||
|
|
Vector3 fwd = Vector3.forward, right = Vector3.right;
|
||
|
|
var fcam = FollowCam;
|
||
|
|
if (fcam != null)
|
||
|
|
{
|
||
|
|
Quaternion q = Quaternion.Euler(0f, fcam.InputReferenceYaw, 0f);
|
||
|
|
fwd = q * Vector3.forward;
|
||
|
|
right = q * Vector3.right;
|
||
|
|
}
|
||
|
|
else if (cameraTransform != null)
|
||
|
|
{
|
||
|
|
fwd = Vector3.ProjectOnPlane(cameraTransform.forward, Vector3.up).normalized;
|
||
|
|
right = Vector3.ProjectOnPlane(cameraTransform.right, Vector3.up).normalized;
|
||
|
|
if (fwd.sqrMagnitude < 0.0001f) fwd = Vector3.ProjectOnPlane(cameraTransform.up, Vector3.up).normalized;
|
||
|
|
}
|
||
|
|
Vector3 d = fwd * input.y + right * input.x;
|
||
|
|
return d.sqrMagnitude > 1f ? d.normalized : d;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void MoveTowards(Vector3 moveDir, float targetSpeed, float dt)
|
||
|
|
{
|
||
|
|
_currentSpeed = Mathf.SmoothDamp(_currentSpeed, targetSpeed, ref _speedDampVelocity,
|
||
|
|
settings != null ? settings.speedSmoothTime : 0.12f);
|
||
|
|
if (_currentSpeed < 0.01f) _currentSpeed = 0f;
|
||
|
|
|
||
|
|
if (moveDir.sqrMagnitude > 0.0001f && !_suppressMoveRotation)
|
||
|
|
{
|
||
|
|
float targetYaw = Mathf.Atan2(moveDir.x, moveDir.z) * Mathf.Rad2Deg;
|
||
|
|
float yaw = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetYaw, ref _rotationDampVelocity,
|
||
|
|
settings != null ? settings.rotationSmoothTime : 0.1f);
|
||
|
|
transform.rotation = Quaternion.Euler(0f, yaw, 0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
ApplyGravityStep(dt);
|
||
|
|
if (_controller.isGrounded && enableKeyboardGamepad && _jumpAction != null && _jumpAction.WasPressedThisFrame())
|
||
|
|
{
|
||
|
|
float jh = settings != null ? settings.jumpHeight : 0f;
|
||
|
|
float g = settings != null ? settings.gravity : -19.62f;
|
||
|
|
if (jh > 0f) _verticalVelocity = Mathf.Sqrt(-2f * g * jh);
|
||
|
|
}
|
||
|
|
|
||
|
|
Vector3 velocity = (moveDir.sqrMagnitude > 0.0001f ? moveDir.normalized : Vector3.zero) * _currentSpeed;
|
||
|
|
velocity.y = _verticalVelocity;
|
||
|
|
_controller.Move(velocity * dt);
|
||
|
|
|
||
|
|
UpdateLocomotionAnimator();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void StopHorizontal(float dt)
|
||
|
|
{
|
||
|
|
_currentSpeed = Mathf.SmoothDamp(_currentSpeed, 0f, ref _speedDampVelocity,
|
||
|
|
settings != null ? settings.speedSmoothTime : 0.12f);
|
||
|
|
if (_currentSpeed < 0.01f) _currentSpeed = 0f;
|
||
|
|
ApplyGravityStep(dt);
|
||
|
|
_controller.Move(new Vector3(0f, _verticalVelocity, 0f) * dt);
|
||
|
|
UpdateLocomotionAnimator();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 무입력 자동 탐색 패턴
|
||
|
|
|
||
|
|
private void AutoBehaviourUpdate(float dt)
|
||
|
|
{
|
||
|
|
if (combat == null) { _actState = ActState.Idle; StopHorizontal(dt); return; }
|
||
|
|
|
||
|
|
_target = combat.FindTarget();
|
||
|
|
|
||
|
|
if (_target == null)
|
||
|
|
{
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
StopHorizontal(dt);
|
||
|
|
IdleVariationUpdate(dt); // PD #715 ③ — 오래 서 있으면 대기 변형 1회
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CancelIdleVariation();
|
||
|
|
|
||
|
|
if (combat.IsInAttackRange(_target))
|
||
|
|
{
|
||
|
|
_actState = ActState.Attack;
|
||
|
|
FaceTarget(dt);
|
||
|
|
StopHorizontal(dt);
|
||
|
|
// 피격 모션이 재생 중이면 그 모션이 끝날 때까지 새 콤보를 시작하지 않는다
|
||
|
|
if (combat.CanAttack && _hurtTimer <= 0f && _comboStep == 0) BeginCombo();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 공격 범위 밖 → 공격 범위까지 접근
|
||
|
|
_actState = ActState.Chase;
|
||
|
|
Vector3 to = _target.transform.position - transform.position;
|
||
|
|
to.y = 0f;
|
||
|
|
float walk = settings != null ? settings.walkSpeed : 2.2f;
|
||
|
|
MoveTowards(to.normalized, walk, dt);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 대기 변형 (PD #715 ③)
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 무입력·무전투가 이어지면 99_Sub 계열 대기 변형을 1회 재생한다.
|
||
|
|
/// 재생 슬롯은 기존 감정 상태(`cryStateName`)를 그대로 쓴다 — 베이스 컨트롤러에서 `Sub_Talk1` 이고,
|
||
|
|
/// 캐릭터별 Override 로 갈아끼울 수 있다(Kazuko = `Cry_wing`). 새 상태를 추가하지 않는다.
|
||
|
|
/// </summary>
|
||
|
|
private void IdleVariationUpdate(float dt)
|
||
|
|
{
|
||
|
|
float iv = settings != null ? settings.idleVariationSeconds : 0f;
|
||
|
|
|
||
|
|
if (_idleVariationPlaying)
|
||
|
|
{
|
||
|
|
_idleVariationTimer -= dt;
|
||
|
|
if (_idleVariationTimer <= 0f) { _idleVariationPlaying = false; _idleTimer = 0f; CrossFadeLocomotion(); }
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (iv <= 0f || animator == null || animator.runtimeAnimatorController == null || string.IsNullOrEmpty(cryStateName)) return;
|
||
|
|
|
||
|
|
_idleTimer += dt;
|
||
|
|
if (_idleTimer < iv) return;
|
||
|
|
|
||
|
|
animator.CrossFade(cryStateName, settings != null ? settings.getUpToCryBlend : 0.12f, 0, 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
_idleVariationTimer = (info.length > 0f && !float.IsInfinity(info.length))
|
||
|
|
? info.length
|
||
|
|
: (settings != null ? settings.crySeconds : 1f);
|
||
|
|
_idleVariationPlaying = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>대기 변형을 중단하고 타이머를 되돌린다. 입력·전투가 들어오면 호출.</summary>
|
||
|
|
private void CancelIdleVariation()
|
||
|
|
{
|
||
|
|
_idleTimer = 0f;
|
||
|
|
if (!_idleVariationPlaying) return;
|
||
|
|
_idleVariationPlaying = false;
|
||
|
|
_idleVariationTimer = 0f;
|
||
|
|
CrossFadeLocomotion();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 콤보 공격 (PD #704 추가지시 1·2)
|
||
|
|
|
||
|
|
/// <summary>콤보 1단계를 시작한다. 이후 단계는 ComboAdvanceUpdate 가 잇는다.</summary>
|
||
|
|
private void BeginCombo()
|
||
|
|
{
|
||
|
|
_comboHitCount = 0;
|
||
|
|
PlayAttackStep(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>지정 단계의 공격 클립을 재생하고, 그 단계의 피해 판정을 1회 예약한다(총 N단계 = N히트).</summary>
|
||
|
|
private void PlayAttackStep(int step)
|
||
|
|
{
|
||
|
|
var s = CombatConfig;
|
||
|
|
_comboStep = step;
|
||
|
|
_comboAdvanceResolved = false;
|
||
|
|
_actState = ActState.Attack;
|
||
|
|
|
||
|
|
string stateName = GetAttackStateName(step);
|
||
|
|
float blend = (step <= 1) ? attackBlendTime : (s != null ? s.comboBlendTime : 0.10f);
|
||
|
|
|
||
|
|
_attackClipLength = combat != null ? combat.AttackFallbackDuration : 0.8f;
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null && !string.IsNullOrEmpty(stateName))
|
||
|
|
{
|
||
|
|
animator.CrossFade(stateName, blend, 0, 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
if (info.IsName(stateName) && info.length > 0f && !float.IsInfinity(info.length))
|
||
|
|
_attackClipLength = info.length; // 폴백 절단 해소 — 실제 클립 길이를 그대로 쓴다
|
||
|
|
}
|
||
|
|
_attackTimer = _attackClipLength;
|
||
|
|
|
||
|
|
// 피해 시점 = 클립 길이 대비 정규화 시각(에셋 값). 에셋이 없을 때만 기존 절대 지연값을 쓴다.
|
||
|
|
float hitNorm = s != null ? s.comboHitNormalizedTime : -1f;
|
||
|
|
_hitDelayTimer = (hitNorm >= 0f) ? _attackClipLength * hitNorm
|
||
|
|
: (combat != null ? combat.AttackHitDelay : 0.25f);
|
||
|
|
_hitPending = true;
|
||
|
|
|
||
|
|
// PD #718 (2) — 스윙 창을 연다. 이펙트는 이 창 동안 검이 지나간 자리를 따라 그려진다.
|
||
|
|
if (slashVfx != null) slashVfx.OnAttackStarted(step, _attackClipLength);
|
||
|
|
|
||
|
|
Debug.Log("[PlayerController] COMBO " + step + "/" + ComboStepCount + " state=" + stateName
|
||
|
|
+ " 클립=" + _attackClipLength.ToString("F2") + "s 타격+" + _hitDelayTimer.ToString("F2") + "s"
|
||
|
|
+ " target=" + ((_target != null) ? _target.name : "-")
|
||
|
|
+ " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 전이 시점에 닿으면 다음 단계로 이을지 판정한다.
|
||
|
|
/// PD #704 추가지시 2 — 대상이 사라졌거나 사거리를 벗어나면 잇지 않고, 현재 클립만 끝내고 복귀한다.
|
||
|
|
/// </summary>
|
||
|
|
private void ComboAdvanceUpdate()
|
||
|
|
{
|
||
|
|
if (_comboAdvanceResolved || _comboStep <= 0 || _attackClipLength <= 0f) return;
|
||
|
|
|
||
|
|
var s = CombatConfig;
|
||
|
|
float advanceAt = (s != null) ? s.comboAdvanceNormalizedTime : 0.78f;
|
||
|
|
float played = 1f - Mathf.Clamp01(_attackTimer / _attackClipLength);
|
||
|
|
if (played < advanceAt) return;
|
||
|
|
|
||
|
|
_comboAdvanceResolved = true;
|
||
|
|
|
||
|
|
bool targetAlive = _target != null && _target.IsAlive;
|
||
|
|
bool inRange = targetAlive && combat != null && combat.IsInAttackRange(_target);
|
||
|
|
if (!targetAlive || !inRange)
|
||
|
|
{
|
||
|
|
// PD #732 — 원래 대상이 죽었거나 벗어났어도 사거리 안에 다른 적이 있으면 그 적으로 콤보를 잇는다.
|
||
|
|
// 아무도 없으면 콤보를 중단하고, 다음 공격은 1타부터 다시 시작한다(EndCombo 가 단계를 0 으로 되돌린다).
|
||
|
|
var alt = combat != null ? combat.FindTarget() : null;
|
||
|
|
if (alt != null && alt.IsAlive && combat.IsInAttackRange(alt))
|
||
|
|
{
|
||
|
|
Debug.Log("[PlayerController] COMBO 대상 교체 " + _comboStep + "/" + ComboStepCount + " -> " + alt.name
|
||
|
|
+ " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
_target = alt; targetAlive = true; inRange = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!targetAlive || !inRange)
|
||
|
|
{
|
||
|
|
Debug.Log("[PlayerController] COMBO 중단 " + _comboStep + "/" + ComboStepCount
|
||
|
|
+ " 사유=" + (!targetAlive ? "대상 없음(사망/소멸)" : "사거리 이탈")
|
||
|
|
+ " — 현재 클립까지만 재생하고 복귀(다음 공격은 1타부터) t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_comboStep >= ComboStepCount) return; // 마지막 단계 → 클립이 끝나면 자연 종료
|
||
|
|
PlayAttackStep(_comboStep + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>콤보를 정상 종료하고 대기/이동으로 돌아간다. 이 시점부터 공격 쿨타임이 돈다.</summary>
|
||
|
|
private void EndCombo(string why)
|
||
|
|
{
|
||
|
|
if (_comboStep > 0)
|
||
|
|
Debug.Log("[PlayerController] COMBO 종료(" + why + ") 마지막단계=" + _comboStep + "/" + ComboStepCount
|
||
|
|
+ " 실제타격=" + _comboHitCount + "회 t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
_comboStep = 0;
|
||
|
|
_attackTimer = 0f;
|
||
|
|
_hitPending = false;
|
||
|
|
_comboAdvanceResolved = false;
|
||
|
|
if (combat != null) combat.ConsumeAttack(); // 쿨타임은 콤보 단위로 소비한다
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
CrossFadeLocomotion();
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>입력·수영 등으로 콤보를 즉시 끊는다. 예약된 피해도 취소한다.</summary>
|
||
|
|
private void CancelCombo(bool backToLocomotion)
|
||
|
|
{
|
||
|
|
if (_comboStep > 0)
|
||
|
|
Debug.Log("[PlayerController] COMBO 취소 단계=" + _comboStep + " 실제타격=" + _comboHitCount
|
||
|
|
+ "회 t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
_comboStep = 0;
|
||
|
|
_attackTimer = 0f;
|
||
|
|
_hitPending = false;
|
||
|
|
_comboAdvanceResolved = false;
|
||
|
|
if (slashVfx != null) slashVfx.CancelSwing(); // PD #718 (3) — 취소 시 이펙트 잔상 제거
|
||
|
|
if (combat != null) combat.ConsumeAttack();
|
||
|
|
if (backToLocomotion) CrossFadeLocomotion();
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>실제 콤보 단계 수. 설정값과 등록된 상태 이름 개수 중 작은 쪽.</summary>
|
||
|
|
private int ComboStepCount
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
var s = CombatConfig;
|
||
|
|
int want = (s != null) ? s.comboStepCount : 3;
|
||
|
|
int max = (attackStateNames != null) ? attackStateNames.Length : 0;
|
||
|
|
return (max <= 0) ? 0 : Mathf.Clamp(want, 1, max);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private string GetAttackStateName(int step)
|
||
|
|
{
|
||
|
|
if (attackStateNames == null || attackStateNames.Length == 0) return null;
|
||
|
|
return attackStateNames[Mathf.Clamp(step - 1, 0, attackStateNames.Length - 1)];
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 수영 (PD #704 범위확정 1)
|
||
|
|
|
||
|
|
/// <summary>물 깊이를 재서 수영 상태를 갱신한다. 경계에서 깜빡이지 않도록 진입/이탈 깊이를 다르게 둔다.</summary>
|
||
|
|
private void UpdateSwimState()
|
||
|
|
{
|
||
|
|
if (waterProbe == null) return;
|
||
|
|
|
||
|
|
float surface;
|
||
|
|
string zone;
|
||
|
|
bool overWater = waterProbe.TryGetSurfaceY(transform.position, out surface, out zone);
|
||
|
|
float depth = overWater ? surface - transform.position.y : float.NegativeInfinity;
|
||
|
|
|
||
|
|
float enter = (settings != null) ? settings.swimEnterDepth : 0.9f;
|
||
|
|
float exit = (settings != null) ? settings.swimExitDepth : 0.55f;
|
||
|
|
|
||
|
|
if (!_isSwimming)
|
||
|
|
{
|
||
|
|
if (overWater && depth >= enter)
|
||
|
|
{
|
||
|
|
_isSwimming = true;
|
||
|
|
_waterSurfaceY = surface;
|
||
|
|
_verticalVelocity = 0f;
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null && !string.IsNullOrEmpty(swimStateName))
|
||
|
|
animator.CrossFade(swimStateName, (settings != null) ? settings.swimBlendTime : 0.18f, 0, 0f);
|
||
|
|
Debug.Log("[PlayerController] SWIM 진입 수면y=" + surface.ToString("F2") + " 깊이=" + depth.ToString("F2")
|
||
|
|
+ "m zone=" + zone + " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!overWater || depth < exit)
|
||
|
|
{
|
||
|
|
_isSwimming = false;
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
CrossFadeLocomotion();
|
||
|
|
Debug.Log("[PlayerController] SWIM 이탈 깊이=" + (overWater ? depth.ToString("F2") + "m" : "물 없음")
|
||
|
|
+ " -> 이동 모션 복귀 t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_waterSurfaceY = surface;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>수영 중 이동. 중력 대신 수면 높이를 따라간다.</summary>
|
||
|
|
private void SwimUpdate(Vector2 input, float dt)
|
||
|
|
{
|
||
|
|
float swim = (settings != null) ? settings.swimSpeed : 1.8f;
|
||
|
|
Vector3 dir = (input.sqrMagnitude > 0.0000001f) ? ScreenToWorldDirection(input) : Vector3.zero;
|
||
|
|
bool moving = dir.sqrMagnitude > 0.0001f;
|
||
|
|
|
||
|
|
_currentSpeed = Mathf.SmoothDamp(_currentSpeed, moving ? swim : 0f, ref _speedDampVelocity,
|
||
|
|
(settings != null) ? settings.speedSmoothTime : 0.12f);
|
||
|
|
if (_currentSpeed < 0.01f) _currentSpeed = 0f;
|
||
|
|
|
||
|
|
if (moving)
|
||
|
|
{
|
||
|
|
float targetYaw = Mathf.Atan2(dir.x, dir.z) * Mathf.Rad2Deg;
|
||
|
|
float yaw = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetYaw, ref _rotationDampVelocity,
|
||
|
|
(settings != null) ? settings.rotationSmoothTime : 0.1f);
|
||
|
|
transform.rotation = Quaternion.Euler(0f, yaw, 0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 수면 유지 — 발밑을 수면보다 일정 깊이 아래에 붙인다(가라앉지 않게)
|
||
|
|
float submerge = (settings != null) ? settings.swimSurfaceSubmerge : 1.15f;
|
||
|
|
float follow = (settings != null) ? settings.swimSurfaceFollowSpeed : 6f;
|
||
|
|
float dy = Mathf.Clamp((_waterSurfaceY - submerge) - transform.position.y, -follow * dt, follow * dt);
|
||
|
|
|
||
|
|
Vector3 horizontal = moving ? dir.normalized * _currentSpeed : Vector3.zero;
|
||
|
|
_controller.Move(new Vector3(horizontal.x * dt, dy, horizontal.z * dt));
|
||
|
|
_verticalVelocity = 0f;
|
||
|
|
|
||
|
|
if (animator != null && _hasSpeedParam)
|
||
|
|
{
|
||
|
|
float blend = (swim > 0f) ? Mathf.Clamp01(_currentSpeed / swim) : 0f;
|
||
|
|
animator.SetFloat(_speedParamHash, blend, (settings != null) ? settings.animatorDampTime : 0.1f, Time.deltaTime);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 사망 (PD #704 범위확정 4)
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 사망 연출. CombatSettings.playerCanDie 가 꺼져 있으면 TakeDamage 가 호출하지 않는다(체력 하한 1 유지).
|
||
|
|
/// </summary>
|
||
|
|
public void Die(Transform source = null)
|
||
|
|
{
|
||
|
|
if (_wakeState == WakeState.Dead) return;
|
||
|
|
|
||
|
|
_wakeState = WakeState.Dead;
|
||
|
|
_actState = ActState.Idle;
|
||
|
|
_isSwimming = false;
|
||
|
|
_comboStep = 0;
|
||
|
|
_attackTimer = 0f;
|
||
|
|
_hitPending = false;
|
||
|
|
_hurtTimer = 0f;
|
||
|
|
_currentSpeed = 0f;
|
||
|
|
|
||
|
|
var s = CombatConfig;
|
||
|
|
float dur = (s != null) ? s.playerDeathFallbackDuration : 1.0f;
|
||
|
|
float blend = (s != null) ? s.playerDeathBlendTime : 0.10f;
|
||
|
|
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null && !string.IsNullOrEmpty(deathStateName))
|
||
|
|
{
|
||
|
|
int hash = Animator.StringToHash(deathStateName);
|
||
|
|
if (animator.HasState(0, hash))
|
||
|
|
{
|
||
|
|
animator.CrossFade(hash, blend, 0, 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
if (info.IsName(deathStateName) && info.length > 0f && !float.IsInfinity(info.length)) dur = info.length;
|
||
|
|
}
|
||
|
|
else Debug.LogWarning("[PlayerController] 사망 상태를 애니메이터에서 찾지 못했습니다: " + deathStateName, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
_deathTimer = dur;
|
||
|
|
Debug.Log("[PlayerController] DEATH 재생 " + dur.ToString("F2") + "s src=" + ((source != null) ? source.name : "-")
|
||
|
|
+ " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 피격 (PD 지시 ③ · ⑥)
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// 몬스터에게 피해를 받는다. 체력은 하한(CombatSettings.playerMinHp) 아래로 내려가지 않으며 사망하지 않는다(⑥).
|
||
|
|
/// 대기·이동 상태에서는 피격 모션을 재생하고, 공격 모션 재생 중이면 생략한다(③).
|
||
|
|
/// </summary>
|
||
|
|
public void TakeDamage(int amount, Transform source = null)
|
||
|
|
{
|
||
|
|
if (_wakeState == WakeState.Dead) return;
|
||
|
|
|
||
|
|
var s = CombatConfig;
|
||
|
|
if (_hp < 0f) _hp = s != null ? s.playerMaxHp : 100f;
|
||
|
|
float floorHp = s != null ? s.playerMinHp : 1f;
|
||
|
|
bool canDie = s != null && s.playerCanDie;
|
||
|
|
|
||
|
|
// playerCanDie 가 꺼져 있으면 기존 규칙대로 하한(기본 1) 에서 멈춘다.
|
||
|
|
_hp = canDie ? Mathf.Max(0f, _hp - amount) : Mathf.Max(floorHp, _hp - amount);
|
||
|
|
|
||
|
|
if (canDie && _hp <= 0f)
|
||
|
|
{
|
||
|
|
WL.UI.DamagePopupSpawner.Spawn(transform.position + Vector3.up * bodyScreenAnchorHeight,
|
||
|
|
amount, WL.UI.DamagePopupSpawner.Kind.ToPlayer);
|
||
|
|
Debug.Log("[PlayerController] DAMAGED " + amount + " -> HP 0/" + MaxHp.ToString("F0") + " 사망 처리 진입");
|
||
|
|
Die(source);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 데미지 숫자 연출 (PD #702-①) — 전투 코드는 UI 를 직접 알지 않고 스포너 창구만 호출한다
|
||
|
|
WL.UI.DamagePopupSpawner.Spawn(transform.position + Vector3.up * bodyScreenAnchorHeight,
|
||
|
|
amount, WL.UI.DamagePopupSpawner.Kind.ToPlayer);
|
||
|
|
|
||
|
|
bool attacking = _attackTimer > 0f;
|
||
|
|
bool playable = _wakeState == WakeState.Playable;
|
||
|
|
string why = attacking ? "공격 모션 중 — 피격 모션 생략"
|
||
|
|
: _isSwimming ? "수영 중 — 피격 모션 생략"
|
||
|
|
: (playable ? "피격 모션 재생" : "기상 시퀀스 중 — 피격 모션 생략");
|
||
|
|
// 판정 기준은 _actState(논리 상태)가 아니라 공격 '애니메이션' 잔여 시간이다(PD 지시 ③).
|
||
|
|
// 로그에도 잔여 시간을 함께 남겨 state=Attack 인데 재생되는 경우(모션은 이미 끝난 상태)를 구분한다.
|
||
|
|
Debug.Log("[PlayerController] DAMAGED " + amount + " -> HP " + _hp.ToString("F0") + "/" + MaxHp.ToString("F0")
|
||
|
|
+ " state=" + _actState + " 공격모션잔여=" + _attackTimer.ToString("F2") + "s " + why
|
||
|
|
+ " src=" + (source != null ? source.name : "-")
|
||
|
|
+ " t=" + Time.timeSinceLevelLoad.ToString("F2") + "s");
|
||
|
|
|
||
|
|
if (attacking || _isSwimming || !playable) return;
|
||
|
|
PlayHitMotion();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void PlayHitMotion()
|
||
|
|
{
|
||
|
|
var s = CombatConfig;
|
||
|
|
float dur = s != null ? s.playerHitFallbackDuration : 1.07f;
|
||
|
|
float blend = s != null ? s.playerHitBlendTime : 0.06f;
|
||
|
|
|
||
|
|
if (animator != null && animator.runtimeAnimatorController != null && !string.IsNullOrEmpty(hitStateName))
|
||
|
|
{
|
||
|
|
int hash = Animator.StringToHash(hitStateName);
|
||
|
|
if (!animator.HasState(0, hash))
|
||
|
|
{
|
||
|
|
Debug.LogWarning("[PlayerController] 피격 상태를 애니메이터에서 찾지 못했습니다: " + hitStateName, this);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
animator.CrossFade(hash, blend, 0, 0f);
|
||
|
|
animator.Update(0f);
|
||
|
|
var info = animator.GetCurrentAnimatorStateInfo(0);
|
||
|
|
if (info.IsName(hitStateName) && info.length > 0f && !float.IsInfinity(info.length)) dur = info.length;
|
||
|
|
}
|
||
|
|
_hurtTimer = dur;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FaceTarget(float dt) { FaceToward(_target, dt); }
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// PD #733 — 공격 중에는 시야 안에서 가장 가까운 생존 적 쪽을 본다.
|
||
|
|
/// 콤보 대상(_target)이 죽었거나 없으면 그 적을 새 대상으로 삼는다(타격 판정은 사거리 검사를 거친다).
|
||
|
|
/// </summary>
|
||
|
|
private void FaceNearestTarget(float dt)
|
||
|
|
{
|
||
|
|
Enemy nearest = combat != null ? combat.FindTarget() : null;
|
||
|
|
if (nearest == null) { FaceToward(_target, dt); return; }
|
||
|
|
if (_target == null || !_target.IsAlive) _target = nearest;
|
||
|
|
FaceToward(nearest, dt);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FaceToward(Enemy e, float dt)
|
||
|
|
{
|
||
|
|
if (e == null) return;
|
||
|
|
Vector3 to = e.transform.position - transform.position;
|
||
|
|
to.y = 0f;
|
||
|
|
if (to.sqrMagnitude < 0.0001f) return;
|
||
|
|
float targetYaw = Mathf.Atan2(to.x, to.z) * Mathf.Rad2Deg;
|
||
|
|
float yaw = Mathf.MoveTowardsAngle(transform.eulerAngles.y, targetYaw, aimTurnSpeed * dt);
|
||
|
|
transform.rotation = Quaternion.Euler(0f, yaw, 0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 물리 / 애니메이터
|
||
|
|
|
||
|
|
private void ApplyGravityOnly(float dt)
|
||
|
|
{
|
||
|
|
ApplyGravityStep(dt);
|
||
|
|
_controller.Move(new Vector3(0f, _verticalVelocity, 0f) * dt);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ApplyGravityStep(float dt)
|
||
|
|
{
|
||
|
|
float g = settings != null ? settings.gravity : -19.62f;
|
||
|
|
float stick = settings != null ? settings.groundedStickVelocity : -2f;
|
||
|
|
float terminal = settings != null ? settings.terminalVelocity : -50f;
|
||
|
|
|
||
|
|
if (_controller.isGrounded && _verticalVelocity < 0f) _verticalVelocity = stick;
|
||
|
|
else _verticalVelocity = Mathf.Max(_verticalVelocity + g * dt, terminal);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>현재 속도를 블렌드 트리 좌표(Idle 0 / Walk 임계값 / Run 1)로 환산해 전달한다.</summary>
|
||
|
|
private void UpdateLocomotionAnimator()
|
||
|
|
{
|
||
|
|
if (animator == null || !_hasSpeedParam) return;
|
||
|
|
|
||
|
|
float walk = settings != null ? settings.walkSpeed : 2.2f;
|
||
|
|
float run = settings != null ? settings.runSpeed : 5.5f;
|
||
|
|
float mid = settings != null ? settings.walkBlendThreshold : 0.5f;
|
||
|
|
|
||
|
|
float blend;
|
||
|
|
if (_currentSpeed <= walk)
|
||
|
|
blend = walk > 0f ? (_currentSpeed / walk) * mid : 0f;
|
||
|
|
else
|
||
|
|
blend = mid + Mathf.Clamp01((_currentSpeed - walk) / Mathf.Max(run - walk, 0.0001f)) * (1f - mid);
|
||
|
|
|
||
|
|
blend = Mathf.Clamp01(blend);
|
||
|
|
|
||
|
|
// PD #715 ③ — 감쇠 SetFloat 는 목표에 점근할 뿐 0 에 닿지 않아 걷기 클립이 미세하게 남는다.
|
||
|
|
// 정지(목표 0)일 때는 별도의 빠른 시간상수로 끌어내리고, 충분히 작아지면 0 으로 못박는다.
|
||
|
|
if (blend <= 0.0001f)
|
||
|
|
{
|
||
|
|
float snap = settings != null ? settings.idleSnapSeconds : 0.15f;
|
||
|
|
float cur = animator.GetFloat(_speedParamHash);
|
||
|
|
if (snap <= 0.0001f || cur <= 0.01f) animator.SetFloat(_speedParamHash, 0f);
|
||
|
|
else animator.SetFloat(_speedParamHash, 0f, snap, Time.deltaTime);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
animator.SetFloat(_speedParamHash, blend,
|
||
|
|
settings != null ? settings.animatorDampTime : 0.1f, Time.deltaTime);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>자동 검증용: 이동 입력을 코드에서 주입한다.</summary>
|
||
|
|
public void SetDebugMove(bool enabled, Vector2 input)
|
||
|
|
{
|
||
|
|
useDebugMoveInput = enabled;
|
||
|
|
debugMoveInput = input;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ───────────────────────────────── 화면 디버그 오버레이 (패드 영역 시각화)
|
||
|
|
|
||
|
|
private void OnGUI()
|
||
|
|
{
|
||
|
|
if (touchSettings == null || !touchSettings.drawDebugOverlay) return;
|
||
|
|
|
||
|
|
var old = GUI.color;
|
||
|
|
|
||
|
|
// PD #706 ② — 플로팅 모드에는 '고정 패드 영역' 개념이 없으므로 영역 상자를 그리지 않는다.
|
||
|
|
if (!touchSettings.floatingPadEverywhere)
|
||
|
|
{
|
||
|
|
Rect pad = touchSettings.GetPadRectPixels(Screen.width, Screen.height);
|
||
|
|
// GUI 좌표는 좌상단 원점 → 화면 좌표를 뒤집는다
|
||
|
|
Rect gui = new Rect(pad.x, Screen.height - pad.y - pad.height, pad.width, pad.height);
|
||
|
|
GUI.color = new Color(1f, 1f, 1f, 0.10f);
|
||
|
|
GUI.Box(gui, GUIContent.none);
|
||
|
|
GUI.color = new Color(1f, 1f, 1f, 0.75f);
|
||
|
|
GUI.Label(new Rect(gui.x + 6f, gui.yMax - 22f, 300f, 20f), "가상 패드 영역 (" + _actState + ")");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_touch != null && _touch.IsPressed)
|
||
|
|
{
|
||
|
|
float r = touchSettings.GetPadRadiusPixels(Screen.width, Screen.height);
|
||
|
|
Vector2 s = _touch.StartPosition, c = _touch.CurrentPosition;
|
||
|
|
GUI.color = _touch.CurrentMode == TouchInputProvider.Mode.VirtualPad
|
||
|
|
? new Color(0.4f, 1f, 0.5f, 0.85f) : new Color(1f, 0.85f, 0.3f, 0.85f);
|
||
|
|
GUI.Box(new Rect(s.x - r, Screen.height - s.y - r, r * 2f, r * 2f), GUIContent.none);
|
||
|
|
GUI.Box(new Rect(c.x - 14f, Screen.height - c.y - 14f, 28f, 28f), GUIContent.none);
|
||
|
|
}
|
||
|
|
GUI.color = old;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|