375 lines
14 KiB
C#
375 lines
14 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Ichni.RhythmGame;
|
|
using Sirenix.OdinInspector;
|
|
using UnityEngine;
|
|
|
|
namespace Ichni
|
|
{
|
|
public partial class NoteJudgeManager : SerializedMonoBehaviour
|
|
{
|
|
public List<Tap> checkingTapList;
|
|
public List<Stay> checkingStayList;
|
|
public List<Hold> checkingHoldList;
|
|
public List<Flick> checkingFlickList;
|
|
|
|
public List<InputUnitTap> inputUnitTapList;
|
|
public List<InputUnitTouch> inputUnitTouchList;
|
|
public List<InputUnitSwipe> inputUnitSwipeList;
|
|
|
|
private List<Tap> _availableTapsBuffer = new List<Tap>(30);
|
|
private List<Hold> _availableHoldsBuffer = new List<Hold>(10);
|
|
private List<Flick> _availableFlicksBuffer = new List<Flick>(10);
|
|
private List<Stay> _availableStaysBuffer = new List<Stay>(30);
|
|
|
|
private List<Tap> _minTapsBuffer = new List<Tap>(5);
|
|
private List<Hold> _minHoldsBuffer = new List<Hold>(5);
|
|
private List<Flick> _minFlicksBuffer = new List<Flick>(5);
|
|
|
|
private InputUnitSwipe _cachedAssumedSwipe = new InputUnitSwipe(0, Vector2.zero, true, true, Vector2.zero);
|
|
|
|
private void Start()
|
|
{
|
|
checkingTapList = new List<Tap>();
|
|
checkingStayList = new List<Stay>();
|
|
checkingHoldList = new List<Hold>();
|
|
checkingFlickList = new List<Flick>();
|
|
inputUnitTapList = new List<InputUnitTap>();
|
|
inputUnitTouchList = new List<InputUnitTouch>();
|
|
inputUnitSwipeList = new List<InputUnitSwipe>();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
if (!GameManager.Instance.songPlayer.isPlaying)
|
|
{
|
|
return;
|
|
}
|
|
|
|
float songTime = CoreServices.TimeProvider.SongTime;
|
|
|
|
foreach (var swipe in inputUnitSwipeList)
|
|
{
|
|
_availableFlicksBuffer.Clear();
|
|
|
|
foreach (Flick flick in checkingFlickList)
|
|
{
|
|
if (flick.CheckJudgeAvailability(swipe))
|
|
{
|
|
_availableFlicksBuffer.Add(flick);
|
|
}
|
|
}
|
|
|
|
if (_availableFlicksBuffer.Count > 0)
|
|
{
|
|
if (swipe.isFirst) // 原 tapSwipeList 逻辑
|
|
{
|
|
GetAllMinNotes(_availableFlicksBuffer, _minFlicksBuffer); // 提醒:内部也需防 new List
|
|
if (_minFlicksBuffer.Count == 1) _minFlicksBuffer[0].ExecuteStartJudge(songTime);
|
|
else if (_minFlicksBuffer.Count > 1) GetNearestNote(_minFlicksBuffer, swipe.inputPosition).ExecuteTapJudge(songTime);
|
|
}
|
|
else // 原 holdSwipeList 逻辑
|
|
{
|
|
_availableFlicksBuffer.Sort();
|
|
_availableFlicksBuffer[0].ExecuteStartJudge(songTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*foreach (InputUnitSwipe tapSwipe in tapSwipeList)
|
|
{
|
|
List<Flick> availableFlicks = new List<Flick>();
|
|
|
|
foreach (Flick flick in checkingFlickList)
|
|
{
|
|
if (flick.CheckJudgeAvailability(tapSwipe))
|
|
{
|
|
availableFlicks.Add(flick);
|
|
}
|
|
}
|
|
|
|
List<Flick> minFlicks = GetAllMinNotes(availableFlicks);
|
|
|
|
if (minFlicks.Count == 1)
|
|
{
|
|
minFlicks[0].ExecuteStartJudge();
|
|
}
|
|
else if (minFlicks.Count > 1)
|
|
{
|
|
GetNearestNote(minFlicks, tapSwipe.inputPosition).ExecuteTapJudge();
|
|
}
|
|
}
|
|
|
|
foreach (InputUnitSwipe inputUnitSwipe in holdSwipeList)
|
|
{
|
|
List<Flick> availableFlicks = new List<Flick>();
|
|
|
|
foreach (Flick flick in checkingFlickList)
|
|
{
|
|
if (flick.CheckJudgeAvailability(inputUnitSwipe))
|
|
{
|
|
availableFlicks.Add(flick);
|
|
}
|
|
}
|
|
|
|
if (availableFlicks.Count > 0)
|
|
{
|
|
availableFlicks.Sort();
|
|
Flick closestFlick = availableFlicks[0];
|
|
closestFlick.ExecuteStartJudge();
|
|
}
|
|
}*/
|
|
|
|
foreach (InputUnitTap inputUnitTap in inputUnitTapList)
|
|
{
|
|
_availableTapsBuffer.Clear();
|
|
_availableHoldsBuffer.Clear();
|
|
|
|
foreach (Tap tap in checkingTapList)
|
|
{
|
|
if (tap.CheckJudgeAvailability(inputUnitTap)) _availableTapsBuffer.Add(tap);
|
|
}
|
|
foreach (Hold hold in checkingHoldList)
|
|
{
|
|
if (hold.CheckJudgeAvailability(inputUnitTap)) _availableHoldsBuffer.Add(hold);
|
|
}
|
|
|
|
bool haveTap = _availableTapsBuffer.Count > 0;
|
|
bool haveHold = _availableHoldsBuffer.Count > 0;
|
|
|
|
Flick closestFlick = null;
|
|
InputUnitSwipe assumedSwipe = new InputUnitSwipe(inputUnitTap.fingerId, inputUnitTap.inputPosition, true, true, Vector2.zero);
|
|
foreach (Flick flick in checkingFlickList)
|
|
{
|
|
if (flick.CheckJudgeAvailability(assumedSwipe))
|
|
{
|
|
if (closestFlick == null || flick.exactJudgeTime < closestFlick.exactJudgeTime)
|
|
{
|
|
closestFlick = flick;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (haveHold && haveTap)
|
|
{
|
|
GetAllMinNotes(_availableHoldsBuffer, _minHoldsBuffer);
|
|
GetAllMinNotes(_availableTapsBuffer, _minTapsBuffer);
|
|
Hold closestHold = _minHoldsBuffer[0];
|
|
Tap closestTap = _minTapsBuffer[0];
|
|
bool holdBlockedByFlick = false;
|
|
bool tapBlockedByFlick = false;
|
|
|
|
if (closestFlick != null)
|
|
{
|
|
if (closestFlick.exactJudgeTime < closestHold.exactJudgeTime)
|
|
{
|
|
holdBlockedByFlick = true;
|
|
}
|
|
|
|
if (closestFlick.exactJudgeTime < closestTap.exactJudgeTime)
|
|
{
|
|
tapBlockedByFlick = true;
|
|
}
|
|
}
|
|
|
|
if (!holdBlockedByFlick && closestHold.exactJudgeTime < closestTap.exactJudgeTime)
|
|
{
|
|
if (_minHoldsBuffer.Count == 1)
|
|
{
|
|
_minHoldsBuffer[0].ExecuteStartJudge(songTime);
|
|
}
|
|
else
|
|
{
|
|
GetNearestNote(_minHoldsBuffer, inputUnitTap.inputPosition).ExecuteStartJudge(songTime);
|
|
}
|
|
}
|
|
else if (!tapBlockedByFlick)
|
|
{
|
|
if (_minTapsBuffer.Count == 1)
|
|
{
|
|
_minTapsBuffer[0].ExecuteStartJudge(songTime);
|
|
}
|
|
else
|
|
{
|
|
GetNearestNote(_minTapsBuffer, inputUnitTap.inputPosition).ExecuteStartJudge(songTime);
|
|
}
|
|
}
|
|
}
|
|
else if (haveHold)
|
|
{
|
|
GetAllMinNotes(_availableHoldsBuffer, _minHoldsBuffer);
|
|
bool holdBlockedByFlick = closestFlick != null && closestFlick.exactJudgeTime < _minHoldsBuffer[0].exactJudgeTime;
|
|
if (!holdBlockedByFlick)
|
|
{
|
|
if (_minHoldsBuffer.Count == 1)
|
|
{
|
|
_minHoldsBuffer[0].ExecuteStartJudge(songTime);
|
|
}
|
|
else
|
|
{
|
|
GetNearestNote(_minHoldsBuffer, inputUnitTap.inputPosition).ExecuteStartJudge(songTime);
|
|
}
|
|
}
|
|
}
|
|
else if (haveTap)
|
|
{
|
|
GetAllMinNotes(_availableTapsBuffer, _minTapsBuffer);
|
|
bool tapBlockedByFlick = closestFlick != null && closestFlick.exactJudgeTime < _minTapsBuffer[0].exactJudgeTime;
|
|
if (!tapBlockedByFlick)
|
|
{
|
|
if (_minTapsBuffer.Count == 1)
|
|
{
|
|
_minTapsBuffer[0].ExecuteStartJudge(songTime);
|
|
}
|
|
else
|
|
{
|
|
GetNearestNote(_minTapsBuffer, inputUnitTap.inputPosition).ExecuteStartJudge(songTime);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (InputUnitTouch inputUnitTouch in inputUnitTouchList)
|
|
{
|
|
_availableStaysBuffer.Clear();
|
|
foreach (Stay stay in checkingStayList)
|
|
{
|
|
if (stay.CheckJudgeAvailability(inputUnitTouch))
|
|
{
|
|
_availableStaysBuffer.Add(stay);
|
|
}
|
|
}
|
|
|
|
_availableHoldsBuffer.Clear();
|
|
foreach (Hold hold in checkingHoldList)
|
|
{
|
|
if (hold.CheckJudgeAvailability(inputUnitTouch))
|
|
{
|
|
_availableHoldsBuffer.Add(hold);
|
|
}
|
|
}
|
|
|
|
foreach (Stay stay in _availableStaysBuffer)
|
|
{
|
|
stay.ExecuteStartJudge(songTime);
|
|
}
|
|
|
|
foreach (Hold hold in _availableHoldsBuffer)
|
|
{
|
|
hold.ExecuteProcessJudge();
|
|
}
|
|
}
|
|
|
|
inputUnitTapList.Clear();
|
|
inputUnitTouchList.Clear();
|
|
inputUnitSwipeList.Clear();
|
|
}
|
|
|
|
public void SetNewInputUnitTap(int fingerId, Vector2 inputPosition)
|
|
{
|
|
InputUnitTap inputUnitTap = new InputUnitTap(fingerId, inputPosition);
|
|
if(!inputUnitTapList.Exists(x => x.fingerId == fingerId))
|
|
{
|
|
inputUnitTapList.Add(inputUnitTap);
|
|
}
|
|
}
|
|
|
|
public void SetNewInputUnitTouch(int fingerId, Vector2 inputPosition)
|
|
{
|
|
InputUnitTouch inputUnitTouch = new InputUnitTouch(fingerId, inputPosition);
|
|
if(!inputUnitTouchList.Exists(x => x.fingerId == fingerId))
|
|
{
|
|
inputUnitTouchList.Add(inputUnitTouch);
|
|
}
|
|
}
|
|
|
|
public void SetNewInputUnitSwipe(int fingerId, Vector2 inputPosition, bool isGeneric, bool isFirst, Vector2 delta)
|
|
{
|
|
InputUnitSwipe inputUnitSwipe = new InputUnitSwipe(fingerId, inputPosition, isGeneric, isFirst, delta);
|
|
if(!inputUnitSwipeList.Exists(x => x.fingerId == fingerId))
|
|
{
|
|
inputUnitSwipeList.Add(inputUnitSwipe);
|
|
}
|
|
}
|
|
}
|
|
|
|
public partial class NoteJudgeManager
|
|
{
|
|
private void GetAllMinNotes<T>(List<T> availableFlicks, List<T> destination) where T : NoteBase
|
|
{
|
|
destination.Clear();
|
|
float minTime = float.MaxValue;
|
|
foreach (T note in availableFlicks)
|
|
{
|
|
if (note.exactJudgeTime < minTime)
|
|
{
|
|
minTime = note.exactJudgeTime;
|
|
destination.Clear();
|
|
destination.Add(note);
|
|
}
|
|
else if (Mathf.Approximately(note.exactJudgeTime, minTime))
|
|
{
|
|
destination.Add(note);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private T GetNearestNote<T>(List<T> notes, Vector2 inputPosition) where T : NoteBase
|
|
{
|
|
float minDistance = float.MaxValue;
|
|
T closestNote = null;
|
|
foreach (T note in notes)
|
|
{
|
|
float distance = Vector2.Distance(inputPosition, note.noteScreenPosition);
|
|
if (distance < minDistance)
|
|
{
|
|
minDistance = distance;
|
|
closestNote = note;
|
|
}
|
|
}
|
|
|
|
return closestNote;
|
|
}
|
|
}
|
|
|
|
public class InputUnit
|
|
{
|
|
public int fingerId;
|
|
public Vector2 inputPosition;
|
|
}
|
|
|
|
public class InputUnitTap : InputUnit
|
|
{
|
|
public InputUnitTap(int fingerId, Vector2 inputPosition)
|
|
{
|
|
this.fingerId = fingerId;
|
|
this.inputPosition = inputPosition;
|
|
}
|
|
}
|
|
|
|
public class InputUnitTouch : InputUnit
|
|
{
|
|
public InputUnitTouch(int fingerId, Vector2 inputPosition)
|
|
{
|
|
this.fingerId = fingerId;
|
|
this.inputPosition = inputPosition;
|
|
}
|
|
}
|
|
|
|
public class InputUnitSwipe : InputUnit
|
|
{
|
|
public Vector2 swipeDirection;
|
|
public bool isGeneric;
|
|
public bool isFirst;
|
|
public InputUnitSwipe(int fingerId, Vector2 inputPosition, bool isGeneric, bool isFirst, Vector2 swipeDirection)
|
|
{
|
|
this.fingerId = fingerId;
|
|
this.inputPosition = inputPosition;
|
|
this.isGeneric = isGeneric;
|
|
this.isFirst = isFirst;
|
|
this.swipeDirection = swipeDirection.normalized;
|
|
}
|
|
}
|
|
} |