Unity 리듬 게임 만들기 — 큐브가 비트에 맞춰 굴러가는 BeatBox 개발기

// CubeRoller.cs 실제 코드
private const float CUBE_SIZE = 1f;
private const float HALF_SIZE = CUBE_SIZE / 2f;
private const float ROLL_ANGLE = 90f;
private const int ROLL_STEPS = 20;

[SerializeField] private float _rollDuration = 0.15f;
[SerializeField] private LayerMask _groundLayer;

private IEnumerator RollCoroutine(RollDirection direction, Vector3 moveDir, Vector3 nextGridPos)
{
    _isRolling = true;

    var pivot = transform.position + (moveDir * HALF_SIZE + Vector3.down * HALF_SIZE);
    var axis = GetRotationAxis(direction);
    var anglePerStep = ROLL_ANGLE / ROLL_STEPS;
    var timePerStep = _rollDuration / ROLL_STEPS;

    for (int i = 0; i < ROLL_STEPS; i++)
    {
        transform.RotateAround(pivot, axis, anglePerStep);
        yield return new WaitForSeconds(timePerStep);
    }

    _targetGridPosition = nextGridPos;
    SnapPosition();
    _isRolling = false;
    OnRollComplete?.Invoke();
}

private void SnapPosition()
{
    var pos = _targetGridPosition;
    transform.position = new Vector3(pos.x, pos.y + HALF_SIZE, pos.z);

    var euler = transform.eulerAngles;
    transform.eulerAngles = new Vector3(
        Mathf.Round(euler.x / ROLL_ANGLE) * ROLL_ANGLE,
        Mathf.Round(euler.y / ROLL_ANGLE) * ROLL_ANGLE,
        Mathf.Round(euler.z / ROLL_ANGLE) * ROLL_ANGLE
    );
}

// CubeController.cs 실제 코드
private void OnMovePerformed(InputAction.CallbackContext ctx)
{
    if (GameManager.Instance.CurrentState != GameState.Playing) return;
    if (_roller.IsRolling) return;

    var input = ctx.ReadValue<Vector2>();
    var inputDir = GetRollDirection(input);
    if (!inputDir.HasValue) return;

    if (_rhythmMode && _judgeSystem != null)
    {
        var judgment = _judgeSystem.Judge();
        if (judgment == Judgment.Miss)
        {
            HandleFall();  // 타이밍 미스 → 즉사
            return;
        }

        if (_levelLoader != null)
        {
            var expectedDir = _levelLoader.GetDirectionAtBeat(_currentBeatIndex);
            var expectedRollDir = LevelDirToRollDir(expectedDir);
            if (inputDir.Value != expectedRollDir)
            {
                HandleFall();  // 방향 미스 → 즉사
                return;
            }
        }
    }

    _roller.TryRoll(inputDir.Value);
}

// RhythmManager.cs 실제 코드
public void StartMusic(AudioClip clip)
{
    _lastReportedBeat = -1;
    _dspSongStartTime = AudioSettings.dspTime + (_startBeatDelay * _secondsPerBeat);
    _audioSource.clip = clip;
    _audioSource.PlayScheduled(_dspSongStartTime + _audioOffset);
    _isPlaying = true;
}

public double GetTimingError()
{
    double currentTime = AudioSettings.dspTime;
    double songPosition = currentTime - _dspSongStartTime;
    double beatPosition = songPosition / _secondsPerBeat;
    double nearestBeat = Math.Round(beatPosition);
    double error = (beatPosition - nearestBeat) * _secondsPerBeat;
    return error;
}

// JudgeSystem.cs 실제 코드
public Judgment Judge()
{
    double error = _rhythmManager.GetTimingError();
    double absError = Math.Abs(error);
    int nearestBeat = _rhythmManager.GetNearestBeatIndex();

    Judgment result;
    if (absError <= _perfectWindow)
        result = Judgment.Perfect;
    else if (absError <= _goodWindow)
        result = Judgment.Good;
    else
        result = Judgment.Miss;

    OnJudgment?.Invoke(result, nearestBeat, error);
    return result;
}

// TileSpawner.cs 실제 코드
public void Initialize(Vector3[] positions, Material defaultMat, Material startMat, Material endMat)
{
    _spawnedTiles = new GameObject[positions.Length];
    _tileMaterials = new Material[positions.Length];
    _originalColors = new Color[positions.Length];

    // 첫 3개: 즉시 배치
    for (int i = 0; i < Mathf.Min(_initialVisibleCount, positions.Length); i++)
        SpawnTileImmediate(i);

    // 다음 5개: 비행 애니메이션 (0.12초 간격 스태거)
    int flyEnd = Mathf.Min(_initialVisibleCount + _lookAheadCount, positions.Length);
    for (int i = _initialVisibleCount; i < flyEnd; i++)
        SpawnTileFlyIn(i, (i - _initialVisibleCount) * 0.12f);
}

// TileSpawner.cs — 커스텀 이징
private static float EaseOutBack(float t)
{
    const float c1 = 1.70158f;
    const float c3 = c1 + 1f;
    return 1f + c3 * Mathf.Pow(t - 1f, 3f) + c1 * Mathf.Pow(t - 1f, 2f);
}

private static float EaseOutBounceLight(float t)
{
    if (t < 0.7f)
        return Mathf.Lerp(0f, 1.1f, t / 0.7f);  // 0→1.1 (오버슈트)
    else
        return Mathf.Lerp(1.1f, 1f, (t - 0.7f) / 0.3f);  // 1.1→1 (안착)
}

private IEnumerator FlyInCoroutine(Transform tile, Vector3 from, Vector3 to, float delay)
{
    if (delay > 0f) yield return new WaitForSeconds(delay);
    float elapsed = 0f;
    while (elapsed < _flyDuration)
    {
        elapsed += Time.deltaTime;
        float t = Mathf.Clamp01(elapsed / _flyDuration);
        tile.position = Vector3.LerpUnclamped(from, to, EaseOutBack(t));
        tile.localScale = Vector3.one * EaseOutBounceLight(t);
        yield return null;
    }
    tile.position = to;
    tile.localScale = Vector3.one;
}

// TileSpawner.cs — HandleBeat
private void HandleBeat(int beatIndex)
{
    int nextTileIndex = _currentPlayerIndex + 1;
    for (int i = 0; i < _glowAheadCount; i++)
    {
        int idx = nextTileIndex + i;
        if (idx < 0 || idx >= _allPositions.Length) continue;
        if (_spawnedTiles[idx] == null) continue;

        float intensity = Mathf.Lerp(_glowIntensity, _glowIntensity * 0.3f,
            (float)i / _glowAheadCount);
        Color color = _glowColors[(beatIndex + i) % _glowColors.Length];
        PulseTile(idx, intensity, color);
    }
}

private IEnumerator FallAwayCoroutine(GameObject tile)
{
    var startPos = tile.transform.position;
    var fallDir = (Vector3.down + new Vector3(
        Random.Range(-0.3f, 0.3f), 0f, Random.Range(-0.3f, 0.3f)
    )).normalized;
    var endPos = startPos + fallDir * _flyDistance;

    float elapsed = 0f;
    while (elapsed < _fallAwayDuration)
    {
        elapsed += Time.deltaTime;
        float progress = Mathf.Clamp01(elapsed / _fallAwayDuration);
        tile.transform.position = Vector3.LerpUnclamped(startPos, endPos, EaseInBack(progress));
        tile.transform.localScale = Vector3.one * (1f - progress);
        yield return null;
    }
    Destroy(tile);
}

// BeatPulse.cs — 큐브 비트 펄스 (전체 코드)
private void HandleBeat(int beatIndex)
{
    _currentTween?.Complete();
    _currentTween = transform.DOPunchScale(_punchScale, _duration, _vibrato, _elasticity)
        .SetEase(Ease.OutQuad);
}