구현 코드

1private struct UndirectedEdgeKey : System.IEquatable<UndirectedEdgeKey>
2{
3    private readonly Vector2Int _min;
4    private readonly Vector2Int _max;
5    public UndirectedEdgeKey(Vector2Int first, Vector2Int second)
6    {
7        var isOrdered = first.x < second.x || (first.x == second.x && first.y < second.y);
8        _min = isOrdered ? first : second;
9        _max = isOrdered ? second : first;
10    }
11    public bool Equals(UndirectedEdgeKey other) => _min == other._min && _max == other._max;
12    public override int GetHashCode() => HashCode.Combine(_min, _max);
13}
14 
15// 좌표를 SnapScale 배 정수로 반올림해 부동소수 오차를 제거
16private static Vector2Int SnapToGrid(Vector3 position) => new Vector2Int(
17    Mathf.RoundToInt(position.x * SnapScale), Mathf.RoundToInt(position.z * SnapScale));
18 
19public static List<Edge> GetBoundaryEdges(
20    IReadOnlyList<Vector3> tileCenters, float radius, float yOffset)
21{
22    var edgeCounts = new Dictionary<UndirectedEdgeKey, EdgeInfo>();
23    foreach (var center in tileCenters)
24    {
25        for (var side = 0; side < HexSides; side++)
26        {
27            var corner = GetHexCornerWorldPosition(center, side, radius, yOffset);
28            var nextCorner = GetHexCornerWorldPosition(center, (side + 1) % HexSides, radius, yOffset);
29            RegisterEdge(edgeCounts, corner, nextCorner);
30        }
31    }
32 
33    var boundary = new List<Edge>();
34    foreach (var entry in edgeCounts)
35        if (entry.Value.Count == 1)   // 두 타일이 공유한 변은 2, 외곽 변만 1
36            boundary.Add(entry.Value.Edge);
37    return boundary;
38}
39 
40private static void RegisterEdge(
41    Dictionary<UndirectedEdgeKey, EdgeInfo> edgeCounts, Vector3 corner, Vector3 nextCorner)
42{
43    var key = new UndirectedEdgeKey(SnapToGrid(corner), SnapToGrid(nextCorner));
44    if (edgeCounts.TryGetValue(key, out var info))
45    {
46        info.Count++;
47        edgeCounts[key] = info;
48        return;
49    }
50    edgeCounts[key] = new EdgeInfo { Count = 1, Edge = new Edge { start = corner, end = nextCorner } };
51}

1private const int MinLoopPoints = 3;   // 점이 셋 미만이면 면이 되지 않는다
2private static readonly Vector2Int NoPrevious = new Vector2Int(int.MinValue, int.MinValue);
3 
4public static List<List<Vector3>> BuildOrderedLoops(List<Edge> edges)
5{
6    var (adjacency, worldPositions) = BuildAdjacency(edges);
7    var visited = new HashSet<Vector2Int>();
8    var loops = new List<List<Vector3>>();
9    foreach (var start in adjacency.Keys)
10    {
11        if (visited.Contains(start))
12            continue;
13        var loop = TraceLoop(start, adjacency, worldPositions, visited);
14        if (loop.Count >= MinLoopPoints)
15            loops.Add(loop);
16    }
17    return loops;
18}
19 
20private static (Dictionary<Vector2Int, List<Vector2Int>>, Dictionary<Vector2Int, Vector3>)
21    BuildAdjacency(List<Edge> edges)
22{
23    var adjacency = new Dictionary<Vector2Int, List<Vector2Int>>();
24    var worldPositions = new Dictionary<Vector2Int, Vector3>();
25    foreach (var edge in edges)
26    {
27        var startKey = SnapToGrid(edge.start);
28        var endKey = SnapToGrid(edge.end);
29        AddUndirectedEdge(adjacency, startKey, endKey);
30        worldPositions.TryAdd(startKey, edge.start);
31        worldPositions.TryAdd(endKey, edge.end);
32    }
33    return (adjacency, worldPositions);
34}
35 
36private static List<Vector3> TraceLoop(Vector2Int start,
37    Dictionary<Vector2Int, List<Vector2Int>> adjacency,
38    Dictionary<Vector2Int, Vector3> worldPositions, HashSet<Vector2Int> visited)
39{
40    var loop = new List<Vector3>();
41    var (current, previous) = (start, NoPrevious);
42    while (true)
43    {
44        visited.Add(current);
45        loop.Add(worldPositions[current]);
46 
47        var next = FindNextNeighbor(adjacency[current], previous);
48        var isLoopClosed = next == null || next.Value == start || visited.Contains(next.Value);
49        if (isLoopClosed)
50            break;
51        previous = current;
52        current = next.Value;
53    }
54    return loop;
55}

1// pointCount: 점 개수 · baseIndex: 시작 정점 · Flat(v): y=0 투영 · Wrap(k, n): 순환 인덱스 · EpsSqr: 미소값²
2const float MinMiterDot = 0.5f;   // 예각에서 폭이 두 배를 넘지 않게 하는 하한
3 
4for (var i = 0; i < pointCount; i++)
5{
6    var point = loop[i];
7    var incoming = FindIncomingDirection(loop, i);
8    var outgoing = FindOutgoingDirection(loop, i);
9 
10    // 폭 방향을 월드 업 기준으로 고정 (카메라 위치와 무관)
11    var incomingNormal = Vector3.Cross(Vector3.up, incoming);
12    var outgoingNormal = Vector3.Cross(Vector3.up, outgoing);
13    var (miter, miterScale) = ComputeMiter(incomingNormal, outgoingNormal);
14    AddBandVertexPair(point, miter * halfWidth * miterScale);
15}
16 
17// 루프의 감김 방향을 확인해 뒤집힌 면을 보정
18var cross = Vector3.Cross(verts[baseIndex + 1] - verts[baseIndex],
19    verts[baseIndex + 2] - verts[baseIndex]);
20if (Vector3.Dot(cross, transform.InverseTransformDirection(Vector3.up)) < 0f)
21    SwapInnerOuter(verts, uvs);
22 
23for (var i = 0; i < pointCount; i++)   // 인접 정점 쌍을 이어 쿼드 스트립 구성
24    AddQuad(tris, baseIndex + i * 2, baseIndex + i * 2 + 1,
25        baseIndex + ((i + 1) % pointCount) * 2, baseIndex + ((i + 1) % pointCount) * 2 + 1);
26 
27private static (Vector3 direction, float scale) ComputeMiter(
28    Vector3 incomingNormal, Vector3 outgoingNormal)
29{
30    var miter = incomingNormal + outgoingNormal;
31    if (miter.sqrMagnitude < EpsSqr)   // 되돌아 꺾이는 경우
32        return (incomingNormal.normalized, 1f);
33    miter.Normalize();
34    var scale = 1f / Mathf.Max(Vector3.Dot(miter, incomingNormal.normalized), MinMiterDot);
35    return (miter, scale);
36}
37private void AddBandVertexPair(Vector3 point, Vector3 offset)
38{
39    verts.Add(transform.InverseTransformPoint(point - offset));   // 안쪽
40    verts.Add(transform.InverseTransformPoint(point + offset));   // 바깥쪽
41    uvs.Add(new Vector2(0.5f, 0f));
42    uvs.Add(new Vector2(0.5f, 1f));
43}
44private static Vector3 FindIncomingDirection(List<Vector3> loop, int i)
45    => FindSegmentDirection(loop, i - 1, step: -1);
46private static Vector3 FindOutgoingDirection(List<Vector3> loop, int i)
47    => FindSegmentDirection(loop, i, step: +1);
48// startIndex 부터 step 방향으로 훑어, 길이 0 세그먼트를 건너뛴 첫 유효 세그먼트의 단위 방향
49private static Vector3 FindSegmentDirection(List<Vector3> loop, int startIndex, int step)
50{
51    var pointCount = loop.Count;
52    for (var offset = 0; offset < pointCount - 1; offset++)
53    {
54        var from = Wrap(startIndex + offset * step, pointCount);
55        var direction = Flat(loop[Wrap(from + 1, pointCount)] - loop[from]);
56        if (direction.sqrMagnitude >= EpsSqr)
57            return direction.normalized;
58    }
59    return Vector3.zero;
60}

1// _cts: 이 대화 객체(DMInfo)가 보유한 CancellationTokenSource 필드
2private async UniTask ProcessForkedMessageAsync(IDMMessageWrapData currentMessage)
3{
4    if (currentMessage.Conditions.IsNullOrZeroCount())
5    {
6        _forkedDMQueue.Enqueue(currentMessage);   // 합류 조건이 없는 메시지는 큐에 쌓기만 한다
7        return;
8    }
9 
10    var consumeQueueTask = ConsumeForkedQueueAsync(_cts.Token);
11    await WaitDefaultIntervalAsync(currentMessage, _cts.Token);
12    var joinTask = ShowJoinMessageAsync(currentMessage, _cts.Token)
13        .ContinueWith(() =>
14        {
15            var hasRemainingForkedMessages = _isForkedStateProperty.Value
16                && _forkedDMQueue.Count > 0;
17            if (hasRemainingForkedMessages)
18                _cts.Cancel();
19        });
20 
21    await UniTask.WhenAll(consumeQueueTask, joinTask);
22    await VerifyShownMessagesAsync(currentMessage, _cts.Token);
23}
24private async UniTask ShowJoinMessageAsync(
25    IDMMessageWrapData currentMessage, CancellationToken cancellationToken)
26{
27    await WaitRequirementsAsync(currentMessage, cancellationToken);
28    await ShowMessageWithIntervalAsync(currentMessage);   // SendMessage 처리가 이 호출 안에서 함께 일어난다
29}
30private async UniTask ConsumeForkedQueueAsync(CancellationToken cancellationToken)
31{
32    while (_forkedDMQueue.Count > 0)
33    {
34        var message = _forkedDMQueue.Dequeue();
35        try
36        {
37            await ShowMessageAsync(message, cancellationToken);
38            if (IsLastMessage(message))
39                NotifyLastMessage();
40        }
41        catch (OperationCanceledException)
42        {
43            ResetForkedQueue();
44            break;
45        }
46    }
47    _isForkedStateProperty.Value = false;
48}

1private async UniTask ShowMessageWithIntervalAsync(IDMMessageWrapData currentMessage)
2{
3    EnterIntervalState(currentMessage);
4    var isForkedJoinPoint = _isForkedStateProperty.Value
5        && currentMessage.Conditions.IsNullOrZeroCount() == false;
6    if (isForkedJoinPoint)
7        SkipQueuedMessageIndices();
8 
9    ShowMessageAndAdvance(currentMessage);
10 
11    try
12    {
13        var shouldWaitInterval = currentMessage.SendMessage == false && currentMessage.Interval > 0;
14        if (shouldWaitInterval)
15            await WaitIntervalAsync(currentMessage);
16    }
17    catch (OperationCanceledException)
18    {
19        RollbackIntervalProgress(currentMessage);   // 취소는 합류 메시지에서만 일어난다
20        throw;
21    }
22    finally
23    {
24        ExitIntervalState();
25    }
26}
27private int QueuedMessageSpan => _forkedDMQueue.Count + 1;   // 큐에 남은 메시지 수 + 합류 메시지
28private void SkipQueuedMessageIndices() => _messageIndex += QueuedMessageSpan;
29private void EnterIntervalState(IDMMessageWrapData currentMessage)
30{
31    _isIntervalInProgressProperty.Value = true;
32    _isSkipIntervalProperty.Value = false;
33    currentMessage.IsIntervalProperty.Value = true;
34}
35private void ShowMessageAndAdvance(IDMMessageWrapData currentMessage)
36{
37    LastMessage = _dmWrapDataList[_messageIndex];
38    currentMessage.IsShownProperty.Value = true;
39    _messageIndex++;
40    _intervalSubject.OnNext(true);
41}
42private void ExitIntervalState()
43{
44    _intervalSubject.OnNext(false);
45    _isIntervalInProgressProperty.Value = false;
46}
47private void RollbackIntervalProgress(IDMMessageWrapData currentMessage)
48{
49    _messageIndex -= QueuedMessageSpan;
50    LastMessage = _dmWrapDataList[_messageIndex];
51    currentMessage.IsIntervalProperty.Value = false;
52}

1public interface ISettingsData
2{
3    void Load();
4    void Save();
5}
6public interface ISettingsView
7{
8    event Action<string, object> ValueChanged;   // 사용자가 옵션을 바꾸면 (key, value)
9    void Initialize(ISettingsData settings);
10    void Commit();                               // 화면의 값을 데이터에 반영
11    void Refresh(string key);                    // 데이터의 값을 화면에 반영
12}
13 
14public abstract class SettingsController : MonoBehaviour
15{
16    private ISettingsData _data;
17    private ISettingsView _view;
18    public event Action<string, object> ValueChanged;
19 
20    public void Initialize(ISettingsData data, ISettingsView view)
21    {
22        _data = data ?? throw new ArgumentNullException(nameof(data));
23        _view = view ?? throw new ArgumentNullException(nameof(view));
24        _data.Load();
25        _view.Initialize(_data);
26        _view.ValueChanged += OnViewValueChanged;
27    }
28    public void Apply()
29    {
30        _view.Commit();
31        _data.Save();
32    }
33    private void OnViewValueChanged(string key, object value)
34    {
35        ApplyToEngine(key, value);
36        ValueChanged?.Invoke(key, value);
37        _view.Refresh(key);
38    }
39    // 오디오 믹서, 해상도처럼 엔진에 반영하는 방법은 카테고리마다 다르다
40    protected abstract void ApplyToEngine(string key, object value);
41    private void OnDestroy()
42    {
43        if (_view != null)
44            _view.ValueChanged -= OnViewValueChanged;
45    }
46}

1public abstract class SettingsDataBase : ScriptableObject, ISettingsData
2{
3    private const string KeyPrefix = "Settings_";
4    private string StorageKey => KeyPrefix + GetType().Name;
5    protected abstract string Serialize();
6    protected abstract void Deserialize(string json);
7 
8    public void Save()
9    {
10        PlayerPrefs.SetString(StorageKey, Serialize());
11        PlayerPrefs.Save();
12    }
13    public void Load()
14    {
15        var json = PlayerPrefs.GetString(StorageKey, string.Empty);
16        if (string.IsNullOrEmpty(json))
17            return;   // 저장된 값이 없으면 ScriptableObject 의 기본값을 그대로 쓴다
18        Deserialize(json);
19    }
20}
21public abstract class SettingsViewBase<TData> : MonoBehaviour, ISettingsView where TData : ISettingsData
22{
23    private readonly Dictionary<string, Action> _refreshHandlers = new();
24    public event Action<string, object> ValueChanged;
25 
26    public void Initialize(ISettingsData settings) => Initialize((TData)settings);
27    protected abstract void Initialize(TData settings);
28    public abstract void Commit();
29    public void Refresh(string key)
30    {
31        if (_refreshHandlers.TryGetValue(key, out var refresh))
32            refresh();
33    }
34    protected void RegisterRefreshHandler(string key, Action handler) => _refreshHandlers[key] = handler;
35    protected void RaiseValueChanged(string key, object value) => ValueChanged?.Invoke(key, value);
36}
37 
38// 카테고리 하나를 추가할 때 쓰는 뷰. 옵션마다 "읽기"와 "키"만 알려 주면 된다
39public class SoundSettingsView : SettingsViewBase<SoundSettingsData>
40{
41    [SerializeField] private SettingsOptionSlider _masterVolume;
42    [SerializeField] private SettingsOptionSlider _bgmVolume;
43    [SerializeField] private SettingsOptionSlider _sfxVolume;
44 
45    protected override void Initialize(SoundSettingsData sound)
46    {
47        Bind(_masterVolume, SoundSettingsData.MasterVolumeKey, sound.GetMasterVolume);
48        Bind(_bgmVolume, SoundSettingsData.BgmVolumeKey, sound.GetBgmVolume);
49        Bind(_sfxVolume, SoundSettingsData.SfxVolumeKey, sound.GetSfxVolume);
50    }
51    private void Bind(SettingsOptionSlider slider, string key, Func<float> read)
52    {
53        slider.Initialize(read(), value => RaiseValueChanged(key, value));
54        RegisterRefreshHandler(key, () => slider.SetValue(read()));
55    }
56    public override void Commit()
57    {
58        _masterVolume.Commit();
59        _bgmVolume.Commit();
60        _sfxVolume.Commit();
61    }
62}

1// NOTE
2// AchievementViewPresenter 클래스를 직접 테스트하려 했으나,
3// 단순히 Observable의 구독 여부만을 검증하기 위해 Substitute의 Received() 함수를 사용하는 경우,
4// AchievementViewPresenter와 IAchievementView, IAchievementDataPresenter를 Mocking하고,
5// IAchievementView 내의 IComponentInterfacePool<IAchievementCell>과
6// IComponentInterfacePool<IAchievementToastCell> 등도 각각 Mocking해야 하는 복잡성이 있었습니다.
7// 특히, [Inject] 속성과 Awake() 함수가 모두 호출되어 Pool이 Init 되었는지를
8// 확인하는 부분에서 테스트가 더 복잡해졌습니다.
9// 이러한 이유로 AchievementViewPresenterProxy 클래스를 생성하여 테스트를 간소화해보았습니다.
10public class AchievementViewPresenterProxy : AchievementViewPresenter
11{
12    public bool ShowTitleCellCalled { get; private set; } = false;
13    public bool ShowToastCellCalled { get; private set; } = false;
14    public IReadOnlyList<IAchievementProgress> ReceivedDataList { get; private set; }
15    public IAchievementData ReceivedAchievementData { get; private set; }
16 
17    // … ShowTitleCell 오버라이드 생략 (동일 패턴) …
18 
19    public override async UniTask<IDisposable> ShowToastCell(IAchievementData data)
20    {
21        ShowToastCellCalled = true;
22        var disposable = await base.ShowToastCell(data);
23        ReceivedAchievementData = data;
24        return disposable;
25    }
26}
27 
28[UnityTest]
29public IEnumerator OnShowToastCellObservable이_데이터를_발행하면_해당_데이터를_인수로_ShowToastCell함수_호출()
30{
31    // Arrange
32    SetupMockToastPool();
33    var achievementData = CreateMockAchievementData();
34    var subject = SetupMockObservable(() => _mockDataPresenter.OnShowToastCellObservable());
35 
36    var proxyPresenter = Container.InstantiateComponent<AchievementViewPresenterProxy>(_testObj);
37 
38    // Act
39    subject.OnNext(achievementData);
40    yield return null;
41 
42    // Assert
43    Assert.IsTrue(proxyPresenter.ShowToastCellCalled);
44    Assert.AreEqual(achievementData, proxyPresenter.ReceivedAchievementData);
45}

1using Cysharp.Threading.Tasks;
2using Fakebook.Model;
3using NUnit.Framework;
4using System.Collections;
5using System.Collections.Generic;
6using UniRx;
7using UnityEngine.TestTools;
8 
9[Category("fakebook")]
10public class DMInfoTests : Zenject.ZenjectUnitTestFixture
11{
12    [UnityTest]
13    public IEnumerator 메세지데이터가_5개있을때_3번째가_SendMessage직후_5번째까지_진행되면_레드닷은_2개()
14    {
15        // Arrange
16        string actualName = "tester";
17 
18        List<IDMMessageData> messageList = new()
19        {
20            DMTestUtil.CreateDMMessage(),
21            DMTestUtil.CreateDMMessage(),
22            DMTestUtil.CreateDMMessageSendMessageTrue(),
23            DMTestUtil.CreateDMMessage(),
24            DMTestUtil.CreateDMMessage(),
25        };
26 
27        var dmData = DMTestUtil.CreateDMData(actualName, messageList.ToArray());
28        var dmInfo = new DMInfo(dmData);
29        dmInfo.OnShowedMessageObservable().Subscribe(_ => { });
30        dmInfo.OnCheckShowedMessageObservable().Subscribe(_ => { });
31 
32        int firstConfirmMessageIndex = 3;
33        bool firstWait = false;
34        dmInfo.OnCheckConditionObservable().Subscribe(_ => UniTask.FromResult(true));
35        dmInfo.OnChatViewOpenObservable().Subscribe(async data =>
36        {
37            if (firstConfirmMessageIndex-- == 0)
38            {
39                await UniTask.WaitUntil(() => firstWait);
40            }
41 
42            return true;
43        });
44 
45        _ = dmInfo.StartMessageObservable();
46 
47        for (int i = 0; i < messageList.Count; i++)
48        {
49            yield return null;
50        }
51 
52        // Act
53        dmInfo.UpdateConfirmIndex();
54        firstWait = true;
55        for (int i = 0; i < messageList.Count - firstConfirmMessageIndex; i++)
56        {
57            yield return null;
58        }
59 
60        // Assert
61        Assert.AreEqual(2, dmInfo.ReddotProperty.Value);
62    }
63}

1using UnityEngine;
2 
3namespace Banjiha.Elementail.Game
4{
5    internal readonly struct MultiHitTimingConfig
6    {
7        public readonly float MaxSeconds;
8        public readonly float MinSeconds;
9        public readonly float MaxSalvoPower;
10        public readonly float SalvoIntensityStartHitCount;
11        public readonly float SalvoIntensityEndHitCount;
12 
13        public MultiHitTimingConfig(
14            float maxSeconds,
15            float minSeconds,
16            float maxSalvoPower,
17            float salvoIntensityStartHitCount,
18            float salvoIntensityEndHitCount)
19        {
20            MaxSeconds = maxSeconds;
21            MinSeconds = minSeconds;
22            MaxSalvoPower = maxSalvoPower;
23            SalvoIntensityStartHitCount = salvoIntensityStartHitCount;
24            SalvoIntensityEndHitCount = salvoIntensityEndHitCount;
25        }
26    }
27 
28    internal static class MultiHitTimingCore
29    {
30        private static float Smoothstep01(float x)
31        {
32            if (x <= 0f) return 0f;
33            if (x >= 1f) return 1f;
34            return x * x * (3f - 2f * x);
35        }
36 
37        private static float GetSalvoIntensity(int hitCount, in MultiHitTimingConfig config)
38        {
39            return Smoothstep01(Mathf.InverseLerp(
40                config.SalvoIntensityStartHitCount,
41                config.SalvoIntensityEndHitCount,
42                hitCount));
43        }
44 
45        public static float GetStepDurationSeconds(int stepIndex, int stepCount, in MultiHitTimingConfig config)
46        {
47            if (stepCount <= 0)
48                return config.MaxSeconds;
49            if (stepCount == 1)
50                return config.MaxSeconds;
51 
52            stepIndex = Mathf.Clamp(stepIndex, 0, stepCount - 1);
53 
54            float u = stepIndex / (float)(stepCount - 1);
55            float s = Smoothstep01(u);
56 
57            float salvoPower = 1f + Mathf.InverseLerp(2f, config.SalvoIntensityEndHitCount, stepCount)
58                * (config.MaxSalvoPower - 1f);
59            float t = Mathf.Pow(s, salvoPower);
60            float effectiveT = Mathf.Clamp01(t * GetSalvoIntensity(stepCount, config));
61            return Mathf.Lerp(config.MaxSeconds, config.MinSeconds, effectiveT);
62        }
63 
64        public static float GetTotalStaggerSeconds(int stepCount, in MultiHitTimingConfig config)
65        {
66            if (stepCount <= 0)
67                return 0f;
68 
69            float sum = 0f;
70            for (int i = 0; i < stepCount; i++)
71                sum += GetStepDurationSeconds(i, stepCount, config);
72            return sum;
73        }
74    }
75 
76    public static class MultiHitAttackTiming
77    {
78        public const float MaxHitSeconds = 0.22f;
79 
80        public const float MinHitSeconds = 0.052f;
81 
82        private static readonly MultiHitTimingConfig Config = new(
83            MaxHitSeconds,
84            MinHitSeconds,
85            maxSalvoPower: 1.52f,
86            salvoIntensityStartHitCount: 10f,
87            salvoIntensityEndHitCount: 30f);
88 
89        public static float GetHitDurationSeconds(int hitIndex, int hitCount)
90            => MultiHitTimingCore.GetStepDurationSeconds(hitIndex, hitCount, Config);
91 
92        public static float GetTotalStaggerSeconds(int hitCount)
93            => MultiHitTimingCore.GetTotalStaggerSeconds(hitCount, Config);
94    }
95 
96    public static class MultiHitCalculateTiming
97    {
98        public const float MaxStepSeconds = 0.30f;
99 
100        public const float MinStepSeconds = 0.14f;
101 
102        private static readonly MultiHitTimingConfig Config = new(
103            MaxStepSeconds,
104            MinStepSeconds,
105            maxSalvoPower: 1.22f,
106            salvoIntensityStartHitCount: 20f,
107            salvoIntensityEndHitCount: 42f);
108 
109        public static float GetStepDurationSeconds(int stepIndex, int stepCount)
110            => MultiHitTimingCore.GetStepDurationSeconds(stepIndex, stepCount, Config);
111 
112        public static float GetTotalStaggerSeconds(int stepCount)
113            => MultiHitTimingCore.GetTotalStaggerSeconds(stepCount, Config);
114    }
115}
116