static bool Prefix(int lineCount, ref BeatmapObjectData __instance)
{
if (__instance.lineIndex > 3 || __instance.lineIndex < 0)
{
if (__instance.lineIndex >= 1000 || __instance.lineIndex <= -1000)
{
int newIndex = __instance.lineIndex;
if (newIndex <= -1000)
{
newIndex += 2000;
}
newIndex = 5001 - 1 - newIndex;
if (newIndex <= 1000)
{
newIndex -= 2000;
}
__instance.SetProperty("lineIndex", newIndex);
return(false);
}
if (__instance.lineIndex == 4)
{
__instance.SetProperty("lineIndex", -1);
}
if (__instance.lineIndex == -1)
{
__instance.SetProperty("lineIndex", 4);
}
return(false);
}
return(true);
}
public static IEnumerator MadScience(float length)
{
yield return(new WaitForSeconds(0f));
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
Plugin.Log("Grabbed BeatmapData");
List <BeatmapObjectData> objects;
float start = Plugin.songAudio.time + 2;
float end = start + length + 2f;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
objects = line.beatmapObjectsData.ToList();
for (int i = 0; i < objects.Count; ++i)
{
BeatmapObjectData beatmapObject = objects[i];
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
objects.Add(NoteToWall(beatmapObject, Plugin.levelData.GameplayCoreSceneSetupData.difficultyBeatmap.level.beatsPerMinute));
}
}
objects = objects.OrderBy(o => o.time).ToList();
line.beatmapObjectsData = objects.ToArray();
objects.Clear();
}
yield return(new WaitForSeconds(length + 2f));
callbackController.SetField("_beatmapData", beatmapData);
}
private static bool IsBomb(BeatmapObjectData beatmapObjectData)
{
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
NoteData obstacleData = beatmapObjectData as NoteData;
return(obstacleData.noteType == NoteType.Bomb);
}
return(false);
}
internal static Vector3 GetNoteOffset(BeatmapObjectData beatmapObjectData, float?startRow, float?startHeight)
{
float distance = -(_noteLinesCount - 1f) * 0.5f + (startRow.HasValue ? _noteLinesCount / 2f : 0); // Add last part to simulate https://github.com/spookyGh0st/beatwalls/#wall
float lineIndex = startRow.GetValueOrDefault(beatmapObjectData.lineIndex);
distance = (distance + lineIndex) * _noteLinesDistance;
return(_rightVec * distance
+ new Vector3(0, LineYPosForLineLayer(beatmapObjectData, startHeight), 0));
}
internal static float GetJumpDuration(BeatmapObjectData beatmapObjectData, float @default)
{
if (beatmapObjectData is CustomObstacleData || beatmapObjectData is CustomNoteData)
{
dynamic dynData = ((dynamic)beatmapObjectData).customData;
float? njs = (float?)Trees.at(dynData, NOTEJUMPSPEED);
float? spawnoffset = (float?)Trees.at(dynData, SPAWNOFFSET);
SpawnDataHelper.GetNoteJumpValues(njs, spawnoffset, out float localJumpDuration, out float _, out Vector3 _, out Vector3 _, out Vector3 _);
return(localJumpDuration);
}
return(@default);
}
private static float GetAheadTime(BeatmapObjectData beatmapObjectData, float @default)
{
if (beatmapObjectData is CustomObstacleData || beatmapObjectData is CustomNoteData)
{
dynamic dynData = ((dynamic)beatmapObjectData).customData;
float? aheadTime = (float)Trees.at(dynData, "aheadTime");
if (aheadTime.HasValue)
{
return(aheadTime.Value);
}
}
return(@default);
}
public static BeatmapObjectData NoteToWall(BeatmapObjectData original, float bpm)
{
NoteData note = original as NoteData;
int startHeight = 120 + (((int)note.noteLineLayer) * 120);
int height = 150;
int width = 1800;
int type = height * 1000 + startHeight + 4001;
float duration = (bpm / 60f) * (1f / 32f);
BeatmapObjectData newWall = new ObstacleData(original.id * 14130, original.time, original.lineIndex, (ObstacleType)type, duration, width);
return(newWall);
}
private static int FakeObjectCheck(int objectCount, BeatmapObjectData beatmapObjectData)
{
if (_noodleRequirement)
{
bool?fake = beatmapObjectData.GetDataForObject().Get <bool?>(Plugin.FAKENOTE);
if (fake.HasValue && fake.Value)
{
return(objectCount);
}
}
return(objectCount + 1);
}
public override void LateUpdate()
{
BeatmapData beatmapData = _beatmapDataModel.beatmapData;
if (beatmapData == null || owner == null || owner.PlayerInfo == null)
{
return;
}
for (int i = 0; i < _beatmapObjectCallbackData.Count; i++)
{
_beatmapObjectDataCallbackCacheList.Clear();
BeatmapObjectCallbackData beatmapObjectCallbackData = _beatmapObjectCallbackData[i];
for (int j = 0; j < beatmapData.beatmapLinesData.Length; j++)
{
while (beatmapObjectCallbackData.nextObjectIndexInLine[j] < beatmapData.beatmapLinesData[j].beatmapObjectsData.Length)
{
BeatmapObjectData beatmapObjectData = beatmapData.beatmapLinesData[j].beatmapObjectsData[beatmapObjectCallbackData.nextObjectIndexInLine[j]];
if (beatmapObjectData.time - beatmapObjectCallbackData.aheadTime >= owner.PlayerInfo.playerProgress)
{
break;
}
if (beatmapObjectData.time >= startSongTime)
{
for (int k = _beatmapObjectDataCallbackCacheList.Count; k >= 0; k--)
{
if (k == 0 || _beatmapObjectDataCallbackCacheList[k - 1].time <= beatmapObjectData.time)
{
_beatmapObjectDataCallbackCacheList.Insert(k, beatmapObjectData);
break;
}
}
}
beatmapObjectCallbackData.nextObjectIndexInLine[j]++;
}
}
foreach (BeatmapObjectData noteData in _beatmapObjectDataCallbackCacheList)
{
beatmapObjectCallbackData.callback(noteData);
}
}
while (_nextEventIndex < beatmapData.beatmapEventData.Length)
{
BeatmapEventData beatmapEventData = beatmapData.beatmapEventData[_nextEventIndex];
if (beatmapEventData.time >= owner.PlayerInfo.playerProgress)
{
break;
}
SendBeatmapEventDidTriggerEvent(beatmapEventData);
_nextEventIndex++;
}
}
// Do not create a NoteCutSoundEffect for fake notes
private static bool Prefix(BeatmapObjectData beatmapObjectData)
{
if (beatmapObjectData is CustomNoteData customNoteData)
{
dynamic dynData = customNoteData.customData;
bool? fake = Trees.at(dynData, FAKENOTE);
if (fake.HasValue && fake.Value)
{
return(false);
}
}
return(true);
}
internal static float LineYPosForLineLayer(BeatmapObjectData beatmapObjectData, float?height)
{
float ypos = _baseLinesYPos;
if (height.HasValue)
{
ypos = (height.Value * _noteLinesDistance) + _baseLinesYPos; // offset by 0.25
}
else if (beatmapObjectData is NoteData noteData)
{
ypos = beatmapObjectSpawnMovementData.LineYPosForLineLayer(noteData.noteLineLayer);
}
return(ypos);
}
internal static T?TryGetObjectData <T>(BeatmapObjectData beatmapObjectData)
{
if (_noodleObjectDatas.TryGetValue(beatmapObjectData, out NoodleObjectData noodleObjectData))
{
if (noodleObjectData is T t)
{
return(t);
}
else
{
throw new InvalidOperationException($"NoodleObjectData was not of correct type. Expected: {typeof(T).Name}, was: {noodleObjectData.GetType().Name}");
}
}
return(default);
static void Postfix(int lineCount, ref BeatmapObjectData __instance, ref int __state)
{
if (!Plugin.active)
{
return;
}
if (__state > 3 || __state < 0)
{
if (__state >= 1000 || __state <= -1000)
{
int newIndex = __state;
bool leftSide = false;
if (newIndex <= -1000)
{
newIndex += 2000;
}
if (newIndex >= 4000)
{
leftSide = true;
}
newIndex = 5000 - newIndex;
if (leftSide)
{
newIndex -= 2000;
}
__instance.SetProperty("lineIndex", newIndex);
}
else if (__state > 3)
{
int diff = ((__state - 3) * 2);
int newlaneCount = 4 + diff;
__instance.SetProperty("lineIndex", newlaneCount - diff - 1 - __state);
}
else if (__state < 0)
{
int diff = ((0 - __state) * 2);
int newlaneCount = 4 + diff;
__instance.SetProperty("lineIndex", newlaneCount - diff - 1 - __state);
}
}
}
internal static Dictionary <string, object?> GetDataForObject(this BeatmapObjectData beatmapObjectData)
{
switch (beatmapObjectData)
{
case CustomObstacleData data:
return(data.customData);
case CustomNoteData data:
return(data.customData);
case CustomWaypointData data:
return(data.customData);
default:
throw new InvalidOperationException($"beatmapObjectdata was not of type CustomObstacleData, CustomNoteData, or CustomWaypointData. Was: {beatmapObjectData.GetType().FullName}.");
}
}
private static void MirrorTransformBeatmapObjects(List <BeatmapObjectData> beatmapObjects, int beatmapLineCount)
{
for (int i = 0; i < beatmapObjects.Count; i++)
{
BeatmapObjectData beatmapObjectData = beatmapObjects[i];
beatmapObjectData.MirrorLineIndex(beatmapLineCount);
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
NoteData noteData = beatmapObjectData as NoteData;
if (noteData != null)
{
noteData.SwitchNoteType();
noteData.MirrorTransformCutDirection();
}
}
}
}
private float GetLastNoteTime()
{
float lastNoteTime = 0f;
foreach (IReadonlyBeatmapLineData beatmapLineData in _gameplayCoreSceneSetupData.difficultyBeatmap.beatmapData.beatmapLinesData)
{
for (int i = beatmapLineData.beatmapObjectsData.Count - 1; i >= 0; i--)
{
BeatmapObjectData beatmapObjectData = beatmapLineData.beatmapObjectsData[i];
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note && ((NoteData)beatmapObjectData).colorType != ColorType.None && beatmapObjectData.time > lastNoteTime)
{
lastNoteTime = beatmapObjectData.time;
}
}
}
return(lastNoteTime);
}
private static void ApplyNoodleData(dynamic dynData, BeatmapObjectData beatmapObjectData, IReadonlyBeatmapData beatmapData)
{
if (NoodleExtensions.NoodleController.NoodleExtensionsActive)
{
ChromaNoodleData chromaNoodleData = new ChromaNoodleData();
dynamic animationObjectDyn = Trees.at(dynData, "_animation");
Dictionary <string, PointDefinition> pointDefinitions = Trees.at(((CustomBeatmapData)beatmapData).customData, "pointDefinitions");
NoodleExtensions.Animation.AnimationHelper.TryGetPointData(animationObjectDyn, COLOR, out PointDefinition localColor, pointDefinitions);
chromaNoodleData.LocalPathColor = localColor;
chromaNoodleData.Track = NoodleExtensions.Animation.AnimationHelper.GetTrackPreload(dynData, beatmapData);
ChromaNoodleDatas.Add(beatmapObjectData, chromaNoodleData);
}
}
public static bool Prefix(BeatmapObjectData beatmapObjectData)
{
if (beatmapObjectData.beatmapObjectType != BeatmapObjectType.Note)
{
return(false);
}
var noteData = beatmapObjectData as NoteData;
switch (Config.instance.ColorNoteToHide)
{
case HideNoteType.Left:
return(noteData.noteType != NoteType.NoteA);
case HideNoteType.Right:
return(noteData.noteType != NoteType.NoteB);
}
return(true);
}
/// <summary>
/// Gets the time of the song the last note is spawned<br></br>
/// (stolen from SaberFactory)
/// </summary>
/// <param name="beatmapData"></param>
/// <returns></returns>
internal static float GetLastNoteTime(this BeatmapData beatmapData)
{
float lastTime = 0f;
IReadOnlyList <IReadonlyBeatmapLineData> beatmapLinesData = beatmapData.beatmapLinesData;
foreach (BeatmapLineData beatMapLineData in beatmapLinesData)
{
IReadOnlyList <BeatmapObjectData> beatmapObjectsData = beatMapLineData.beatmapObjectsData;
for (int i = beatmapObjectsData.Count - 1; i >= 0; i--)
{
BeatmapObjectData beatmapObjectData = beatmapObjectsData[i];
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note && ((NoteData)beatmapObjectData).colorType != ColorType.None)
{
if (beatmapObjectData.time > lastTime)
{
lastTime = beatmapObjectData.time;
}
}
}
}
return(lastTime);
}
private static bool Prefix(BeatmapLineData[] ____beatmapLinesData, BeatmapData __instance, ref IEnumerable <BeatmapObjectData> __result)
{
IEnumerable <BeatmapObjectData> getObjects(BeatmapLineData[] _beatmapLinesData)
{
BeatmapLineData[] beatmapLinesData = _beatmapLinesData;
int[] idxs = new int[beatmapLinesData.Length];
while (true)
{
BeatmapObjectData?minBeatmapObjectData = null;
var num = float.MaxValue;
for (var i = 0; i < beatmapLinesData.Length; i++)
{
if (idxs[i] < beatmapLinesData[i].beatmapObjectsData.Count)
{
BeatmapObjectData beatmapObjectData = beatmapLinesData[i].beatmapObjectsData[idxs[i]];
var time = beatmapObjectData.time;
if (time < num)
{
num = time;
minBeatmapObjectData = beatmapObjectData;
}
}
}
if (minBeatmapObjectData == null)
{
break;
}
yield return(minBeatmapObjectData);
idxs[minBeatmapObjectData.lineIndex > 3 ? 3 : minBeatmapObjectData.lineIndex < 0 ? 0 : minBeatmapObjectData.lineIndex]++;
minBeatmapObjectData = null;
}
}
__result = getObjects(____beatmapLinesData);
return(false);
}
public static float GetLastNoteTime(this BeatmapData beatmapData)
{
var lastTime = 0f;
var beatmapLinesData = beatmapData.beatmapLinesData;
foreach (BeatmapLineData beatMapLineData in beatmapLinesData)
{
var beatmapObjectsData = beatMapLineData.beatmapObjectsData;
for (int i = beatmapObjectsData.Count - 1; i >= 0; i--)
{
BeatmapObjectData beatmapObjectData = beatmapObjectsData[i];
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note && ((NoteData)beatmapObjectData).colorType != ColorType.None)
{
if (beatmapObjectData.time > lastTime)
{
lastTime = beatmapObjectData.time;
}
}
}
}
return(lastTime);
}
private static void ModifyObjects(List <BeatmapObjectData> beatmapObjects, int beatmapLineCount)
{
for (int i = 0; i < beatmapObjects.Count; i++)
{
BeatmapObjectData beatmapObjectData = beatmapObjects[i];
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
NoteData noteData = beatmapObjectData as NoteData;
if (noteData != null)
{
if (Settings.NoArrows)
{
noteData.SetNoteToAnyCutDirection();
}
if (Settings.OneColour && noteData.noteType == NoteType.NoteA)
{
noteData.SwitchNoteType();
}
}
}
}
}
private static bool ShouldUseBeatmapObject(BeatmapObjectData beatmapObjectData, GameplayModifiers.EnabledObstacleType enabledObstaclesType, bool noBombs)
{
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
if (enabledObstaclesType == GameplayModifiers.EnabledObstacleType.NoObstacles)
{
return(false);
}
if (enabledObstaclesType == GameplayModifiers.EnabledObstacleType.FullHeightOnly)
{
ObstacleData obstacleData = beatmapObjectData as ObstacleData;
return(obstacleData.obstacleType == ObstacleType.FullHeight);
}
}
else if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note)
{
NoteData noteData = beatmapObjectData as NoteData;
if (noteData.noteType == NoteType.Bomb)
{
return(!noBombs);
}
}
return(true);
}
public static bool IsNote(this BeatmapObjectData data)
{
return(data is NoteData note && note.gameplayType != NoteData.GameplayType.Bomb);
}
static void Prefix(int lineCount, ref BeatmapObjectData __instance, ref int __state)
{
__state = __instance.lineIndex;
}
private static float GetAheadTime(BeatmapObjectCallbackController.BeatmapObjectCallbackData beatmapObjectCallbackData, BeatmapObjectData beatmapObjectData, float @default)
{
if (beatmapObjectCallbackData.callback.Method == _beatmapObjectSpawnControllerCallback &&
(beatmapObjectData is CustomObstacleData || beatmapObjectData is CustomNoteData || beatmapObjectData is WaypointData))
{
dynamic dynData = ((dynamic)beatmapObjectData).customData;
float? aheadTime = (float?)Trees.at(dynData, "aheadTime");
if (aheadTime.HasValue)
{
return(aheadTime.Value);
}
}
return(@default);
}
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 override void SpawnBeatmapObject(BeatmapObjectData beatmapObjectData)
{
if (_disableSpawning)
{
return;
}
float num = _moveDistance / _moveSpeed;
float num2 = _jumpDistance / _noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = transform.forward;
Vector3 a = transform.position;
a += forward * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a2 = a - forward * _moveDistance;
Vector3 a3 = a - forward * (_moveDistance + _jumpDistance);
Vector3 noteOffset = GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType == ObstacleType.Top) ? (_topObstaclePosY + _globalJumpOffsetY) : _verticalObstaclePosY);
float height = (obstacleData.obstacleType == ObstacleType.Top) ? _topObstacleHeight : _verticalObstacleHeight;
ObstacleController obstacleController = _obstaclePool.Spawn();
SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(a + noteOffset, Quaternion.identity);
obstacleController.Init(obstacleData, _spawnRotationProcesser.rotation, a + noteOffset, a2 + noteOffset, a3 + noteOffset, num, num2, beatmapObjectData.time - _spawnAheadTime, _noteLinesDistance, height);
obstacleController.SetPrivateField("_playerController", owner);
obstacleController.SetPrivateField("_audioTimeSyncController", onlineSyncController);
obstacleController.finishedMovementEvent += ResetControllers;
obstacleController.didDissolveEvent += ResetControllers;
_activeObstacles.Add(obstacleController);
this.GetPrivateField <Action <BeatmapObjectSpawnController, ObstacleController> >("obstacleDiStartMovementEvent")?.Invoke(this, obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = transform.forward;
Vector3 a4 = transform.position;
a4 += forward2 * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a5 = a4 - forward2 * _moveDistance;
Vector3 a6 = a4 - forward2 * (_moveDistance + _jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
a6 += forward2 * _topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController noteController = _bombNotePool.Spawn();
SetNoteControllerEventCallbacks(noteController);
noteController.transform.SetPositionAndRotation(a4 + noteOffset2, Quaternion.identity);
noteController.Init(noteData, _spawnRotationProcesser.rotation, a4 + noteOffset2, a5 + noteOffset2, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
var noteJump = noteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController.noteDidFinishJumpEvent += ResetControllers;
noteController.noteWasCutEvent += ResetControllersNoteWasCut;
noteController.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(noteController);
}
else if (noteData.noteType.IsBasicNote())
{
MemoryPool <NoteController> memoryPool = (noteData.noteType == NoteType.NoteA) ? _noteAPool : _noteBPool;
if (_numberOfSpawnedBasicNotes == 0)
{
_firstBasicNoteTime = noteData.time;
}
bool flag = _firstBasicNoteTime == noteData.time;
NoteController noteController2 = memoryPool.Spawn();
SetNoteControllerEventCallbacks(noteController2);
Vector3 noteOffset3 = GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
noteController2.transform.SetPositionAndRotation(a4 + noteOffset3, Quaternion.identity);
GameNoteController gameNoteController = noteController2 as GameNoteController;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, _spawnRotationProcesser.rotation, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity, _disappearingArrows, _ghostNotes && !flag);
}
else
{
noteController2.Init(noteData, _spawnRotationProcesser.rotation, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
}
var noteJump = noteController2.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController2.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController2.noteDidFinishJumpEvent += ResetControllers;
noteController2.noteWasCutEvent += ResetControllersNoteWasCut;
noteController2.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(noteController2);
_numberOfSpawnedBasicNotes++;
if (_prevSpawnedNormalNoteController != null)
{
float time = _prevSpawnedNormalNoteController.noteData.time;
float time2 = noteController2.noteData.time;
}
_prevSpawnedNormalNoteController = noteController2;
}
}
this.GetPrivateField <Action <BeatmapObjectSpawnController, BeatmapObjectData, float, float> >("beatmapObjectWasSpawnedEvent")?.Invoke(this, beatmapObjectData, num, num2);
}
public override void BeatmapObjectSpawnCallback(BeatmapObjectData beatmapObjectData)
{
if (_disableSpawning)
{
return;
}
float num = _moveDistance / _moveSpeed;
float num2 = _jumpDistance / _noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = transform.forward;
Vector3 a = transform.position;
a += forward * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a2 = a - forward * _moveDistance;
Vector3 a3 = a - forward * (_moveDistance + _jumpDistance);
Vector3 noteOffset = GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType != ObstacleType.Top) ? _verticalObstaclePosY : (_topObstaclePosY + _globalYJumpOffset));
ObstacleController.Pool pool = (obstacleData.obstacleType != ObstacleType.Top) ? _fullHeightObstaclePool : _topObstaclePool;
ObstacleController obstacleController = pool.Spawn();
SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(a + noteOffset, Quaternion.identity);
obstacleController.Init(obstacleData, a + noteOffset, a2 + noteOffset, a3 + noteOffset, num, num2, beatmapObjectData.time - _spawnAheadTime, _noteLinesDistance);
obstacleController.SetPrivateField("_playerController", owner);
obstacleController.SetPrivateField("_audioTimeSyncController", onlineSyncController);
obstacleController.finishedMovementEvent += ResetControllers;
obstacleController.didDissolveEvent += ResetControllers;
_activeObstacles.Add(obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = transform.forward;
Vector3 a4 = transform.position;
a4 += forward2 * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a5 = a4 - forward2 * _moveDistance;
Vector3 a6 = a4 - forward2 * (_moveDistance + _jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
a6 += forward2 * _topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController bombNoteController = _bombNotePool.Spawn();
SetNoteControllerEventCallbacks(bombNoteController);
bombNoteController.transform.SetPositionAndRotation(a4 + noteOffset2, Quaternion.identity);
bombNoteController.Init(noteData, a4 + noteOffset2, a5 + noteOffset2, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
var noteJump = bombNoteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
bombNoteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
bombNoteController.noteDidFinishJumpEvent += ResetControllers;
bombNoteController.noteWasCutEvent += ResetControllersNoteWasCut;
bombNoteController.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(bombNoteController);
}
else if (noteData.noteType.IsBasicNote())
{
NoteController.Pool pool2 = (noteData.noteType != NoteType.NoteA) ? _noteBPool : _noteAPool;
NoteController basicNoteController = pool2.Spawn();
SetNoteControllerEventCallbacks(basicNoteController);
Vector3 noteOffset3 = GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
basicNoteController.transform.SetPositionAndRotation(a4 + noteOffset3, Quaternion.identity);
GameNoteController gameNoteController = basicNoteController as GameNoteController;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity, _disappearingArrows, _ghostNotes);
}
else
{
basicNoteController.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
}
var noteJump = basicNoteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
basicNoteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
basicNoteController.GetComponentsInChildren <BoxCollider>().First(x => x.name == "BigCuttable").size = _defaultBigCuttableSize * 1.65f;
basicNoteController.GetComponentsInChildren <BoxCollider>().First(x => x.name == "SmallCuttable").size = _defaultSmallCuttableSize * 1.65f;
basicNoteController.noteDidFinishJumpEvent += ResetControllers;
basicNoteController.noteWasCutEvent += ResetControllersNoteWasCut;
basicNoteController.noteDidDissolveEvent += ResetControllers;
_prevSpawnedNormalNoteController = basicNoteController;
_activeNotes.Add(basicNoteController);
}
}
}
public static BeatmapData CreateTransformedData(BeatmapData beatmapData)
{
bool isDarthModeOn = Plugin.IsDarthModeOn;
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++;
}
}
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)
{
noteData.SetNoteToAnyCutDirection();
if (!isDarthModeOn && num2 <= 2)
{
noteData.TransformNoteAOrBToRandomType();
}
}
}
array[k]++;
num4++;
}
}
}while (flag);
return(beatmapData);
}
