629 lines
25 KiB
C#
629 lines
25 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using Dreamteck.Splines;
|
||
using Sirenix.OdinInspector;
|
||
using TMPro;
|
||
using UnityEngine;
|
||
|
||
namespace Ichni.RhythmGame
|
||
{
|
||
public abstract partial class NoteBase : GameElement, IHaveTimeDurationSubmodule, IComparable<NoteBase>
|
||
{
|
||
#region [暴露属性字段] Basic & Info
|
||
[Title("Basic Info")]
|
||
public float exactJudgeTime;
|
||
public NoteJudgeIntervals judgeIntervals;
|
||
|
||
[Title("Track Info")]
|
||
public bool isOnTrack;
|
||
public Track track;
|
||
public SplinePositioner trackPositioner;
|
||
|
||
[Title("NoteVisual")]
|
||
public NoteVisualBase noteVisual;
|
||
|
||
[Title("Submodules")]
|
||
public TimeDurationSubmodule timeDurationSubmodule { get; set; }
|
||
public NoteJudgeSubmodule NoteJudgeSubmodule { get; set; }
|
||
public NoteAudioSubmodule NoteAudioSubmodule { get; set; }
|
||
|
||
[Title("In-Game Info")]
|
||
public bool isDuringJudging;
|
||
public Vector2 noteScreenPosition;
|
||
public Vector2 perfectNoteScreenPosition;
|
||
public bool isFirstJudged;
|
||
public bool isFinalJudged;
|
||
public override int HierarchyPriority => -10;
|
||
|
||
[Title("Debug")]
|
||
public TMP_Text judgeRankHint;
|
||
#endregion
|
||
|
||
#region [运行时缓存变量] GC-Free 核心状态层
|
||
protected List<EffectBase> generateEffects;
|
||
protected List<EffectBase> generalJudgeEffects;
|
||
protected List<EffectBase> perfectEffects;
|
||
protected List<EffectBase> goodEffects;
|
||
protected List<EffectBase> badEffects;
|
||
protected List<EffectBase> missEffects;
|
||
protected List<EffectBase> afterJudgeEffects;
|
||
|
||
protected float judgedTriggerTime;
|
||
protected NoteJudgeType judgedType;
|
||
protected bool isJudgedAndDestroying;
|
||
protected float destroyTimer;
|
||
protected Pose judgedEffectPose;
|
||
protected bool hasJudgedEffectPose;
|
||
|
||
// 用于记录是否离开屏幕的最后一帧有效坐标
|
||
protected Vector2 lastValidScreenPosition = -Vector2.one;
|
||
#endregion
|
||
|
||
#region [生命周期] Initialization
|
||
public override void SetDefaultSubmodules()
|
||
{
|
||
timeDurationSubmodule = new TimeDurationSubmodule(this);
|
||
NoteJudgeSubmodule = new NoteJudgeSubmodule(this);
|
||
}
|
||
|
||
public override void AfterInitialize()
|
||
{
|
||
// 安全读取字典防报错
|
||
generateEffects = GetEffectListSafe("Generate");
|
||
generalJudgeEffects = GetEffectListSafe("GeneralJudge");
|
||
perfectEffects = GetEffectListSafe("Perfect");
|
||
goodEffects = GetEffectListSafe("Good");
|
||
badEffects = GetEffectListSafe("Bad");
|
||
missEffects = GetEffectListSafe("Miss");
|
||
afterJudgeEffects = GetEffectListSafe("AfterJudge");
|
||
|
||
noteScreenPosition = Vector2.zero;
|
||
perfectNoteScreenPosition = -Vector2.one;
|
||
lastValidScreenPosition = -Vector2.one; // 初始化
|
||
judgedEffectPose = default;
|
||
hasJudgedEffectPose = false;
|
||
|
||
if (NoteJudgeSubmodule?.judgeUnitList != null)
|
||
{
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
NoteJudgeSubmodule.judgeUnitList[i].ResetSpatialState();
|
||
}
|
||
}
|
||
|
||
float beyondTime = 0f;
|
||
|
||
// 【Review修改】：使用无 GC 预存列表操作替代 String 调用
|
||
if (generateEffects != null)
|
||
{
|
||
for (int i = 0; i < generateEffects.Count; i++)
|
||
{
|
||
EffectBase effectBase = generateEffects[i];
|
||
if (effectBase is NoteGenerateEffect ge)
|
||
{
|
||
ge.Recover();
|
||
beyondTime = Mathf.Max(beyondTime, ge.generateTime);
|
||
}
|
||
else
|
||
{
|
||
effectBase.Recover();
|
||
}
|
||
}
|
||
}
|
||
|
||
if (exactJudgeTime - beyondTime - 0.5f > -GameManager.Instance.songInformation.delay)
|
||
{
|
||
gameObject.SetActive(false);
|
||
GameManager.Instance.noteManager.RegisterNote(this, exactJudgeTime - beyondTime - 0.5f);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 当 NoteVisual 被动态挂载或替换后，重新缓存效果列表并刷新 NoteManager 注册。
|
||
/// </summary>
|
||
public void RefreshNoteVisualCaches()
|
||
{
|
||
generateEffects = GetEffectListSafe("Generate");
|
||
generalJudgeEffects = GetEffectListSafe("GeneralJudge");
|
||
perfectEffects = GetEffectListSafe("Perfect");
|
||
goodEffects = GetEffectListSafe("Good");
|
||
badEffects = GetEffectListSafe("Bad");
|
||
missEffects = GetEffectListSafe("Miss");
|
||
afterJudgeEffects = GetEffectListSafe("AfterJudge");
|
||
|
||
float beyondTime = 0f;
|
||
if (generateEffects != null)
|
||
{
|
||
for (int i = 0; i < generateEffects.Count; i++)
|
||
{
|
||
EffectBase effectBase = generateEffects[i];
|
||
if (effectBase is NoteGenerateEffect ge)
|
||
{
|
||
ge.nowEffectState = EffectBase.EffectState.Before;
|
||
ge.Recover();
|
||
beyondTime = Mathf.Max(beyondTime, ge.generateTime);
|
||
}
|
||
else
|
||
{
|
||
effectBase.nowEffectState = EffectBase.EffectState.Before;
|
||
effectBase.Recover();
|
||
}
|
||
}
|
||
}
|
||
|
||
if (exactJudgeTime - beyondTime - 0.5f > -GameManager.Instance.songInformation.delay)
|
||
{
|
||
gameObject.SetActive(false);
|
||
GameManager.Instance.noteManager.RegisterNote(this, exactJudgeTime - beyondTime - 0.5f);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region [轮询更新] Main Update & Visual Calculate
|
||
public virtual void ManualPrepareForJudge(float currentSongTime)
|
||
{
|
||
if (isJudgedAndDestroying || isFinalJudged) return;
|
||
|
||
// 判定前必须先完成本帧的轨迹、屏幕坐标与判定区域采样。
|
||
UpdateNoteInTrack(currentSongTime);
|
||
UpdateSpatialStateBeforeJudgeScreenSample(currentSongTime);
|
||
UpdateJudgeSpatialState(currentSongTime);
|
||
SetJudgeArea();
|
||
}
|
||
|
||
protected virtual void UpdateSpatialStateBeforeJudgeScreenSample(float currentSongTime)
|
||
{
|
||
}
|
||
|
||
protected virtual void UpdateJudgeSpatialState(float currentSongTime)
|
||
{
|
||
if (perfectNoteScreenPosition != -Vector2.one) return;
|
||
|
||
if (isDuringJudging)
|
||
{
|
||
UpdateJudgeScreenPosition(currentSongTime);
|
||
}
|
||
|
||
if (exactJudgeTime <= currentSongTime)
|
||
{
|
||
perfectNoteScreenPosition = noteScreenPosition;
|
||
}
|
||
}
|
||
|
||
public virtual bool ManualResolveAfterJudge(float currentSongTime)
|
||
{
|
||
// 若被 Judge 判定击中进入到特效摧毁倒计时
|
||
if (isJudgedAndDestroying)
|
||
{
|
||
UpdatePostJudgeEffects();
|
||
|
||
destroyTimer -= Time.deltaTime;
|
||
if (destroyTimer <= 0)
|
||
{
|
||
isJudgedAndDestroying = false;
|
||
|
||
// 【池化核心】调用 NoteManager 向 LeanPool 归还自己，向外抛出 false 要求将自己从更新名单剔除
|
||
GameManager.Instance.noteManager.DespawnNote(this);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
if (isFinalJudged) return true;
|
||
|
||
if (generateEffects != null)
|
||
{
|
||
for (int i = 0; i < generateEffects.Count; i++)
|
||
{
|
||
generateEffects[i].UpdateEffect(exactJudgeTime);
|
||
}
|
||
}
|
||
// 自然 Miss 判定
|
||
if (!isFirstJudged && currentSongTime > exactJudgeTime + judgeIntervals.afterMiss)
|
||
{
|
||
Miss(exactJudgeTime + judgeIntervals.afterMiss);
|
||
GameManager.Instance.playingRecorder.resultData.Add(judgeIntervals.afterMiss);
|
||
isFirstJudged = true;
|
||
isFinalJudged = true;
|
||
RemoveFromCheckingList();
|
||
}
|
||
|
||
// AutoPlay
|
||
if (SettingsManager.instance.settingsSaveData.autoPlay && !isFirstJudged && currentSongTime >= exactJudgeTime)
|
||
{
|
||
ExecuteStartJudge(currentSongTime);
|
||
}
|
||
return true; // 仍然存活
|
||
}
|
||
|
||
public Vector2 GetScreenPosition()
|
||
{
|
||
Camera cam = GameManager.Instance.cameraManager.gameCamera.cam;
|
||
Vector3 screenPoint = cam.WorldToScreenPoint(noteVisual.noteVisualPosition);
|
||
|
||
// 判断是否在屏幕内并且在相机前方 (z>0)
|
||
bool isInsideScreen = screenPoint.z > 0 &&
|
||
screenPoint.x >= 0 && screenPoint.x <= Screen.width &&
|
||
screenPoint.y >= 0 && screenPoint.y <= Screen.height;
|
||
|
||
if (isInsideScreen)
|
||
{
|
||
// 如果在视野中，则缓存坐标并返回
|
||
lastValidScreenPosition = new Vector2(screenPoint.x, screenPoint.y);
|
||
return lastValidScreenPosition;
|
||
}
|
||
else
|
||
{
|
||
// 如果已经离开屏幕，但是曾经存在缓存，就返回离开前最后一帧坐标
|
||
if (lastValidScreenPosition != -Vector2.one)
|
||
{
|
||
return lastValidScreenPosition;
|
||
}
|
||
|
||
// 极端情况（生成时直接在屏幕外），直接返回换算的外界坐标兜底
|
||
return new Vector2(screenPoint.x, screenPoint.y);
|
||
}
|
||
}
|
||
|
||
protected void UpdateJudgeScreenPosition(float songTime)
|
||
{
|
||
noteScreenPosition = GetScreenPosition();
|
||
if (NoteJudgeSubmodule?.judgeUnitList == null) return;
|
||
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
NoteJudgeSubmodule.judgeUnitList[i].UpdateSpatialState(songTime, noteScreenPosition);
|
||
}
|
||
}
|
||
|
||
protected virtual void SetJudgeArea()
|
||
{
|
||
if (!SettingsManager.instance.settingsSaveData.debugMode || NoteJudgeSubmodule?.judgeUnitList == null) return;
|
||
|
||
if (isDuringJudging && !isFirstJudged)
|
||
{
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
var unit = NoteJudgeSubmodule.judgeUnitList[i];
|
||
if (!unit.isShowingJudge) unit.SetShowingJudge(true);
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
var unit = NoteJudgeSubmodule.judgeUnitList[i];
|
||
if (unit.isShowingJudge) unit.UpdateJudge();
|
||
}
|
||
|
||
if (!isDuringJudging && isFinalJudged)
|
||
{
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
var unit = NoteJudgeSubmodule.judgeUnitList[i];
|
||
if (unit.isShowingJudge) unit.SetShowingJudge(false);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region [轨道运动] Track Logic
|
||
public void UpdateNoteInTrack(float songTime)
|
||
{
|
||
if (!isOnTrack || track.trackTimeSubmodule == null) return;
|
||
|
||
if (track.trackTimeSubmodule is TrackTimeSubmoduleMovable)
|
||
{
|
||
UpdateNoteInMovableTrack(songTime);
|
||
}
|
||
else if (track.trackTimeSubmodule is TrackTimeSubmoduleStatic)
|
||
{
|
||
UpdateNoteInStaticTrack(songTime);
|
||
}
|
||
}
|
||
|
||
public virtual void UpdateNoteInMovableTrack(float songTime)
|
||
{
|
||
TrackTimeSubmoduleMovable trackTimeSubmoduleMovable = track.trackTimeSubmodule as TrackTimeSubmoduleMovable;
|
||
trackPositioner.SetPercent(trackTimeSubmoduleMovable.GetTrackPercent(exactJudgeTime));
|
||
}
|
||
|
||
public virtual void UpdateNoteInStaticTrack(float songTime)
|
||
{
|
||
TrackTimeSubmoduleStatic trackTimeSubmoduleStatic = track.trackTimeSubmodule as TrackTimeSubmoduleStatic;
|
||
|
||
float startMove = exactJudgeTime - trackTimeSubmoduleStatic.trackTotalTime;
|
||
float percent = AnimationCurveEvaluator.Evaluate(trackTimeSubmoduleStatic.animationCurveType, (songTime - startMove) / trackTimeSubmoduleStatic.trackTotalTime);
|
||
|
||
percent = Mathf.Clamp01(percent); // 替代 Max 和 Min 系统调用
|
||
trackPositioner.SetPercent(1 - percent);
|
||
}
|
||
|
||
public virtual void SetPerfectPosition()
|
||
{
|
||
if (isOnTrack && track.trackTimeSubmodule is TrackTimeSubmoduleMovable movable)
|
||
{
|
||
float notePercent = movable.GetTrackPercent(CoreServices.TimeProvider.SongTime);
|
||
trackPositioner.SetPercent(notePercent);
|
||
}
|
||
}
|
||
|
||
protected virtual void SlowOffsetAfterExactJudgeTime()
|
||
{
|
||
if (isOnTrack && track.trackTimeSubmodule is TrackTimeSubmoduleMovable movable)
|
||
{
|
||
float slowedTime = (CoreServices.TimeProvider.SongTime - exactJudgeTime) * 0.8f;
|
||
float notePercent = movable.GetTrackPercent(exactJudgeTime + slowedTime);
|
||
trackPositioner.SetPercent(notePercent);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region [打击判定分发] Judge Dispatcher
|
||
public virtual void Perfect(float triggerTime) { ExecuteJudge(NoteJudgeType.Perfect, triggerTime); }
|
||
public virtual void Good(float triggerTime) { ExecuteJudge(NoteJudgeType.Good, triggerTime); }
|
||
public virtual void Bad(float triggerTime){ ExecuteJudge(NoteJudgeType.Bad, triggerTime); }
|
||
public virtual void Miss(float triggerTime) { ExecuteJudge(NoteJudgeType.Miss, triggerTime); }
|
||
public virtual void ExecuteStartJudge(float triggerTime) {}
|
||
protected virtual void RemoveFromCheckingList() => throw new NotImplementedException();
|
||
|
||
protected virtual NoteJudgeType GetStartJudgeType(float timeDifference)
|
||
{
|
||
return judgeIntervals.GetNoteJudgeType(timeDifference);
|
||
}
|
||
|
||
public NoteJudgeType PreviewStartJudgeType(float triggerTime)
|
||
{
|
||
// Keep candidate resolution pure. The actual Note state changes only after one candidate is selected.
|
||
return GetStartJudgeType(triggerTime - exactJudgeTime);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判断输入的真实发生时间是否位于该 Note 的起始判定窗口内。
|
||
/// checking 列表使用本帧 SongTime 维护，而输入时间可能比本帧时间早几毫秒；
|
||
/// 因此必须单独过滤窗口外输入，不能把它当成可 fallback 的 Miss 候选。
|
||
/// </summary>
|
||
public bool IsWithinStartJudgeWindow(float inputSongTime)
|
||
{
|
||
float timeDifference = inputSongTime - exactJudgeTime;
|
||
return timeDifference >= judgeIntervals.beforeMiss.intervalStart &&
|
||
timeDifference <= judgeIntervals.afterMiss;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取最终判定发生当帧缓存的 JudgeEffect 世界姿态。
|
||
/// 特效应使用该姿态，而不是在延迟执行时重新读取 SongTime 或已经切换后的轨道/摄像机状态。
|
||
/// </summary>
|
||
public bool TryGetJudgedEffectPose(out Pose pose)
|
||
{
|
||
pose = judgedEffectPose;
|
||
return hasJudgedEffectPose;
|
||
}
|
||
|
||
private void CaptureJudgedEffectPose()
|
||
{
|
||
hasJudgedEffectPose = false;
|
||
|
||
Transform judgeEffectTransform = noteVisual?.judgeEffect?.transform;
|
||
if (judgeEffectTransform == null) return;
|
||
|
||
judgedEffectPose = new Pose(judgeEffectTransform.position, judgeEffectTransform.rotation);
|
||
hasJudgedEffectPose = true;
|
||
}
|
||
|
||
private void PrepareJudgedEffectPose(NoteJudgeType judgeType)
|
||
{
|
||
List<EffectBase> judgedEffects = judgeType switch
|
||
{
|
||
NoteJudgeType.Perfect => perfectEffects,
|
||
NoteJudgeType.Good => goodEffects,
|
||
NoteJudgeType.Bad => badEffects,
|
||
NoteJudgeType.Miss => missEffects,
|
||
_ => null
|
||
};
|
||
|
||
if (judgedEffects == null) return;
|
||
|
||
for (int i = 0; i < judgedEffects.Count; i++)
|
||
{
|
||
if (judgedEffects[i] is NoteEffectBase noteEffect)
|
||
{
|
||
noteEffect.PrepareJudgedEffectPose();
|
||
}
|
||
}
|
||
}
|
||
|
||
protected virtual void ExecuteJudge(NoteJudgeType judgeType, float triggerTime)
|
||
{
|
||
isDuringJudging = false;
|
||
isFirstJudged = true;
|
||
judgedTriggerTime = triggerTime;
|
||
judgedType = judgeType;
|
||
|
||
// 判定之后轨道、摄像机或 Note 层级都可能立即变化，必须先冻结本次打击特效的世界姿态。
|
||
PrepareJudgedEffectPose(judgeType);
|
||
CaptureJudgedEffectPose();
|
||
|
||
switch (judgeType)
|
||
{
|
||
case NoteJudgeType.Perfect:
|
||
GameManager.Instance.playingRecorder.AddPerfect();
|
||
break;
|
||
case NoteJudgeType.Good:
|
||
GameManager.Instance.playingRecorder.AddGood();
|
||
break;
|
||
case NoteJudgeType.Bad:
|
||
GameManager.Instance.playingRecorder.AddBad();
|
||
break;
|
||
case NoteJudgeType.Miss:
|
||
GameManager.Instance.playingRecorder.AddMiss();
|
||
break;
|
||
}
|
||
|
||
NoteAudioSubmodule.PlayNoteJudgeAudios(judgeType);
|
||
|
||
if (isOnTrack) track.childElementList.Remove(this);
|
||
|
||
if (NoteJudgeSubmodule?.judgeUnitList != null)
|
||
{
|
||
for (int i = 0; i < NoteJudgeSubmodule.judgeUnitList.Count; i++)
|
||
{
|
||
var unit = NoteJudgeSubmodule.judgeUnitList[i];
|
||
if (unit.isShowingJudge)
|
||
{
|
||
unit.SetShowingJudge(false);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 启动销毁计时器接管
|
||
isJudgedAndDestroying = true;
|
||
destroyTimer = 1.2f;
|
||
}
|
||
|
||
protected virtual void UpdatePostJudgeEffects()
|
||
{
|
||
UpdateEffectListInternal(generalJudgeEffects, judgedTriggerTime);
|
||
switch (judgedType)
|
||
{
|
||
case NoteJudgeType.Perfect:
|
||
UpdateEffectListInternal(perfectEffects, judgedTriggerTime);
|
||
break;
|
||
case NoteJudgeType.Good:
|
||
UpdateEffectListInternal(goodEffects, judgedTriggerTime);
|
||
break;
|
||
case NoteJudgeType.Bad:
|
||
UpdateEffectListInternal(badEffects, judgedTriggerTime);
|
||
break;
|
||
case NoteJudgeType.Miss:
|
||
UpdateEffectListInternal(missEffects, judgedTriggerTime);
|
||
break;
|
||
}
|
||
UpdateEffectListInternal(afterJudgeEffects, exactJudgeTime);
|
||
}
|
||
|
||
// 【Review修改】：改用强制 for 循环，彻底禁用带局部参数传递的 Lambda 方法与扩展
|
||
private void UpdateEffectListInternal(List<EffectBase> effects, float time)
|
||
{
|
||
if (effects == null) return;
|
||
for (int i = 0; i < effects.Count; i++)
|
||
{
|
||
effects[i].UpdateEffect(time);
|
||
}
|
||
}
|
||
|
||
protected List<EffectBase> GetEffectListSafe(string key)
|
||
{
|
||
if (noteVisual?.effectSubmodule?.effectCollection != null &&
|
||
noteVisual.effectSubmodule.effectCollection.TryGetValue(key, out var list))
|
||
{
|
||
return list;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public int CompareTo(NoteBase other)
|
||
{
|
||
return exactJudgeTime.CompareTo(other.exactJudgeTime);
|
||
}
|
||
#endregion
|
||
}
|
||
|
||
#region [类附属依赖系统] Judge Type & Intervals
|
||
public abstract partial class NoteBase
|
||
{
|
||
public enum NoteJudgeType
|
||
{
|
||
Perfect = 0,
|
||
Good = 1,
|
||
Bad = 2,
|
||
Miss = 3,
|
||
NotJudged = -999
|
||
}
|
||
|
||
public static NoteJudgeType GetLowerType(NoteJudgeType typeA, NoteJudgeType typeB)
|
||
{
|
||
if (typeA == NoteJudgeType.NotJudged) return typeB;
|
||
if (typeB == NoteJudgeType.NotJudged) return typeA;
|
||
return typeA > typeB ? typeA : typeB;
|
||
}
|
||
|
||
public class NoteJudgeIntervals
|
||
{
|
||
public TimeInterval beforeMiss, beforeBad, beforeGood, perfect, afterGood, afterBad;
|
||
public float afterMiss;
|
||
|
||
public static readonly NoteJudgeIntervals TapDefault = new NoteJudgeIntervals(
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, -0.125f),
|
||
new TimeInterval(-0.125f, -0.1f), new TimeInterval(-0.1f, 0.1f),
|
||
new TimeInterval(0.1f, 0.125f), new TimeInterval(0.125f, 0.15f), 0.15f);
|
||
|
||
public static readonly NoteJudgeIntervals StayDefault = new NoteJudgeIntervals(
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, -0.15f),
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, 0.15f),
|
||
new TimeInterval(0.15f, 0.15f), new TimeInterval(0.15f, 0.15f), 0.15f);
|
||
|
||
public static readonly NoteJudgeIntervals HoldDefault = new NoteJudgeIntervals(
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, -0.125f),
|
||
new TimeInterval(-0.125f, -0.1f), new TimeInterval(-0.1f, 0.1f),
|
||
new TimeInterval(0.1f, 0.125f), new TimeInterval(0.125f, 0.15f), 0.15f);
|
||
|
||
public static readonly NoteJudgeIntervals FlickDefault = new NoteJudgeIntervals(
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, -0.15f),
|
||
new TimeInterval(-0.15f, -0.15f), new TimeInterval(-0.15f, 0.15f),
|
||
new TimeInterval(0.15f, 0.15f), new TimeInterval(0.15f, 0.15f), 0.15f);
|
||
|
||
public NoteJudgeIntervals(TimeInterval beforeMiss, TimeInterval beforeBad, TimeInterval beforeGood,
|
||
TimeInterval perfect, TimeInterval afterGood, TimeInterval afterBad, float afterMiss)
|
||
{
|
||
this.beforeMiss = beforeMiss; this.beforeBad = beforeBad;
|
||
this.beforeGood = beforeGood; this.perfect = perfect;
|
||
this.afterGood = afterGood; this.afterBad = afterBad;
|
||
this.afterMiss = afterMiss;
|
||
}
|
||
|
||
public NoteJudgeType GetNoteJudgeType(float timeDifference)
|
||
{
|
||
if (beforeMiss.IsInInterval(timeDifference)) return NoteJudgeType.Miss;
|
||
if (beforeBad.IsInInterval(timeDifference)) return NoteJudgeType.Bad;
|
||
if (beforeGood.IsInInterval(timeDifference)) return NoteJudgeType.Good;
|
||
if (perfect.IsInInterval(timeDifference)) return NoteJudgeType.Perfect;
|
||
if (afterGood.IsInInterval(timeDifference)) return NoteJudgeType.Good;
|
||
if (afterBad.IsInInterval(timeDifference)) return NoteJudgeType.Bad;
|
||
|
||
return NoteJudgeType.Miss;
|
||
}
|
||
}
|
||
|
||
public class TimeInterval
|
||
{
|
||
public float intervalStart;
|
||
public float intervalEnd;
|
||
|
||
public TimeInterval(float start, float end)
|
||
{
|
||
intervalStart = start;
|
||
intervalEnd = end;
|
||
}
|
||
|
||
public bool IsInInterval(float time)
|
||
{
|
||
if (Mathf.Approximately(intervalStart, intervalEnd)) return false;
|
||
return time >= intervalStart && time <= intervalEnd;
|
||
}
|
||
}
|
||
|
||
public static string GetNoteTypeName(NoteBase note)
|
||
{
|
||
return note switch
|
||
{
|
||
Tap => "Tap",
|
||
Stay => "Stay",
|
||
Hold => "Hold",
|
||
Flick => "Flick",
|
||
_ => throw new NotImplementedException("Note type not recognized")
|
||
};
|
||
}
|
||
}
|
||
#endregion
|
||
}
|