카타나 제로 스타일 액션 게임 기술 해부 — 탐지·레이캐스트·스킬 판정·코드 VFX

// GameLifetimeScope.cs
[DefaultExecutionOrder(0)] // Must build before SceneLifetimeScope (order 1)
public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.RegisterComponentInHierarchy<PoolManager>().AsImplementedInterfaces().AsSelf();
        builder.RegisterComponentInHierarchy<AudioManager>().AsImplementedInterfaces().AsSelf();
        builder.Register<GameEventBus>(Lifetime.Singleton);
    }

    protected override void Awake()
    {
        base.Awake();
        Time.timeScale = 1f; // Guard against timeScale pollution from editor testing

        // Enemies should not physically push each other — only player collision matters
        int enemyLayer = LayerMask.NameToLayer("Enemy");
        if (enemyLayer >= 0)
            Physics2D.IgnoreLayerCollision(enemyLayer, enemyLayer, true);
    }
}

// GameEventBus.cs
public class GameEventBus
{
    public static GameEventBus Current { get; private set; }

    public readonly Subject<Unit> OnPlayerDied = new();
    public readonly Subject<Unit> OnPlayerHit = new();
    public readonly Subject<EnemyDeadEvent> OnEnemyDied = new();
    public readonly Subject<DamageEvent> OnDamageDealt = new();
    public readonly Subject<int> OnWaveStarted = new();
    public readonly Subject<Unit> OnWaveCompleted = new();
    public readonly Subject<Unit> OnGameOver = new();
    public readonly Subject<Unit> OnGameClear = new();

    public GameEventBus() => Current = this;
}

// EnemyIdleStateBase.cs — 지상·비행 순찰 상태의 공통 베이스
public override void Update()
{
    if (Enemy.DistanceToPlayer() < Enemy.AlertDetectionRange && Enemy.IsPlayerInFOV())
    {
        Enemy.AlertNearbyEnemies();
        Enemy.ChangeState(AlertTarget);
        return;
    }

    OnIdleTick();

    _timer -= Time.unscaledDeltaTime;
    if (_timer <= 0f)
    {
        if (_isWalking) StartPause();
        else            StartWalk();
    }
}

// EnemyBase.cs
public virtual bool IsPlayerInFOV()
{
    if (Player == null) return false;
    Vector2 toPlayer = (Vector2)Player.position - (Vector2)transform.position;
    if (toPlayer.sqrMagnitude < 0.01f) return true;
    float facingDir = Mathf.Sign(transform.localScale.x);
    var forward = new Vector2(facingDir, 0f);
    if (Vector2.Angle(forward, toPlayer.normalized) > _fovAngle * 0.5f) return false;
    return HasLineOfSightToPlayer();
}

// Shared raycast kernel used by HasLineOfSightToPlayer and HasLineOfSightToEnemy.
private bool HasLineOfSight(Vector2 origin, Vector2 target)
{
    Vector2 dir  = target - origin;
    float   dist = dir.magnitude;
    if (dist < 0.1f) return true;
    var hit = Physics2D.Raycast(origin, dir / dist, dist, _wallMask);
    return hit.collider == null;
}

// PlayerMovement.cs — CheckWalls() 상체 레이 루프
const int RAY_COUNT = 5;
float yMin     = b.center.y;
float yMax     = b.max.y - 0.05f;
// Cast from center outward — avoids origin-inside-wall failure when player penetrates
float castDist = b.extents.x + _wallCheckDistance;

// ...

for (int i = 0; i < RAY_COUNT; i++)
{
    float y      = Mathf.Lerp(yMin, yMax, (float)i / (RAY_COUNT - 1));
    var   origin = new Vector2(b.center.x, y);
    bool  isTopTwo = i >= RAY_COUNT - 2;

    var hitL = Physics2D.Raycast(origin, Vector2.left, castDist, layerMask);
    if (hitL.collider != null)
    {
        _isTouchingWallLeft = true;
        if (hitL.distance < _wallClosestDistLeft)
        {
            _wallClosestDistLeft = hitL.distance;
            _wallLeftX = b.center.x - hitL.distance;
            closestNormalLeft = hitL.normal;
        }
        if (isTopTwo) topTwoHitLeft++;
    }
    // ... 오른쪽도 동일
}

// PlayerMovement.cs — CheckGrounded()
// CircleCast from above feet downward — avoids start-inside-collider misses on TilemapCollider2D
var groundHit = Physics2D.CircleCast(
    (Vector2)_groundCheckPoint.position + Vector2.up * 0.2f,
    _groundCheckRadius,
    Vector2.down,
    0.3f,
    _groundLayer);
_isGrounded = groundHit.collider != null;

// EnemyState.cs — FSM 노드의 최소 인터페이스
public abstract class EnemyState
{
    protected EnemyBase Enemy { get; private set; }

    public void Init(EnemyBase enemy) => Enemy = enemy;

    public virtual bool IsIdleState => false;

    public abstract void Enter();
    public virtual void Update() { }
    public virtual void FixedUpdate() { }
    public virtual void Exit() { }
}

// RangedEnemyMovementState.cs — 사거리 유지 본문을 한 곳에
public override void FixedUpdate()
{
    float dist = Enemy.DistanceToPlayer();

    if (dist < PREFERRED_MIN)        // 4f
    {
        Enemy.FleeFromPlayer(Enemy.MoveSpeed);
        SetSpeed(1f);
        return;
    }

    if (dist > PREFERRED_MAX)        // 8f
    {
        Enemy.MoveTowardPlayer(Enemy.MoveSpeed);
        SetSpeed(1f);
        return;
    }

    Enemy.StopMovement();
    SetSpeed(0f);
}

// PlayerController.cs — DetermineState()
private void DetermineState()
{
    if (_currentState == PlayerState.Dead) return;
    if (_isRolling) return;

    if (_movement.IsClimbingLedge) { TransitionTo(PlayerState.WallClimb); return; }

    // Skills own their state until the coroutine completes
    if (_skillDashSlash.IsActive) return;

    if (_movement.IsDashing && !_movement.IsAirDash) { TransitionTo(PlayerState.Dash); return; }

    // ... 카운터어택 등 일부 우선순위 분기 생략 ...

    // Aerial state takes priority over regular attack
    if (!_movement.IsGrounded)
    {
        TransitionTo(_rb.linearVelocity.y >= 0f ? PlayerState.Jump : PlayerState.Fall);
        return;
    }

    if (_combat.IsAttacking) { TransitionTo(PlayerState.Attack); return; }

    TransitionTo(Mathf.Abs(_moveInput.x) > 0.01f ? PlayerState.Run : PlayerState.Idle);
}

// DamageDealer.cs
private void OnTriggerEnter2D(Collider2D other)
{
    if (other.CompareTag(_ownerTag)) return;
    if (!other.TryGetComponent<IHittable>(out var hittable)) return;
    if (!hittable.IsAlive) return;

    Vector2 knockDir = _attackDir;

    var info = new DamageInfo
    {
        Amount               = _damage,
        HitPoint             = other.ClosestPoint(transform.position),
        KnockbackDir         = knockDir,
        KnockbackForce       = _knockbackForce,
        HitStopDuration      = _hitStopDuration,
        ScreenShakeIntensity = _screenShakeIntensity,
        IsCritical           = false
    };

    hittable.TakeDamage(info);
}

// IHittable.cs
public struct DamageInfo
{
    public int Amount;
    public Vector2 HitPoint;
    public Vector2 KnockbackDir;
    public float KnockbackForce;
    public float HitStopDuration;
    public float ScreenShakeIntensity;
    public bool IsCritical;
}

public interface IHittable
{
    void TakeDamage(DamageInfo info);
    bool IsAlive { get; }
}

// PhysicsUtil.cs — 근접 공격용 5점 시야 판정
public static bool HasLineOfSight(Vector2 origin, Collider2D target, LayerMask wallMask)
{
    if (wallMask == 0) return true;

    Bounds  b = target.bounds;
    const float k = 0.05f;
    _sampleBuf[0] = b.center;
    _sampleBuf[1] = new Vector2(b.center.x,            (float)b.max.y - k);
    _sampleBuf[2] = new Vector2(b.center.x,            (float)b.min.y + k);
    _sampleBuf[3] = new Vector2((float)b.min.x + k,    b.center.y);
    _sampleBuf[4] = new Vector2((float)b.max.x - k,    b.center.y);

    foreach (var pt in _sampleBuf)
        if (!Physics2D.Linecast(origin, pt, wallMask))
            return true;

    return false;
}

// SlashVFXController.cs
public Vector2[] GetWorldHitPoints(int comboIndex, int sampleCount = 8)
{
    if (comboIndex < 0 || comboIndex >= 3 || _shapes == null) return System.Array.Empty<Vector2>();

    GetTransformedBezierPoints(comboIndex, _shapes[comboIndex],
        out Vector2 p0, out Vector2 p1, out Vector2 p2, out Vector2 p3);
    Vector2 origin = GetVfxOrigin(comboIndex);

    var pts = new Vector2[sampleCount];
    for (int i = 0; i < sampleCount; i++)
    {
        float   t = i / (float)(sampleCount - 1);
        Vector2 b = BezierCubic(t, p0, p1, p2, p3);
        pts[i]    = origin + b;
    }
    return pts;
}

private static Vector2 BezierCubic(float t, Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3)
{
    float u = 1f - t;
    return u*u*u*p0 + 3f*u*u*t*p1 + 3f*u*t*t*p2 + t*t*t*p3;
}

// PlayerCombat.cs
private void BezierHitCheck(int comboIndex, Vector2 attackDir)
{
    if (_slashVFX == null) return;

    _bezierHitSet.Clear();
    var pts      = _slashVFX.GetWorldHitPoints(comboIndex, _bezierHitSamples);
    var knockDir = new Vector2(attackDir.x, 0.2f).normalized;

    Vector2 attackOrigin = (Vector2)transform.position + Vector2.up * _attackPivotHeight;
    foreach (var pt in pts)
    {
        var cols = Physics2D.OverlapCircleAll(pt, _lungeCastRadius, _enemyLayerMask);
        foreach (var col in cols)
            ApplyHitToCollider(col, pt, comboIndex, knockDir, attackOrigin);
    }
}

private void ApplyHitToCollider(Collider2D col, Vector2 hitPoint, int comboIndex, Vector2 knockDir, Vector2 attackOrigin)
{
    var hittable = col.GetComponentInParent<IHittable>();
    if (hittable == null || !hittable.IsAlive || !_bezierHitSet.Add(hittable)) return;
    if (!PhysicsUtil.HasLineOfSight(attackOrigin, col, _wallLayerMask)) return;

    hittable.TakeDamage(new DamageInfo
    {
        Amount               = COMBO_DAMAGE[comboIndex],
        // ...
    });
}

// SkillBase.cs
private void Update()
{
    if (_cooldownTimer > 0f)
    {
        _cooldownTimer -= Time.unscaledDeltaTime;
        if (_cooldownTimer < 0f) _cooldownTimer = 0f;

        var reactive = CooldownReactive;
        if (reactive != null) reactive.Value = _cooldownTimer;
    }
    OnUpdate();
}

public bool TryActivate()
{
    if (!IsReady) return false;
    if (!_stats.IsAlive) return false;
    if (!CanActivate()) return false;

    _cooldownTimer = Cooldown;
    var reactive = CooldownReactive;
    if (reactive != null) reactive.Value = _cooldownTimer;

    StartCoroutine(ExecuteWrapper());
    return true;
}

// SkillDashSlash.cs — 초승달이 날아가며 경로를 훑는다
while (traveled < maxRange)
{
    float   step   = speed * Time.unscaledDeltaTime;
    traveled      += step;
    Vector3 offset = moveDir * step;

    for (int i = 0; i < ARC_POINTS; i++)
    {
        positions[i] += offset;
        _crescentLR.SetPosition(i, positions[i]);
        _crescentGlowLR.SetPosition(i, positions[i]);
    }

    Vector2 midpoint = (
        (Vector2)positions[0] +
        (Vector2)positions[ARC_POINTS / 2] +
        (Vector2)positions[ARC_POINTS - 1]
    ) / 3f;

    var overlaps = Physics2D.OverlapCircleAll(midpoint, radius * 0.75f, enemyMask);
    foreach (var col in overlaps)
    {
        var h = col.GetComponentInParent<IHittable>();
        if (h == null || !h.IsAlive || !hitSet.Add(h)) continue;

        h.TakeDamage(new DamageInfo { /* Amount = 9999, ... */ });
    }
    yield return null;
}

// SlashVFXController.cs — draw → hold → fade 3단계
private void ComputeSlashFrame(float elapsed, out int reveal, out float alpha)
{
    if (elapsed < _drawTime)
    {
        float rawT   = elapsed / _drawTime;
        float easedT = 1f - (1f - rawT) * (1f - rawT);
        reveal = Mathf.Clamp(Mathf.RoundToInt(easedT * _slashPoints), 2, _slashPoints);
        alpha  = 1f;
    }
    else if (elapsed < _drawTime + _holdTime)
    {
        reveal = _slashPoints;
        alpha  = 1f;
    }
    else
    {
        float fadeT = (elapsed - _drawTime - _holdTime) / _fadeTime;
        reveal = _slashPoints;
        alpha  = Mathf.Clamp01(1f - fadeT);
    }
}

// AfterImageController.cs
var img = _poolManager.Get<AfterImageEffect>(PoolKeys.AfterImage);
if (img == null) return;

img.transform.position   = _sourceRenderer.transform.position;
img.transform.localScale = _sourceRenderer.transform.lossyScale;
var captured = img;
img.Initialize(
    _sourceRenderer.sprite, _sourceRenderer.flipX,
    _sourceRenderer.sortingLayerID, _sourceRenderer.sortingOrder,
    color,
    () => _poolManager.Release(PoolKeys.AfterImage, captured),
    useOverlayLayer);

// HitStopController.cs
private IEnumerator HitStopRoutine(float duration)
{
    Time.timeScale = 0.05f; // near-freeze — avoids hard-stop lag feel
    yield return GetWait(duration);
    // Restore to the appropriate base timeScale — prioritise kill-cam, then dodge slow-mo
    if (KillCamController.IsActive)
        Time.timeScale = 0.3f;
    else if (PerfectDodgeController.IsSlowMoActive)
        Time.timeScale = PerfectDodgeController.SlowMoTimeScale;
    else
        Time.timeScale = 1f;
    _stopCoroutine = null;
}