int FetchNotePlayMode(HitEvent nextHitObject)
{
if (timingIndex < timingPointsList.Count && nextHitObject.getOffset() >= timingPointsList[timingIndex].getOffset())
{
return(timingPointsList[timingIndex].getPlaymode());
}
else if (timingIndex < timingPointsList.Count && nextHitObject.getOffset() < timingPointsList[timingIndex].getOffset())
{
return(timingPointsList[timingIndex - 1].getPlaymode());
}
else
{
return(0); // Default to "step" mode if neither apply
}
}
public bool InStartHoldHitWindow(HitEvent currentNote, double _localCurrentOffset)
{
if (_localCurrentOffset >= currentNote.getOffset() - greatHitWindow && _localCurrentOffset <= currentNote.getOffset() + okHitWindow)
{
return(true);
}
else
{
return(false);
}
}
bool InGoodHitWindow(HitEvent currentNote, double _localCurrentOffset)
{
if (_localCurrentOffset >= currentNote.getOffset() - goodHitWindow && _localCurrentOffset <= currentNote.getOffset() + goodHitWindow)
{
return(true);
}
else
{
return(false);
}
}
public bool MissedHitWindow(HitEvent currentNote, double _localCurrentOffset)
{
if (_localCurrentOffset > currentNote.getOffset() + okHitWindow)
{
return(true);
}
else
{
return(false);
}
}
void spawnStepNote(GameObject ring, Transform spawner, HitEvent hitObject, KeyCode key)
{
if (hitObject.IsHold())
{
int offsetDiff = hitObject.getEndOffset() - hitObject.getOffset();
StopCoroutine(spawnStepHold(ring, spawner, hitObject, offsetDiff, key));
StartCoroutine(spawnStepHold(ring, spawner, hitObject, offsetDiff, key));
}
else
{
var currentRing = Instantiate(ring, spawner.position, spawner.rotation);
currentRing.transform.SetParent(noteHolder.transform);
currentRing.transform.localScale = ring.transform.localScale;
if (hitObject.IsMine())
{
currentRing.AddComponent <Mine>().Initialize(spawner.position, hitbox.transform.position, hitObject.getOffset(), scrollDelay, key, hitObject);
}
else
{
currentRing.AddComponent <Ring>().Initialize(spawner.position, hitbox.transform.position, hitObject.getOffset(), scrollDelay, key, hitObject);
}
}
}
void spawnMemoryNote(GameObject ring, Transform spawner, HitEvent hitObject, KeyCode key)
{
if (MemoryNoteManager.Instance.currentMemorySequence.Count > 0)
{
HitEvent memNote = MemoryNoteManager.Instance.currentMemorySequence.Dequeue();
var currentRing = Instantiate(ring, spawner.localPosition, Quaternion.identity);
currentRing.transform.SetParent(diamondHolder.transform, false);
hitObject.setPlayMode(FetchNotePlayMode(hitObject));
currentRing.GetComponent <DiamondRing>().Initialize(diamondHitbox.transform.localScale, hitObject.getOffset(), scrollDelay, hitObject);
if (hitObject.getColorIntArray().Length == 4)
{
colorIntArray = hitObject.getColorIntArray();
}
int intKey = Array.IndexOf(colorIntArray, memNote.getKey());
switch (intKey)
{
case 0: // LEFT
currentRing.GetComponent <DiamondRing>().keyCode = keyLeft;
break;
case 1: // DOWN
currentRing.GetComponent <DiamondRing>().keyCode = keyDown;
break;
case 2: // UP
currentRing.GetComponent <DiamondRing>().keyCode = keyUp;
break;
case 3: // RIGHT
currentRing.GetComponent <DiamondRing>().keyCode = keyRight;
break;
default:
break;
}
}
}
IEnumerator spawnStepHold(GameObject ring, Transform spawner, HitEvent hitObject, int offsetDiff, KeyCode key)
{
GameObject startHold = Instantiate(ring, spawner.position, spawner.rotation);
startHold.transform.SetParent(noteHolder.transform);
startHold.transform.localScale = ring.transform.localScale;
startHold.AddComponent <StartHold>();
GameObject midHold = Instantiate(midRing, spawner.position, spawner.rotation);
midHold.transform.SetParent(noteHolder.transform);
midHold.AddComponent <MidHold>();
GameObject endHold = Instantiate(ring, spawner.position, spawner.rotation);
endHold.transform.SetParent(noteHolder.transform);
endHold.transform.localScale = ring.transform.localScale;
startHold.GetComponent <StartHold>().Initialize(spawner.position, hitbox.transform.position, hitObject.getOffset(), scrollDelay, key, midHold, endHold, noteHolder, hitObject);
midHold.GetComponent <MidHold>().Initialize(spawner.position, hitbox.transform.position, hitObject.getOffset(), scrollDelay, key, startHold, endHold, hitObject);
yield return(new WaitForSecondsRealtime(offsetDiff / 1000f));
endHold.AddComponent <EndHold>();
endHold.GetComponent <EndHold>().Initialize(spawner.position, hitbox.transform.position, hitObject.getEndOffset(), scrollDelay, key, startHold, midHold, hitObject);
}
void FetchCurrentNote()
{
while (index < hitEventsList.Count)
{
//gets latest timing points
offsetTime = (AudioSettings.dspTime - startTime) * 1000 + scrollDelay;
//Debug.Log("OFFSET TIME: " + offsetTime);
if (timingIndex < timingPointsList.Count && offsetTime >= timingPointsList[timingIndex].getOffset())
{
scrollDelay = delayHandler.GetComponent <DelayHandler>().UpdateBPM(timingPointsList[timingIndex].getMsPerBeat());
if (timingPointsList[timingIndex].getPlaymode() == 0) // step
{
baseScore = noteBaseScore;
memoryMode = false;
invertedMemoryMode = false;
}
else
{
baseScore = memoryBaseScore;
memoryMode = timingPointsList[timingIndex].getPlaymode() == 1 ? true : false;
invertedMemoryMode = timingPointsList[timingIndex].getPlaymode() == -1 ? true : false;
}
timingIndex++;
}
noteOffsetTime = (AudioSettings.dspTime - startTime) * 1000;
noteOffsetTime += scrollDelay;
HitEvent hitObject = hitEventsList[index];
if (noteOffsetTime >= hitObject.getOffset())
{
//Debug.Log("Note " + hitObject.getOffset() + " Spawn time: " + offsetTime + "\nNote offset: " + noteOffsetTime);
if ((hitObject.IsNote() || hitObject.IsHold()) && !noteFlag)
{
spawnNotes(hitObject);
}
noteFlag = true;
if (hitObject.isFlashYellow() || hitObject.isFlashGreen() || hitObject.isFlashRed() || hitObject.isFlashBlue())
{
HitEvent memoryNote = new HitEvent();
memoryNote.setSequenceStart(isSequenceStart);
if (hitObject.isFlashYellow())
{
StartCoroutine(FlashMemoryPrompt("yellow", hitObject.IsflashBlack()));
memoryNote.setKey("0");
memorySequence.Enqueue(memoryNote);
}
if (hitObject.isFlashGreen())
{
StartCoroutine(FlashMemoryPrompt("green", hitObject.IsflashBlack()));
memoryNote.setKey("1");
memorySequence.Enqueue(memoryNote);
}
if (hitObject.isFlashRed())
{
StartCoroutine(FlashMemoryPrompt("red", hitObject.IsflashBlack()));
memoryNote.setKey("2");
memorySequence.Enqueue(memoryNote);
}
if (hitObject.isFlashBlue())
{
StartCoroutine(FlashMemoryPrompt("blue", hitObject.IsflashBlack()));
memoryNote.setKey("3");
memorySequence.Enqueue(memoryNote);
}
isSequenceStart = false;
}
else
{
isSequenceStart = true;
}
if (index + 1 < hitEventsList.Count)
{
HitEvent nextHitObject = hitEventsList[index + 1];
int nextHitMode = FetchNotePlayMode(nextHitObject);
// Check if the next note is a memory input corresponding to the start of memory sequence
if (memorySequence.Count > 0)
{
if (nextHitMode != 0 && nextHitObject.IsNote() && memorySequence.Peek().isSequenceStart())
{
StopCoroutine(HandleMemoryStart(nextHitObject, nextHitMode));
StartCoroutine(HandleMemoryStart(nextHitObject, nextHitMode));
}
}
StopCoroutine(HandleMemorySprites(hitObject, FetchNotePlayMode(hitObject)));
StartCoroutine(HandleMemorySprites(hitObject, FetchNotePlayMode(hitObject)));
}
}
else // if next hit object doesn't need to be spawned now
{
break;
}
noteFlag = false;
index++;
}
}