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;
}
private Beatmap ConvertToEntry(BeatmapDataModel dataModel)
{
return(_recentBeatmaps.FirstOrDefault(k =>
k.FolderName == dataModel.FolderName &&
k.Version == dataModel.Version
));
}
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;
}
public static async Task <string> GetThumbByBeatmapDbId(BeatmapDataModel dataModel)
{
if (_appDbOperator.GetMapThumb(dataModel.BeatmapDbId, out var path) && path != null)
{
return(path);
}
var osuFilePath = dataModel.InOwnDb
? Path.Combine(Domain.CustomSongPath, dataModel.FolderName, dataModel.BeatmapFileName)
: Path.Combine(Domain.OsuSongPath, dataModel.FolderName, dataModel.BeatmapFileName);
if (!File.Exists(osuFilePath))
{
return(null);
}
//lock (CountLock)
//{
// _thumbCount++;
//}
var osuFile = await OSharp.Beatmap.OsuFile.ReadFromFileAsync(@"\\?\" + osuFilePath, options =>
{
options.IncludeSection("Events");
options.IgnoreSample();
options.IgnoreStoryboard();
})
.ConfigureAwait(false);
var guidStr = Guid.NewGuid().ToString();
//lock (CountLock)
//{
// _thumbCount--;
//}
var sourceBgFile = osuFile.Events?.BackgroundInfo?.Filename;
if (string.IsNullOrWhiteSpace(sourceBgFile))
{
_appDbOperator.SetMapThumb(dataModel.BeatmapDbId, null);
return(null);
}
var sourceBgPath = dataModel.InOwnDb
? Path.Combine(Domain.CustomSongPath, dataModel.FolderName, sourceBgFile)
: Path.Combine(Domain.OsuSongPath, dataModel.FolderName, sourceBgFile);
if (!File.Exists(sourceBgPath))
{
//_appDbOperator.SetMapThumb(dataModel.BeatmapDbId, null);
return(null);
}
ResizeImageAndSave(sourceBgPath, guidStr, height: 200);
_appDbOperator.SetMapThumb(dataModel.BeatmapDbId, guidStr);
return(guidStr);
}
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!");
}
public static IEnumerable <BeatmapDataModel> ToDataModels(
this IEnumerable <BeatmapEntry> entries,
bool distinctByVersion = false)
{
return(entries.Select((entry, i) =>
{
var model = new BeatmapDataModel
{
Artist = entry.Artist,
ArtistUnicode = entry.ArtistUnicode,
BeatmapId = entry.BeatmapId,
Creator = entry.Creator,
FolderName = entry.FolderName,
GameMode = entry.GameMode,
SongSource = entry.SongSource,
SongTags = entry.SongTags,
Title = entry.Title,
TitleUnicode = entry.TitleUnicode,
Version = entry.Version,
BeatmapFileName = entry.BeatmapFileName,
};
try
{
switch (entry.GameMode)
{
case GameMode.Standard:
model.Stars = Math.Round(entry.DiffStarRatingStandard[Mods.None], 2);
break;
case GameMode.Taiko:
model.Stars = Math.Round(entry.DiffStarRatingTaiko[Mods.None], 2);
break;
case GameMode.CatchTheBeat:
model.Stars = Math.Round(entry.DiffStarRatingCtB[Mods.None], 2);
break;
case GameMode.Mania:
model.Stars = Math.Round(entry.DiffStarRatingMania[Mods.None], 2);
break;
}
}
catch (Exception)
{
// ignored
}
return model;
}).Distinct(new DataModelComparer(distinctByVersion)));
}
private static List <BeatmapDataModel> InnerToDataModelList(this IEnumerable <Beatmap> beatmaps)
{
return(beatmaps.Select((beatmap, i) =>
{
var model = new BeatmapDataModel
{
Artist = beatmap.Artist,
ArtistUnicode = beatmap.ArtistUnicode,
BeatmapId = beatmap.BeatmapId,
Creator = beatmap.Creator,
FolderName = beatmap.FolderName,
OSharpGameMode = beatmap.GameMode,
SongSource = beatmap.SongSource,
SongTags = beatmap.SongTags,
Title = beatmap.Title,
TitleUnicode = beatmap.TitleUnicode,
Version = beatmap.Version,
BeatmapFileName = beatmap.BeatmapFileName,
InOwnDb = beatmap.InOwnFolder,
BeatmapDbId = beatmap.Id
};
try
{
switch (beatmap.GameMode)
{
case OSharp.Beatmap.Sections.GamePlay.GameMode.Circle:
model.Stars = Math.Round(beatmap.DiffSrNoneStandard, 2);
break;
case OSharp.Beatmap.Sections.GamePlay.GameMode.Taiko:
model.Stars = Math.Round(beatmap.DiffSrNoneTaiko, 2);
break;
case OSharp.Beatmap.Sections.GamePlay.GameMode.Catch:
model.Stars = Math.Round(beatmap.DiffSrNoneCtB, 2);
break;
case OSharp.Beatmap.Sections.GamePlay.GameMode.Mania:
model.Stars = Math.Round(beatmap.DiffSrNoneMania, 2);
break;
}
}
catch (Exception)
{
// ignored
}
return model;
}).ToList());
}
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 <BeatmapDataModel>().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 IEnumerable <BeatmapDataModel> Transform(this IEnumerable <BeatmapEntry> list, bool multiVersions)
{
return(list.Select((entry, i) =>
{
var model = new BeatmapDataModel
{
Id = multiVersions ? (i + 1).ToString("00") : "",
Artist = entry.Artist,
ArtistUnicode = entry.ArtistUnicode,
BeatmapId = entry.BeatmapId,
Creator = entry.Creator,
FolderName = entry.FolderName,
GameMode = entry.GameMode,
SongSource = entry.SongSource,
SongTags = entry.SongTags,
Title = entry.Title,
TitleUnicode = entry.TitleUnicode,
Version = entry.Version,
BeatmapFileName = entry.BeatmapFileName,
};
try
{
switch (entry.GameMode)
{
case GameMode.Standard:
model.Stars = Math.Round(entry.DiffStarRatingStandard[Mods.None], 2);
break;
case GameMode.Taiko:
model.Stars = Math.Round(entry.DiffStarRatingTaiko[Mods.None], 2);
break;
case GameMode.CatchTheBeat:
model.Stars = Math.Round(entry.DiffStarRatingCtB[Mods.None], 2);
break;
case GameMode.Mania:
model.Stars = Math.Round(entry.DiffStarRatingMania[Mods.None], 2);
break;
}
}
catch (Exception)
{
// ignored
}
return model;
}).Distinct(new Comparer(multiVersions)).ToList());
}
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;
}
/// <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);
}
}
private void SceneManagerOnActiveSceneChanged(Scene arg0, Scene scene)
{
try
{
this._playerController = FindObjectOfType <PlayerController>();
if (scene.buildIndex == 1)
{
IsLeftSaberOn = true;
if (_beatmapObjectSpawnController != null)
{
_beatmapObjectSpawnController.noteWasCutEvent -= this.HandleNoteWasCutEvent;
}
if (_mainSettingsModel != null && stored)
{
StartCoroutine(RestoreNoEnergy());
}
}
if (scene.buildIndex == 5)
{
var _mainGameSceneSetup = FindObjectOfType <MainGameSceneSetup>();
this._gameSongController = FindObjectOfType <GameSongController>();
this._noteCutEffectSpawner = FindObjectOfType <NoteCutEffectSpawner>();
this._beatmapObjectSpawnController = FindObjectOfType <BeatmapObjectSpawnController>();
_noteCutHapticEffect = ReflectionUtil.GetPrivateField <NoteCutHapticEffect>(_noteCutEffectSpawner, "_noteCutHapticEffect");
_hapticFeedbackController = ReflectionUtil.GetPrivateField <HapticFeedbackController>(_noteCutHapticEffect, "_hapticFeedbackController");
_mainSettingsModel = ReflectionUtil.GetPrivateField <MainSettingsModel>(_hapticFeedbackController, "_mainSettingsModel");
_mainSettingsModel.controllersRumbleEnabled = true;
this._mainGameSceneSetupData = ReflectionUtil.GetPrivateField <MainGameSceneSetupData>(_mainGameSceneSetup, "_mainGameSceneSetupData");
if (!stored)
{
storedNoEnergy = _mainGameSceneSetupData.gameplayOptions.noEnergy;
}
stored = true;
if (_mainGameSceneSetupData.gameplayMode == GameplayMode.SoloNoArrows)
{
BeatmapDataModel _beatmapDataModel = ReflectionUtil.GetPrivateField <BeatmapDataModel>(_mainGameSceneSetup, "_beatmapDataModel");
BeatmapData beatmapData = CreateTransformedBeatmapData(_mainGameSceneSetupData.difficultyLevel.beatmapData, _mainGameSceneSetupData.gameplayOptions, _mainGameSceneSetupData.gameplayMode);
if (beatmapData != null)
{
_beatmapDataModel.beatmapData = beatmapData;
ReflectionUtil.SetPrivateField(_mainGameSceneSetup, "_beatmapDataModel", _beatmapDataModel);
}
if (Plugin.IsOneColorModeOn)
{
_mainGameSceneSetupData.gameplayOptions.noEnergy = true;
_sabers = FindObjectsOfType <Saber>();
Saber targetSaber = (Plugin.IsColorRed) ? _playerController.leftSaber : _playerController.rightSaber;
Saber otherSaber = (Plugin.IsColorRed) ? _playerController.rightSaber : _playerController.leftSaber;
if (targetSaber == null || otherSaber == null)
{
return;
}
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);
if (Plugin.IsColorRed)
{
ReflectionUtil.SetPrivateField(_playerController, "_rightSaber", targetSaber);
ReflectionUtil.SetPrivateField(_playerController, "_leftSaber", newSaber);
}
else
{
ReflectionUtil.SetPrivateField(_playerController, "_leftSaber", targetSaber);
ReflectionUtil.SetPrivateField(_playerController, "_rightSaber", newSaber);
}
_playerController.leftSaber.gameObject.SetActive(IsLeftSaberOn);
if (_beatmapObjectSpawnController != null)
{
_beatmapObjectSpawnController.noteWasCutEvent += this.HandleNoteWasCutEvent;
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
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 Beatmap ConvertToEntry(BeatmapDataModel dataModel)
{
return(_safeDbOperator.GetBeatmapsFromFolder(dataModel.FolderName)
.FirstOrDefault(k => k.Version == dataModel.Version));
}
private Beatmap ConvertToEntry(BeatmapDataModel dataModel)
{
return(BeatmapQuery.FilterByFolder(dataModel.FolderName)
.FirstOrDefault(k => k.Version == dataModel.Version));
}
private void AddEvents()
{
_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
{
_beatmapObjectSpawnController = Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().FirstOrDefault();
if (_beatmapObjectSpawnController == null)
{
Console.WriteLine("SPAWN CONTROLLER NULL");
//_beatmapObjectSpawnController = _saberRoot.AddComponent<BeatmapObjectSpawnController>();
}
_scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().FirstOrDefault();
if (_scoreController == null)
{
Console.WriteLine("SCORE CONTROLLER NULL");
//_scoreController = _saberRoot.AddComponent<ScoreController>();
}
_saberCollisionManager =
Resources.FindObjectsOfTypeAll <ObstacleSaberSparkleEffectManager>().FirstOrDefault();
if (_saberCollisionManager == null)
{
Console.WriteLine("COLLISION MANAGER NULL");
//_saberCollisionManager = _saberRoot.AddComponent<ObstacleSaberSparkleEffectManager>();
}
_gameEnergyCounter = Resources.FindObjectsOfTypeAll <GameEnergyCounter>().FirstOrDefault();
if (_gameEnergyCounter == null)
{
Console.WriteLine("energery counter null");
//_gameEnergyCounter = _saberRoot.AddComponent<GameEnergyCounter>();
}
_beatmapCallback = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault();
if (_beatmapCallback == null)
{
Console.WriteLine("BEATMAP CALLBACK NULL");
//_beatmapCallback = _saberRoot.AddComponent<BeatmapObjectCallbackController>();
}
_gamePauseManager = Resources.FindObjectsOfTypeAll <GamePauseManager>().FirstOrDefault();
if (_gamePauseManager == null)
{
Console.WriteLine("GamePauseManager Null");
//_gamePauseManager = _saberRoot.AddComponent<GamePauseManager>();
}
_playerHeadAndObstacleInteraction = Resources.FindObjectsOfTypeAll <PlayerHeadAndObstacleInteraction>().FirstOrDefault();
if (_playerHeadAndObstacleInteraction == null)
{
Console.WriteLine("PlayerHeadAndObstacleInteraction Null");
//_playerHeadAndObstacleInteraction = _saberRoot.AddComponent<PlayerHeadAndObstacleInteraction>();
}
_beatmapObjectSpawnController.noteWasCutEvent += SliceCallBack;
_beatmapObjectSpawnController.noteWasMissedEvent += NoteMissCallBack;
_scoreController.multiplierDidChangeEvent += MultiplierCallBack;
_scoreController.comboDidChangeEvent += ComboChangeEvent;
_saberCollisionManager.sparkleEffectDidStartEvent += SaberStartCollide;
_saberCollisionManager.sparkleEffectDidEndEvent += SaberEndCollide;
_gameEnergyCounter.gameEnergyDidReach0Event += FailLevelCallBack;
_beatmapCallback.beatmapEventDidTriggerEvent += LightEventCallBack;
// ReflectionUtil.SetPrivateField(_gamePauseManager, "_gameDidResumeSignal", (Action)OnPauseMenuClosed); //For some reason _gameDidResumeSignal isn't public.
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine(e.Message);
throw;
}
try
{
MainGameSceneSetup mgs = GetGameSceneSetup();
BeatmapDataModel _beatmapDataModel = ReflectionUtil.GetPrivateField <BeatmapDataModel>(mgs, "_beatmapDataModel");
BeatmapData beatmapData = _beatmapDataModel.beatmapData;
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
float LastTime = 0.0f;
for (int i = 0; i < beatmapLinesData.Length; i++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[i].beatmapObjectsData;
for (int j = beatmapObjectsData.Length - 1; j > 0; j--)
{
if (beatmapObjectsData[j].beatmapObjectType == BeatmapObjectType.Note)
{
if (((NoteData)beatmapObjectsData[j]).noteType != NoteType.Bomb)
{
if (beatmapObjectsData[j].time > LastTime)
{
LastNoteId = beatmapObjectsData[j].id;
LastTime = beatmapObjectsData[j].time;
}
break;
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine(e.Message);
throw;
}
}
private BeatmapEntry ConvertToEntry(BeatmapDataModel dataModel)
{
return(_entries.GetBeatmapsetsByFolder(dataModel.FolderName)
.FirstOrDefault(k => k.Version == dataModel.Version));
}
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);
}
}
}
