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);
}
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 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 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 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);
}
public FolderBeatMapDataSO()
{
BeatmapLineData lineData = new BeatmapLineData
{
beatmapObjectsData = new BeatmapObjectData[0]
};
this._beatmapData = new FolderBeatMapData(
new BeatmapLineData[1]
{
lineData
},
new BeatmapEventData[1]
{
new BeatmapEventData(0, BeatmapEventType.Event0, 0)
});
}
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);
}
// Token: 0x0600125F RID: 4703 RVA: 0x000404A0 File Offset: 0x0003E6A0
public static CustomBeatmapData GetBeatmapDataFromBeatmapSaveData(List <CustomBeatmapSaveData.NoteData> notesSaveData, List <CustomBeatmapSaveData.ObstacleData> obstaclesSaveData,
List <CustomBeatmapSaveData.EventData> eventsSaveData, float startBPM, float shuffle, float shufflePeriod,
List <CustomBeatmapSaveData.CustomEventData> customEventsSaveData, dynamic customData, dynamic customLevelData,
BeatmapDataLoader beatmapDataLoader)
{
try
{
// IPA's reflectionutil sucks
object _notesInTimeRowProcessor = beatmapDataLoader.GetType().GetField("_notesInTimeRowProcessor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(beatmapDataLoader);
MethodInfo ProcessBasicNotesInTimeRow = _notesInTimeRowProcessor.GetType().GetMethod("ProcessBasicNotesInTimeRow", BindingFlags.Instance | BindingFlags.Public);
MethodInfo ProcessNotesInTimeRow = _notesInTimeRowProcessor.GetType().GetMethod("ProcessNotesInTimeRow", BindingFlags.Instance | BindingFlags.Public);
// remainder of this method copied from SongLoaderPlugin@12de0cf, with changes:
// BeatmapData, NoteData, EventData, and ObstacleData replaced with their Custom counterparts
// customData fields propagated to new objects
List <BeatmapObjectData>[] array = new List <BeatmapObjectData> [4];
List <BeatmapEventData> list = new List <BeatmapEventData>(eventsSaveData.Count);
List <BPMChangeData> list2 = new List <BPMChangeData>();
list2.Add(new BPMChangeData(0f, 0f, startBPM));
BPMChangeData bpmchangeData = list2[0];
foreach (CustomBeatmapSaveData.EventData eventData in eventsSaveData)
{
if (eventData.type.IsBPMChangeEvent())
{
float time = eventData.time;
int value = eventData.value;
float bpmChangeStartTime = bpmchangeData.bpmChangeStartTime + beatmapDataLoader.GetRealTimeFromBPMTime(time - bpmchangeData.bpmChangeStartBPMTime, (float)value, shuffle, shufflePeriod);
list2.Add(new BPMChangeData(bpmChangeStartTime, time, (float)value));
}
}
for (int i = 0; i < 4; i++)
{
array[i] = new List <BeatmapObjectData>(3000);
}
int num = 0;
float num2 = -1f;
List <CustomNoteData> list3 = new List <CustomNoteData>(4);
List <CustomNoteData> list4 = new List <CustomNoteData>(4);
int num3 = 0;
foreach (CustomBeatmapSaveData.NoteData noteData in notesSaveData)
{
float time2 = noteData.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time2)
{
num3++;
}
BPMChangeData bpmchangeData2 = list2[num3];
float num4 = bpmchangeData2.bpmChangeStartTime + beatmapDataLoader.GetRealTimeFromBPMTime(time2 - bpmchangeData2.bpmChangeStartBPMTime, bpmchangeData2.bpm, shuffle, shufflePeriod);
int lineIndex = noteData.lineIndex;
NoteLineLayer lineLayer = noteData.lineLayer;
NoteLineLayer startNoteLineLayer = NoteLineLayer.Base;
NoteType type = noteData.type;
NoteCutDirection cutDirection = noteData.cutDirection;
if (list3.Count > 0 && list3[0].time < num4 - 0.001f && type.IsBasicNote())
{
ProcessBasicNotesInTimeRow.Invoke(_notesInTimeRowProcessor, new object[] { list3.Cast <NoteData>().ToList(), num4 });
num2 = list3[0].time;
list3.Clear();
}
if (list4.Count > 0 && list4[0].time < num4 - 0.001f)
{
ProcessNotesInTimeRow.Invoke(_notesInTimeRowProcessor, new object[] { list4.Cast <NoteData>().ToList() });
list4.Clear();
}
CustomNoteData noteData2 = new CustomNoteData(num++, num4, lineIndex, lineLayer, startNoteLineLayer, type, cutDirection, float.MaxValue, num4 - num2, noteData._customData ?? Tree());
int lineNum = lineIndex > 3 ? 3 : lineIndex < 0 ? 0 : lineIndex;
array[lineNum].Add(noteData2);
CustomNoteData item = noteData2;
if (noteData2.noteType.IsBasicNote())
{
list3.Add(item);
}
list4.Add(item);
}
ProcessBasicNotesInTimeRow.Invoke(_notesInTimeRowProcessor, new object[] { list3.Cast <NoteData>().ToList(), float.MaxValue });
ProcessNotesInTimeRow.Invoke(_notesInTimeRowProcessor, new object[] { list4.Cast <NoteData>().ToList() });
num3 = 0;
foreach (CustomBeatmapSaveData.ObstacleData obstacleData in obstaclesSaveData)
{
float time3 = obstacleData.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time3)
{
num3++;
}
BPMChangeData bpmchangeData3 = list2[num3];
float time4 = bpmchangeData3.bpmChangeStartTime + beatmapDataLoader.GetRealTimeFromBPMTime(time3 - bpmchangeData3.bpmChangeStartBPMTime, bpmchangeData3.bpm, shuffle, shufflePeriod);
int lineIndex2 = obstacleData.lineIndex;
ObstacleType type2 = obstacleData.type;
float realTimeFromBPMTime = beatmapDataLoader.GetRealTimeFromBPMTime(obstacleData.duration, startBPM, shuffle, shufflePeriod);
int width = obstacleData.width;
CustomObstacleData item2 = new CustomObstacleData(num++, time4, lineIndex2, type2, realTimeFromBPMTime, width, obstacleData._customData ?? Tree());
int lineNum = lineIndex2 > 3 ? 3 : lineIndex2 < 0 ? 0 : lineIndex2;
array[lineNum].Add(item2);
}
foreach (CustomBeatmapSaveData.EventData eventData2 in eventsSaveData)
{
float time5 = eventData2.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time5)
{
num3++;
}
BPMChangeData bpmchangeData4 = list2[num3];
float time6 = bpmchangeData4.bpmChangeStartTime + beatmapDataLoader.GetRealTimeFromBPMTime(time5 - bpmchangeData4.bpmChangeStartBPMTime, bpmchangeData4.bpm, shuffle, shufflePeriod);
BeatmapEventType type3 = eventData2.type;
int value2 = eventData2.value;
CustomBeatmapEventData item3 = new CustomBeatmapEventData(time6, type3, value2, eventData2.customData ?? Tree());
list.Add(item3);
}
if (list.Count == 0)
{
list.Add(new CustomBeatmapEventData(0f, BeatmapEventType.Event0, 1, Tree()));
list.Add(new CustomBeatmapEventData(0f, BeatmapEventType.Event4, 1, Tree()));
}
var customEvents = new Dictionary <string, List <CustomEventData> >(customEventsSaveData.Count);
foreach (CustomBeatmapSaveData.CustomEventData customEventData in customEventsSaveData)
{
if (!customEvents.ContainsKey(customEventData.type))
{
customEvents[customEventData.type] = new List <CustomEventData>();
}
float time7 = customEventData.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time7)
{
num3++;
}
BPMChangeData bpmchangeData5 = list2[num3];
float time8 = bpmchangeData5.bpmChangeStartTime + beatmapDataLoader.GetRealTimeFromBPMTime(time7 - bpmchangeData5.bpmChangeStartBPMTime, bpmchangeData5.bpm, shuffle, shufflePeriod);
customEvents[customEventData.type].Add(new CustomEventData(time8, customEventData.type, customEventData.data ?? Tree()));
}
foreach (var pair in customEvents)
{
pair.Value.Sort((x, y) => x.time.CompareTo(y.time));
}
BeatmapLineData[] array2 = new BeatmapLineData[4];
for (int j = 0; j < 4; j++)
{
array[j].Sort(delegate(BeatmapObjectData x, BeatmapObjectData y)
{
if (x.time == y.time)
{
return(0);
}
return((x.time <= y.time) ? -1 : 1);
});
array2[j] = new BeatmapLineData();
array2[j].beatmapObjectsData = array[j].ToArray();
}
return(new CustomBeatmapData(array2, list.ToArray(), customEvents, customData, customLevelData));
} catch (Exception e)
{
Plugin.logger.Critical("Exception loading CustomBeatmap!");
Plugin.logger.Critical(e);
Debug.LogError("Exception loading CustomBeatmap!");
Debug.LogError(e);
throw e;
}
}
internal static IEnumerator DelayedStart()
{
yield return(new WaitForEndOfFrame());
AudioTimeSyncController = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().First();
BeatmapObjectSpawnController beatmapObjectSpawnController = Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().First();
BeatmapObjectManager beatmapObjectManager = _beatmapObjectSpawnAccessor(ref beatmapObjectSpawnController) as BeatmapObjectManager;
SongBPM = beatmapObjectSpawnController.currentBpm;
BeatmapObjectCallbackController coreSetup = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
IReadonlyBeatmapData beatmapData = coreSetup.GetField <IReadonlyBeatmapData, BeatmapObjectCallbackController>("_beatmapData");
beatmapObjectManager.noteWasCutEvent -= NoteColorizer.ColorizeSaber;
beatmapObjectManager.noteWasCutEvent += NoteColorizer.ColorizeSaber;
if (ChromaConfig.Instance.LightshowModifier)
{
foreach (BeatmapLineData b in beatmapData.beatmapLinesData)
{
BeatmapLineData refBeatmapLineData = b;
_beatmapObjectsDataAccessor(ref refBeatmapLineData) = b.beatmapObjectsData.Where((source, index) => b.beatmapObjectsData[index].beatmapObjectType != BeatmapObjectType.Note).ToList();
}
foreach (Saber saber in Resources.FindObjectsOfTypeAll <Saber>())
{
saber.gameObject.SetActive(false);
}
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission("Chroma");
if (ChromaConfig.Instance.PlayersPlace)
{
GameObject.Find("PlayersPlace")?.SetActive(false);
}
if (ChromaConfig.Instance.Spectrograms)
{
GameObject.Find("Spectrograms")?.SetActive(false);
}
if (ChromaConfig.Instance.BackColumns)
{
GameObject.Find("BackColumns")?.SetActive(false);
}
if (ChromaConfig.Instance.Buildings)
{
GameObject.Find("Buildings")?.SetActive(false);
}
}
if (Harmony.HasAnyPatches(HARMONYID))
{
if (beatmapData is CustomBeatmapData customBeatmap)
{
if (ChromaConfig.Instance.EnvironmentEnhancementsEnabled)
{
// Spaghetti code below until I can figure out a better way of doing this
dynamic dynData = customBeatmap.beatmapCustomData;
List <object> objectsToKill = Trees.at(dynData, "_environmentRemoval");
if (objectsToKill != null)
{
IEnumerable <GameObject> gameObjects = Resources.FindObjectsOfTypeAll <GameObject>();
foreach (string s in objectsToKill.Cast <string>())
{
if (s == "TrackLaneRing" || s == "BigTrackLaneRing")
{
foreach (GameObject n in gameObjects.Where(obj => obj.name.Contains(s)))
{
if (s == "TrackLaneRing" && n.name.Contains("Big"))
{
continue;
}
n.SetActive(false);
}
}
else
{
foreach (GameObject n in gameObjects
.Where(obj => obj.name.Contains(s) && (obj.scene.name?.Contains("Environment") ?? false) && (!obj.scene.name?.Contains("Menu") ?? false)))
{
n.SetActive(false);
}
}
}
}
}
}
// please let me kill legacy
LegacyLightHelper.Activate(beatmapData.beatmapEventsData);
}
}
static bool Prefix(BeatmapData beatmapData, ref BeatmapData __result)
{
MethodInfo MirrorTransformBeatmapObjects = typeof(BeatDataMirrorTransform).GetMethod("MirrorTransformBeatmapObjects", BindingFlags.Static | BindingFlags.NonPublic);
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
int num = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
num += beatmapLinesData[j].beatmapObjectsData.Length;
}
List <BeatmapObjectData> list = new List <BeatmapObjectData>(num);
bool flag;
do
{
flag = false;
float num2 = 999999f;
int num3 = 0;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
if (num4 < beatmapObjectsData.Length)
{
flag = true;
float time = beatmapObjectsData[num4].time;
if (time < num2)
{
num2 = time;
num3 = k;
}
}
}
if (flag)
{
list.Add(beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy());
array[num3]++;
}
}while (flag);
MirrorTransformBeatmapObjects.Invoke(null, new object[] { list, beatmapData.beatmapLinesData.Length });
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < list.Count; l++)
{
BeatmapObjectData beatmapObjectData = list[l];
array2[beatmapObjectData.lineIndex]++;
}
BeatmapLineData[] array3 = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
array3[m] = new BeatmapLineData();
array3[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < list.Count; n++)
{
BeatmapObjectData beatmapObjectData2 = list[n];
int lineIndex = beatmapObjectData2.lineIndex;
array3[lineIndex].beatmapObjectsData[array[lineIndex]] = beatmapObjectData2;
array[lineIndex]++;
}
CustomBeatmapEventData[] array4 = new CustomBeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
CustomBeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5] as CustomBeatmapEventData;
if (beatmapEventData == null)
{
continue;
}
if (beatmapEventData.type.IsRotationEvent())
{
int value = 7 - beatmapEventData.value;
array4[num5] = new CustomBeatmapEventData(beatmapEventData.time, beatmapEventData.type, value, beatmapEventData.customData ?? Tree());
}
else
{
array4[num5] = beatmapEventData;
}
}
if (beatmapData is CustomBeatmapData customBeatmap)
{
__result = new CustomBeatmapData(array3, array4, customBeatmap.customEventData, customBeatmap.beatmapCustomData, customBeatmap.levelCustomData);
}
else
{
__result = new BeatmapData(array3, array4);
}
return(false);
}
static bool Prefix(BeatmapData beatmapData, GameplayModifiers.EnabledObstacleType enabledObstaclesType, bool noBombs, ref BeatmapData __result)
{
MethodInfo ShouldUseBeatmapObject = typeof(BeatmapDataObstaclesAndBombsTransform).GetMethod("ShouldUseBeatmapObject", BindingFlags.Static | BindingFlags.NonPublic);
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
int num = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
num += beatmapLinesData[j].beatmapObjectsData.Length;
}
List <BeatmapObjectData> list = new List <BeatmapObjectData>(num);
bool flag;
do
{
flag = false;
float num2 = 999999f;
int num3 = 0;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
if (num4 < beatmapObjectsData.Length)
{
flag = true;
float time = beatmapObjectsData[num4].time;
if (time < num2)
{
num2 = time;
num3 = k;
}
}
}
if (flag)
{
if (Convert.ToBoolean(ShouldUseBeatmapObject.Invoke(null, new object[] { beatmapLinesData[num3].beatmapObjectsData[array[num3]], enabledObstaclesType, noBombs })))
{
list.Add(beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy());
}
array[num3]++;
}
}while (flag);
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < list.Count; l++)
{
BeatmapObjectData beatmapObjectData = list[l];
array2[beatmapObjectData.lineIndex]++;
}
BeatmapLineData[] array3 = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
array3[m] = new BeatmapLineData();
array3[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < list.Count; n++)
{
BeatmapObjectData beatmapObjectData2 = list[n];
int lineIndex = beatmapObjectData2.lineIndex;
array3[lineIndex].beatmapObjectsData[array[lineIndex]] = beatmapObjectData2;
array[lineIndex]++;
}
CustomBeatmapEventData[] array4 = new CustomBeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
CustomBeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5] as CustomBeatmapEventData;
if (beatmapEventData == null)
{
continue;
}
array4[num5] = beatmapEventData;
}
if (beatmapData is CustomBeatmapData customBeatmap)
{
__result = new CustomBeatmapData(array3, array4, customBeatmap.customEventData, customBeatmap.beatmapCustomData, customBeatmap.levelCustomData);
}
else
{
__result = new BeatmapData(array3, array4);
}
return(false);
}
public static BeatmapData ApplyModifiers(BeatmapData beatmapData)
{
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
int num = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
num += beatmapLinesData[j].beatmapObjectsData.Length;
}
List <BeatmapObjectData> list = new List <BeatmapObjectData>(num);
bool flag;
do
{
flag = false;
float num2 = 999999f;
int num3 = 0;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
if (num4 < beatmapObjectsData.Length)
{
flag = true;
BeatmapObjectData beatmapObjectData = beatmapObjectsData[num4];
float time = beatmapObjectData.time;
if (time < num2)
{
num2 = time;
num3 = k;
}
}
}
if (flag)
{
var note = beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy();
if (!(Settings.RemoveBombs && IsBomb(note)))
{
list.Add(beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy());
}
array[num3]++;
}
}while (flag);
ModifyObjects(list, beatmapData.beatmapLinesData.Length);
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < list.Count; l++)
{
BeatmapObjectData beatmapObjectData2 = list[l];
array2[beatmapObjectData2.lineIndex]++;
}
BeatmapLineData[] array3 = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
array3[m] = new BeatmapLineData();
array3[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < list.Count; n++)
{
BeatmapObjectData beatmapObjectData3 = list[n];
int lineIndex = beatmapObjectData3.lineIndex;
array3[lineIndex].beatmapObjectsData[array[lineIndex]] = beatmapObjectData3;
array[lineIndex]++;
}
BeatmapEventData[] array4 = new BeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
BeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5];
array4[num5] = beatmapEventData.GetCopy();
}
return(new BeatmapData(array3, array4));
//return new SongData(songData.BeatsPerMinute, Settings.OverrideJumpSpeed ? Settings.NoteJumpSpeed : songData.NoteJumpSpeed, array3, array4);
}
static bool Prefix(BeatmapData beatmapData, GameplayModifiers.EnabledObstacleType enabledObstaclesType, bool noBombs, ref BeatmapData __result)
{
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
int num = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
num += beatmapLinesData[j].beatmapObjectsData.Length;
}
List <BeatmapObjectData> list = new List <BeatmapObjectData>(num);
bool flag;
do
{
flag = false;
float num2 = 999999f;
int num3 = 0;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
if (num4 < beatmapObjectsData.Length)
{
flag = true;
BeatmapObjectData beatmapObjectData = beatmapObjectsData[num4];
float time = beatmapObjectData.time;
if (time < num2)
{
num2 = time;
num3 = k;
}
}
}
if (flag)
{
BeatmapObjectData beatmapObjectData2 = beatmapLinesData[num3].beatmapObjectsData[array[num3]];
if (ShouldUseBeatmapObject(beatmapObjectData2, enabledObstaclesType, noBombs))
{
list.Add(beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy());
}
array[num3]++;
}
}while (flag);
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < list.Count; l++)
{
BeatmapObjectData beatmapObjectData3 = list[l];
int number = beatmapObjectData3.lineIndex;
if (number > 3)
{
number = 3;
}
if (number < 0)
{
number = 0;
}
array2[number]++;
}
BeatmapLineData[] array3 = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
array3[m] = new BeatmapLineData();
array3[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < list.Count; n++)
{
BeatmapObjectData beatmapObjectData4 = list[n];
int lineIndex = beatmapObjectData4.lineIndex;
int number = lineIndex;
if (number > 3)
{
number = 3;
}
if (number < 0)
{
number = 0;
}
array3[number].beatmapObjectsData[array[number]] = beatmapObjectData4;
array[number]++;
}
BeatmapEventData[] array4 = new BeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
BeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5];
array4[num5] = beatmapEventData.GetCopy();
}
__result = new BeatmapData(array3, array4);
return(false);
}
static bool Prefix(ref BeatmapDataLoader __instance, List <BeatmapSaveData.NoteData> notesSaveData, List <BeatmapSaveData.ObstacleData> obstaclesSaveData, List <BeatmapSaveData.EventData> eventsSaveData, float startBPM, float shuffle, float shufflePeriod, ref Object ____notesInTimeRowProcessor, ref BeatmapData __result)
{
List <BeatmapObjectData>[] array = new List <BeatmapObjectData> [4];
List <BeatmapEventData> list = new List <BeatmapEventData>(eventsSaveData.Count);
List <BPMChangeData> list2 = new List <BPMChangeData>();
list2.Add(new BPMChangeData(0f, 0f, startBPM));
BPMChangeData bpmchangeData = list2[0];
foreach (BeatmapSaveData.EventData eventData in eventsSaveData)
{
if (eventData.type.IsBPMChangeEvent())
{
float time = eventData.time;
int value = eventData.value;
float bpmChangeStartTime = bpmchangeData.bpmChangeStartTime + __instance.GetRealTimeFromBPMTime(time - bpmchangeData.bpmChangeStartBPMTime, (float)value, shuffle, shufflePeriod);
list2.Add(new BPMChangeData(bpmChangeStartTime, time, (float)value));
}
}
for (int i = 0; i < 4; i++)
{
array[i] = new List <BeatmapObjectData>(3000);
}
int num = 0;
float num2 = -1f;
List <NoteData> list3 = new List <NoteData>(4);
List <NoteData> list4 = new List <NoteData>(4);
int num3 = 0;
foreach (BeatmapSaveData.NoteData noteData in notesSaveData)
{
float time2 = noteData.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time2)
{
num3++;
}
BPMChangeData bpmchangeData2 = list2[num3];
float num4 = bpmchangeData2.bpmChangeStartTime + __instance.GetRealTimeFromBPMTime(time2 - bpmchangeData2.bpmChangeStartBPMTime, bpmchangeData2.bpm, shuffle, shufflePeriod);
int lineIndex = noteData.lineIndex;
NoteLineLayer lineLayer = noteData.lineLayer;
NoteLineLayer startNoteLineLayer = NoteLineLayer.Base;
NoteType type = noteData.type;
NoteCutDirection cutDirection = noteData.cutDirection;
if (list3.Count > 0 && list3[0].time < num4 - 0.001f && type.IsBasicNote())
{
____notesInTimeRowProcessor.InvokeMethod("ProcessBasicNotesInTimeRow", list3, num4);
num2 = list3[0].time;
list3.Clear();
}
if (list4.Count > 0 && list4[0].time < num4 - 0.001f)
{
____notesInTimeRowProcessor.InvokeMethod("ProcessNotesInTimeRow", list4);
list4.Clear();
}
NoteData noteData2 = new NoteData(num++, num4, lineIndex, lineLayer, startNoteLineLayer, type, cutDirection, float.MaxValue, num4 - num2);
int lineNum = lineIndex > 3 ? 3 : lineIndex < 0 ? 0 : lineIndex;
array[lineNum].Add(noteData2);
NoteData item = noteData2;
if (noteData2.noteType.IsBasicNote())
{
list3.Add(item);
}
list4.Add(item);
}
____notesInTimeRowProcessor.InvokeMethod("ProcessBasicNotesInTimeRow", list3, float.MaxValue);
____notesInTimeRowProcessor.InvokeMethod("ProcessNotesInTimeRow", list4);
num3 = 0;
foreach (BeatmapSaveData.ObstacleData obstacleData in obstaclesSaveData)
{
float time3 = obstacleData.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time3)
{
num3++;
}
BPMChangeData bpmchangeData3 = list2[num3];
float time4 = bpmchangeData3.bpmChangeStartTime + __instance.GetRealTimeFromBPMTime(time3 - bpmchangeData3.bpmChangeStartBPMTime, bpmchangeData3.bpm, shuffle, shufflePeriod);
int lineIndex2 = obstacleData.lineIndex;
ObstacleType type2 = obstacleData.type;
float realTimeFromBPMTime = __instance.GetRealTimeFromBPMTime(obstacleData.duration, startBPM, shuffle, shufflePeriod);
int width = obstacleData.width;
ObstacleData item2 = new ObstacleData(num++, time4, lineIndex2, type2, realTimeFromBPMTime, width);
int lineNum = lineIndex2 > 3 ? 3 : lineIndex2 < 0 ? 0 : lineIndex2;
array[lineNum].Add(item2);
}
foreach (BeatmapSaveData.EventData eventData2 in eventsSaveData)
{
float time5 = eventData2.time;
while (num3 < list2.Count - 1 && list2[num3 + 1].bpmChangeStartBPMTime < time5)
{
num3++;
}
BPMChangeData bpmchangeData4 = list2[num3];
float time6 = bpmchangeData4.bpmChangeStartTime + __instance.GetRealTimeFromBPMTime(time5 - bpmchangeData4.bpmChangeStartBPMTime, bpmchangeData4.bpm, shuffle, shufflePeriod);
BeatmapEventType type3 = eventData2.type;
int value2 = eventData2.value;
BeatmapEventData item3 = new BeatmapEventData(time6, type3, value2);
list.Add(item3);
}
if (list.Count == 0)
{
list.Add(new BeatmapEventData(0f, BeatmapEventType.Event0, 1));
list.Add(new BeatmapEventData(0f, BeatmapEventType.Event4, 1));
}
BeatmapLineData[] array2 = new BeatmapLineData[4];
for (int j = 0; j < 4; j++)
{
array[j].Sort(delegate(BeatmapObjectData x, BeatmapObjectData y)
{
if (x.time == y.time)
{
return(0);
}
if (x.time <= y.time)
{
return(-1);
}
return(1);
});
array2[j] = new BeatmapLineData();
array2[j].beatmapObjectsData = array[j].ToArray();
}
__result = new BeatmapData(array2, list.ToArray());
return(false);
}
static bool Prefix(BeatmapData beatmapData, ref BeatmapData __result)
{
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
int num = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
num += beatmapLinesData[j].beatmapObjectsData.Length;
}
List <BeatmapObjectData> list = new List <BeatmapObjectData>(num);
bool flag;
do
{
flag = false;
float num2 = 999999f;
int num3 = 0;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
if (num4 < beatmapObjectsData.Length)
{
flag = true;
BeatmapObjectData beatmapObjectData = beatmapObjectsData[num4];
float time = beatmapObjectData.time;
if (time < num2)
{
num2 = time;
num3 = k;
}
}
}
if (flag)
{
list.Add(beatmapLinesData[num3].beatmapObjectsData[array[num3]].GetCopy());
array[num3]++;
}
}while (flag);
MirrorTransformBeatmapObjects(list, beatmapData.beatmapLinesData.Length);
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < list.Count; l++)
{
BeatmapObjectData beatmapObjectData2 = list[l];
int number = beatmapObjectData2.lineIndex;
if (number > 3)
{
number = 3;
}
if (number < 0)
{
number = 0;
}
array2[number]++;
}
BeatmapLineData[] array3 = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
array3[m] = new BeatmapLineData();
array3[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < list.Count; n++)
{
BeatmapObjectData beatmapObjectData3 = list[n];
int lineIndex = beatmapObjectData3.lineIndex;
int number = lineIndex;
if (number > 3)
{
number = 3;
}
if (number < 0)
{
number = 0;
}
array3[number].beatmapObjectsData[array[number]] = beatmapObjectData3;
array[number]++;
}
BeatmapEventData[] array4 = new BeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
BeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5];
if (beatmapEventData.type.IsRotationEvent())
{
int value = 7 - beatmapEventData.value;
array4[num5] = new BeatmapEventData(beatmapEventData.time, beatmapEventData.type, value);
}
else
{
array4[num5] = beatmapEventData;
}
}
__result = new BeatmapData(array3, array4);
return(false);
}
public static CustomBeatmap CreateTransformedData(BeatmapData beatmapData, ref ChromaBehaviour chromaBehaviour, ref PlayerSpecificSettings playerSettings, ref BaseGameModeType baseGameMode, ref float bpm)
{
ColourManager.TechnicolourLightsForceDisabled = false;
ChromaLogger.Log("Checking for registered JSONBeatmap for " + beatmapData.ToString() + " (" + ChromaJSONBeatmap.chromaBeatmaps.Count + " registered maps total)");
ChromaJSONBeatmap chromaInjectmap = ChromaJSONBeatmap.GetChromaBeatmap(beatmapData);
if (beatmapData == null)
{
ChromaLogger.Log("Null beatmapData", ChromaLogger.Level.ERROR);
}
if (playerSettings == null)
{
ChromaLogger.Log("Null playerSettings", ChromaLogger.Level.ERROR);
}
List <CustomBeatmapObject> customBeatmapData = new List <CustomBeatmapObject>();
beatmapData = beatmapData.GetCopy();
BeatmapLineData[] beatmapLinesData = beatmapData.beatmapLinesData;
int[] array = new int[beatmapLinesData.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = 0;
}
UnityEngine.Random.InitState(0);
bool flag;
do
{
flag = false;
float num = 999999f;
int num2 = 0;
for (int j = 0; j < beatmapLinesData.Length; j++)
{
BeatmapObjectData[] beatmapObjectsData = beatmapLinesData[j].beatmapObjectsData;
int num3 = array[j];
while (num3 < beatmapObjectsData.Length && beatmapObjectsData[num3].time < num + 0.001f)
{
flag = true;
BeatmapObjectData beatmapObjectData = beatmapObjectsData[num3];
float time = beatmapObjectData.time;
if (Mathf.Abs(time - num) < 0.001f)
{
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
num2++;
}
}
else if (time < num)
{
num = time;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
num2 = 1;
}
else
{
num2 = 0;
}
}
num3++;
}
}
CustomBeatmapObject customBeatmapObject = null;
for (int k = 0; k < beatmapLinesData.Length; k++)
{
BeatmapObjectData[] beatmapObjectsData2 = beatmapLinesData[k].beatmapObjectsData;
int num4 = array[k];
while (num4 < beatmapObjectsData2.Length && beatmapObjectsData2[num4].time < num + 0.001f)
{
BeatmapObjectData beatmapObjectData2 = beatmapObjectsData2[num4];
if (beatmapObjectData2.beatmapObjectType == BeatmapObjectType.Note)
{
NoteData noteData = beatmapObjectData2 as NoteData;
if (noteData != null)
{
if (noteData.noteType == NoteType.NoteA || noteData.noteType == NoteType.NoteB)
{
customBeatmapObject = new CustomBeatmapNote(beatmapObjectData2 as NoteData);
}
else if (noteData.noteType == NoteType.Bomb)
{
customBeatmapObject = new CustomBeatmapBomb(beatmapObjectData2 as NoteData);
}
}
}
else if (beatmapObjectData2.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacle = beatmapObjectData2 as ObstacleData;
if (obstacle != null)
{
customBeatmapObject = new CustomBeatmapBarrier(obstacle);
}
}
array[k]++;
num4++;
if (customBeatmapObject == null)
{
ChromaLogger.Log("Null beatmap object! ID:" + beatmapObjectData2.id + " LI:" + beatmapObjectData2.lineIndex + " T:" + beatmapObjectData2.time, ChromaLogger.Level.WARNING);
}
else
{
customBeatmapData.Add(customBeatmapObject); //CT Added
}
}
}
}while (flag);
CustomBeatmap customBeatmap = new CustomBeatmap(customBeatmapData);
try {
ChromaLogger.Log("Modifying map data...");
if (beatmapData == null)
{
ChromaLogger.Log("Null beatmapData", ChromaLogger.Level.ERROR);
}
if (beatmapData.beatmapEventData == null)
{
ChromaLogger.Log("Null beatmapData.beatmapEventData", ChromaLogger.Level.ERROR);
}
ModifyCustomBeatmapEvent?.Invoke(beatmapData.notesCount * beatmapData.beatmapEventData.Length, ref customBeatmap, ref beatmapData, ref playerSettings, ref baseGameMode, ref bpm);
//ModifyCustomBeatmap(beatmapData.notesCount * beatmapData.beatmapEventData.Length, ref customBeatmap, ref beatmapData, ref playerSettings, ref baseGameMode, ref bpm);
} catch (Exception e) {
ChromaLogger.Log("Exception modifying map data...", ChromaLogger.Level.ERROR);
ChromaLogger.Log(e);
}
customBeatmapData = customBeatmap.CustomBeatmapObjects;
//from Tweaks
int[] array2 = new int[beatmapLinesData.Length];
for (int l = 0; l < customBeatmapData.Count; l++)
{
BeatmapObjectData beatmapObjectData2 = customBeatmapData[l].Data;
array2[Mathf.Clamp(beatmapObjectData2.lineIndex, 0, 3)]++; //array2[beatmapObjectData2.lineIndex]++;
}
BeatmapLineData[] linesData = new BeatmapLineData[beatmapLinesData.Length];
for (int m = 0; m < beatmapLinesData.Length; m++)
{
linesData[m] = new BeatmapLineData();
linesData[m].beatmapObjectsData = new BeatmapObjectData[array2[m]];
array[m] = 0;
}
for (int n = 0; n < customBeatmapData.Count; n++)
{
BeatmapObjectData beatmapObjectData3 = customBeatmapData[n].Data;
int lineIndex = Mathf.Clamp(beatmapObjectData3.lineIndex, 0, 3); //beatmapObjectData3.lineIndex;
linesData[lineIndex].beatmapObjectsData[array[lineIndex]] = beatmapObjectData3;
array[lineIndex]++;
}
BeatmapEventData[] eventsData = new BeatmapEventData[beatmapData.beatmapEventData.Length];
for (int num5 = 0; num5 < beatmapData.beatmapEventData.Length; num5++)
{
BeatmapEventData beatmapEventData = beatmapData.beatmapEventData[num5];
eventsData[num5] = beatmapEventData.GetCopy();
}
if (ChromaConfig.LightshowModifier)
{
linesData = new BeatmapLineData[0];
}
beatmapData = new BeatmapData(linesData, eventsData);
if (chromaInjectmap != null)
{
chromaInjectmap.Inject(beatmapData);
}
customBeatmap.BeatmapData = beatmapData;
/*
* LIGHTING EVENTS
*/
if (ChromaConfig.CustomColourEventsEnabled || ChromaConfig.CustomSpecialEventsEnabled)
{
BeatmapEventData[] bevData = beatmapData.beatmapEventData;
ChromaColourEvent unfilledEvent = null;
for (int i = bevData.Length - 1; i >= 0; i--)
{
//Forcing lane change
switch (bevData[i].value)
{
case ChromaEvent.CHROMA_EVENT_RING_ROTATE_LEFT:
bevData[i].SetProperty("type", BeatmapEventType.Event8);
break;
case ChromaEvent.CHROMA_EVENT_RING_ROTATE_RIGHT:
bevData[i].SetProperty("type", BeatmapEventType.Event8);
break;
case ChromaEvent.CHROMA_EVENT_RING_ROTATE_RESET:
bevData[i].SetProperty("type", BeatmapEventType.Event8);
break;
}
ChromaEvent cLight = ApplyCustomEvent(bevData[i], ref unfilledEvent);
if (cLight != null)
{
ColourManager.TechnicolourLightsForceDisabled = true;
}
}
}
return(customBeatmap);
}
static bool Prefix(List <BeatmapSaveData.NoteData> notesSaveData, List <BeatmapSaveData.ObstacleData> obstaclesSaveData, List <BeatmapSaveData.EventData> eventsSaveData, float beatsPerMinute, float shuffle, float shufflePeriod, ref BeatmapData __result)
{
List <BeatmapObjectData>[] array = new List <BeatmapObjectData> [4];
List <BeatmapEventData> list = new List <BeatmapEventData>(eventsSaveData.Count);
for (int i = 0; i < 4; i++)
{
array[i] = new List <BeatmapObjectData>(3000);
}
int num = 0;
NoteData noteData = null;
float num2 = -1f;
List <NoteData> list2 = new List <NoteData>(4);
float num3 = 0f;
foreach (BeatmapSaveData.NoteData noteData2 in notesSaveData)
{
float realTimeFromBPMTime = GetRealTimeFromBPMTime(noteData2.time, beatsPerMinute, shuffle, shufflePeriod);
if (num3 > realTimeFromBPMTime)
{
Debug.LogError("Notes are not ordered.");
}
num3 = realTimeFromBPMTime;
int lineIndex = noteData2.lineIndex;
NoteLineLayer lineLayer = noteData2.lineLayer;
NoteLineLayer startNoteLineLayer = NoteLineLayer.Base;
if (noteData != null && noteData.lineIndex == lineIndex && Mathf.Abs(noteData.time - realTimeFromBPMTime) < 0.0001f)
{
if (noteData.startNoteLineLayer == NoteLineLayer.Base)
{
startNoteLineLayer = NoteLineLayer.Upper;
}
else
{
startNoteLineLayer = NoteLineLayer.Top;
}
}
NoteType type = noteData2.type;
NoteCutDirection cutDirection = noteData2.cutDirection;
if (list2.Count > 0 && list2[0].time < realTimeFromBPMTime - 0.001f && type.IsBasicNote())
{
ProcessBasicNotesInTimeRow(list2, realTimeFromBPMTime);
num2 = list2[0].time;
list2.Clear();
}
NoteData noteData3 = new NoteData(num++, realTimeFromBPMTime, lineIndex, lineLayer, startNoteLineLayer, type, cutDirection, float.MaxValue, realTimeFromBPMTime - num2);
int number = lineIndex;
if (number < 0)
{
number = 0;
}
if (number > 3)
{
number = 3;
}
array[number].Add(noteData3);
noteData = noteData3;
if (noteData3.noteType.IsBasicNote())
{
list2.Add(noteData);
}
}
ProcessBasicNotesInTimeRow(list2, float.MaxValue);
foreach (BeatmapSaveData.ObstacleData obstacleData in obstaclesSaveData)
{
float realTimeFromBPMTime2 = GetRealTimeFromBPMTime(obstacleData.time, beatsPerMinute, shuffle, shufflePeriod);
int lineIndex2 = obstacleData.lineIndex;
ObstacleType type2 = obstacleData.type;
float realTimeFromBPMTime3 = GetRealTimeFromBPMTime(obstacleData.duration, beatsPerMinute, shuffle, shufflePeriod);
int width = obstacleData.width;
ObstacleData item = new ObstacleData(num++, realTimeFromBPMTime2, lineIndex2, type2, realTimeFromBPMTime3, width);
int number2 = lineIndex2;
if (number2 < 0)
{
number2 = 0;
}
if (number2 > 3)
{
number2 = 3;
}
array[number2].Add(item);
}
foreach (BeatmapSaveData.EventData eventData in eventsSaveData)
{
float realTimeFromBPMTime4 = GetRealTimeFromBPMTime(eventData.time, beatsPerMinute, shuffle, shufflePeriod);
BeatmapEventType type3 = eventData.type;
int value = eventData.value;
BeatmapEventData item2 = new BeatmapEventData(realTimeFromBPMTime4, type3, value);
list.Add(item2);
}
if (list.Count == 0)
{
list.Add(new BeatmapEventData(0f, BeatmapEventType.Event0, 1));
list.Add(new BeatmapEventData(0f, BeatmapEventType.Event4, 1));
}
BeatmapLineData[] array2 = new BeatmapLineData[4];
for (int j = 0; j < 4; j++)
{
array[j].Sort(delegate(BeatmapObjectData x, BeatmapObjectData y)
{
if (x.time == y.time)
{
return(0);
}
return((x.time <= y.time) ? -1 : 1);
});
array2[j] = new BeatmapLineData();
array2[j].beatmapObjectsData = array[j].ToArray();
}
__result = new BeatmapData(array2, list.ToArray());
return(false);
}
// Token: 0x0600125F RID: 4703 RVA: 0x000404A0 File Offset: 0x0003E6A0
public static CustomBeatmapData GetBeatmapDataFromBeatmapSaveData(List <CustomBeatmapSaveData.NoteData> notesSaveData, List <CustomBeatmapSaveData.ObstacleData> obstaclesSaveData,
List <CustomBeatmapSaveData.EventData> eventsSaveData, float beatsPerMinute, float shuffle, float shufflePeriod,
List <CustomBeatmapSaveData.CustomEventData> customEventsSaveData, dynamic customData, dynamic customLevelData)
{
try
{
// remainder of this method copied from SongLoaderPlugin@12de0cf, with changes:
// BeatmapData, NoteData, EventData, and ObstacleData replaced with their Custom counterparts
// customData fields propagated to new objects
List <BeatmapObjectData>[] array = new List <BeatmapObjectData> [4];
List <BeatmapEventData> list = new List <BeatmapEventData>(eventsSaveData.Count);
for (int i = 0; i < 4; i++)
{
array[i] = new List <BeatmapObjectData>(3000);
}
int num = 0;
CustomNoteData noteData = null;
float num2 = -1f;
List <CustomNoteData> list2 = new List <CustomNoteData>(4);
float num3 = 0f;
foreach (CustomBeatmapSaveData.NoteData noteData2 in notesSaveData)
{
float realTimeFromBPMTime = GetRealTimeFromBPMTime(noteData2.time, beatsPerMinute, shuffle, shufflePeriod);
if (num3 > realTimeFromBPMTime)
{
Debug.LogError("Notes are not ordered.");
}
num3 = realTimeFromBPMTime;
int lineIndex = noteData2.lineIndex;
NoteLineLayer lineLayer = noteData2.lineLayer;
NoteLineLayer startNoteLineLayer = NoteLineLayer.Base;
if (noteData != null && noteData.lineIndex == lineIndex && Mathf.Abs(noteData.time - realTimeFromBPMTime) < 0.0001f)
{
if (noteData.startNoteLineLayer == NoteLineLayer.Base)
{
startNoteLineLayer = NoteLineLayer.Upper;
}
else
{
startNoteLineLayer = NoteLineLayer.Top;
}
}
NoteType type = noteData2.type;
NoteCutDirection cutDirection = noteData2.cutDirection;
if (list2.Count > 0 && list2[0].time < realTimeFromBPMTime - 0.001f && type.IsBasicNote())
{
ProcessBasicNotesInTimeRow(list2, realTimeFromBPMTime);
num2 = list2[0].time;
list2.Clear();
}
CustomNoteData noteData3 = new CustomNoteData(num++, realTimeFromBPMTime, lineIndex, lineLayer, startNoteLineLayer, type, cutDirection, float.MaxValue, realTimeFromBPMTime - num2, noteData2._customData ?? Tree());
int number = lineIndex;
if (number < 0)
{
number = 0;
}
if (number > 3)
{
number = 3;
}
array[number].Add(noteData3);
noteData = noteData3;
if (noteData3.noteType.IsBasicNote())
{
list2.Add(noteData);
}
}
ProcessBasicNotesInTimeRow(list2, float.MaxValue);
foreach (CustomBeatmapSaveData.ObstacleData obstacleData in obstaclesSaveData)
{
float realTimeFromBPMTime2 = GetRealTimeFromBPMTime(obstacleData.time, beatsPerMinute, shuffle, shufflePeriod);
int lineIndex2 = obstacleData.lineIndex;
ObstacleType type2 = obstacleData.type;
float realTimeFromBPMTime3 = GetRealTimeFromBPMTime(obstacleData.duration, beatsPerMinute, shuffle, shufflePeriod);
int width = obstacleData.width;
CustomObstacleData item = new CustomObstacleData(num++, realTimeFromBPMTime2, lineIndex2, type2, realTimeFromBPMTime3, width, obstacleData._customData ?? Tree());
int number2 = lineIndex2;
if (number2 < 0)
{
number2 = 0;
}
if (number2 > 3)
{
number2 = 3;
}
array[number2].Add(item);
}
foreach (CustomBeatmapSaveData.EventData eventData in eventsSaveData)
{
float realTimeFromBPMTime4 = GetRealTimeFromBPMTime(eventData.time, beatsPerMinute, shuffle, shufflePeriod);
BeatmapEventType type3 = eventData.type;
int value = eventData.value;
CustomBeatmapEventData item2 = new CustomBeatmapEventData(realTimeFromBPMTime4, type3, value, eventData.customData ?? Tree());
list.Add(item2);
}
if (list.Count == 0)
{
list.Add(new CustomBeatmapEventData(0f, BeatmapEventType.Event0, 1, Tree()));
list.Add(new CustomBeatmapEventData(0f, BeatmapEventType.Event4, 1, Tree()));
}
var customEvents = new Dictionary <string, List <CustomEventData> >(customEventsSaveData.Count);
foreach (CustomBeatmapSaveData.CustomEventData customEventData in customEventsSaveData)
{
if (!customEvents.ContainsKey(customEventData.type))
{
customEvents[customEventData.type] = new List <CustomEventData>();
}
customEvents[customEventData.type].Add(new CustomEventData(GetRealTimeFromBPMTime(customEventData.time, beatsPerMinute, shuffle, shufflePeriod), customEventData.type, customEventData.data ?? Tree()));
}
foreach (var pair in customEvents)
{
pair.Value.Sort((x, y) => x.time.CompareTo(y.time));
}
BeatmapLineData[] array2 = new BeatmapLineData[4];
for (int j = 0; j < 4; j++)
{
array[j].Sort(delegate(BeatmapObjectData x, BeatmapObjectData y)
{
if (x.time == y.time)
{
return(0);
}
return((x.time <= y.time) ? -1 : 1);
});
array2[j] = new BeatmapLineData();
array2[j].beatmapObjectsData = array[j].ToArray();
}
return(new CustomBeatmapData(array2, list.ToArray(), customEvents, customData, customLevelData));
} catch (Exception e)
{
Plugin.logger.Critical("Exception loading CustomBeatmap!");
Plugin.logger.Critical(e);
Debug.LogError("Exception loading CustomBeatmap!");
Debug.LogError(e);
throw e;
}
}
