static bool Prefix(GameNoteController __instance, Saber saber, Vector3 cutPoint, Quaternion orientation, Vector3 cutDirVec, bool allowBadCut,
ref AudioTimeSyncController ____audioTimeSyncController, ref BoxCuttableBySaber ____bigCuttableBySaber, ref BoxCuttableBySaber ____smallCuttableBySaber, NoteBasicCutInfoSO ____noteBasicCutInfo)
{
if ((int)__instance.noteData.cutDirection >= 2000)
{
float timeDeviation = __instance.noteData.time - ____audioTimeSyncController.songTime;
bool flag;
bool flag2;
bool flag3;
float cutDirDeviation;
____noteBasicCutInfo.GetBasicCutInfo(__instance.noteTransform, __instance.noteData.noteType, NoteCutDirection.Any, saber.saberType, saber.bladeSpeed, cutDirVec, out flag, out flag2, out flag3, out cutDirDeviation);
float swingRating = 0f;
SaberAfterCutSwingRatingCounter afterCutSwingRatingCounter = null;
if (flag && flag2 && flag3)
{
swingRating = saber.ComputeSwingRating();
afterCutSwingRatingCounter = saber.CreateAfterCutSwingRatingCounter();
}
else if (!allowBadCut)
{
return(false);
}
Vector3 vector = orientation * Vector3.up;
Plane plane = new Plane(vector, cutPoint);
float cutDistanceToCenter = Mathf.Abs(plane.GetDistanceToPoint(__instance.noteTransform.position));
NoteCutInfo noteCutInfo = new NoteCutInfo(flag2, flag, flag3, false, saber.bladeSpeed, cutDirVec, saber.saberType, swingRating, timeDeviation, cutDirDeviation, plane.ClosestPointOnPlane(__instance.transform.position), vector, afterCutSwingRatingCounter, cutDistanceToCenter);
____bigCuttableBySaber.canBeCut = false;
____smallCuttableBySaber.canBeCut = false;
__instance.SendNoteWasCutEvent(noteCutInfo);
return(false);
}
return(true);
}
internal static void Prefix(ref BeatmapObjectsInstaller __instance, ref GameNoteController ____normalBasicNotePrefab, ref BombNoteController ____bombNotePrefab)
{
var mib = __instance as MonoInstallerBase;
DiContainer Container = Accessors.GetDiContainer(ref mib);
_staticGameNotePrefab = ____normalBasicNotePrefab;
_staticBombNotePrefab = ____bombNotePrefab;
if (_staticGameNotePrefab != null)
{
____normalBasicNotePrefab = _staticGameNotePrefab;
}
if (_staticBombNotePrefab != null)
{
____bombNotePrefab = _staticBombNotePrefab;
}
var normal = InstallModelProviderSystem(Container, ____normalBasicNotePrefab);
var bomb = InstallModelProviderSystem(Container, ____bombNotePrefab);
if (normal != null)
{
normal.gameObject.SetActive(false);
____normalBasicNotePrefab.gameObject.SetActive(false);
____normalBasicNotePrefab = normal;
}
if (bomb != null)
{
bomb.gameObject.SetActive(false);
____bombNotePrefab.gameObject.SetActive(false);
____bombNotePrefab = bomb;
}
}
internal void Init(PluginConfig pluginConfig,
NoteAssetLoader noteAssetLoader,
[Inject(Id = "cn.left.arrow")] SiraPrefabContainer.Pool leftArrowNotePool,
[Inject(Id = "cn.right.arrow")] SiraPrefabContainer.Pool rightArrowNotePool,
[InjectOptional(Id = "cn.left.dot")] SiraPrefabContainer.Pool leftDotNotePool,
[InjectOptional(Id = "cn.right.dot")] SiraPrefabContainer.Pool rightDotNotePool)
{
_pluginConfig = pluginConfig;
_leftArrowNotePool = leftArrowNotePool;
_rightArrowNotePool = rightArrowNotePool;
_leftDotNotePool = leftDotNotePool ?? _leftArrowNotePool;
_rightDotNotePool = rightDotNotePool ?? _rightArrowNotePool;
_customNote = noteAssetLoader.CustomNoteObjects[noteAssetLoader.SelectedNote];
_gameNoteController = GetComponent <GameNoteController>();
_customNoteColorNoteVisuals = gameObject.AddComponent <CustomNoteColorNoteVisuals>();
_gameNoteController.noteWasCutEvent += WasCut;
_gameNoteController.noteWasMissedEvent += DidFinish;
_gameNoteController.didInitEvent += Controller_DidInit;
_customNoteColorNoteVisuals.didInitEvent += Visuals_DidInit;
noteCube = _gameNoteController.gameObject.transform.Find("NoteCube");
MeshRenderer noteMesh = GetComponentInChildren <MeshRenderer>();
noteMesh.forceRenderingOff = true;
}
public void HandleSaberSwingRatingCounterDidFinish(ISaberSwingRatingCounter swingRatingCounter)
{
GameNoteController gameNote = _notesBeingCut[swingRatingCounter];
OnNoteCutFinished(gameNote.noteData, swingRatingCounter);
_notesBeingCut.Remove(swingRatingCounter);
swingRatingCounter.UnregisterDidFinishReceiver(this);
}
public void Init(NuisanceManager nuisanceManager)
{
_nuisanceManager = nuisanceManager;
_gameNoteController = GetComponent <GameNoteController>();
_gameNoteController.didInitEvent.Add(this);
_gameNoteController.noteWasCutEvent.Add(this);
_gameNoteController.noteWasMissedEvent.Add(this);
}
private void Start()
{
Cnv = GetComponentInParent <ColorNoteVisuals>();
Gnc = GetComponentInParent <GameNoteController>();
if (Gnc)
{
_isDisappearingArrow = Gnc.GetPrivateField <bool>("_disappearingArrow");
}
}
/*
* private static ConditionalWeakTable<GameObject, ActiveNoteColorizer> activeNoteColorizerMap = new ConditionalWeakTable<GameObject, ActiveNoteColorizer>();
*
* private readonly CustomNoteController customNote;
*
* private readonly CustomNoteColorNoteVisuals customNoteVisuals;
* private readonly float colorStrength;
*/
public CustomNoteColorizer(GameNoteController note)
{
Logger.log.Notice("CustomNoteColorizer created");
/*
* customNote = note.gameObject.GetComponent<CustomNoteController>();
*
* customNoteVisuals = Helper.GetValue<CustomNoteColorNoteVisuals>(customNote, "_customNoteColorNoteVisuals");
* colorStrength = Helper.GetValue<CustomNote>(customNote, "_customNote").Descriptor.NoteColorStrength;
*/
}
static bool Prefix(GameNoteController __instance, Saber saber)
{
if (Config.ignoreBadColor)
{
NoteType noteType = __instance.noteData.noteType;
SaberType saberType = saber.saberType;
bool saberTypeOK = ((noteType == NoteType.NoteA && saberType == SaberType.SaberA) || (noteType == NoteType.NoteB && saberType == SaberType.SaberB));
return(saberTypeOK);
}
else
{
return(true);
}
}
private static bool Prefix(GameNoteController __instance, NoteData noteData, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos,
float moveDuration, float jumpDuration, float startTime, float jumpGravity, bool disappearingArrow, bool ghostNote,
ref bool ____disappearingArrow, ref bool ____ghostNote, ref BoxCuttableBySaber ____bigCuttableBySaber, ref BoxCuttableBySaber ____smallCuttableBySaber)
{
var beatmapData = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap.beatmapData;
____disappearingArrow = disappearingArrow;
____ghostNote = (noteData.id >= beatmapData.bombsCount + beatmapData.notesCount) ? true : ghostNote;
____bigCuttableBySaber.canBeCut = false;
____smallCuttableBySaber.canBeCut = false;
((NoteController)__instance).Init(noteData, moveStartPos, moveEndPos, jumpEndPos, moveDuration, jumpDuration, startTime, jumpGravity);
return(false);
}
static bool Prefix(GameNoteController __instance, Saber saber)
{
if (Config.ignoreBadColor ||
(Config.fourSabers && (saber.name == NalulunaModifierController.saberFootLName || saber.name == NalulunaModifierController.saberFootRName)))
{
ColorType colorType = __instance.noteData.colorType;
SaberType saberType = saber.saberType;
bool saberTypeOK = ((colorType == ColorType.ColorA && saberType == SaberType.SaberA) || (colorType == ColorType.ColorB && saberType == SaberType.SaberB));
return(saberTypeOK);
}
else
{
return(true);
}
}
public static void Postfix(GameNoteController __instance, Saber saber)
{
if (sabers == null)
{
sabers = Resources.FindObjectsOfTypeAll <Saber>();
}
var otherSaber = sabers.Where((x) => x != saber).First();
if (Vector3.Distance(otherSaber.saberBladeTopPos, __instance.gameObject.transform.position) < threshold)
{
if (spawner == null)
{
spawner = Resources.FindObjectsOfTypeAll <NoteCutEffectSpawner>().FirstOrDefault();
}
ReflectionUtil.GetField <NoteCutHapticEffect, NoteCutEffectSpawner>(spawner, "_noteCutHapticEffect").HitNote(otherSaber.saberType);
}
}
public new void SpawnBasicNote(NoteData noteData, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos, float moveDuration, float jumpDuration, float jumpGravity, float rotation, bool disappearingArrow, bool ghostNote, float cutDirectionAngleOffset)
{
NoteController noteController = ((noteData.noteType == NoteType.NoteA) ? _noteAPool : _noteBPool).Spawn();
SetNoteControllerEventCallbacks(noteController);
noteController.transform.SetPositionAndRotation(moveStartPos, Quaternion.identity);
GameNoteController gameNoteController = noteController as GameNoteController;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, rotation, moveStartPos, moveEndPos, jumpEndPos, moveDuration, jumpDuration, jumpGravity, disappearingArrow, ghostNote, cutDirectionAngleOffset);
}
else
{
noteController.Init(noteData, rotation, moveStartPos, moveEndPos, jumpEndPos, moveDuration, jumpDuration, jumpGravity, cutDirectionAngleOffset);
}
this.GetPrivateField <Action <NoteController> >("noteWasSpawnedEvent")?.Invoke(noteController);
}
public static void Postfix(ref GameNoteController __instance, ref BoxCuttableBySaber[] ____bigCuttableBySaberList, ref Transform ____noteTransform)
{
if (Plugin.Active)
{
____noteTransform.localScale = new Vector3(1f, 1f, 1f);
}
if (__instance.noteData is GameNote)
{
foreach (var bigCuttable in ____bigCuttableBySaberList)
{
bigCuttable.canBeCut = false;
}
if (GameController.mapParams?.gameType == GameType.TicTacToe)
{
____noteTransform.localScale *= 0.6f;
}
}
}
private GameNoteController DecorateNote(GameNoteController original)
{
if (!_shouldSetup)
{
return(original);
}
original.gameObject.AddComponent <CustomNoteController>();
ColorNoteVisuals originalVisuals = original.GetComponent <ColorNoteVisuals>();
CustomNoteColorNoteVisuals customVisuals = original.gameObject.AddComponent <CustomNoteColorNoteVisuals>();
customVisuals.enabled = false;
foreach (FieldInfo info in originalVisuals.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
{
info.SetValue(customVisuals, info.GetValue(originalVisuals));
}
UnityEngine.Object.Destroy(originalVisuals);
return(original);
}
internal void Init(PluginConfig pluginConfig,
NoteAssetLoader noteAssetLoader,
[Inject(Id = "cn.left.arrow")] SiraPrefabContainer.Pool leftArrowNotePool,
[Inject(Id = "cn.right.arrow")] SiraPrefabContainer.Pool rightArrowNotePool,
[InjectOptional(Id = "cn.left.dot")] SiraPrefabContainer.Pool leftDotNotePool,
[InjectOptional(Id = "cn.right.dot")] SiraPrefabContainer.Pool rightDotNotePool)
{
_pluginConfig = pluginConfig;
_leftArrowNotePool = leftArrowNotePool;
_rightArrowNotePool = rightArrowNotePool;
_leftDotNotePool = leftDotNotePool ?? _leftArrowNotePool;
_rightDotNotePool = rightDotNotePool ?? _rightArrowNotePool;
_customNote = noteAssetLoader.CustomNoteObjects[noteAssetLoader.SelectedNote];
_gameNoteController = GetComponent <GameNoteController>();
_customNoteColorNoteVisuals = gameObject.AddComponent <CustomNoteColorNoteVisuals>();
_gameNoteController.didInitEvent.Add(this);
_gameNoteController.noteWasMissedEvent.Add(this);
_gameNoteController.noteWasCutEvent.Add(this);
_customNoteColorNoteVisuals.didInitEvent += Visuals_DidInit;
noteCube = _gameNoteController.gameObject.transform.Find("NoteCube");
MeshRenderer noteMesh = GetComponentInChildren <MeshRenderer>();
if (_pluginConfig.HMDOnly == false && LayerUtils.HMDOverride == false)
{
// only disable if custom notes display on both hmd and display
noteMesh.forceRenderingOff = true;
}
else
{
noteMesh.gameObject.layer = (int)LayerUtils.NoteLayer.ThirdPerson;
}
}
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 static void Postfix(GameNoteController __instance)
{
if (colorSuckers == null)
{
colorSuckers = new List <ColorSucker>();
}
if (__instance)
{
if (!__instance.noteTransform.gameObject.GetComponent <NoteShrinker>())
{
var noteShrinker = __instance.noteTransform.gameObject.AddComponent <NoteShrinker>();
noteShrinker.gameNoteController = __instance;
noteShrinker.strength = ModifierManager.instance != null ? ModifierManager.instance.noteShrinkerStrength : 1;
}
if (!__instance.noteTransform.gameObject.GetComponent <ColorSucker>())
{
var colorSucker = __instance.noteTransform.gameObject.AddComponent <ColorSucker>();
colorSucker.gameNoteController = __instance;
colorSucker.strength = ModifierManager.instance != null ? ModifierManager.instance.colorSuckerStrength : 1;
colorSuckers.Add(colorSucker);
}
void OnMonsterAdded(object self, MonsterStatus status)
{
if (!ModifierManager.instance)
{
return;
}
foreach (var monsterModifier in ModifierManager.instance.modifiers)
{
if (__instance.noteTransform.gameObject.GetComponent(monsterModifier) is Modifier modifier)
{
modifier.EnableModifier();
}
}
}
void OnMonsterRemoved(object self, MonsterStatus status)
{
if (!ModifierManager.instance)
{
return;
}
foreach (var monsterModifier in ModifierManager.instance.modifiers)
{
if (__instance.noteTransform.gameObject.GetComponent(monsterModifier) is Modifier modifier)
{
modifier.DisableModifier();
}
}
}
if (!Plugin.config.Value.Enabled && ModifierManager.instance != null)
{
ModifierManager.instance.noteCountDuration = (int)Math.Ceiling(35 * FightSabersGameplaySetup.instance.ColorSuckerStrength);
foreach (var monsterModifier in ModifierManager.instance.modifiers)
{
if (__instance.noteTransform.gameObject.GetComponent(monsterModifier) is Modifier modifier)
{
modifier.EnableModifier();
}
}
}
else if (MonsterGenerator.instance)
{
MonsterGenerator.instance.MonsterAdded += OnMonsterAdded;
MonsterGenerator.instance.MonsterRemoved += OnMonsterRemoved;
}
}
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static bool Prefix(GameNoteController __instance)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
return(FakeNoteHelper.GetCuttable(__instance.noteData));
}
private static bool Prefix(BeatmapObjectSpawnController __instance, BeatmapObjectData beatmapObjectData, ref bool ____disableSpawning, ref float ____moveDistance, ref float ____moveSpeed, ref float ____jumpDistance, ref float ____noteJumpMovementSpeed, ref float ____topObstaclePosY, ref float ____globalYJumpOffset, ref float ____verticalObstaclePosY, ref ObstacleController.Pool ____obstaclePool, ref float ____spawnAheadTime, ref float ____noteLinesDistance, ref Action <BeatmapObjectSpawnController, ObstacleController> ___obstacleDiStartMovementEvent, ref float ____topLinesZPosOffset, ref NoteController.Pool ____bombNotePool, ref NoteController.Pool ____noteAPool, ref NoteController.Pool ____noteBPool, ref int ____numberOfSpawnedBasicNotes, ref float ____firstBasicNoteTime, ref NoteController ____prevSpawnedNormalNoteController, ref bool ____disappearingArrows, ref bool ____ghostNotes, ref Action <BeatmapObjectSpawnController, BeatmapObjectData, float, float> ___beatmapObjectWasSpawnedEvent,
ref float ____topObstacleHeight, ref float ____verticalObstacleHeight)
{
if (!Plugin.active)
{
return(true);
}
float angleFloat;
Quaternion angle = ExtraBeatmapData.beatmapObjectsAngles.TryGetValue(beatmapObjectData.id, out angleFloat) ? Quaternion.Euler(0f, angleFloat, 0f) : Quaternion.identity;
if (____disableSpawning)
{
return(false);
}
float num2 = ____moveDistance / ____moveSpeed;
float num3 = ____jumpDistance / ____noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = __instance.transform.forward;
Vector3 vector = __instance.transform.position;
vector += forward * (____moveDistance + ____jumpDistance * 0.5f);
Vector3 vector2 = vector - forward * ____moveDistance;
Vector3 vector3 = vector - forward * (____moveDistance + ____jumpDistance);
Vector3 noteOffset = __instance.GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType == ObstacleType.Top) ? (____topObstaclePosY + ____globalYJumpOffset) : ____verticalObstaclePosY);
float height = (obstacleData.obstacleType == ObstacleType.Top) ? ____topObstacleHeight : ____verticalObstacleHeight;
ObstacleController obstacleController = ____obstaclePool.Spawn();
__instance.SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(angle * (vector + noteOffset), angle);
obstacleController.Init(obstacleData, angle * (vector + noteOffset), angle * (vector2 + noteOffset), angle * (vector3 + noteOffset), num2, num3, beatmapObjectData.time - ____spawnAheadTime, ____noteLinesDistance, height);
___obstacleDiStartMovementEvent?.Invoke(__instance, obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = __instance.transform.forward;
Vector3 vector4 = __instance.transform.position;
vector4 += forward2 * (____moveDistance + ____jumpDistance * 0.5f);
Vector3 vector5 = vector4 - forward2 * ____moveDistance;
Vector3 vector6 = vector4 - forward2 * (____moveDistance + ____jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
vector6 += forward2 * ____topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = __instance.GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = __instance.JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController noteController = ____bombNotePool.Spawn();
__instance.SetNoteControllerEventCallbacks(noteController);
noteController.transform.SetPositionAndRotation(angle * (vector4 + noteOffset2), angle);
lastSpawnedObjectId = beatmapObjectData.id;
noteController.Init(noteData, angle * (vector4 + noteOffset2), angle * (vector5 + noteOffset2), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity);
}
else
{
if (noteData.noteType.IsBasicNote())
{
MemoryPool <NoteController> memoryPool = (noteData.noteType == NoteType.NoteA) ? ____noteAPool : ____noteBPool;
if (____numberOfSpawnedBasicNotes == 0)
{
____firstBasicNoteTime = noteData.time;
}
bool isFirstNote = ____firstBasicNoteTime == noteData.time;
NoteController noteController2 = memoryPool.Spawn();
__instance.SetNoteControllerEventCallbacks(noteController2);
Vector3 noteOffset3 = __instance.GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
noteController2.transform.SetPositionAndRotation(angle * (vector4 + noteOffset3), angle);
GameNoteController gameNoteController = noteController2 as GameNoteController;
lastSpawnedObjectId = beatmapObjectData.id;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, angle * (vector4 + noteOffset3), angle * (vector5 + noteOffset3), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity, ____disappearingArrows, ____ghostNotes && !isFirstNote);
}
else
{
noteController2.Init(noteData, angle * (vector4 + noteOffset3), angle * (vector5 + noteOffset3), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity);
}
____numberOfSpawnedBasicNotes++;
if (____prevSpawnedNormalNoteController != null)
{
float time = ____prevSpawnedNormalNoteController.noteData.time;
float time2 = noteController2.noteData.time;
}
____prevSpawnedNormalNoteController = noteController2;
}
}
}
___beatmapObjectWasSpawnedEvent?.Invoke(__instance, beatmapObjectData, num2, num3);
return(false);
}
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);
}
}
}
private static bool Prefix(GameNoteController __instance)
{
return(FakeNoteHelper.GetCuttable(__instance.noteData));
}
