public static IEnumerator SpeedChange(float length, float pitch)
{
var text = GameObject.Find("Multi Powers").GetComponent <MultiGMPDisplay>().activeCommandText;
text.text += " Speed | ";
float beatAlignOffset = Plugin.soundEffectManager.GetField <float>("_beatAlignOffset");
GameplayCoreSceneSetup sceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
float songspeedmul = Plugin.levelData.GameplayCoreSceneSetupData.gameplayModifiers.songSpeedMul;
Plugin.songAudio.pitch = pitch;
Plugin.currentSongSpeed = pitch;
AudioManagerSO mixer = sceneSetup.GetField <AudioManagerSO>("_audioMixer");
mixer.musicPitch = 1f / pitch;
// if (pitch != 1f)
// Plugin.AudioTimeSync.forcedAudioSync = true;
// else
// Plugin.AudioTimeSync.forcedAudioSync = false;
Plugin.soundEffectManager.SetField("_beatAlignOffset", beatAlignOffset * (1.5f * pitch));
yield return(new WaitForSeconds(length));
Plugin.songAudio.pitch = songspeedmul;
Plugin.currentSongSpeed = songspeedmul;
mixer.musicPitch = 1 / songspeedmul;
if (songspeedmul == 1f)
{
mixer.musicPitch = 1;
// Plugin.AudioTimeSync.forcedAudioSync = false;
}
Plugin.soundEffectManager.SetField("_beatAlignOffset", beatAlignOffset);
text.text = text.text.Replace(" Speed | ", "");
}
public static IEnumerator NoArrows()
{
Plugin.Log("Starting");
yield return(new WaitForSeconds(0f));
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
Plugin.Log(dataModel.beatmapData.bombsCount.ToString());
BeatmapData beatmapData = dataModel.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;
}
static bool Prefix(ref GameplayCoreSceneSetup __instance)
{
IPALogger log = Plugin._logger;
log.Debug("Started patch!");
bool is360 = false;
IDifficultyBeatmap difficultyBeatmap = IPAUtils.GetField <GameplayCoreSceneSetupData, GameplayCoreSceneSetup>(__instance, "_sceneSetupData").difficultyBeatmap;
BeatmapEventData[] beatmapEventData = difficultyBeatmap.beatmapData.beatmapEventData;
SpawnRotationProcessor rotProcessor = new SpawnRotationProcessor();
foreach (BeatmapEventData beatmapEvent in beatmapEventData)
{
if (!(beatmapEvent.type == BeatmapEventType.Event14 || beatmapEvent.type == BeatmapEventType.Event15))
{
continue;
}
if (rotProcessor.RotationForEventValue(beatmapEvent.value) != 0)
{
log.Debug("360 is true!");
is360 = true;
break;
}
}
if (!is360)
{
IPAUtils.SetProperty <BeatmapData, int>(difficultyBeatmap.beatmapData, "spawnRotationEventsCount", 0);
}
return(true);
}
public override void EnableModifier()
{
if (!_audioTimeSyncController)
{
_audioTimeSyncController = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().FirstOrDefault();
}
if (!_gameCoreSceneSetup)
{
_gameCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
}
if (!_mixer)
{
_mixer = _gameCoreSceneSetup.GetPrivateField <AudioManagerSO>("_audioMixer");
}
_audioSource = _audioTimeSyncController.GetPrivateField <AudioSource>("_audioSource");
_baseTimeScale = _audioTimeSyncController.GetPrivateField <float>("_timeScale");
gameObject.Tween("TimeWarping" + gameObject.GetInstanceID(), _baseTimeScale,
_baseTimeScale + Mathf.Clamp(0.2f * strength, 0, float.PositiveInfinity),
1f, TweenScaleFunctions.Linear, tween =>
{
_audioTimeSyncController.SetPrivateField("_timeScale", tween.CurrentValue);
_audioSource.pitch = tween.CurrentValue;
_mixer.musicPitch = 1f / tween.CurrentValue;
});
// RIP TimeController
//gameObject.Tween("TimeWarping" + gameObject.GetInstanceID(), TimeController.Instance.ManipulatedTime,
// Mathf.Clamp(1.25f * strength, 1, float.PositiveInfinity), 1f, TweenScaleFunctions.Linear,
// tween => {
// TimeController.Instance.ManipulatedTime = tween.CurrentValue;
// });
}
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));
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
Plugin.Log("Grabbed dataModel");
BeatmapData beatmapData = dataModel.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 / Plugin.ChatConfig.bombChance) * 100);
int randMin = 100;
int random = Random.Range(1, randMax);
// Plugin.Log("Min: " + randMin + " Max: " + randMax + " Number: " + random);
if (random <= randMin || Plugin.ChatConfig.bombChance == 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 | ", "");
dataModel.beatmapData = beatmapData;
}
private GameplayCoreSceneSetup GetGameplayCoreSetup()
{
GameplayCoreSceneSetup s = GameObject.FindObjectOfType <GameplayCoreSceneSetup>();
if (s == null)
{
s = UnityEngine.Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
}
return(s);
}
IEnumerator ReadEvents()
{
yield return(new WaitForSeconds(0f));
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
BeatmapData beatmapData = ReadBeatmapEvents(dataModel.beatmapData, ChromaLiteConfig.RGBLightsEnabled, ChromaLiteConfig.SpecialEventsEnabled);
//ChromaLogger.Log("Events read!");
}
private IEnumerator DelayedStart()
{
yield return(new WaitForSeconds(0f));
ChromaBehaviourInstantiated?.Invoke(this);
beatmapObjectSpawnController = UnityEngine.Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().First();
if (beatmapObjectSpawnController != null)
{
songBPM = beatmapObjectSpawnController.GetField <float>("_beatsPerMinute");
ChromaLogger.Log("BPM Found : " + songBPM);
}
GameplayCoreSceneSetup coreSetup = GetGameplayCoreSetup();
if (coreSetup != null)
{
ChromaLogger.Log("Found GCSS properly!", ChromaLogger.Level.DEBUG);
try {
GCSSFound(SceneManager.GetActiveScene(), coreSetup);
} catch (Exception e) {
ChromaLogger.Log(e);
}
}
if (beatmapObjectSpawnController != null)
{
beatmapObjectSpawnController.obstacleDiStartMovementEvent += HandleObstacleDidStartMovementEvent;
beatmapObjectSpawnController.noteWasCutEvent += HandleNoteWasCutEvent;
beatmapObjectSpawnController.noteWasMissedEvent += HandleNoteWasMissedEvent;
}
scoreController = GameObject.FindObjectsOfType <ScoreController>().FirstOrDefault();
if (scoreController != null)
{
scoreController.comboDidChangeEvent += ComboChangedEvent;
}
VFX.VFXRainbowBarriers.Instantiate(songBPM);
if (ColourManager.TechnicolourSabers)
{
Saber[] sabers = GameObject.FindObjectsOfType <Saber>();
if (sabers != null)
{
VFX.VFXRainbowSabers.Instantiate(sabers, songBPM, true, ChromaConfig.MatchTechnicolourSabers, ChromaConfig.MatchTechnicolourSabers ? 1f : 0.8f);
}
}
//yield return new WaitForSeconds(5f);
IsLoadingSong = false;
}
public static void ApplyModifiers()
{
Plugin.Log("Modifying BeatMap Data", Plugin.LogLevel.Info);
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetPrivateField <BeatmapDataModel>("_beatmapDataModel");
BeatmapData beatmapData = dataModel.beatmapData;
BeatmapObjectData[] objects;
NoteData noteData;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData;
foreach (BeatmapObjectData beatmapObject in objects)
{
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
noteData = beatmapObject as NoteData;
if (noteData != null)
{
if (Settings.NoArrows)
{
noteData.SetNoteToAnyCutDirection();
}
if (Settings.OneColour && noteData.noteType == NoteType.NoteA)
{
noteData.SwitchNoteType();
}
if (noteData.noteType == NoteType.Bomb && Settings.RemoveBombs)
{
//Admittedly ghetto way of removing bombs but should be amusing at the very least
noteData.MirrorLineIndex(10);
}
}
}
}
}
//return new SongData(songData.BeatsPerMinute, Settings.OverrideJumpSpeed ? Settings.NoteJumpSpeed : songData.NoteJumpSpeed, array3, array4);
}
public static IEnumerator TempNoArrows(float length)
{
var text = GameObject.Find("Chat Powers").GetComponent <GamePlayModifiersPlus.TwitchStuff.GMPDisplay>().activeCommandText;
text.text += " NoArrows | ";
yield return(new WaitForSeconds(0f));
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
Plugin.Log("Grabbed dataModel");
BeatmapData beatmapData = dataModel.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.SetNoteToAnyCutDirection();
note.TransformNoteAOrBToRandomType();
}
}
}
}
yield return(new WaitForSeconds(length + 2f));
text.text = text.text.Replace(" NoArrows | ", "");
// dataModel.beatmapData = beatmapData;
}
public static void ResetPowers(bool resetMessage)
{
GMPUI.rainbow = false;
GMPUI.funky = false;
GMPUI.njsRandom = false;
GMPUI.randomSize = false;
Plugin.altereddNoteScale = 1f;
Time.timeScale = 1;
Plugin.timeScale = 1;
Plugin.superRandom = false;
if (resetMessage)
{
Plugin.spawnController.SetField("_disappearingArrows", false);
Plugin.colorA.SetColor(Plugin.oldColorA);
Plugin.colorB.SetColor(Plugin.oldColorB);
var text = GameObject.Find("Chat Powers").GetComponent <GamePlayModifiersPlus.TwitchStuff.GMPDisplay>().cooldownText;
text.text = " ";
var text2 = GameObject.Find("Chat Powers").GetComponent <GamePlayModifiersPlus.TwitchStuff.GMPDisplay>().activeCommandText;
text2.text = "";
GameplayCoreSceneSetup sceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
AudioMixerSO mixer = sceneSetup.GetField <AudioMixerSO>("_audioMixer");
float songspeedmul = Plugin.levelData.gameplayCoreSetupData.gameplayModifiers.songSpeedMul;
Plugin.AudioTimeSync.SetField("_timeScale", songspeedmul);
Plugin.songAudio.pitch = songspeedmul;
Plugin.currentSongSpeed = songspeedmul;
mixer.musicPitch = 1 / songspeedmul;
if (songspeedmul == 1f)
{
mixer.musicPitch = 1;
Plugin.AudioTimeSync.forcedAudioSync = false;
}
if (Plugin.pauseManager.gameState == StandardLevelGameplayManager.GameState.Paused)
{
Plugin.AudioTimeSync.Pause();
}
resetMessage = false;
}
}
private void Start()
{
try
{
Console.WriteLine("Darth Maul Loaded");
this._playerController = FindObjectOfType <PlayerController>();
this._head = ReflectionUtil.GetPrivateField <Transform>(_playerController, "_headTransform");
this.isDarthModeOn = Plugin.IsDarthModeOn;
this.isOneHanded = Plugin.IsOneHanded;
this.mainController = Plugin.MainController;
this.isAutoDetect = Plugin.IsAutoDetect;
this.separation = Plugin.Separation;
hapticFeedbackHooks = new HapticFeedbackHooks();
hapticFeedbackHooks.StartHooking();
//var _mainGameSceneSetup = FindObjectOfType<MainGameSceneSetup>();
//_mainGameSceneSetupData = ReflectionUtil.GetPrivateField<MainGameSceneSetupData>(_mainGameSceneSetup, "_mainGameSceneSetupData");
levelSetup = BS_Utils.Plugin.LevelData;
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
if (Plugin.IsDarthModeOn)
{
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission("Darth Maul");
//var _beatmapDataModel = ReflectionUtil.GetPrivateField<BeatmapDataModel>(gameplayCoreSceneSetup, "_beatmapDataModel");
//var beatmapData = CreateTransformedBeatmapData(levelSetup.GameplayCoreSceneSetupData.difficultyBeatmap.beatmapData.GetCopy(), levelSetup);
//if (beatmapData != null)
//{
// _beatmapDataModel.beatmapData = beatmapData;
//}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
private IEnumerator UpdatePresenceAfterFrame()
{
yield return(true);
MainFlowCoordinator _mainFlowCoordinator = Resources.FindObjectsOfTypeAll <MainFlowCoordinator>().FirstOrDefault();
GameplayCoreSceneSetup _gameplaySetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
if (_gameplaySetup == null)
{
yield break;
}
FieldInfo _gameplayCoreSceneSetupDataField = typeof(SceneSetup <GameplayCoreSceneSetupData>).GetField("_sceneSetupData", BindingFlags.NonPublic | BindingFlags.Instance);
GameplayCoreSceneSetupData _mainSetupData = _gameplayCoreSceneSetupDataField.GetValue(_gameplaySetup) as GameplayCoreSceneSetupData;
if (_mainSetupData == null || _gameplaySetup == null || _mainFlowCoordinator == null)
{
yield break;
}
IDifficultyBeatmap diff = _mainSetupData.difficultyBeatmap;
this.songName = $"{diff.level.songName}";
ReplayController.Create(songName);
}
/// <summary>
/// Performs the transformation
/// </summary>
public IEnumerator TransformBeatMap()
{
yield return(new WaitForSecondsRealtime(0.1f));
if (this.NoArrowsOption && BS_Utils.Plugin.LevelData.IsSet)
{
// Check for game mode and early exit on One Saber or NoArrows
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
var beatmap = data.difficultyBeatmap;
string serializedName = beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName;
if (serializedName == OneSaberName || serializedName == NoArrowsName)
{
// Do not transform for One Saber or legitimate No Arrows mode
Logging.Info($"Cannot transform song: {beatmap.level.songName} due to being a One Saber or No Arrows map");
yield break;
}
// Transform the loaded in-memory map
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
if (gameplayCoreSceneSetup == null)
{
yield break;
}
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
BeatmapData beatmapData = dataModel.beatmapData;
Logging.Info("Disabling submission on NoArrowsOption turned on.");
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission("NoArrowsRandom");
// Applying NoArrowsRandom transformation
Logging.Info($"Transforming song: {beatmap.level.songName}");
var transformedBeatmap = BeatmapDataNoArrowsTransform.CreateTransformedData(beatmapData, true);
var beatmapDataModel = gameplayCoreSceneSetup.GetPrivateField <BeatmapDataModel>("_beatmapDataModel");
beatmapDataModel.SetPrivateField("_beatmapData", transformedBeatmap);
}
}
public static IEnumerator OneColor()
{
Plugin.Log("Starting");
yield return(new WaitForSeconds(0f));
GameplayCoreSceneSetup gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
BeatmapDataModel dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
Plugin.Log(dataModel.beatmapData.bombsCount.ToString());
BeatmapData beatmapData = dataModel.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.SetProperty("noteType", NoteType.NoteB);
}
}
}
//Adjust Sabers for one color
var leftSaberType = Plugin.player.leftSaber.GetField <SaberTypeObject>("_saberType");
try
{
leftSaberType.SetField("_saberType", Saber.SaberType.SaberB);
}
catch (System.Exception ex)
{
Plugin.Log(ex.ToString());
}
Plugin.Log("2 " + Plugin.player.leftSaber.saberType.ToString());
/*
* var playerController = Resources.FindObjectsOfTypeAll<PlayerController>().First();
* Saber targetSaber = playerController.rightSaber;
* Saber otherSaber = playerController.leftSaber;
* var targetCopy = Instantiate(targetSaber.gameObject);
* Saber newSaber = targetCopy.GetComponent<Saber>();
* targetCopy.transform.parent = targetSaber.transform.parent;
* targetCopy.transform.localPosition = Vector3.zero;
* targetCopy.transform.localRotation = Quaternion.identity;
* targetSaber.transform.parent = otherSaber.transform.parent;
* targetSaber.transform.localPosition = Vector3.zero;
* targetSaber.transform.localRotation = Quaternion.identity;
* otherSaber.gameObject.SetActive(false);
*
* ReflectionUtil.SetPrivateField(playerController, "_leftSaber", targetSaber);
* ReflectionUtil.SetPrivateField(playerController, "_rightSaber", newSaber);
*
* playerController.leftSaber.gameObject.SetActive(true);
*/
// dataModel.beatmapData = beatmapData;
}
private void GCSSFound(Scene scene, GameplayCoreSceneSetup gcss)
{
ChromaLogger.Log("Found GCSS!", ChromaLogger.Level.DEBUG);
//Plugin.PlayReloadSound();
_playerController = FindObjectOfType <PlayerController>();
if (_playerController == null)
{
ChromaLogger.Log("Player Controller not found!", ChromaLogger.Level.WARNING);
}
/*if (!SceneUtils.IsTargetGameScene(scene.buildIndex)) {
* ChromaLogger.Log("Somehow we got to the point where we override a map, while not playing a map. How did this happen?", ChromaLogger.Level.WARNING);
* return;
* }*/
if (gcss == null)
{
ChromaLogger.Log("Failed to obtain MainGameSceneSetup", ChromaLogger.Level.WARNING);
return;
}
//GameplayCoreSetupData mgData = ReflectionUtil.GetPrivateField<MainGameSceneSetupData>(mgs, "_mainGameSceneSetupData");
BS_Utils.Gameplay.LevelData levelData = BS_Utils.Plugin.LevelData;
if (!levelData.IsSet)
{
ChromaLogger.Log("BS_Utils LevelData is not set", ChromaLogger.Level.WARNING);
return;
}
PlayerSpecificSettings playerSettings = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.playerSpecificSettings;
//Map
BeatmapDataModel _beatmapDataModel = ReflectionUtil.GetField <BeatmapDataModel>(gcss, "_beatmapDataModel");
if (_beatmapDataModel == null)
{
ChromaLogger.Log("{XXX} : NULL BEATMAP DATA MODEL", ChromaLogger.Level.ERROR);
}
if (_beatmapDataModel.beatmapData == null)
{
ChromaLogger.Log("{XXX} : NULL BEATMAP DATA MODEL BEATMAP DATA", ChromaLogger.Level.ERROR);
}
//BeatmapData beatmapData = CreateTransformedBeatmapData(mgData.difficultyLevel.beatmapData, mgData.gameplayOptions, mgData.gameplayMode);
BeatmapData beatmapData = CreateTransformedBeatmapData(_beatmapDataModel.beatmapData, playerSettings, BaseGameMode.CurrentBaseGameMode);
if (beatmapData != null)
{
_beatmapDataModel.beatmapData = beatmapData;
ReflectionUtil.SetField(gcss, "_beatmapDataModel", _beatmapDataModel);
}
foreach (IChromaBehaviourExtension extension in extensions)
{
extension.PostInitialization(songBPM, beatmapData, playerSettings, scoreController);
}
//modes = GetModes(mgData.gameplayMode, chromaSong);
if (ChromaConfig.DebugMode)
{
Console.WriteLine();
Console.WriteLine();
ChromaLogger.Log("Gamemode: " + BaseGameMode.CurrentBaseGameMode.ToString() + " -- Party: " + BaseGameMode.PartyMode, ChromaLogger.Level.DEBUG);
}
//ChromaLogger.Log("Modify Sabers was called", ChromaLogger.Level.DEBUG);
ColourManager.RefreshLights();
if (ChromaConfig.LightshowModifier)
{
foreach (Saber saber in GameObject.FindObjectsOfType <Saber>())
{
saber.gameObject.SetActive(false);
}
}
}
private void OneSceneChanged(Scene oldScene, Scene newScene)
{
Object.Destroy(Resources.FindObjectsOfTypeAll <UIElementsCreator>().FirstOrDefault()?.gameObject);
if (newScene.name == MenuSceneName)
{
if (_resetNoFail)
{
var resultsViewController =
Resources.FindObjectsOfTypeAll <ResultsViewController>().FirstOrDefault();
if (resultsViewController != null)
{
resultsViewController.continueButtonPressedEvent +=
ResultsViewControllerOnContinueButtonPressedEvent;
}
}
if (SpeedSettingsObject != null)
{
return;
}
var volumeSettings = Resources.FindObjectsOfTypeAll <VolumeSettingsController>().FirstOrDefault();
if (volumeSettings == null)
{
return;
}
volumeSettings.gameObject.SetActive(false);
SpeedSettingsObject = Object.Instantiate(volumeSettings.gameObject);
SpeedSettingsObject.SetActive(false);
volumeSettings.gameObject.SetActive(true);
if (SpeedSettingsObject == null)
{
return;
}
var volume = SpeedSettingsObject.GetComponent <VolumeSettingsController>();
ReflectionUtil.CopyComponent(volume, typeof(IncDecSettingsController),
typeof(SpeedSettingsController), SpeedSettingsObject);
Object.DestroyImmediate(volume);
SpeedSettingsObject.GetComponentInChildren <TMP_Text>().text = "SPEED";
Object.DontDestroyOnLoad(SpeedSettingsObject);
//NJS Object
if (NjsSettingsObject != null)
{
return;
}
var volumeSettings2 = Resources.FindObjectsOfTypeAll <VolumeSettingsController>().FirstOrDefault();
if (volumeSettings2 == null)
{
return;
}
volumeSettings2.gameObject.SetActive(false);
NjsSettingsObject = Object.Instantiate(volumeSettings2.gameObject);
NjsSettingsObject.SetActive(false);
volumeSettings2.gameObject.SetActive(true);
if (NjsSettingsObject == null)
{
return;
}
var volume2 = NjsSettingsObject.GetComponent <VolumeSettingsController>();
ReflectionUtil.CopyComponent(volume2, typeof(IncDecSettingsController),
typeof(NjsSettingsController), NjsSettingsObject);
Object.DestroyImmediate(volume2);
NjsSettingsObject.GetComponentInChildren <TMP_Text>().text = "NJS";
Object.DontDestroyOnLoad(NjsSettingsObject);
//Spawn Offset Object
if (SpawnOffsetSettingsObject != null)
{
return;
}
var volumeSettings3 = Resources.FindObjectsOfTypeAll <VolumeSettingsController>().FirstOrDefault();
if (volumeSettings3 == null)
{
return;
}
volumeSettings3.gameObject.SetActive(false);
SpawnOffsetSettingsObject = Object.Instantiate(volumeSettings3.gameObject);
SpawnOffsetSettingsObject.SetActive(false);
volumeSettings3.gameObject.SetActive(true);
if (SpawnOffsetSettingsObject == null)
{
return;
}
var volume3 = SpawnOffsetSettingsObject.GetComponent <VolumeSettingsController>();
ReflectionUtil.CopyComponent(volume3, typeof(IncDecSettingsController),
typeof(SpawnOffsetController), SpawnOffsetSettingsObject);
Object.DestroyImmediate(volume3);
SpawnOffsetSettingsObject.GetComponentInChildren <TMP_Text>().text = "Spawn Offset";
Object.DontDestroyOnLoad(SpawnOffsetSettingsObject);
}
else if (newScene.name == GameSceneName)
{
CustomEffectPoolsInstaller customEffectPoolsInstaller = null;
var effectPoolsInstaller = Resources.FindObjectsOfTypeAll <EffectPoolsInstaller>().FirstOrDefault();
if (effectPoolsInstaller != null)
{
customEffectPoolsInstaller = (CustomEffectPoolsInstaller)ReflectionUtil.CopyComponent(effectPoolsInstaller,
typeof(EffectPoolsInstaller), typeof(CustomEffectPoolsInstaller), effectPoolsInstaller.gameObject);
}
SceneContext sceneContext = null;
SceneDecoratorContext sceneDecoratorContext = null;
try
{
Console.WriteLine("Custom effect Pool Installer Made");
foreach (var gameObject in newScene.GetRootGameObjects())
{
if (sceneContext == null)
{
sceneContext = gameObject.GetComponentInChildren <SceneContext>(true);
}
}
foreach (var gameObject in SceneManager.GetSceneByName(ContextSceneName).GetRootGameObjects())
{
if (sceneDecoratorContext == null)
{
sceneDecoratorContext = gameObject.GetComponentInChildren <SceneDecoratorContext>(true);
}
}
if (sceneContext != null && sceneDecoratorContext != null)
{
var prop = typeof(Context).GetField("_installers", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
var installersList = (List <MonoInstaller>)prop.GetValue(sceneDecoratorContext);
installersList.Remove(effectPoolsInstaller);
Object.DestroyImmediate(effectPoolsInstaller);
installersList.Add(customEffectPoolsInstaller);
Console.WriteLine("Custom effect Pool Installer Added");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
if (_levelData == null)
{
_levelData = Resources.FindObjectsOfTypeAll <StandardLevelSceneSetupDataSO>().FirstOrDefault();
if (_levelData == null)
{
return;
}
_levelData.didFinishEvent += MainGameSceneSetupDataOnDidFinishEvent;
}
if (_spawnController == null)
{
_spawnController = Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().FirstOrDefault();
}
if (_lastLevelId != _levelData.difficultyBeatmap.level.levelID &&
!string.IsNullOrEmpty(_lastLevelId))
{
PlayingNewSong = true;
HasTimeScaleChanged = false;
TimeScale = 1;
_lastLevelId = _levelData.difficultyBeatmap.level.levelID;
}
else
{
PlayingNewSong = false;
}
if (IsEqualToOne(TimeScale))
{
HasTimeScaleChanged = false;
}
_lastLevelId = _levelData.difficultyBeatmap.level.levelID;
_gameCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
AudioTimeSync = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().FirstOrDefault();
_songAudio = AudioTimeSync.GetPrivateField <AudioSource>("_audioSource");
_mixer = _gameCoreSceneSetup.GetPrivateField <AudioMixerSO>("_audioMixer");
PracticeMode = (_levelData.gameplayCoreSetupData.practiceSettings != null && !BS_Utils.Gameplay.Gamemode.IsIsolatedLevel);
//Check if Multiplayer is active, disable accordingly
if (PluginManager.Plugins.Any(x => x.Name == "Beat Saber Multiplayer"))
{
GameObject client = GameObject.Find("MultiplayerClient");
if (client != null)
{
Console.WriteLine("[PracticePlugin] Found MultiplayerClient game object!");
multiActive = true;
}
else
{
Console.WriteLine("[PracticePlugin] MultiplayerClient game object not found!");
}
}
if (multiActive == true)
{
PracticeMode = false;
}
if (!PracticeMode)
{
TimeScale = Mathf.Clamp(TimeScale, 1, SpeedMaxSize);
}
if (PracticeMode)
{
if (_levelData.gameplayCoreSetupData.practiceSettings.songSpeedMul != 1f)
{
_timeScale = _levelData.gameplayCoreSetupData.practiceSettings.songSpeedMul;
}
else
{
_timeScale = _levelData.gameplayCoreSetupData.gameplayModifiers.songSpeedMul;
}
SharedCoroutineStarter.instance.StartCoroutine(DelayedUI());
}
}
}
private IEnumerator UpdatePresenceAfterFrame()
{
// Wait for next frame
yield return(true);
// Fetch all required objects
_mainFlowCoordinator = Resources.FindObjectsOfTypeAll <MainFlowCoordinator>().FirstOrDefault();
_gameplaySetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
if (_z == null)
{
_z = Resources.FindObjectsOfTypeAll <Component>().FirstOrDefault(c => c != null && c.GetType().Name == "Z");
if (_z == null)
{
logger.Warn("No element of type \"Z\" found. Maybe the game isn't running a version of ScoreSaber supporting replay ?");
}
}
if (_gameplaySetup != null)
{
_mainSetupData = _gameplayCoreSceneSetupDataField.GetValue(_gameplaySetup) as GameplayCoreSceneSetupData;
}
#if DEBUG
logger.Debug("_gameplaySetup: " + _gameplaySetup);
logger.Debug("_gameplayCoreSceneSetupDataField: " + _gameplayCoreSceneSetupDataField);
logger.Debug("_mainSetupData: " + _mainSetupData);
GetFlowTypeHumanReadable(); // Used to debug print values
#endif
// Check if every required object is found
if (_mainSetupData == null || _gameplaySetup == null || _mainFlowCoordinator == null)
{
logger.Error("Error finding the scriptable objects required to update presence. (_mainSetupData: " + (_mainSetupData == null ? "N/A" : "OK") + ", _gameplaySetup: " + (_gameplaySetup == null ? "N/A" : "OK") + ", _mainFlowCoordinator: " + (_mainFlowCoordinator == null ? "N/A" : "OK"));
Presence.details = "Playing";
DiscordRpc.UpdatePresence(Presence);
yield break;
}
// Set presence main values
IDifficultyBeatmap diff = _mainSetupData.difficultyBeatmap;
Presence.details = $"{diff.level.songName} | {diff.difficulty.Name()}";
Presence.state = "";
if (_z != null)
{
//Console.WriteLine("--------------------------");
FieldInfo[] fields = _z.GetType().GetFields((BindingFlags)(-1));
foreach (FieldInfo fi in fields)
{
if (fi.FieldType.Name == "Mode" && fi.GetValue(_z).ToString() == "Playback")
{
Presence.state += "[Replay] ";
}
//logger.Debug("Discord Presence - [" + fi.Name + ": " + fi.FieldType.Name + "] => " + fi.GetValue(_z));
}
}
if (diff.level.levelID.Contains('∎'))
{
Presence.state += "Custom | ";
}
if (_mainSetupData.practiceSettings != null)
{
Presence.state += "Practice | ";
}
Presence.state += GetFlowTypeHumanReadable() + " ";
#if DEBUG
logger.Debug("Discord Presence - diff.parentDifficultyBeatmapSet.beatmapCharacteristic: " + diff.parentDifficultyBeatmapSet.beatmapCharacteristic);
logger.Debug("Discord Presence - _gameplaySetup._oneColorBeatmapCharacteristic: " + typeof(GameplayCoreSceneSetup).GetField("_oneColorBeatmapCharacteristic", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(_gameplaySetup));
#endif
// Update gamemode (Standard / One Saber / No Arrow)
if (_mainSetupData.gameplayModifiers.noArrows || diff.parentDifficultyBeatmapSet.beatmapCharacteristic.ToString().ToLower().Contains("noarrow"))
{
_gamemode = GameMode.NoArrows;
}
else if (diff.parentDifficultyBeatmapSet.beatmapCharacteristic == (BeatmapCharacteristicSO)_oneColorBeatmapCharacteristic.GetValue(_gameplaySetup))
{
_gamemode = GameMode.OneSaber;
}
else if (diff.parentDifficultyBeatmapSet.beatmapCharacteristic.ToString().ToLower().Contains("90degree"))
{
_gamemode = GameMode.NinetyDegree;
}
else if (diff.parentDifficultyBeatmapSet.beatmapCharacteristic.ToString().ToLower().Contains("360degree"))
{
_gamemode = GameMode.ThreeSixtyDegree;
}
else
{
_gamemode = GameMode.Standard;
}
string gameplayModeText = _gamemode == GameMode.OneSaber ? "One Saber" : _gamemode == GameMode.NoArrows ? "No Arrow" : _gamemode == GameMode.NinetyDegree ? "90º" : _gamemode == GameMode.ThreeSixtyDegree ? "360º" : "Standard";
Presence.state += gameplayModeText;
// Set music speak
if (_mainSetupData.practiceSettings != null)
{
if (_mainSetupData.practiceSettings.songSpeedMul != 1.0f)
{
Presence.state += " | Speed x" + _mainSetupData.practiceSettings.songSpeedMul;
}
}
else
{
if (_mainSetupData.gameplayModifiers.songSpeedMul != 1.0f)
{
Presence.state += " | Speed x" + _mainSetupData.gameplayModifiers.songSpeedMul;
}
}
// Set common gameplay modifiers
if (_mainSetupData.gameplayModifiers.noFail)
{
Presence.state += " | No Fail";
}
if (_mainSetupData.gameplayModifiers.instaFail)
{
Presence.state += " | Instant Fail";
}
if (_mainSetupData.gameplayModifiers.disappearingArrows)
{
Presence.state += " | Disappearing Arrows";
}
if (_mainSetupData.gameplayModifiers.ghostNotes)
{
Presence.state += " | Ghost Notes";
}
Presence.largeImageKey = "default";
Presence.largeImageText = "Beat Saber";
Presence.smallImageKey = GetFlowTypeHumanReadable() == "Party" ? "party" : _gamemode == GameMode.OneSaber ? "one_saber" : _gamemode == GameMode.NoArrows ? "no_arrows" : _gamemode == GameMode.NinetyDegree ? "90" : _gamemode == GameMode.ThreeSixtyDegree ? "360" : "solo";
Presence.smallImageText = gameplayModeText;
Presence.startTimestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
// Set startTimestamp offset if we are in training mode
if (_mainSetupData.practiceSettings != null)
{
#if DEBUG
logger.Debug("Discord Presence - _mainSetupData.practiceSettings.startSongTime: " + _mainSetupData.practiceSettings.startSongTime);
#endif
if (_mainSetupData.practiceSettings.startInAdvanceAndClearNotes)
{
Presence.startTimestamp -= (long)Mathf.Max(0f, _mainSetupData.practiceSettings.startSongTime - 3f);
}
else
{
Presence.startTimestamp -= (long)_mainSetupData.practiceSettings.startSongTime;
}
}
DiscordRpc.UpdatePresence(Presence);
}
