public static IEnumerator MadScience(float length)
{
yield return(new WaitForSeconds(0f));
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
Plugin.Log("Grabbed BeatmapData");
List <BeatmapObjectData> objects;
float start = Plugin.songAudio.time + 2;
float end = start + length + 2f;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData.ToList();
for (int i = 0; i < objects.Count; ++i)
{
BeatmapObjectData beatmapObject = objects[i];
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
objects.Add(NoteToWall(beatmapObject, Plugin.levelData.GameplayCoreSceneSetupData.difficultyBeatmap.level.beatsPerMinute));
}
}
objects = objects.OrderBy(o => o.time).ToList();
line.beatmapObjectsData = objects.ToArray();
objects.Clear();
}
yield return(new WaitForSeconds(length + 2f));
callbackController.SetField("_beatmapData", beatmapData);
}
public void Init(OnlinePlayerController newOwner)
{
BeatmapObjectCallbackController original = FindObjectsOfType <BeatmapObjectCallbackController>().First(x => !(x is OnlineBeatmapCallbackController));
foreach (FieldInfo info in original.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic).Where(x => !x.Name.ToLower().Contains("event")))
{
info.SetValue(this, info.GetValue(original));
}
owner = newOwner;
_beatmapObjectDataCallbackCacheList = new List <BeatmapObjectData>();
_beatmapObjectCallbackData = new List <BeatmapObjectCallbackData>();
_beatmapDataModel = new GameObject("CustomBeatmapDataModel").AddComponent <BeatmapDataModel>();
if (BS_Utils.Plugin.LevelData.IsSet)
{
LevelOptionsInfo levelInfo = owner.playerInfo.updateInfo.playerLevelOptions;
IDifficultyBeatmap diffBeatmap = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap.level.beatmapLevelData.difficultyBeatmapSets.First(x => x.beatmapCharacteristic.serializedName == owner.playerInfo.updateInfo.playerLevelOptions.characteristicName).difficultyBeatmaps.First(x => x.difficulty == owner.playerInfo.updateInfo.playerLevelOptions.difficulty);
BeatmapData data = diffBeatmap.beatmapData;
_beatmapDataModel.beatmapData = BeatDataTransformHelper.CreateTransformedBeatmapData(data, levelInfo.modifiers.ToGameplayModifiers(), PracticeSettings.defaultPracticeSettings, PlayerSpecificSettings.defaultSettings);
HandleBeatmapDataModelDidChangeBeatmapData();
Plugin.log.Info($"Set custom BeatmapDataModel for difficulty {levelInfo.difficulty}");
}
}
public void Construct(IVRPlatformHelper vrPlatformHelper, BeatmapObjectCallbackController callbackController, AudioTimeSyncController audioTimeSyncController, VRControllersInputManager vrControllersInputManager)
{
_vrPlatformHelper = vrPlatformHelper;
_callbackController = callbackController;
_audioTimeSyncController = audioTimeSyncController;
_vrControllersInputManager = vrControllersInputManager;
}
internal static IEnumerator DelayedStart(BeatmapObjectSpawnController beatmapObjectSpawnController)
{
yield return(new WaitForEndOfFrame());
BeatmapObjectSpawnController = beatmapObjectSpawnController;
// prone to breaking if anything else implements these interfaces
BeatmapObjectManager beatmapObjectManager = _beatmapObjectSpawnAccessor(ref beatmapObjectSpawnController) as BeatmapObjectManager;
BeatmapObjectCallbackController coreSetup = _callbackControllerAccessor(ref beatmapObjectSpawnController) as BeatmapObjectCallbackController;
IAudioTimeSource = _audioTimeSourceAccessor(ref coreSetup);
IReadonlyBeatmapData beatmapData = _beatmapDataAccessor(ref coreSetup);
beatmapObjectManager.noteWasCutEvent -= NoteColorizer.ColorizeSaber;
beatmapObjectManager.noteWasCutEvent += NoteColorizer.ColorizeSaber;
if (Harmony.HasAnyPatches(HARMONYID))
{
if (beatmapData is CustomBeatmapData customBeatmap)
{
if (ChromaConfig.Instance.EnvironmentEnhancementsEnabled)
{
EnvironmentEnhancementManager.Init(customBeatmap, beatmapObjectSpawnController.noteLinesDistance);
}
}
// please let me kill legacy
LegacyLightHelper.Activate(beatmapData.beatmapEventsData);
}
}
private void Start()
{
_eventManager = gameObject.GetComponent <EventManager>();
if (_eventManager == null)
{
_eventManager = gameObject.AddComponent <EventManager>();
}
_eventManager.OnLevelStart.Invoke();
_scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().FirstOrDefault();
if (_scoreController == null)
{
return;
}
_saberCollisionManager =
Resources.FindObjectsOfTypeAll <ObstacleSaberSparkleEffectManager>().FirstOrDefault();
_gameEnergyCounter = Resources.FindObjectsOfTypeAll <GameEnergyCounter>().FirstOrDefault();
_beatmapObjectCallbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
_scoreController.noteWasCutEvent += SliceCallBack;
_scoreController.noteWasMissedEvent += NoteMissCallBack;
_scoreController.multiplierDidChangeEvent += MultiplierCallBack;
_scoreController.comboDidChangeEvent += ComboChangeEvent;
_saberCollisionManager.sparkleEffectDidStartEvent += SaberStartCollide;
_saberCollisionManager.sparkleEffectDidEndEvent += SaberEndCollide;
_gameEnergyCounter.gameEnergyDidReach0Event += FailLevelCallBack;
_beatmapObjectCallbackController.beatmapEventDidTriggerEvent += OnBeatmapEventDidTriggerEvent;
}
public static IEnumerator NoArrows()
{
yield return(new WaitForSeconds(0f));
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
Plugin.Log("Grabbed BeatmapData");
BeatmapObjectData[] objects;
NoteData note;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData;
foreach (BeatmapObjectData beatmapObject in objects)
{
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
note = beatmapObject as NoteData;
note.SetNoteToAnyCutDirection();
}
}
}
// dataModel.beatmapData = beatmapData;
}
public void Inject(ILoggerProvider loggerProvider, LoadedAvatar avatar, ScoreController scoreController, BeatmapObjectCallbackController beatmapObjectCallbackController, ILevelEndActions levelEndActions)
{
_logger = loggerProvider.CreateLogger <AvatarGameplayEventsPlayer>(avatar.descriptor.name);
_scoreController = scoreController;
_levelEndActions = levelEndActions;
_beatmapObjectCallbackController = beatmapObjectCallbackController;
}
IEnumerator FindEventCallback()
{
yield return(new WaitUntil(() => GameObject.Find("Vertical Grid Callback")));
callbackController = GameObject.Find("Vertical Grid Callback").GetComponent <BeatmapObjectCallbackController>();
rotationCallback = Resources.FindObjectsOfTypeAll <RotationCallbackController>().First();
atsc = rotationCallback.atsc;
if (RotationController != null)
{
RotationController.RotationCallback = rotationCallback;
RotationController.Init();
}
callbackController.EventPassedThreshold += EventPassed;
foreach (LightsManager manager in LightingManagers)
{
yield return(new WaitUntil(() => manager.ControllingLights.Any()));
IEnumerable <LightingEvent> allLights = manager.ControllingLights;
IEnumerable <LightingEvent> lights = allLights.Where(x => !x.UseInvertedPlatformColors);
IEnumerable <LightingEvent> invertedLights = allLights.Where(x => x.UseInvertedPlatformColors);
manager.ChangeColor(BlueColor, 0, lights);
manager.ChangeColor(RedColor, 0, invertedLights);
}
}
IEnumerator FindEventCallback()
{
yield return(new WaitUntil(() => GameObject.Find("Vertical Grid Callback")));
callbackController = GameObject.Find("Vertical Grid Callback").GetComponent <BeatmapObjectCallbackController>();
callbackController.EventPassedThreshold += EventPassed;
}
private void Start()
{
_leftEventManager = _leftSaber.GetComponent <EventManager>();
if (_leftEventManager == null)
{
_leftEventManager = _leftSaber.AddComponent <EventManager>();
}
_rightEventManager = _rightSaber.GetComponent <EventManager>();
if (_rightEventManager == null)
{
_rightEventManager = _rightSaber.AddComponent <EventManager>();
}
_leftEventManager.OnLevelStart.Invoke();
_rightEventManager.OnLevelStart.Invoke();
try
{
_scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().FirstOrDefault();
if (_scoreController == null)
{
Console.WriteLine("SCORE CONTROLLER NULL");
}
_saberCollisionManager =
Resources.FindObjectsOfTypeAll <ObstacleSaberSparkleEffectManager>().FirstOrDefault();
if (_saberCollisionManager == null)
{
Console.WriteLine("COLLISION MANAGER NULL");
}
_gameEnergyCounter = Resources.FindObjectsOfTypeAll <GameEnergyCounter>().FirstOrDefault();
if (_gameEnergyCounter == null)
{
Console.WriteLine("energery counter null");
}
_beatmapCallback = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
if (_beatmapCallback == null)
{
Console.WriteLine("BEATMAP CALLBACK NULL");
}
_scoreController.noteWasCutEvent += SliceCallBack;
_scoreController.noteWasMissedEvent += NoteMissCallBack;
_scoreController.multiplierDidChangeEvent += MultiplierCallBack;
_scoreController.comboDidChangeEvent += ComboChangeEvent;
_saberCollisionManager.sparkleEffectDidStartEvent += SaberStartCollide;
_saberCollisionManager.sparkleEffectDidEndEvent += SaberEndCollide;
_gameEnergyCounter.gameEnergyDidReach0Event += FailLevelCallBack;
_beatmapCallback.beatmapEventDidTriggerEvent += LightEventCallBack;
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine(e.Message);
throw;
}
}
IEnumerator GrabLight()
{
yield return(new WaitUntil(() => Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().Any()));
Ec = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
Debug.Log("Found LightController");
StartCoroutine(GrabColors());
}
public bool IsChromaActive()
{
BeatmapObjectCallbackController s = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
BeatmapData _beatmapData = s?.GetField <BeatmapData, BeatmapObjectCallbackController>("_beatmapData");
var beatmap = SongCore.Collections.RetrieveDifficultyData(BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap).additionalDifficultyData;
return(beatmap._requirements.Contains("Chroma") || beatmap._suggestions.Contains("Chroma") ||
(_beatmapData?.beatmapEventData?.Any(n => n.value >= 2000000000) ?? false));
}
public static IEnumerator RandomBombs(float length)
{
var text = GameObject.Find("Chat Powers").GetComponent <GamePlayModifiersPlus.TwitchStuff.GMPDisplay>().activeCommandText;
text.text += " Bombs | ";
yield return(new WaitForSeconds(0f));
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
Plugin.Log("Grabbed BeatmapData");
BeatmapObjectData[] objects;
NoteData note;
float start = Plugin.songAudio.time + 2;
float end = start + length + 2f;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData;
foreach (BeatmapObjectData beatmapObject in objects)
{
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
if (beatmapObject.time > start && beatmapObject.time < end)
{
try
{
// Plugin.Log("Attempting to Convert to Bomb");
note = beatmapObject as NoteData;
int randMax = (int)((1 / ChatConfig.bombsChance) * 100);
int randMin = 100;
int random = Random.Range(1, randMax);
// Plugin.Log("Min: " + randMin + " Max: " + randMax + " Number: " + random);
if (random <= randMin || ChatConfig.bombsChance == 1)
{
note.SetProperty("noteType", NoteType.Bomb);
}
}
catch (System.Exception ex)
{
Plugin.Log(ex.ToString());
}
}
}
}
}
yield return(new WaitForSeconds(length + 2f));
text.text = text.text.Replace(" Bombs | ", "");
callbackController.SetField("_beatmapData", beatmapData);
}
/// <summary>
/// Only ever called once, mainly used to initialize variables.
/// </summary>
private void Awake()
{
Logger.log?.Debug($"{name}: Awake()");
port.Open();
Logger.log.Info("Open Port");
Ec = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
StartCoroutine(GrabLight());
}
public void Inject(
BeatmapObjectCallbackController bocc,
LightRotationEventEffect[] rotationEffects,
LightPairRotationEventEffect[] pairRotationEffects
)
{
this.bocc = bocc;
this.rotationEffects = rotationEffects;
this.pairRotationEffects = pairRotationEffects;
}
public void Inject(
BeatmapObjectCallbackController bocc,
TrackLaneRingsRotationEffectSpawner[] rotationEffects,
TrackLaneRingsPositionStepEffectSpawner[] positionStepEffects
)
{
this.bocc = bocc;
this.rotationEffects = rotationEffects;
this.positionStepEffects = positionStepEffects;
}
public void Inject(ILoggerProvider loggerProvider, LoadedAvatar avatar, ScoreController scoreController, BeatmapObjectCallbackController beatmapObjectCallbackController, ILevelEndActions levelEndActions)
{
_logger = loggerProvider.CreateLogger <AvatarGameplayEventsPlayer>(avatar.descriptor.name);
_scoreController = scoreController;
_levelEndActions = levelEndActions;
_beatmapObjectCallbackController = beatmapObjectCallbackController;
// unfortunately this is not bound through Zenject
_sparkleEffectManager = FindObjectOfType <ObstacleSaberSparkleEffectManager>();
}
public AvatarGameplayEventsPlayer(ILogger <AvatarGameplayEventsPlayer> logger, PlayerAvatarManager avatarManager, ScoreController scoreController, [InjectOptional] ILevelEndActions levelEndActions, [InjectOptional] IMultiplayerLevelEndActionsPublisher multiplayerLevelEndActions, BeatmapObjectCallbackController beatmapObjectCallbackController, ObstacleSaberSparkleEffectManager sparkleEffectManager)
{
_logger = logger;
_avatarManager = avatarManager;
_scoreController = scoreController;
_levelEndActions = levelEndActions;
_multiplayerLevelEndActions = multiplayerLevelEndActions;
_beatmapObjectCallbackController = beatmapObjectCallbackController;
_sparkleEffectManager = sparkleEffectManager;
}
private IEnumerator TransformMap()
{
yield return(new WaitForSecondsRealtime(0.01f));
if (BS_Utils.Plugin.LevelData.Mode == BS_Utils.Gameplay.Mode.Multiplayer)
{
yield break;
}
var config = Configuration.instance.ConfigurationData;
// Set up for One Color
if (config.OneColor && !config.NoArrowsRandom)
{
this.useLeft =
(config.PlayMode == PlayMode.BeatSaber && config.UseLeftSaber) ||
(config.PlayMode == PlayMode.DarthMaul && config.UseLeftController) ||
(config.PlayMode == PlayMode.BeatSpear && config.UseLeftSpear);
this.undesiredNoteType = this.useLeft ? ColorType.ColorB : ColorType.ColorA;
}
try
{
BeatmapObjectCallbackController callbackController = null;
BeatmapData beatmapData = null;
BeatmapObjectCallbackController[] callbackControllers = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>();
foreach (BeatmapObjectCallbackController cbc in callbackControllers)
{
if (cbc.GetField <BeatmapData>("_beatmapData") != null)
{
callbackController = cbc;
beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
}
}
if (config.NoArrowsRandom)
{
// Transform the map to No Arrows Random using the ingame algorithm first
AlternativePlay.Logger.Info($"Transforming NoArrowsRandom for song: {this.currentBeatmap.level.songName}");
var transformedBeatmap = BeatmapDataNoArrowsTransform.CreateTransformedData(beatmapData);
callbackController.SetNewBeatmapData(transformedBeatmap);
}
// Transform every note
this.TransformNotes(beatmapData);
// Touch Notes speed detection is not handled here but in the HarmonyPatches
}
catch (Exception e)
{
AlternativePlay.Logger.Error($"Transforming Error: {this.currentBeatmap.level.songName}");
AlternativePlay.Logger.Error($"Error Message: {e.Message}");
AlternativePlay.Logger.Error($"Stack Trace: {e.StackTrace}");
}
}
// printing char each cycle -> going into serial monitor (Arduino IDE) -> enabling timestamps => Subtract earlier time from newer time.
void Awake()
{
_spawnController = FindObjectOfType <BeatmapObjectManager>();
Plugin.log.Notice("Initializing..");
Plugin.log.Notice(Settings.instance.EventChoice);
BSEvents.gameSceneActive += OnGameSceneActive;
BSEvents.songPaused += OnSongPaused;
BSEvents.songUnpaused += OnSongUnpaused;
Ec = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
Cm = Resources.FindObjectsOfTypeAll <ColorManager>().LastOrDefault();
BMD = Resources.FindObjectsOfTypeAll <BeatmapLevelSO>().FirstOrDefault();
if (Settings.instance.EventChoice == "noteCuts")
{
Plugin.log.Info("Adding event listner to noteCuts");
_spawnController.noteWasCutEvent += OnNoteCut; //Flash on note cuts
}
if (Settings.instance.EventChoice == "lightEvents")
{
Plugin.log.Info("Adding event listner to lightEvents");
Ec.beatmapEventDidTriggerEvent += EventHappened; //Flash on map's light events
}
BSEvents.menuSceneActive += menuSceneActive;
C1 = Cm.ColorForNoteType(NoteType.NoteB);
redLeft = Mathf.RoundToInt(C1.r * 255);
greenLeft = Mathf.RoundToInt(C1.g * 255);
blueLeft = Mathf.RoundToInt(C1.b * 255);
C2 = Cm.ColorForNoteType(NoteType.NoteA);
redRight = Mathf.RoundToInt(C2.r * 255);
greenRight = Mathf.RoundToInt(C2.g * 255);
blueRight = Mathf.RoundToInt(C2.b * 255);
BPM = (int)BMD.beatsPerMinute; //Not used, may come useful in future
Plugin.log.Info(" BPM = " + BPM.ToString());
if (Settings.arduinoPort.IsOpen)
{
if (Settings.instance.RainbowMode)
{
StartRainbowMode(Settings.arduinoPort);
}
else
{
Plugin.log.Info("Sending Color to arduino...");
SendColorToArduino(Settings.arduinoPort);
}
}
}
IEnumerator ReadEvents()
{
yield return(new WaitForSeconds(0f));
BeatmapObjectCallbackController beatmapObjectCallbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>()
.FirstOrDefault();
BeatmapData dataModel = beatmapObjectCallbackController.GetField <BeatmapData>("_beatmapData");
BeatmapData beatmapData = ReadBeatmapEvents(dataModel);
//ChromaLogger.Log("Events read!");
}
IEnumerator FindEventCallback()
{
yield return(new WaitUntil(() => GameObject.Find("Vertical Grid Callback")));
callbackController = GameObject.Find("Vertical Grid Callback").GetComponent <BeatmapObjectCallbackController>();
rotationCallback = Resources.FindObjectsOfTypeAll <RotationCallbackController>().First();
if (RotationController != null)
{
RotationController.RotationCallback = rotationCallback;
RotationController.Init();
}
callbackController.EventPassedThreshold += EventPassed;
}
private IEnumerator Setup()
{
yield return(new WaitForSeconds(0.1f));
callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().LastOrDefault();
originalSpawnMovementData = GameObjects.spawnController.GetField <BeatmapObjectSpawnMovementData, BeatmapObjectSpawnController>("_beatmapObjectSpawnMovementData");
seManager = Resources.FindObjectsOfTypeAll <NoteCutSoundEffectManager>().LastOrDefault();
progessController = Resources.FindObjectsOfTypeAll <SongProgressUIController>().LastOrDefault();
pauseManager = Resources.FindObjectsOfTypeAll <PauseMenuManager>().LastOrDefault();
// switchTime = 20f;
switchTime = GameObjects.songAudio.clip.length - 1f;
Task.Run(PrepareNextSong);
}
private void LevelLoaded()
{
callbackController = GameObject.Find("Vertical Grid Callback").GetComponent <BeatmapObjectCallbackController>();
rotationCallback = Resources.FindObjectsOfTypeAll <RotationCallbackController>().First();
atsc = rotationCallback.atsc;
if (RotationController != null)
{
RotationController.RotationCallback = rotationCallback;
RotationController.Init();
}
callbackController.EventPassedThreshold += EventPassed;
RefreshLightingManagers();
}
public void Awake()
{
beatmapObjectCallbackController = GetComponent <BeatmapObjectCallbackController>();
var initData = beatmapObjectCallbackController.GetField <BeatmapObjectCallbackController.InitData, BeatmapObjectCallbackController>("_initData");
audioTimeSyncController = beatmapObjectCallbackController.GetField <IAudioTimeSource, BeatmapObjectCallbackController>("_audioTimeSource") as AudioTimeSyncController;
spawningStartTime = initData.spawningStartTime;
songTime = audioTimeSyncController.songTime;
songDeltaTime = audioTimeSyncController.songTime; // first delta is the point the song starts at, not 0
eventLoopbackCallbackIds = new Dictionary <string, int>();
SetNewBeatmapData(initData.beatmapData);
Plugin.invokeCallbackControllerAwake(this);
}
public static void Prefix(BeatmapObjectCallbackController __instance)
{
//Logger.log.Info("Creating CustomEventCallbackController");
var controller = __instance.gameObject.AddComponent <CustomEventCallbackController>();
/*
* controller.customEventDidTriggerEvent +=
* e =>
* {
* Logger.log.Info(e.type + " (" + e.time + ")");
* };
*/
}
public void Init(OnlinePlayerController newOwner, OnlineAudioTimeController onlineSyncController)
{
BeatmapObjectCallbackController original = FindObjectsOfType <BeatmapObjectCallbackController>().First(x => !(x is OnlineBeatmapCallbackController));
transform.position = original.transform.position;
owner = newOwner;
_audioTimeSource = onlineSyncController;
_initData = original.GetPrivateField <InitData>("_initData");
_beatmapData = original.GetPrivateField <BeatmapData>("_beatmapData");
}
private void SceneManagerOnSceneLoaded(Scene newScene, LoadSceneMode mode)
{
_eventManager = gameObject.GetComponent <EventManager>();
if (_eventManager == null)
{
_eventManager = gameObject.AddComponent <EventManager>();
}
_scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().FirstOrDefault();
if (_scoreController == null)
{
return;
}
//_eventManager.OnLevelStart?.Invoke(); // replaced by LevelStartedEvent()
_saberCollisionManager =
Resources.FindObjectsOfTypeAll <ObstacleSaberSparkleEffectManager>().FirstOrDefault();
_gameEnergyCounter = Resources.FindObjectsOfTypeAll <GameEnergyCounter>().FirstOrDefault();
_beatmapObjectCallbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
_beatmapDataModel = Resources.FindObjectsOfTypeAll <BeatmapDataSO>().FirstOrDefault();
_scoreController.noteWasCutEvent += SliceCallBack;
_scoreController.noteWasMissedEvent += NoteMissCallBack;
_scoreController.multiplierDidChangeEvent += MultiplierCallBack;
_scoreController.comboDidChangeEvent += ComboChangeEvent;
if (_saberCollisionManager)
{
_saberCollisionManager.sparkleEffectDidStartEvent += SaberStartCollide;
_saberCollisionManager.sparkleEffectDidEndEvent += SaberEndCollide;
}
if (_gameEnergyCounter)
{
_gameEnergyCounter.gameEnergyDidReach0Event += FailLevelCallBack;
}
if (_beatmapObjectCallbackController)
{
_beatmapObjectCallbackController.beatmapEventDidTriggerEvent += OnBeatmapEventDidTriggerEvent;
}
_lastNoteId = -1;
/*if (_beatmapDataModel)
* {
* _beatmapDataModel.beatmapDataDidChangeEvent += BeatmapDataChangedCallback;
* BeatmapDataChangedCallback();
* }*/
}
public static IEnumerator Reverse(float length)
{
var text = GameObject.Find("Chat Powers").GetComponent <GamePlayModifiersPlus.TwitchStuff.GMPDisplay>().activeCommandText;
text.text += " Reverse | ";
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
Plugin.Log("Grabbed BeatmapData");
BeatmapObjectData[] objects;
NoteData note;
float start = Plugin.songAudio.time + 2;
float end = start + length + 2f;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData;
foreach (BeatmapObjectData beatmapObject in objects)
{
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
if (beatmapObject.time > start && beatmapObject.time < end)
{
note = beatmapObject as NoteData;
note.SwitchNoteType();
// note.MirrorTransformCutDirection();
// note.MirrorLineIndex(4);
}
}
}
}
yield return(new WaitForSeconds(2f));
GMPUI.reverse = true;
AdjustNjsOrOffset();
Plugin.reverseSound.Play();
DestroyNotes();
//Code to show some kinda prompt here maybe
yield return(new WaitForSeconds(length));
GMPUI.reverse = false;
AdjustNjsOrOffset();
//Code to destroy notes here
Plugin.reverseSound.Play();
DestroyNotes();
text.text = text.text.Replace(" Reverse | ", "");
}
public void Init(OnlinePlayerController newOwner)
{
BeatmapObjectCallbackController original = FindObjectsOfType <BeatmapObjectCallbackController>().First(x => !x.name.StartsWith("Online"));
foreach (FieldInfo info in original.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Default).Where(x => !x.Name.ToLower().Contains("event")))
{
info.SetValue(this, info.GetValue(original));
}
owner = newOwner;
_beatmapObjectDataCallbackCacheList = new List <BeatmapObjectData>();
_beatmapObjectCallbackData = new List <BeatmapObjectCallbackData>();
}
