using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using BurstLinq;
using UnityEngine;
using UnityEngine.Pool;
using Jukebox;
using HeavenStudio.Util;
using HeavenStudio.Games;
using HeavenStudio.Common;
using Cysharp.Threading.Tasks;
namespace HeavenStudio
{
public class GameManager : MonoBehaviour
{
const int SoundPoolSizeMin = 32;
const int SoundPoolSizeMax = 32;
[Header("Lists")]
[NonSerialized] public RiqBeatmap Beatmap = new();
[NonSerialized] public ObjectPool<Sound> SoundObjects;
[Header("Components")]
[NonSerialized] public Camera GameCamera, CursorCam, OverlayCamera, StaticCamera;
[NonSerialized] public CircleCursor CircleCursor;
[NonSerialized] public GameObject GamesHolder;
[NonSerialized] public Games.Global.Flash fade;
[NonSerialized] public Games.Global.Filter filter;
[Header("Games")]
Coroutine currentGameSwitchIE;
[NonSerialized]
public int currentEvent, currentTempoEvent, currentVolumeEvent, currentSectionEvent,
currentPreEvent, currentPreSwitch, currentPreSequence;
public string currentGame { get; private set; }
public GameObject minigameObj { get; private set; }
public Minigame minigame { get; private set; }
public RiqEntity lastSection { get; private set; }
public RiqEntity currentSection { get; private set; }
public double endBeat { get; private set; }
public double startBeat { get; private set; }
public double nextSectionBeat { get; private set; }
public double SectionProgress { get; private set; }
public float MarkerWeight { get; private set; }
public int MarkerCategory { get; private set; }
public bool playMode { get; private set; }
public bool autoplay { get; private set; }
public bool canInput { get; private set; }
public bool GameHasSplitColours
{
get
{
var inf = GetGameInfo(currentGame);
if (inf == null) return false;
return inf.splitColorL != null && inf.splitColorR != null;
}
}
bool AudioLoadDone;
bool ChartLoadError;
//bool exiting; Unused value - Marc
List<double> eventBeats, preSequenceBeats, tempoBeats, volumeBeats, sectionBeats;
List<RiqEntity> allGameSwitches;
public event Action<double> onBeatChanged;
public event Action<RiqEntity, RiqEntity> onSectionChange;
public event Action<double> onBeatPulse;
public event Action<double> onPlay;
public event Action<double> onPause;
public event Action<double> onUnPause;
public int BeatmapEntities()
{
return Beatmap.Entities.Count + Beatmap.TempoChanges.Count + Beatmap.VolumeChanges.Count + Beatmap.SectionMarkers.Count;
}
public static GameManager instance { get; private set; }
private EventCaller eventCaller;
public Conductor conductor;
// average input accuracy (msec)
List<int> inputOffsetSamples = new List<int>();
float averageInputOffset = 0;
public float AvgInputOffset
{
get
{
return averageInputOffset;
}
set
{
inputOffsetSamples.Add((int)value);
averageInputOffset = (float)inputOffsetSamples.Average();
}
}
// input accuracy (%)
bool skillStarCollected = false, noMiss = true;
// cleared sections
List<bool> clearedSections = new List<bool>();
public bool ClearedSection
{
set
{
clearedSections.Add(value);
}
}
JudgementManager.JudgementInfo judgementInfo;
private void Awake()
{
instance = this;
//exiting = false; Unused value - Marc
}
public void Init(bool preLoaded = false)
{
AudioLoadDone = false;
ChartLoadError = false;
currentPreEvent = 0;
currentPreSwitch = 0;
currentPreSequence = 0;
GameObject filter = new GameObject("filter");
this.filter = filter.AddComponent<Games.Global.Filter>();
eventCaller = this.gameObject.AddComponent<EventCaller>();
eventCaller.GamesHolder = GamesHolder.transform;
eventCaller.Init(this);
canInput = true;
// note: serialize this shit in the inspector //
GameObject textbox = Instantiate(Resources.Load<GameObject>("Prefabs/Common/Textbox"));
textbox.name = "Textbox";
GameObject timingDisp = Instantiate(Resources.Load<GameObject>("Prefabs/Common/Overlays/TimingAccuracy"));
timingDisp.name = "TimingDisplay";
GameObject skillStarDisp = Instantiate(Resources.Load<GameObject>("Prefabs/Common/Overlays/SkillStar"));
skillStarDisp.name = "SkillStar";
GameObject overlays = Instantiate(Resources.Load<GameObject>("Prefabs/Common/Overlays"));
overlays.name = "Overlays";
GoForAPerfect.instance.Disable();
/////
SoundByte.BasicCheck();
SoundObjects = new ObjectPool<Sound>(CreatePooledSound, OnTakePooledSound, OnReturnPooledSound, OnDestroyPooledSound, true, SoundPoolSizeMin, SoundPoolSizeMax);
if (preLoaded)
{
LoadRemix(false);
}
else
{
RiqFileHandler.ClearCache();
NewRemix();
}
SortEventsList();
conductor.SetBpm(Beatmap.TempoChanges[0]["tempo"]);
conductor.SetVolume(Beatmap.VolumeChanges[0]["volume"]);
conductor.firstBeatOffset = Beatmap.data.offset;
if (!preLoaded)
{
if (Beatmap.Entities.Count == 0)
{
SetGame("noGame");
}
else
{
SetCurrentEventToClosest(0, true);
}
}
if (playMode)
{
StartCoroutine(WaitReadyAndPlayCo(startBeat, 1f));
}
}
Sound CreatePooledSound()
{
GameObject oneShot = new GameObject($"Pooled Scheduled Sound");
oneShot.transform.SetParent(transform);
AudioSource audioSource = oneShot.AddComponent<AudioSource>();
audioSource.playOnAwake = false;
Sound snd = oneShot.AddComponent<Sound>();
oneShot.SetActive(false);
return snd;
}
// Called when an item is returned to the pool using Release
void OnReturnPooledSound(Sound snd)
{
snd.Stop();
}
// Called when an item is taken from the pool using Get
void OnTakePooledSound(Sound snd)
{
snd.gameObject.SetActive(true);
}
// If the pool capacity is reached then any items returned will be destroyed.
void OnDestroyPooledSound(Sound snd)
{
snd.Stop();
Destroy(snd.gameObject);
}
public void NewRemix()
{
AudioLoadDone = false;
Beatmap = new("1", "HeavenStudio");
Beatmap.data.properties = new(Minigames.propertiesModel);
RiqEntity t = Beatmap.AddNewTempoChange(0, 120f);
t.CreateProperty("swingDivision", 1f);
Beatmap.AddNewVolumeChange(0, 100f);
Beatmap.data.offset = 0f;
conductor.musicSource.clip = null;
RiqFileHandler.WriteRiq(Beatmap);
AudioLoadDone = true;
}
public IEnumerator LoadMusic()
{
ChartLoadError = false;
IEnumerator load = RiqFileHandler.LoadSong();
while (true)
{
object current = load.Current;
try
{
if (load.MoveNext() == false)
{
break;
}
current = load.Current;
}
catch (System.IO.FileNotFoundException f)
{
Debug.LogWarning("chart has no music: " + f.Message);
conductor.musicSource.clip = null;
AudioLoadDone = true;
yield break;
}
catch (Exception e)
{
Debug.LogError($"Failed to load music: {e.Message}");
GlobalGameManager.ShowErrorMessage("Error Loading Music", e.Message + "\n\n" + e.StackTrace);
AudioLoadDone = true;
ChartLoadError = true;
yield break;
}
yield return current;
}
conductor.musicSource.clip = RiqFileHandler.StreamedAudioClip;
AudioLoadDone = true;
}
public void LoadRemix(bool editor = false)
{
AudioLoadDone = false;
ChartLoadError = false;
try
{
Beatmap = RiqFileHandler.ReadRiq();
}
catch (Exception e)
{
Debug.LogError($"Failed to load remix: {e.Message}");
GlobalGameManager.ShowErrorMessage("Error Loading RIQ", e.Message + "\n\n" + e.StackTrace);
ChartLoadError = true;
return;
}
if (!editor)
StartCoroutine(LoadMusic());
SortEventsList();
conductor.SetBpm(Beatmap.TempoChanges[0]["tempo"]);
conductor.SetVolume(Beatmap.VolumeChanges[0]["volume"]);
conductor.firstBeatOffset = Beatmap.data.offset;
if (!playMode)
{
Stop(0);
}
SetCurrentEventToClosest(0, true);
if (editor)
{
if (Beatmap.data.riqOrigin != "HeavenStudio")
{
string origin = Beatmap.data.riqOrigin?.DisplayName() ?? "Unknown Origin";
GlobalGameManager.ShowErrorMessage("Warning",
$"This chart came from\n<alpha=#AA>{origin}</color>\nand uses content not included in Heaven Studio.\n\n<color=\"yellow\">You may be able to edit this chart in Heaven Studio to be used in its original program.</color>");
}
}
}
public void ScoreInputAccuracy(double beat, double accuracy, bool late, double time, float weight = 1, bool doDisplay = true)
{
// push the hit event to the timing display
if (doDisplay)
TimingAccuracyDisplay.instance.MakeAccuracyVfx(time, late);
if (weight > 0 && MarkerWeight > 0)
{
judgementInfo.inputs.Add(new JudgementManager.InputInfo
{
beat = beat,
accuracyState = accuracy,
timeOffset = time,
weight = weight * MarkerWeight,
category = MarkerCategory
});
if (accuracy < Minigame.rankOkThreshold)
{
SkillStarManager.instance.KillStar();
GoForAPerfect.instance.Miss();
SectionMedalsManager.instance.MakeIneligible();
noMiss = false;
}
}
if (SkillStarManager.instance.IsEligible && !skillStarCollected && accuracy >= 1f)
{
if (SkillStarManager.instance.DoStarJust())
skillStarCollected = true;
}
}
public void DoSectionCompletion(double beat, bool clear, string name, double score)
{
judgementInfo.medals.Add(new JudgementManager.MedalInfo
{
beat = beat,
cleared = clear
});
}
public List<Minigames.Minigame> SeekAheadAndPreload(double start, float seekTime = 8f)
{
List<Minigames.Minigame> gamesToPreload = new();
List<RiqEntity> entitiesAtSameBeat = ListPool<RiqEntity>.Get();
Minigames.Minigame inf;
// seek ahead to preload games that have assetbundles
if (currentPreSwitch < allGameSwitches.Count && currentPreSwitch >= 0)
{
if (start + seekTime >= allGameSwitches[currentPreSwitch].beat)
{
string gameName = allGameSwitches[currentPreSwitch].datamodel.Split('/')[2];
inf = GetGameInfo(gameName);
if (inf != null && !(inf.inferred || inf.fxOnly))
{
if (inf.UsesAssetBundle && !(inf.AssetsLoaded || inf.AlreadyLoading))
{
gamesToPreload.Add(inf);
Debug.Log($"ASYNC loading assetbundles for game {gameName}");
inf.LoadAssetsAsync().Forget();
}
}
currentPreSwitch++;
}
}
//then check game entities
if (currentPreEvent < Beatmap.Entities.Count && currentPreEvent >= 0)
{
if (start + seekTime >= eventBeats[currentPreEvent])
{
foreach (RiqEntity entity in Beatmap.Entities)
{
if (entity.beat == Beatmap.Entities[currentPreEvent].beat && !EventCaller.FXOnlyGames().Contains(eventCaller.GetMinigame(entity.datamodel.Split('/')[0])))
{
entitiesAtSameBeat.Add(entity);
}
}
SortEventsByPriority(entitiesAtSameBeat);
foreach (RiqEntity entity in entitiesAtSameBeat)
{
string gameName = entity.datamodel.Split('/')[0];
inf = GetGameInfo(gameName);
if (inf != null && !(inf.inferred || inf.fxOnly))
{
if (inf.UsesAssetBundle && !inf.AssetsLoaded)
{
gamesToPreload.Add(inf);
Debug.Log($"ASYNC loading assetbundles for game {gameName}");
inf.LoadAssetsAsync().Forget();
}
}
currentPreEvent++;
}
}
}
ListPool<RiqEntity>.Release(entitiesAtSameBeat);
return gamesToPreload;
}
public void SeekAheadAndDoPreEvent(double start)
{
if (currentPreSequence < Beatmap.Entities.Count && currentPreSequence >= 0)
{
List<RiqEntity> entitiesInRange = ListPool<RiqEntity>.Get();
while (currentPreSequence < preSequenceBeats.Count && start >= preSequenceBeats[currentPreSequence])
{
entitiesInRange.Clear();
foreach (RiqEntity entity in Beatmap.Entities)
{
string[] entityDatamodel = entity.datamodel.Split('/');
double seekTime = eventCaller.GetGameAction(entityDatamodel[0], entityDatamodel[1]).preFunctionLength;
if (entity.beat - seekTime == preSequenceBeats[currentPreSequence])
{
entitiesInRange.Add(entity);
}
}
SortEventsByPriority(entitiesInRange);
foreach (RiqEntity entity in entitiesInRange)
{
eventCaller.CallPreEvent(entity);
currentPreSequence++;
}
}
ListPool<RiqEntity>.Release(entitiesInRange);
}
}
private void Update()
{
if (BeatmapEntities() < 1)
return;
if (conductor.WaitingForDsp || !conductor.isPlaying)
return;
double clampedBeat = Math.Max(conductor.songPositionInBeatsAsDouble, 0);
if (currentTempoEvent < Beatmap.TempoChanges.Count && currentTempoEvent >= 0)
{
if (conductor.songPositionInBeatsAsDouble >= tempoBeats[currentTempoEvent])
{
conductor.SetBpm(Beatmap.TempoChanges[currentTempoEvent]["tempo"]);
currentTempoEvent++;
}
}
if (currentVolumeEvent < Beatmap.VolumeChanges.Count && currentVolumeEvent >= 0)
{
if (conductor.songPositionInBeatsAsDouble >= volumeBeats[currentVolumeEvent])
{
conductor.SetVolume(Beatmap.VolumeChanges[currentVolumeEvent]["volume"]);
currentVolumeEvent++;
}
}
if (currentSectionEvent < Beatmap.SectionMarkers.Count && currentSectionEvent >= 0)
{
if (conductor.songPositionInBeatsAsDouble >= sectionBeats[currentSectionEvent])
{
RiqEntity marker = Beatmap.SectionMarkers[currentSectionEvent];
if (!string.IsNullOrEmpty(marker["sectionName"]))
{
Debug.Log("Section " + marker["sectionName"] + " started");
lastSection = currentSection;
if (currentSectionEvent < Beatmap.SectionMarkers.Count)
currentSection = marker;
else
currentSection = null;
nextSectionBeat = endBeat;
foreach (RiqEntity futureSection in Beatmap.SectionMarkers)
{
if (futureSection.beat < marker.beat) continue;
if (futureSection == marker) continue;
if (!string.IsNullOrEmpty(futureSection["sectionName"]))
{
nextSectionBeat = futureSection.beat;
break;
}
}
onSectionChange?.Invoke(currentSection, lastSection);
}
if (OverlaysManager.OverlaysEnabled)
{
if (PersistentDataManager.gameSettings.perfectChallengeType != PersistentDataManager.PerfectChallengeType.Off)
{
if (marker["startPerfect"] && GoForAPerfect.instance != null && GoForAPerfect.instance.perfect && !GoForAPerfect.instance.gameObject.activeSelf)
{
GoForAPerfect.instance.Enable(marker.beat);
}
}
}
MarkerWeight = marker["weight"];
MarkerCategory = marker["category"];
currentSectionEvent++;
}
}
if (conductor.songPositionInBeatsAsDouble >= Math.Ceiling(_playStartBeat) + _pulseTally)
{
if (minigame != null) minigame.OnBeatPulse(Math.Ceiling(_playStartBeat) + _pulseTally);
onBeatPulse?.Invoke(Math.Ceiling(_playStartBeat) + _pulseTally);
_pulseTally++;
}
float seekTime = 8f;
//seek ahead to preload games that have assetbundles
SeekAheadAndPreload(clampedBeat, seekTime);
SeekAheadAndDoPreEvent(clampedBeat);
if (currentEvent < Beatmap.Entities.Count && currentEvent >= 0)
{
List<RiqEntity> entitiesInRange = ListPool<RiqEntity>.Get();
List<RiqEntity> fxEntities = ListPool<RiqEntity>.Get();
// allows for multiple events on the same beat to be executed on the same frame, so no more 1-frame delay
while (currentEvent < eventBeats.Count && clampedBeat >= eventBeats[currentEvent] && this.conductor.isPlaying)
{
fxEntities.Clear();
entitiesInRange.Clear();
using (PooledObject<List<RiqEntity>> pool = ListPool<RiqEntity>.Get(out List<RiqEntity> currentBeatEntities))
{
currentBeatEntities = Beatmap.Entities.FindAll(c => c.beat == eventBeats[currentEvent]);
foreach (RiqEntity entity in currentBeatEntities)
{
if (EventCaller.FXOnlyGames().Contains(eventCaller.GetMinigame(entity.datamodel.Split('/')[0])))
{
fxEntities.Add(entity);
}
else
{
entitiesInRange.Add(entity);
}
}
}
SortEventsByPriority(fxEntities);
SortEventsByPriority(entitiesInRange);
// FX entities should ALWAYS execute before gameplay entities
foreach (RiqEntity entity in fxEntities)
{
eventCaller.CallEvent(entity, true);
currentEvent++;
}
foreach (RiqEntity entity in entitiesInRange)
{
// if game isn't loaded, run inactive event
if (entity.datamodel.Split('/')[0] != currentGame)
{
eventCaller.CallEvent(entity, false);
}
else
{
eventCaller.CallEvent(entity, true);
}
// Thank you to @shshwdr for bring this to my attention
currentEvent++;
}
}
ListPool<RiqEntity>.Release(entitiesInRange);
ListPool<RiqEntity>.Release(fxEntities);
}
if (currentSection == null)
{
SectionProgress = 0;
}
else
{
double currectSectionStart = conductor.GetSongPosFromBeat(currentSection.beat);
SectionProgress = (conductor.songPosition - currectSectionStart) / (conductor.GetSongPosFromBeat(nextSectionBeat) - currectSectionStart);
}
}
private void LateUpdate()
{
OverlaysManager.instance.TogleOverlaysVisibility(Editor.Editor.instance == null || Editor.Editor.instance.fullscreen || ((PersistentDataManager.gameSettings.overlaysInEditor) && (!Editor.Editor.instance.fullscreen)) || HeavenStudio.Editor.GameSettings.InPreview);
if (!conductor.isPlaying)
return;
if (conductor.songPositionInBeatsAsDouble >= Math.Ceiling(_playStartBeat) + _latePulseTally)
{
if (minigame != null) minigame.OnLateBeatPulse(Math.Ceiling(_playStartBeat) + _latePulseTally);
onBeatPulse?.Invoke(Math.Ceiling(_playStartBeat) + _latePulseTally);
_latePulseTally++;
}
}
public static void PlaySFXArbitrary(double beat, float length, string game, string name, float pitch, float volume, bool looping, int offset)
{
if (string.IsNullOrEmpty(name)) return;
Sound sound;
if (game == "common")
{
sound = SoundByte.PlayOneShot(name, beat, pitch, volume, looping, null, (offset / 1000f));
}
else
{
SoundByte.PreloadGameAudioClips(game);
sound = SoundByte.PlayOneShotGame(game + "/" + name, beat, pitch, volume, looping, true, (offset / 1000f));
}
if (looping)
{
BeatAction.New(null, new() {
new(beat + length, () => sound.KillLoop(0)),
});
}
}
public void PlayAnimationArbitrary(string animator, string animation, float scale)
{
Transform animTrans = minigameObj.transform.Find(animator);
if (animTrans != null && animTrans.TryGetComponent(out Animator anim))
{
anim.DoScaledAnimationAsync(animation, scale);
}
}
public void ToggleInputs(bool inputs)
{
canInput = inputs;
}
public void ToggleAutoplay(bool auto)
{
autoplay = auto;
}
public void TogglePlayMode(bool mode)
{
playMode = mode;
}
#region Play Events
private double _playStartBeat = 0;
private int _pulseTally = 0;
private int _latePulseTally = 0;
public void Play(double beat, float delay = 0f)
{
bool paused = conductor.isPaused;
_playStartBeat = beat;
_pulseTally = 0;
_latePulseTally = 0;
canInput = true;
if (!paused)
{
inputOffsetSamples.Clear();
averageInputOffset = 0;
TimingAccuracyDisplay.instance.ResetArrow();
SkillStarManager.instance.Reset();
skillStarCollected = false;
noMiss = true;
GoForAPerfect.instance.perfect = true;
GoForAPerfect.instance.Disable();
SectionMedalsManager.instance.Reset();
clearedSections.Clear();
judgementInfo = new JudgementManager.JudgementInfo
{
inputs = new List<JudgementManager.InputInfo>(),
medals = new List<JudgementManager.MedalInfo>()
};
MarkerWeight = 1;
MarkerCategory = 0;
if (playMode && delay > 0)
{
GlobalGameManager.ForceFade(0, delay * 0.5f, delay * 0.5f);
}
}
StartCoroutine(PlayCo(beat, delay));
//onBeatChanged?.Invoke(beat);
}
private IEnumerator PlayCo(double beat, float delay = 0f)
{
bool paused = conductor.isPaused;
if (!paused)
{
conductor.SetBpm(Beatmap.TempoChanges[0]["tempo"]);
conductor.SetVolume(Beatmap.VolumeChanges[0]["volume"]);
conductor.firstBeatOffset = Beatmap.data.offset;
conductor.PlaySetup(beat);
SetCurrentEventToClosest(beat, true);
Debug.Log("Playing at " + beat);
KillAllSounds();
if (delay > 0)
{
yield return new WaitForSeconds(delay);
}
Minigame miniGame = null;
if (minigameObj != null && minigameObj.TryGetComponent<Minigame>(out miniGame))
{
if (miniGame != null)
{
miniGame.OnPlay(beat);
}
}
onPlay?.Invoke(beat);
bool hasStartPerfect = false;
foreach (RiqEntity marker in Beatmap.SectionMarkers)
{
if (marker["startPerfect"])
{
hasStartPerfect = true;
break;
}
}
if (OverlaysManager.OverlaysEnabled && !hasStartPerfect)
{
if (PersistentDataManager.gameSettings.perfectChallengeType != PersistentDataManager.PerfectChallengeType.Off)
{
GoForAPerfect.instance.Enable(0);
}
}
}
else
{
onUnPause?.Invoke(beat);
}
if (playMode)
{
CircleCursor.LockCursor(true);
}
Application.backgroundLoadingPriority = ThreadPriority.Low;
conductor.Play(beat);
}
public void Pause()
{
conductor.Pause();
Util.SoundByte.PauseOneShots();
onPause?.Invoke(conductor.songPositionInBeatsAsDouble);
canInput = false;
}
public void Stop(double beat, bool restart = false, float restartDelay = 0f)
{
// I feel like I should standardize the names
if (conductor.isPlaying)
{
SkillStarManager.instance.KillStar();
TimingAccuracyDisplay.instance.StopStarFlash();
GoForAPerfect.instance.Disable();
SectionMedalsManager.instance.OnRemixEnd(endBeat, currentSection);
}
Minigame miniGame;
if (minigameObj != null && minigameObj.TryGetComponent<Minigame>(out miniGame))
{
if (miniGame != null)
{
miniGame.OnStop(beat);
}
}
conductor.Stop(beat);
conductor.SetBeat(beat);
KillAllSounds();
if (restart)
{
Play(0, restartDelay);
}
else if (playMode)
{
//exiting = true; Unused value - Marc
judgementInfo.star = skillStarCollected;
judgementInfo.perfect = GoForAPerfect.instance.perfect;
judgementInfo.noMiss = noMiss;
judgementInfo.time = DateTime.Now;
JudgementManager.SetPlayInfo(judgementInfo, Beatmap);
GlobalGameManager.LoadScene("Judgement", 0.35f, 0f, DestroyGame);
CircleCursor.LockCursor(false);
}
else
{
conductor.SetBeat(beat);
}
Application.backgroundLoadingPriority = ThreadPriority.Normal;
}
public void SafePlay(double beat, float delay, bool discord)
{
StartCoroutine(WaitReadyAndPlayCo(beat, delay, discord));
}
private IEnumerator WaitReadyAndPlayCo(double beat, float delay = 1f, bool discord = true)
{
SoundByte.UnloadAudioClips();
SoundByte.PreloadAudioClipAsync("skillStar");
SoundByte.PreloadAudioClipAsync("perfectMiss");
conductor.SetBeat(beat);
WaitUntil yieldOverlays = new WaitUntil(() => OverlaysManager.OverlaysReady);
WaitUntil yieldBeatmap = new WaitUntil(() => Beatmap != null && BeatmapEntities() > 0);
WaitUntil yieldAudio = new WaitUntil(() => AudioLoadDone || (ChartLoadError && !GlobalGameManager.IsShowingDialog));
WaitUntil yieldGame = null;
List<Minigames.Minigame> gamesToPreload = SetCurrentEventToClosest(beat, true);
Debug.Log($"Preloading {gamesToPreload.Count} games");
if (gamesToPreload.Count > 0)
{
yieldGame = new WaitUntil(() => gamesToPreload.All(x => x.AssetsLoaded));
}
// wait for overlays to be ready
// Debug.Log("waiting for overlays");
yield return yieldOverlays;
// wait for beatmap to be loaded
// Debug.Log("waiting for beatmap");
yield return yieldBeatmap;
//wait for audio clip to be loaded
// Debug.Log("waiting for audio");
yield return yieldAudio;
//wait for games to be loaded
// Debug.Log("waiting for minigames");
if (yieldGame != null)
yield return yieldGame;
SkillStarManager.instance.KillStar();
TimingAccuracyDisplay.instance.StopStarFlash();
GoForAPerfect.instance.Disable();
SectionMedalsManager.instance?.Reset();
if (discord)
{
GlobalGameManager.UpdateDiscordStatus(Beatmap["remixtitle"].ToString(), false, true);
}
Play(beat, delay);
yield break;
}
public void KillAllSounds()
{
// Debug.Log("Killing all sounds");
SoundObjects.Clear();
SoundByte.KillOneShots();
}
#endregion
#region List Functions
public void SortEventsList()
{
Beatmap.Entities.Sort((x, y) => x.beat.CompareTo(y.beat));
Beatmap.TempoChanges.Sort((x, y) => x.beat.CompareTo(y.beat));
Beatmap.VolumeChanges.Sort((x, y) => x.beat.CompareTo(y.beat));
Beatmap.SectionMarkers.Sort((x, y) => x.beat.CompareTo(y.beat));
eventBeats = Beatmap.Entities.Select(c => c.beat).ToList();
tempoBeats = Beatmap.TempoChanges.Select(c => c.beat).ToList();
volumeBeats = Beatmap.VolumeChanges.Select(c => c.beat).ToList();
sectionBeats = Beatmap.SectionMarkers.Select(c => c.beat).ToList();
allGameSwitches = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
preSequenceBeats = new List<double>();
string[] seekEntityDatamodel;
foreach (RiqEntity entity in Beatmap.Entities)
{
seekEntityDatamodel = entity.datamodel.Split('/');
double seekTime = eventCaller.GetGameAction(seekEntityDatamodel[0], seekEntityDatamodel[1]).preFunctionLength;
preSequenceBeats.Add(entity.beat - seekTime);
}
preSequenceBeats.Sort();
}
void SortEventsByPriority(List<RiqEntity> entities)
{
string[] xDatamodel;
string[] yDatamodel;
entities.Sort((x, y) =>
{
xDatamodel = x.datamodel.Split('/');
yDatamodel = y.datamodel.Split('/');
Minigames.GameAction xAction = eventCaller.GetGameAction(xDatamodel[0], xDatamodel[1]);
Minigames.GameAction yAction = eventCaller.GetGameAction(yDatamodel[0], yDatamodel[1]);
return yAction.priority.CompareTo(xAction.priority);
});
}
public static double GetClosestInList(List<double> list, double compareTo)
{
if (list.Count > 0)
return list.Aggregate((x, y) => Math.Abs(x - compareTo) < Math.Abs(y - compareTo) ? x : y);
else
return double.MinValue;
}
public static int GetIndexAfter(List<double> list, double compareTo)
{
list.Sort();
if (list.Count > 0)
{
foreach (double item in list)
{
if (item >= compareTo)
{
return Math.Max(list.IndexOf(item), 0);
}
}
return list.Count;
}
return 0;
}
public static int GetIndexBefore(List<double> list, double compareTo)
{
list.Sort();
if (list.Count > 0)
{
foreach (double item in list)
{
if (item >= compareTo)
{
return Math.Max(list.IndexOf(item) - 1, 0);
}
}
return list.Count - 1;
}
return 0;
}
public List<Minigames.Minigame> SetCurrentEventToClosest(double beat, bool canPreload = false)
{
SortEventsList();
List<Minigames.Minigame> preload = new();
onBeatChanged?.Invoke(beat);
if (Beatmap.Entities.Count > 0)
{
currentEvent = GetIndexAfter(eventBeats, beat);
currentPreEvent = GetIndexAfter(eventBeats, beat);
currentPreSequence = GetIndexAfter(eventBeats, beat);
string newGame = Beatmap.Entities[Math.Min(currentEvent, eventBeats.Count - 1)].datamodel.Split(0);
if (allGameSwitches.Count > 0)
{
int index = GetIndexBefore(allGameSwitches.Select(c => c.beat).ToList(), beat);
currentPreSwitch = index;
var closestGameSwitch = allGameSwitches[index];
if (closestGameSwitch.beat <= beat)
{
newGame = closestGameSwitch.datamodel.Split(2);
}
else if (closestGameSwitch.beat > beat)
{
if (index == 0)
{
newGame = Beatmap.Entities[0].datamodel.Split(0);
}
else
{
if (index - 1 >= 0)
{
newGame = allGameSwitches[index - 1].datamodel.Split(2);
}
else
{
newGame = Beatmap.Entities[Beatmap.Entities.IndexOf(closestGameSwitch) - 1].datamodel.Split(0);
}
}
}
}
if (!GetGameInfo(newGame).fxOnly)
{
if (canPreload)
{
Minigames.Minigame inf = GetGameInfo(newGame);
if (inf != null && inf.UsesAssetBundle && !inf.AssetsLoaded)
{
preload.Add(inf);
}
}
StartCoroutine(WaitAndSetGame(newGame));
}
List<RiqEntity> allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "end" });
if (allEnds.Count > 0)
endBeat = allEnds.Select(c => c.beat).Min();
else
endBeat = conductor.SongLengthInBeatsAsDouble();
}
else
{
SetGame("noGame");
endBeat = conductor.SongLengthInBeatsAsDouble();
}
if (Beatmap.TempoChanges.Count > 0)
{
currentTempoEvent = 0;
//for tempo changes, just go over all of em until the last one we pass
for (int t = 0; t < tempoBeats.Count; t++)
{
// Debug.Log("checking tempo event " + t + " against beat " + beat + "( tc beat " + tempoChanges[t] + ")");
if (tempoBeats[t] > beat)
{
break;
}
currentTempoEvent = t;
}
// Debug.Log("currentTempoEvent is now " + currentTempoEvent);
}
if (Beatmap.VolumeChanges.Count > 0)
{
currentVolumeEvent = 0;
for (int t = 0; t < volumeBeats.Count; t++)
{
if (volumeBeats[t] > beat)
{
break;
}
currentVolumeEvent = t;
}
}
lastSection = null;
currentSection = null;
if (Beatmap.SectionMarkers.Count > 0)
{
currentSectionEvent = 0;
for (int t = 0; t < sectionBeats.Count; t++)
{
if (sectionBeats[t] > beat)
{
break;
}
currentSectionEvent = t;
}
}
onSectionChange?.Invoke(currentSection, lastSection);
preload.AddRange(SeekAheadAndPreload(beat));
return preload;
}
#endregion
/// <summary>
/// While playing a chart, switches the currently active game
/// Should only be called by chart entities
/// </summary>
/// <param name="game">name of the game to switch to</param>
/// <param name="beat">beat of the chart entity calling the switch</param>
/// <param name="flash">hide the screen during the switch</param>
public void SwitchGame(string game, double beat, bool flash)
{
if (game != currentGame)
{
if (currentGameSwitchIE != null)
StopCoroutine(currentGameSwitchIE);
currentGameSwitchIE = StartCoroutine(SwitchGameIE(game, beat, flash));
}
}
IEnumerator SwitchGameIE(string game, double beat, bool flash)
{
if (flash)
{
HeavenStudio.StaticCamera.instance.ToggleCanvasVisibility(false);
}
SetGame(game, false);
Minigame miniGame;
if (minigameObj != null && minigameObj.TryGetComponent<Minigame>(out miniGame))
{
if (miniGame != null)
{
miniGame.OnGameSwitch(beat);
}
}
while (conductor.GetUnSwungBeat(beat + 0.25) > Math.Max(conductor.unswungSongPositionInBeatsAsDouble, 0))
{
if (!conductor.isPlaying)
{
HeavenStudio.StaticCamera.instance.ToggleCanvasVisibility(true);
SetAmbientGlowToCurrentMinigameColor();
StopCoroutine(currentGameSwitchIE);
}
yield return null;
}
HeavenStudio.StaticCamera.instance.ToggleCanvasVisibility(true);
SetAmbientGlowToCurrentMinigameColor();
}
/// <summary>
/// Immediately sets the current minigame to the specified game
/// </summary>
/// <param name="game"></param>
/// <param name="useMinigameColor"></param>
private void SetGame(string game, bool useMinigameColor = true)
{
ResetCamera(); // resetting camera before setting new minigame so minigames can set camera values in their awake call - Rasmus
GameObject prefab = GetGamePrefab(game);
if (prefab == null) return;
Destroy(minigameObj);
minigameObj = Instantiate(prefab);
if (minigameObj.TryGetComponent<Minigame>(out var minigame))
{
this.minigame = minigame;
minigame.minigameName = game;
minigame.gameManager = this;
minigame.conductor = conductor;
}
Vector3 originalScale = minigameObj.transform.localScale;
minigameObj.transform.parent = eventCaller.GamesHolder.transform;
minigameObj.transform.localScale = originalScale;
minigameObj.name = game;
SetCurrentGame(game, useMinigameColor);
}
string currentGameRequest = null;
/// <summary>
/// Waits for a given game to preload, then sets it as the current game
/// </summary>
/// <param name="game"></param>
/// <param name="useMinigameColor"></param>
/// <returns></returns>
private IEnumerator WaitAndSetGame(string game, bool useMinigameColor = true)
{
if (game == currentGameRequest)
{
yield break;
}
currentGameRequest = game;
var inf = GetGameInfo(game);
if (inf != null && inf.UsesAssetBundle)
{
if (!(inf.AssetsLoaded || inf.AlreadyLoading))
{
// Debug.Log($"ASYNC loading assetbundles for game {game}");
inf.LoadAssetsAsync().Forget();
yield return new WaitUntil(() => inf.AssetsLoaded);
}
SetGame(game, useMinigameColor);
currentGameRequest = null;
}
else
{
SetGame(game, useMinigameColor);
currentGameRequest = null;
}
}
public void DestroyGame()
{
SoundByte.UnloadAudioClips();
SetGame("noGame");
}
/// <summary>
/// Get the game prefab for a given game name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public GameObject GetGamePrefab(string name)
{
if (name is null or "" or "noGame")
{
return Resources.Load<GameObject>($"Games/noGame");
}
Minigames.Minigame gameInfo = GetGameInfo(name);
if (gameInfo != null)
{
if (gameInfo.inferred)
{
return Resources.Load<GameObject>($"Games/noGame");
}
if (gameInfo.fxOnly)
{
var gameInfos = Beatmap.Entities
.Select(x => x.datamodel.Split(0))
.Select(x => GetGameInfo(x))
.Where(x => x != null)
.Where(x => !x.fxOnly)
.Where(x => x.LoadableName is not "noGame" or "" or null);
if (gameInfos.Count() > 0)
{
gameInfo = gameInfos.FirstOrDefault();
if (gameInfo == null) return Resources.Load<GameObject>($"Games/noGame");
}
else
{
return Resources.Load<GameObject>($"Games/noGame");
}
}
GameObject prefab;
if (gameInfo.UsesAssetBundle)
{
//game is packed in an assetbundle, load from that instead
if (gameInfo.AssetsLoaded && gameInfo.LoadedPrefab != null) return gameInfo.LoadedPrefab;
// couldn't load cached prefab, try loading from resources (usually indev games with mispacked assetbundles)
Debug.LogWarning($"Failed to load prefab for game {name} from assetbundle, trying Resources...");
prefab = Resources.Load<GameObject>($"Games/{name}");
if (prefab != null)
{
return prefab;
}
else
{
Debug.LogWarning($"Game {name} not found, using noGame");
return Resources.Load<GameObject>($"Games/noGame");
}
}
// games with no assetbundle (usually indev games)
prefab = Resources.Load<GameObject>($"Games/{name}");
if (prefab != null)
{
return prefab;
}
else
{
Debug.LogWarning($"Game {name} not found, using noGame");
return Resources.Load<GameObject>($"Games/noGame");
}
}
else
{
Debug.LogWarning($"Game {name} not found, using noGame");
return Resources.Load<GameObject>($"Games/noGame");
}
}
public Minigames.Minigame GetGameInfo(string name)
{
return eventCaller.GetMinigame(name);
}
public bool TryGetMinigame<T>(out T mg) where T : Minigame
{
if (minigame is T tempMinigame)
{
mg = tempMinigame;
return true;
}
else
{
mg = null;
return false;
}
}
Color colMain;
public void SetCurrentGame(string game, bool useMinigameColor = true)
{
currentGame = game;
if (GetGameInfo(currentGame) != null)
{
colMain = StringUtils.Hex2RGB(GetGameInfo(currentGame).color);
CircleCursor.SetCursorColors(colMain, StringUtils.Hex2RGB(GetGameInfo(currentGame).splitColorL), StringUtils.Hex2RGB(GetGameInfo(currentGame).splitColorR));
if (useMinigameColor) HeavenStudio.StaticCamera.instance.SetAmbientGlowColour(colMain, true);
else HeavenStudio.StaticCamera.instance.SetAmbientGlowColour(Color.black, false);
}
else
{
CircleCursor.SetCursorColors(Color.white, Color.white, Color.white);
HeavenStudio.StaticCamera.instance.SetAmbientGlowColour(Color.black, false);
}
CircleCursor.ClearTrail(false);
}
private void SetAmbientGlowToCurrentMinigameColor()
{
if (GetGameInfo(currentGame) != null)
HeavenStudio.StaticCamera.instance.SetAmbientGlowColour(StringUtils.Hex2RGB(GetGameInfo(currentGame).color), true);
}
private bool SongPosLessThanClipLength(float t)
{
if (conductor.musicSource.clip != null)
return conductor.GetSongPosFromBeat(t) < conductor.musicSource.clip.length;
else
return true;
}
public void ResetCamera()
{
HeavenStudio.GameCamera.ResetAdditionalTransforms();
}
}
}