protected List <NoteData> GetNoteData(IReadonlyBeatmapData data)
{
return(data
.GetBeatmapDataItems <NoteData>()
.Where(noteData => noteData.gameplayType != NoteData.GameplayType.Bomb && !ShouldIgnoreNote(noteData))
.ToList());
}
private static IReadonlyBeatmapData ExcludeFakeNoteAndAllWalls(IReadonlyBeatmapData result)
{
foreach (BeatmapLineData b in result.beatmapLinesData)
{
BeatmapLineData refBeatmapLineData = b;
_beatmapObjectsDataAccessor(ref refBeatmapLineData) = b.beatmapObjectsData.Where(n =>
{
Dictionary <string, object?> dynData;
switch (n)
{
case CustomNoteData customNoteData:
dynData = customNoteData.customData;
break;
case CustomObstacleData customObstacleData:
return(false);
default:
return(true);
}
bool?fake = dynData.Get <bool?>(FAKENOTE);
if (fake.HasValue && fake.Value)
{
return(false);
}
return(true);
}).ToList();
}
return(result);
}
internal static void DeserializeBeatmapData(IReadonlyBeatmapData beatmapData)
{
NoodleEventDatas = new Dictionary <CustomEventData, NoodleEventData>();
foreach (CustomEventData customEventData in ((CustomBeatmapData)beatmapData).customEventsData)
{
NoodleEventData noodleEventData;
switch (customEventData.type)
{
case ANIMATETRACK:
case ASSIGNPATHANIMATION:
noodleEventData = ProcessCoroutineEvent(customEventData, beatmapData);
break;
case ASSIGNPLAYERTOTRACK:
noodleEventData = new NoodlePlayerTrackEventData()
{
Track = GetTrackPreload(customEventData.data, beatmapData),
};
break;
case ASSIGNTRACKPARENT:
noodleEventData = ProcessParentTrackEvent(customEventData.data, beatmapData);
break;
default:
continue;
}
NoodleEventDatas.Add(customEventData, noodleEventData);
}
}
internal static void DeserializeBeatmapData(IReadonlyBeatmapData beatmapData)
{
NoodleObjectDatas = new Dictionary <BeatmapObjectData, NoodleObjectData>();
foreach (BeatmapObjectData beatmapObjectData in beatmapData.beatmapObjectsData)
{
NoodleObjectData noodleObjectData;
dynamic customData;
switch (beatmapObjectData)
{
case CustomNoteData customNoteData:
customData = customNoteData.customData;
noodleObjectData = ProcessCustomNote(customData);
break;
case CustomObstacleData customObstacleData:
customData = customObstacleData.customData;
noodleObjectData = ProcessCustomObstacle(customData);
break;
case CustomWaypointData customWaypointData:
customData = customWaypointData.customData;
noodleObjectData = new NoodleObjectData();
break;
default:
continue;
}
FinalizeCustomObject(customData, noodleObjectData, beatmapData);
NoodleObjectDatas.Add(beatmapObjectData, noodleObjectData);
}
}
static bool Prefix(IReadonlyBeatmapData beatmapData, ref IReadonlyBeatmapData __result)
{
if (!Configuration.PluginConfig.Instance.wallsInZenMode)
{
return(true);
}
BeatmapData copyWithoutBeatmapObjects = beatmapData.GetCopyWithoutBeatmapObjects();
BeatmapData.CopyBeatmapObjectsWaypointsOnly(beatmapData, copyWithoutBeatmapObjects);
foreach (BeatmapObjectData beatmapObjectData in beatmapData.beatmapObjectsData)
{
if (beatmapObjectData.beatmapObjectType != BeatmapObjectType.Obstacle)
{
continue;
}
copyWithoutBeatmapObjects.AddBeatmapObjectData(beatmapObjectData.GetCopy());
}
__result = copyWithoutBeatmapObjects;
return(false);
}
/*public static IEnumerable<Track> GetTrackArray(dynamic customData, string name = TRACK)
* {
* IEnumerable<string> trackNames = ((List<object>)Trees.at(customData, name)).Cast<string>();
* if (trackNames == null)
* {
* return null;
* }
*
* HashSet<Track> tracks = new HashSet<Track>();
* foreach (string trackName in trackNames)
* {
* if (Tracks.TryGetValue(trackName, out Track track))
* {
* tracks.Add(track);
* }
* else
* {
* NoodleLogger.Log($"Could not find track {trackName}!", IPA.Logging.Logger.Level.Error);
* }
* }
*
* return tracks;
* }*/
public static IEnumerable <Track> GetTrackArrayPreload(dynamic customData, IReadonlyBeatmapData beatmapData, string name = TRACK)
{
IEnumerable <string> trackNames = ((List <object>)Trees.at(customData, name)).Cast <string>();
if (trackNames == null)
{
return(null);
}
HashSet <Track> tracks = new HashSet <Track>();
foreach (string trackName in trackNames)
{
if (((CustomBeatmapData)beatmapData).customData.tracks.TryGetValue(trackName, out Track track))
{
tracks.Add(track);
}
else
{
NoodleLogger.Log($"Could not find track {trackName}!", IPA.Logging.Logger.Level.Error);
}
}
return(tracks);
}
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);
}
}
// ReSharper disable once CognitiveComplexity
private List <NpsInfo> GetNpsSections(IReadonlyBeatmapData beatmapData)
{
var npsSections = new List <NpsInfo>();
var songDuration = _audioTimeSyncController.songLength;
if (songDuration < 0)
{
return(npsSections);
}
var notes = beatmapData.GetBeatmapDataItems <NoteData>()
.Where(noteData => noteData.gameplayType != NoteData.GameplayType.Bomb)
.OrderBy(s => s.time)
.ToList();
if (!notes.Any())
{
return(npsSections);
}
var tempNoteCount = 0;
var startingTime = notes[0].time;
npsSections.Add(new NpsInfo(0, 0, startingTime));
for (var i = 0; i < notes.Count; ++i)
{
tempNoteCount += 1;
if (i <= 0 || (i % 25 != 0 && i + 1 != notes.Count))
{
continue;
}
float nps;
if (tempNoteCount >= 25)
{
nps = tempNoteCount / (notes[i].time - startingTime);
}
else // end of a map or a map with notes.Count < 25
{
// if total notes count < 25 - do the usual way
// if there are more than 25 notes - try to normalize nps with data from tempNoteCount and (25 - tempNoteCount) notes from a section before
nps = notes.Count < 25
? tempNoteCount / (notes[i].time - notes[0].time)
: 25 / (notes[i].time - notes[i - 25].time);
}
if (!float.IsInfinity(nps))
{
npsSections.Add(new NpsInfo(nps, startingTime, notes[i].time));
}
tempNoteCount = 0;
startingTime = notes[i].time;
}
npsSections.Add(new NpsInfo(0, startingTime, songDuration));
return(npsSections);
}
internal static void PostfixHelper(ref IReadonlyBeatmapData __result, BeatmapData beatmapData)
{
if (beatmapData is CustomBeatmapData customBeatmapData)
{
__result = new CustomBeatmapData(beatmapData,
customBeatmapData.customEventData, customBeatmapData.customData, customBeatmapData.beatmapCustomData, customBeatmapData.levelCustomData);
}
}
public static bool CreateTransformedData(IReadonlyBeatmapData beatmapData, ref IReadonlyBeatmapData __result)
{
;
__result = beatmapData;
return(false);
}
internal static void DeserializeBeatmapData(IReadonlyBeatmapData beatmapData)
{
_chromaEventDatas = new Dictionary <BeatmapEventData, ChromaEventData>();
foreach (BeatmapEventData beatmapEventData in beatmapData.beatmapEventsData)
{
try
{
if (beatmapEventData is CustomBeatmapEventData customBeatmapEventData)
{
Dictionary <string, object?> customData = customBeatmapEventData.customData;
ChromaEventData chromaEventData = new ChromaEventData(
customData.Get <object>(LIGHTID),
customData.Get <object>(PROPAGATIONID),
ChromaUtils.GetColorFromData(customData),
customData.Get <bool?>(LOCKPOSITION).GetValueOrDefault(false),
customData.Get <string>(NAMEFILTER),
customData.Get <int?>(DIRECTION),
customData.Get <bool?>(COUNTERSPIN),
customData.Get <bool?>(RESET),
customData.Get <float?>(STEP),
customData.Get <float?>(PROP),
customData.Get <float?>(SPEED) ?? customData.Get <float?>(PRECISESPEED),
customData.Get <float?>(ROTATION),
customData.Get <float?>(STEPMULT).GetValueOrDefault(1f),
customData.Get <float?>(PROPMULT).GetValueOrDefault(1f),
customData.Get <float?>(SPEEDMULT).GetValueOrDefault(1f));
Dictionary <string, object?>?gradientObject = customData.Get <Dictionary <string, object?> >(LIGHTGRADIENT);
if (gradientObject != null)
{
string? easingstring = gradientObject.Get <string>(EASING);
Functions easing;
if (string.IsNullOrEmpty(easingstring))
{
easing = Functions.easeLinear;
}
else
{
easing = (Functions)Enum.Parse(typeof(Functions), easingstring);
}
chromaEventData.GradientObject = new ChromaEventData.GradientObjectData(
gradientObject.Get <float>(DURATION),
ChromaUtils.GetColorFromData(gradientObject, STARTCOLOR) ?? Color.white,
ChromaUtils.GetColorFromData(gradientObject, ENDCOLOR) ?? Color.white,
easing);
}
_chromaEventDatas.Add(beatmapEventData, chromaEventData);
}
}
catch (Exception e)
{
Plugin.Logger.Log($"Could not create ChromaEventData for event {beatmapEventData.type} at {beatmapEventData.time}", IPA.Logging.Logger.Level.Error);
Plugin.Logger.Log(e, IPA.Logging.Logger.Level.Error);
}
}
}
private static IReadonlyBeatmapData ReorderLineData(IReadonlyBeatmapData beatmapData)
{
if (beatmapData is CustomBeatmapData)
{
CustomBeatmapData customBeatmapData = (CustomBeatmapData)beatmapData.GetCopy();
// there is some ambiguity with these variables but who frikkin cares
float startHalfJumpDurationInBeats = 4;
float maxHalfJumpDistance = 18;
float moveDuration = 0.5f;
for (int i = 0; i < customBeatmapData.beatmapLinesData.Count; i++)
{
BeatmapLineData beatmapLineData = customBeatmapData.beatmapLinesData[i] as BeatmapLineData;
foreach (BeatmapObjectData beatmapObjectData in beatmapLineData.beatmapObjectsData)
{
dynamic customData;
if (beatmapObjectData is CustomObstacleData || beatmapObjectData is CustomNoteData || beatmapObjectData is CustomWaypointData)
{
customData = beatmapObjectData;
}
else
{
NoodleLogger.Log("beatmapObjectData was not CustomObstacleData, CustomNoteData, or CustomWaypointData");
continue;
}
dynamic dynData = customData.customData;
float noteJumpMovementSpeed = (float?)Trees.at(dynData, NOTEJUMPSPEED) ?? GameplayCoreInstallerInstallBindings.CachedNoteJumpMovementSpeed;
float noteJumpStartBeatOffset = (float?)Trees.at(dynData, NOTESPAWNOFFSET) ?? GameplayCoreInstallerInstallBindings.CachedNoteJumpStartBeatOffset;
// how do i not repeat this in a reasonable way
float num = 60f / (float)Trees.at(dynData, "bpm");
float num2 = startHalfJumpDurationInBeats;
while (noteJumpMovementSpeed * num * num2 > maxHalfJumpDistance)
{
num2 /= 2f;
}
num2 += noteJumpStartBeatOffset;
if (num2 < 1f)
{
num2 = 1f;
}
float jumpDuration = num * num2 * 2f;
dynData.aheadTime = moveDuration + (jumpDuration * 0.5f);
}
_beatmapObjectsDataAccessor(ref beatmapLineData) = beatmapLineData.beatmapObjectsData.OrderBy(n => n.time - (float)((dynamic)n).customData.aheadTime).ToList();
}
return(customBeatmapData);
}
NoodleLogger.Log("beatmapData was not CustomBeatmapData", IPA.Logging.Logger.Level.Error);
return(beatmapData);
}
private static void Postfix(IReadonlyBeatmapData __result)
{
// Skip if calling class is MultiplayerConnectPlayerInstaller
StackTrace stackTrace = new StackTrace();
if (!stackTrace.GetFrame(2).GetMethod().Name.Contains("MultiplayerConnectedPlayerInstaller"))
{
NoodleObjectDataManager.DeserializeBeatmapData(__result);
Animation.NoodleEventDataManager.DeserializeBeatmapData(__result);
}
}
public BSEvents([InjectOptional] ILevelEndActions levelEndActions, IReadonlyBeatmapData beatmapData, ObstacleSaberSparkleEffectManager obstacleSaberSparkleEffectManager, ScoreController scoreController, BeatmapObjectManager beatmapObjectManager, BeatmapCallbacksController beatmapCallbacksController, ComboController comboController)
{
_levelEndActions = levelEndActions;
_beatmapData = beatmapData;
_obstacleSaberSparkleEffectManager = obstacleSaberSparkleEffectManager;
_scoreController = scoreController;
_beatmapObjectManager = beatmapObjectManager;
_beatmapCallbacksController = beatmapCallbacksController;
_comboController = comboController;
_bombSubtypeIdentifier = NoteData.SubtypeIdentifier(ColorType.None);
}
internal void Construct(SiraLog siraLog, PluginConfig config, ScvAssetLoader assetLoader, AudioTimeSyncController audioTimeSyncController,
IReadonlyBeatmapData beatmap, TimeTweeningManager timeTweeningManager)
{
_timeTweeningManager = timeTweeningManager;
_assetLoader = assetLoader;
_siraLog = siraLog;
_config = config;
_audioTimeSyncController = audioTimeSyncController;
_beatmapData = beatmap;
name = $"{nameof(SongChartVisualizer)} View";
}
private static IReadonlyBeatmapData ReorderLineData(IReadonlyBeatmapData beatmapData, float defaultNoteJumpMovementSpeed, float defaultNoteJumpStartBeatOffset)
{
if (beatmapData is CustomBeatmapData customBeatmapData)
{
// there is some ambiguity with these variables but who frikkin cares
float startHalfJumpDurationInBeats = 4;
float maxHalfJumpDistance = 18;
float moveDuration = 0.5f;
for (int i = 0; i < customBeatmapData.beatmapLinesData.Count; i++)
{
BeatmapLineData beatmapLineData = customBeatmapData.beatmapLinesData[i] as BeatmapLineData;
foreach (BeatmapObjectData beatmapObjectData in beatmapLineData.beatmapObjectsData)
{
dynamic customData;
if (beatmapObjectData is CustomObstacleData || beatmapObjectData is CustomNoteData)
{
customData = beatmapObjectData;
}
else
{
throw new System.Exception("BeatmapObjectData was not CustomObstacleData or CustomNoteData");
}
dynamic dynData = customData.customData;
float noteJumpMovementSpeed = (float?)Trees.at(dynData, NOTEJUMPSPEED) ?? defaultNoteJumpMovementSpeed;
float noteJumpStartBeatOffset = (float?)Trees.at(dynData, NOTESPAWNOFFSET) ?? defaultNoteJumpStartBeatOffset;
// how do i not repeat this in a reasonable way
float num = 60f / (float)Trees.at(dynData, "bpm");
float num2 = startHalfJumpDurationInBeats;
while (noteJumpMovementSpeed * num * num2 > maxHalfJumpDistance)
{
num2 /= 2f;
}
num2 += noteJumpStartBeatOffset;
if (num2 < 1f)
{
num2 = 1f;
}
float jumpDuration = num * num2 * 2f;
dynData.aheadTime = moveDuration + (jumpDuration * 0.5f);
}
_beatmapObjectsDataAccessor(ref beatmapLineData) = beatmapLineData.beatmapObjectsData.OrderBy(n => n.time - (float)((dynamic)n).customData.aheadTime).ToList();
}
}
return(beatmapData);
}
private static void Postfix(IReadonlyBeatmapData beatmapData, ref IReadonlyBeatmapData __result)
{
if (Settings.ChromaConfig.Instance.ForceZenWallsEnabled)
{
foreach (BeatmapObjectData beatmapObjectData in beatmapData.beatmapObjectsData)
{
if (beatmapObjectData is ObstacleData)
{
((BeatmapData)__result).AddBeatmapObjectData(beatmapObjectData.GetCopy());
}
}
}
}
private static IReadonlyBeatmapData ReorderLineData(IReadonlyBeatmapData beatmapData)
{
if (beatmapData is CustomBeatmapData)
{
CustomBeatmapData customBeatmapData = (CustomBeatmapData)beatmapData.GetCopy();
// there is some ambiguity with these variables but who frikkin cares
float startHalfJumpDurationInBeats = 4;
float maxHalfJumpDistance = 18;
float moveDuration = 0.5f;
for (int i = 0; i < customBeatmapData.beatmapLinesData.Count; i++)
{
BeatmapLineData beatmapLineData = (BeatmapLineData)customBeatmapData.beatmapLinesData[i];
foreach (BeatmapObjectData beatmapObjectData in beatmapLineData.beatmapObjectsData)
{
Dictionary <string, object?> dynData = beatmapObjectData.GetDataForObject();
float noteJumpMovementSpeed = dynData.Get <float?>(NOTEJUMPSPEED) ?? GameplayCoreInstallerInstallBindings.CachedNoteJumpMovementSpeed;
float noteJumpStartBeatOffset = dynData.Get <float?>(NOTESPAWNOFFSET) ?? GameplayCoreInstallerInstallBindings.CachedNoteJumpStartBeatOffset;
// how do i not repeat this in a reasonable way
float num = 60f / dynData.Get <float>("bpm");
float num2 = startHalfJumpDurationInBeats;
while (noteJumpMovementSpeed * num * num2 > maxHalfJumpDistance)
{
num2 /= 2f;
}
num2 += noteJumpStartBeatOffset;
if (num2 < 1f)
{
num2 = 1f;
}
float jumpDuration = num * num2 * 2f;
dynData["aheadTime"] = moveDuration + (jumpDuration * 0.5f);
}
_beatmapObjectsDataAccessor(ref beatmapLineData) = beatmapLineData.beatmapObjectsData
.OrderBy(n => n.time - (float)(n.GetDataForObject()["aheadTime"] ?? throw new System.InvalidOperationException($"Could not get aheadTime for [{n.GetType().FullName}] at time [{n.time}].")))
.ToList();
}
return(customBeatmapData);
}
Logger.Log("beatmapData was not CustomBeatmapData", IPA.Logging.Logger.Level.Error);
return(beatmapData);
}
private GameSaberSetup(PluginConfig config, SaberSet saberSet, MainAssetStore mainAssetStore,
IReadonlyBeatmapData beatmap, RandomUtil randomUtil)
{
_config = config;
_saberSet = saberSet;
_mainAssetStore = mainAssetStore;
_beatmapData = beatmap.CastChecked <BeatmapData>();
_randomUtil = randomUtil;
_oldLeftSaberModel = _saberSet.LeftSaber;
_oldRightSaberModel = _saberSet.RightSaber;
Setup();
}
internal static void DeserializeBeatmapData(IReadonlyBeatmapData beatmapData)
{
ChromaObjectDatas = new Dictionary <BeatmapObjectData, ChromaObjectData>();
if (NoodleExtensionsInstalled)
{
ChromaNoodleDatas = new Dictionary <BeatmapObjectData, ChromaNoodleData>();
}
foreach (BeatmapObjectData beatmapObjectData in beatmapData.beatmapObjectsData)
{
ChromaObjectData chromaObjectData;
dynamic customData;
switch (beatmapObjectData)
{
case CustomNoteData customNoteData:
customData = customNoteData.customData;
chromaObjectData = new ChromaNoteData()
{
Color = ChromaUtils.GetColorFromData(customData),
DisableSpawnEffect = Trees.at(customData, DISABLESPAWNEFFECT),
};
break;
case CustomObstacleData customObstacleData:
customData = customObstacleData.customData;
chromaObjectData = new ChromaObjectData()
{
Color = ChromaUtils.GetColorFromData(customData),
};
break;
case CustomWaypointData customWaypointData:
customData = customWaypointData.customData;
chromaObjectData = new ChromaObjectData();
break;
default:
continue;
}
if (NoodleExtensionsInstalled)
{
ApplyNoodleData(customData, beatmapObjectData, beatmapData);
}
ChromaObjectDatas.Add(beatmapObjectData, chromaObjectData);
}
}
private static IReadonlyBeatmapData ExcludeFakeNote(IReadonlyBeatmapData result)
{
foreach (BeatmapLineData b in result.beatmapLinesData)
{
BeatmapLineData refBeatmapLineData = b;
_beatmapObjectsDataAccessor(ref refBeatmapLineData) = b.beatmapObjectsData.Where(n =>
{
dynamic dynData = null;
switch (n)
{
case CustomNoteData customNoteData:
dynData = customNoteData.customData;
break;
case CustomObstacleData customObstacleData:
return(false);
default:
return(true);
}
bool?fake = Trees.at(dynData, FAKENOTE);
if (fake.HasValue && fake.Value)
{
return(false);
}
return(true);
}).ToList();
}
if (result is CustomBeatmapData customBeatmapData)
{
string[] excludedTypes = new string[]
{
ANIMATETRACK,
ASSIGNPATHANIMATION,
ASSIGNPLAYERTOTRACK,
ASSIGNTRACKPARENT,
};
customBeatmapData.customEventsData.RemoveAll(n => excludedTypes.Contains(n.type));
customBeatmapData.customData.isMultiplayer = true;
}
return(result);
}
internal static void HandleTrackData(
GameObject gameObject,
Dictionary <string, object?> gameObjectData,
IReadonlyBeatmapData beatmapData,
float noteLinesDistance,
TrackLaneRing?trackLaneRing,
ParametricBoxController?parametricBoxController,
BeatmapObjectsAvoidance?beatmapObjectsAvoidance)
{
Track?track = GetTrack(gameObjectData, beatmapData);
if (track != null)
{
GameObjectTrackController trackController = gameObject.AddComponent <GameObjectTrackController>();
trackController.Init(track, noteLinesDistance, trackLaneRing, parametricBoxController, beatmapObjectsAvoidance);
}
}
private static IReadonlyBeatmapData ExcludeFakeNoteAndAllWalls(IReadonlyBeatmapData result)
{
foreach (BeatmapLineData b in result.beatmapLinesData)
{
BeatmapLineData refBeatmapLineData = b;
_beatmapObjectsDataAccessor(ref refBeatmapLineData) = b.beatmapObjectsData.Where(n =>
{
Dictionary <string, object?> dynData;
switch (n)
{
case CustomNoteData customNoteData:
dynData = customNoteData.customData;
break;
case CustomObstacleData customObstacleData:
return(false);
default:
return(true);
}
bool?fake = dynData.Get <bool?>(FAKENOTE);
if (fake.HasValue && fake.Value)
{
return(false);
}
return(true);
}).ToList();
}
if (result is CustomBeatmapData customBeatmapData)
{
string[] excludedTypes = new string[]
{
ASSIGNPLAYERTOTRACK,
ASSIGNTRACKPARENT,
};
customBeatmapData.customEventsData.RemoveAll(n => excludedTypes.Contains(n.type));
}
return(result);
}
static void Postfix(IReadonlyBeatmapData beatmapData, ref IReadonlyBeatmapData __result, bool leftHanded)
{
if (!BS_Utils.Plugin.LevelData.IsSet || BS_Utils.Plugin.LevelData.Mode != BS_Utils.Gameplay.Mode.Standard || !UI.ModifierUI.instance.modEnabled)
{
return;
}
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission("DiffReducer");
__result = beatmapData.GetFilteredCopy(x =>
{
if (x is BeatmapObjectData && !UI.ModifierUI.instance.simplifiedMap.Any(y => x.CompareTo(y) == 0))
{
return(null);
}
return(x);
});
}
internal static void HandleTrackData(
GameObject gameObject,
dynamic gameObjectData,
IReadonlyBeatmapData beatmapData,
float noteLinesDistance,
TrackLaneRing trackLaneRing,
ParametricBoxController parametricBoxController)
{
if (NoodleController.NoodleExtensionsActive)
{
Track track = NoodleExtensions.Animation.AnimationHelper.GetTrackPreload(gameObjectData, beatmapData);
if (track != null)
{
GameObjectTrackController trackController = gameObject.AddComponent <GameObjectTrackController>();
trackController.Init(track, noteLinesDistance, trackLaneRing, parametricBoxController);
}
}
}
/*public static Track GetTrack(dynamic customData, string name = TRACK)
* {
* string trackName = Trees.at(customData, name);
* if (trackName == null)
* {
* return null;
* }
*
* if (Tracks.TryGetValue(trackName, out Track track))
* {
* return track;
* }
* else
* {
* NoodleLogger.Log($"Could not find track {trackName}!", IPA.Logging.Logger.Level.Error);
* return null;
* }
* }*/
public static Track GetTrackPreload(dynamic customData, IReadonlyBeatmapData beatmapData, string name = TRACK)
{
string trackName = Trees.at(customData, name);
if (trackName == null)
{
return(null);
}
if (((CustomBeatmapData)beatmapData).customData.tracks.TryGetValue(trackName, out Track track))
{
return(track);
}
else
{
NoodleLogger.Log($"Could not find track {trackName}!", IPA.Logging.Logger.Level.Error);
return(null);
}
}
private static void Postfix(IReadonlyBeatmapData __result)
{
foreach (BeatmapEventData beatmapEventData in __result.beatmapEventsData)
{
if (beatmapEventData.type.IsRotationEvent())
{
if (beatmapEventData is CustomBeatmapEventData customData)
{
dynamic dynData = customData.customData;
float? rotation = (float?)Trees.at(dynData, ROTATION);
if (rotation.HasValue)
{
dynData._rotation = rotation * -1;
}
}
}
}
}
private static void Postfix(IReadonlyBeatmapData __result)
{
foreach (BeatmapEventData beatmapEventData in __result.beatmapEventsData)
{
if (beatmapEventData.type.IsRotationEvent())
{
if (beatmapEventData is CustomBeatmapEventData customData)
{
Dictionary <string, object?> dynData = customData.customData;
float?rotation = dynData.Get <float?>(ROTATION);
if (rotation.HasValue)
{
dynData["_rotation"] = rotation * -1;
}
}
}
}
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Postfix(IReadonlyBeatmapData __result)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
foreach (BeatmapEventData beatmapEventData in __result.beatmapEventsData)
{
if (beatmapEventData.type.IsRotationEvent())
{
if (beatmapEventData is CustomBeatmapEventData customData)
{
dynamic dynData = customData.customData;
float? rotation = (float?)Trees.at(dynData, ROTATION);
if (rotation.HasValue)
{
dynData._rotation = rotation * -1;
}
}
}
}
}
private static bool Prefix(IReadonlyBeatmapData beatmapData, ref IReadonlyBeatmapData __result)
{
if (Settings.ChromaConfig.Instance.ForceZenWallsEnabled)
{
BeatmapData copyWithoutBeatmapObjects = beatmapData.GetCopyWithoutBeatmapObjects();
BeatmapData.CopyBeatmapObjectsWaypointsOnly(beatmapData, copyWithoutBeatmapObjects);
foreach (BeatmapObjectData beatmapObjectData in beatmapData.beatmapObjectsData)
{
if (beatmapObjectData is ObstacleData)
{
copyWithoutBeatmapObjects.AddBeatmapObjectData(beatmapObjectData.GetCopy());
}
}
__result = copyWithoutBeatmapObjects;
return(false);
}
return(true);
}
