private static void TrackColorize(NoteController instance, NoteData noteData, NoteMovement noteMovement)
{
if (NoodleExtensions.NoodleController.NoodleExtensionsActive)
{
ChromaNoodleData chromaData = ChromaNoodleDatas[noteData];
Track track = chromaData.Track;
PointDefinition pathPointDefinition = chromaData.LocalPathColor;
if (track != null || pathPointDefinition != null)
{
NoteJump noteJump = _noteJumpAccessor(ref noteMovement);
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (noteData.time - (jumpDuration * 0.5f));
float normalTime = elapsedTime / jumpDuration;
Chroma.AnimationHelper.GetColorOffset(pathPointDefinition, track, normalTime, out Color? colorOffset);
if (colorOffset.HasValue)
{
Color color = colorOffset.Value;
if (instance is BombNoteController bnc)
{
bnc.SetBombColor(color);
}
else
{
instance.SetNoteColors(color, color);
instance.SetActiveColors();
}
}
}
}
}
public GameObject GetPooledPurpleNote(bool isStar = false)
{
for (int i = 0; i < PooledBlueNotes.Count; i++)
{
if (!PooledBlueNotes[i].activeInHierarchy)
{
Component[] objs = PooledBlueNotes[i].GetComponents(typeof(Component)); //Remove Scripts
foreach (Component comp in objs)
{
if (comp.GetType() == typeof(NoteJump))
{
NoteJump test = comp as NoteJump;
Destroy(test);
}
}
Transform[] ts = PooledBlueNotes[i].transform.GetComponentsInChildren <Transform>(true);
foreach (Transform t in ts)
{
if (t.gameObject.name == "Box")
{
t.gameObject.transform.localRotation = Quaternion.identity;
}
}
PooledBlueNotes[i].transform.localRotation = Quaternion.identity;
return(PooledBlueNotes[i]);
}
}
GameObject newPurple = Instantiate(bluePrefab);
newPurple.SetActive(false);
PooledBlueNotes.Add(newPurple);
return(newPurple);
}
void OnTriggerEnter(Collider other)
{
if (other.name == "Box")
{
velocityEstimator.BeginEstimatingVelocity();
hitNote = null;
mainManager.Vibrate(Controller, device);
_Sliced hull = other.gameObject.Slice(cutPlane.transform.position, cutPlane.transform.up, crossMat);
if (hull != null)
{
hull.CreateLowerHull(other.gameObject, crossMat);
hull.CreateUpperHull(other.gameObject, crossMat);
}
Component[] objs = other.gameObject.transform.parent.GetComponents(typeof(Component)); //Remove Scripts
foreach (Component comp in objs)
{
if (comp.GetType() == typeof(NoteJump))
{
hitNote = comp as NoteJump;
if (hitNote.note._type == handColor)
{
hitSpeed = velocityEstimator.speed;
if (correctHit(hitNote.note._cutDirection))
{
mainManager.gameManager.UpdateScore(false);
}
else
{
//Play a wrong hit sound here
mainManager.gameManager.UpdateScore(true);
}
}
else
{
//Play a wrong hit sound here
mainManager.gameManager.UpdateScore(true);
}
hitNote.gameObject.SetActive(false);
}
}
}
}
public static void SpawnBombNote(NoteData note, int noteIndex)
{
GameObject newNote = ObjectPooler._current.GetPooledBombNote();
Vector3 position = new Vector3(GameObject.Find(note._lineLayer.ToString() + note._lineIndex.ToString()).transform.position.x, GameObject.Find(note._lineLayer.ToString() + note._lineIndex.ToString()).transform.position.y, mainManager.gameManager.SpawnPoint.transform.position.z);
NoteJump tempCube = newNote.AddComponent <NoteJump>();
tempCube.noteIndex = noteIndex;
tempCube.note = note;
tempCube.currentColor = note._type;
newNote.transform.position = position;
newNote.SetActive(true);
}
public override void SetNoteControllerEventCallbacks(NoteController noteController)
{
noteController.noteDidStartJumpEvent += HandleNoteDidStartJump;
noteController.noteDidFinishJumpEvent += HandleNoteDidFinishJump;
noteController.noteWasCutEvent += HandleNoteWasCut;
noteController.noteWasMissedEvent += HandleNoteWasMissed;
noteController.noteDidDissolveEvent += HandleNoteDidDissolve;
NoteJump noteJump = noteController.GetComponent <NoteJump>();
NoteJumpPlayerController(ref noteJump) = owner;
NoteJumpAudioTimeSyncController(ref noteJump) = onlineSyncController;
NoteFloorMovement noteFloorMovement = noteController.GetComponent <NoteFloorMovement>();
NoteFloorMovementAudioTimeSyncController(ref noteFloorMovement) = onlineSyncController;
_activeNotes.Add(noteController);
}
public static void Postfix(NoteJump __instance, Vector3 startPos, Vector3 endPos, float jumpDuration, float startTime, float gravity, float flipYSide, NoteCutDirection cutDirection, ref Quaternion ____startRotation, ref Quaternion ____middleRotation, ref Quaternion ____endRotation, ref int ____randomRotationIdx, ref Vector3[] ____randomRotations)
{
if (!Plugin.active)
{
return;
}
Vector3 eulerAngles = ____endRotation.eulerAngles;
eulerAngles.y = __instance.transform.rotation.eulerAngles.y;
____endRotation.eulerAngles = eulerAngles;
Vector3 vector = ____endRotation.eulerAngles;
____randomRotationIdx = (____randomRotationIdx + Mathf.RoundToInt(Mathf.Abs(startPos.x) * 10f) + 1) % ____randomRotations.Length;
vector += ____randomRotations[____randomRotationIdx] * 20f;
____middleRotation = Quaternion.Euler(vector);
____startRotation = __instance.transform.rotation;
}
public override void RemoveNoteControllerEventCallbacks(NoteController noteController)
{
noteController.noteDidStartJumpEvent -= HandleNoteDidStartJump;
noteController.noteDidFinishJumpEvent -= HandleNoteDidFinishJump;
noteController.noteWasCutEvent -= HandleNoteWasCut;
noteController.noteWasMissedEvent -= HandleNoteWasMissed;
noteController.noteDidDissolveEvent -= HandleNoteDidDissolve;
NoteJump noteJump = noteController.GetComponent <NoteJump>();
NoteJumpPlayerController(ref noteJump) = _localPlayer;
NoteJumpAudioTimeSyncController(ref noteJump) = _localSyncController;
NoteFloorMovement noteFloorMovement = noteController.GetComponent <NoteFloorMovement>();
NoteFloorMovementAudioTimeSyncController(ref noteFloorMovement) = _localSyncController;
if (_activeNotes != null)
{
_activeNotes.Remove(noteController);
}
}
private static void Postfix(NoteController __instance, NoteData noteData, NoteMovement ____noteMovement)
{
if (noteData is CustomNoteData customData)
{
dynamic dynData = customData.customData;
float?cutDir = (float?)Trees.at(dynData, CUTDIRECTION);
NoteJump noteJump = _noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = _noteFloorMovementAccessor(ref ____noteMovement);
if (cutDir.HasValue)
{
Quaternion rotation = Quaternion.Euler(0, 0, cutDir.Value);
_endRotationAccessor(ref noteJump) = rotation;
Vector3 vector = rotation.eulerAngles;
vector += _randomRotationsAccessor(ref noteJump)[_randomRotationIdxAccessor(ref noteJump)] * 20;
Quaternion midrotation = Quaternion.Euler(vector);
_middleRotationAccessor(ref noteJump) = midrotation;
}
}
}
private static void TrackColorize(NoteController instance, NoteData noteData, NoteMovement noteMovement)
{
if (NoodleExtensions.NoodleController.NoodleExtensionsActive && noteData is CustomNoteData customData)
{
dynamic dynData = customData.customData;
Track track = AnimationHelper.GetTrack(dynData);
dynamic animationObject = Trees.at(dynData, ANIMATION);
if (track != null || animationObject != null)
{
NoteJump noteJump = _noteJumpAccessor(ref noteMovement);
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (noteData.time - (jumpDuration * 0.5f));
float normalTime = elapsedTime / jumpDuration;
Chroma.AnimationHelper.GetColorOffset(animationObject, track, normalTime, out Color? colorOffset);
if (colorOffset.HasValue)
{
Color color = colorOffset.Value;
if (instance is BombNoteController bnc)
{
bnc.SetBombColor(color);
}
else
{
instance.SetNoteColors(color, color);
dynData.color0 = color;
dynData.color1 = color;
instance.SetActiveColors();
}
}
}
}
}
private static void Postfix(NoteController __instance, NoteData ____noteData, NoteMovement ____noteMovement)
{
ChromaObjectData?chromaData = TryGetObjectData <ChromaObjectData>(____noteData);
if (chromaData == null)
{
return;
}
Track? track = chromaData.Track;
PointDefinition?pathPointDefinition = chromaData.LocalPathColor;
if (track != null || pathPointDefinition != null)
{
NoteJump noteJump = _noteJumpAccessor(ref ____noteMovement);
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (____noteData.time - (jumpDuration * 0.5f));
float normalTime = elapsedTime / jumpDuration;
Chroma.AnimationHelper.GetColorOffset(pathPointDefinition, track, normalTime, out Color? colorOffset);
if (colorOffset.HasValue)
{
Color color = colorOffset.Value;
if (__instance is BombNoteController)
{
__instance.ColorizeBomb(color);
}
else
{
__instance.ColorizeNote(color);
}
}
}
}
static void Postfix(
NoteJump __instance,
ref Vector3 __result,
AudioTimeSyncController ____audioTimeSyncController,
float ____beatTime,
float ____jumpDuration,
Vector3 ____localPosition,
Vector3 ____startPos,
Vector3 ____endPos,
Quaternion ____worldRotation)
{
if (Config.parabola)
{
float time = ____audioTimeSyncController.songTime - ____beatTime + ____jumpDuration * 0.5f;
float amount = time / ____jumpDuration;
float amountHalf = amount - 0.25f;
____localPosition.y = ____localPosition.y - 60f * (amountHalf * amountHalf - 0.0625f);
//____localPosition.z = playerController.MoveTowardsHead(____startPos.z, ____endPos.z, ____inverseWorldRotation, num2);
____localPosition.z = Mathf.Lerp(____startPos.z, ____endPos.z, amount);
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
if (Config.centering)
{
____localPosition.x = ____localPosition.x / 2f + center.x / 2f;
____localPosition.y = ____localPosition.y / 2f + center.y / 2f;
____localPosition.y = ____localPosition.y + 0.3f;
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
//if (tick++ % 9 == 0) Logger.log.Debug($"NoteJumpManualUpdate: num2={num2}, __result={__result}, ____startPos={____startPos}, ____endPos={____endPos}");
if (Config.vacuum)
{
if (playerController == null)
{
playerController = Resources.FindObjectsOfTypeAll <PlayerController>().FirstOrDefault();
}
if (playerController != null)
{
float time = ____audioTimeSyncController.songTime - ____beatTime + ____jumpDuration * 0.5f;
float amount = time / ____jumpDuration;
amount = Mathf.Clamp01(amount * 2);
if (amount > 0.7f)
{
Vector3 endPos = playerController.rightSaber.saberBladeTopPos;
float t = (amount - 0.5f) * 2;
t = t * t * t * t;
____localPosition.x = Mathf.Lerp(____localPosition.x, endPos.x, t);
____localPosition.y = Mathf.Lerp(____localPosition.y, endPos.y, t);
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
}
}
if (Config.feet)
{
____localPosition.y = 0.1f;
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
if (Config.centering)
{
____localPosition.y = ____localPosition.y / 2f + center.y / 2f;
}
}
}
private static bool Prefix(NoteMovement __instance, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos, float moveDuration, float jumpDuration, float startTime, float jumpGravity, float flipYSide, NoteCutDirection cutDirection, ref float ____zOffset, ref NoteFloorMovement ____floorMovement, ref Vector3 ____position, ref Vector3 ____prevPosition, ref NoteJump ____jump, ref Action ___didInitEvent)
{
if (!Plugin.active)
{
return(true);
}
moveStartPos += __instance.transform.forward * ____zOffset;
moveEndPos += __instance.transform.forward * ____zOffset;
jumpEndPos += __instance.transform.forward * ____zOffset;
____floorMovement.Init(moveStartPos, moveEndPos, moveDuration, startTime);
____position = ____floorMovement.SetToStart();
____prevPosition = ____position;
____jump.Init(moveEndPos, jumpEndPos, jumpDuration, startTime + moveDuration, jumpGravity, flipYSide, cutDirection);
ReflectionUtil.SetPrivateProperty(__instance, "movementPhase", NoteMovement.MovementPhase.MovingOnTheFloor);
___didInitEvent?.Invoke();
return(false);
}
public static bool Prefix(NoteJump __instance, ref Vector3 __result, ref AudioTimeSyncController ____audioTimeSyncController, ref float ____startTime, ref float ____jumpDuration, ref Vector3 ____startPos, ref Vector3 ____endPos, ref Vector3 ____localPosition, ref PlayerController ____playerController, ref float ____startVerticalVelocity, ref float ____gravity, ref float ____yAvoidance, ref Quaternion ____startRotation, ref Quaternion ____middleRotation, ref Quaternion ____endRotation, ref Transform ____rotatedObject, ref float ____endDistanceOffest, ref bool ____halfJumpMarkReported, ref Action ___noteJumpDidPassHalfEvent, ref bool ____threeQuartersMarkReported, ref Action <NoteJump> ___noteJumpDidPassThreeQuartersEvent, ref float ____missedTime, ref bool ____missedMarkReported, ref Action ___noteJumpDidPassMissedMarkerEvent, ref Action ___noteJumpDidFinishEvent)
{
if (!Plugin.active)
{
return(true);
}
float songTime = ____audioTimeSyncController.songTime;
float num = songTime - ____startTime;
float num2 = num / ____jumpDuration;
____localPosition = Vector3.LerpUnclamped(____startPos + __instance.transform.rotation * ____playerController.headPos * Mathf.Min(1f, num2 * 2f), ____endPos + __instance.transform.rotation * ____playerController.headPos, num2);
____localPosition.y = ____startPos.y + ____startVerticalVelocity * num - ____gravity * num * num * 0.5f;
if (____yAvoidance != 0f && num2 < 0.25f)
{
float num3 = 0.5f - Mathf.Cos(num2 * 8f * 3.14159274f) * 0.5f;
____localPosition.y += num3 * ____yAvoidance;
}
if (num2 < 0.5f)
{
Quaternion quaternion;
if (num2 < 0.125f)
{
quaternion = Quaternion.Lerp(____startRotation, ____middleRotation, Mathf.Sin(num2 * 3.14159274f * 4f));
}
else
{
quaternion = Quaternion.Lerp(____middleRotation, ____endRotation, Mathf.Sin((num2 - 0.125f) * 3.14159274f * 2f));
}
Vector3 headPos = ____playerController.headPos;
headPos.y = Mathf.Lerp(headPos.y, ____localPosition.y, 0.8f);
Vector3 normalized = (____localPosition - headPos).normalized;
Quaternion quaternion2 = default(Quaternion);
quaternion2.SetLookRotation(normalized, ____rotatedObject.up);
____rotatedObject.rotation = Quaternion.Lerp(quaternion, quaternion2, num2 * 2f);
}
if (num2 >= 0.5f && !____halfJumpMarkReported)
{
____halfJumpMarkReported = true;
___noteJumpDidPassHalfEvent?.Invoke();
}
if (num2 >= 0.75f && !____threeQuartersMarkReported)
{
____threeQuartersMarkReported = true;
___noteJumpDidPassThreeQuartersEvent?.Invoke(__instance);
}
if (songTime >= ____missedTime && !____missedMarkReported)
{
____missedMarkReported = true;
___noteJumpDidPassMissedMarkerEvent?.Invoke();
}
if (____threeQuartersMarkReported)
{
float num4 = (num2 - 0.75f) / 0.25f;
num4 = num4 * num4 * num4;
____localPosition -= Vector3.LerpUnclamped(Vector3.zero, __instance.transform.forward * ____endDistanceOffest, num4);
}
if (num2 >= 1f)
{
___noteJumpDidFinishEvent?.Invoke();
}
Vector3 vector = ____localPosition;
__instance.transform.position = ____localPosition;
__result = vector;
return(false);
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Prefix(NoteController __instance, NoteData ____noteData, NoteMovement ____noteMovement)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
if (____noteData is CustomNoteData customData)
{
CustomNoteData = customData;
dynamic dynData = customData.customData;
Track track = Trees.at(dynData, "track");
dynamic animationObject = Trees.at(dynData, "_animation");
if (track != null || animationObject != null)
{
NoteJump noteJump = NoteControllerInit._noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = NoteControllerInit._noteFloorMovementAccessor(ref ____noteMovement);
// idk i just copied base game time
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (____noteData.time - (jumpDuration * 0.5f));
elapsedTime = NoteJumpManualUpdate.NoteJumpTimeAdjust(elapsedTime, jumpDuration);
float normalTime = elapsedTime / jumpDuration;
AnimationHelper.GetObjectOffset(animationObject, track, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?dissolveArrow, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 moveStartPos = Trees.at(dynData, "moveStartPos");
Vector3 moveEndPos = Trees.at(dynData, "moveEndPos");
Vector3 jumpEndPos = Trees.at(dynData, "jumpEndPos");
Vector3 offset = positionOffset.Value;
_floorStartPosAccessor(ref floorMovement) = moveStartPos + offset;
_floorEndPosAccessor(ref floorMovement) = moveEndPos + offset;
_jumpStartPosAccessor(ref noteJump) = moveEndPos + offset;
_jumpEndPosAccessor(ref noteJump) = jumpEndPos + offset;
}
Transform transform = __instance.transform;
if (rotationOffset.HasValue || localRotationOffset.HasValue)
{
Quaternion worldRotation = Trees.at(dynData, "worldRotation");
Quaternion localRotation = Trees.at(dynData, "localRotation");
Quaternion worldRotationQuatnerion = worldRotation;
if (rotationOffset.HasValue)
{
worldRotationQuatnerion *= rotationOffset.Value;
Quaternion inverseWorldRotation = Quaternion.Euler(-worldRotationQuatnerion.eulerAngles);
NoteControllerInit._worldRotationJumpAccessor(ref noteJump) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
NoteControllerInit._worldRotationFloorAccessor(ref floorMovement) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
CutoutEffect cutoutEffect = Trees.at(dynData, "cutoutEffect");
if (cutoutEffect == null)
{
BaseNoteVisuals baseNoteVisuals = __instance.gameObject.GetComponent <BaseNoteVisuals>();
CutoutAnimateEffect cutoutAnimateEffect = _noteCutoutAnimateEffectAccessor(ref baseNoteVisuals);
CutoutEffect[] cutoutEffects = _cutoutEffectAccessor(ref cutoutAnimateEffect);
cutoutEffect = cutoutEffects.First(n => n.name != "NoteArrow"); // 1.11 NoteArrow has been added to the CutoutAnimateEffect and we don't want that
dynData.cutoutAnimateEffect = cutoutEffect;
}
cutoutEffect.SetCutout(1 - dissolve.Value);
}
if (dissolveArrow.HasValue && __instance.noteData.noteType != NoteType.Bomb)
{
DisappearingArrowController disappearingArrowController = Trees.at(dynData, "disappearingArrowController");
if (disappearingArrowController == null)
{
disappearingArrowController = __instance.gameObject.GetComponent <DisappearingArrowController>();
dynData.disappearingArrowController = disappearingArrowController;
}
disappearingArrowController.SetArrowTransparency(dissolveArrow.Value);
}
if (cuttable.HasValue)
{
bool enabled = cuttable.Value >= 1;
switch (__instance)
{
case GameNoteController gameNoteController:
BoxCuttableBySaber bigCuttableBySaber = _gameNoteBigCuttableAccessor(ref gameNoteController);
if (bigCuttableBySaber.enabled != enabled)
{
bigCuttableBySaber.enabled = enabled;
_gameNoteSmallCuttableAccessor(ref gameNoteController).enabled = enabled;
}
break;
case BombNoteController bombNoteController:
CuttableBySaber boxCuttableBySaber = _bombNoteCuttableAccessor(ref bombNoteController);
if (boxCuttableBySaber.enabled != enabled)
{
boxCuttableBySaber.enabled = enabled;
}
break;
}
}
}
}
}
static void Postfix(
NoteJump __instance,
ref Vector3 __result,
AudioTimeSyncController ____audioTimeSyncController,
float ____beatTime,
float ____jumpDuration,
Vector3 ____localPosition,
Vector3 ____startPos,
Vector3 ____endPos,
Quaternion ____worldRotation,
Quaternion ____middleRotation,
Transform ____rotatedObject)
{
if (Config.parabola)
{
float time = ____audioTimeSyncController.songTime - ____beatTime + ____jumpDuration * 0.5f;
float amount = time / ____jumpDuration;
float amountHalf = amount - 0.25f;
____localPosition.y = ____localPosition.y - 60f * (amountHalf * amountHalf - 0.0625f);
//____localPosition.z = playerController.MoveTowardsHead(____startPos.z, ____endPos.z, ____inverseWorldRotation, num2);
____localPosition.z = Mathf.Lerp(____startPos.z, ____endPos.z, amount);
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
if (Config.centering)
{
float time = ____audioTimeSyncController.songTime - ____beatTime + ____jumpDuration * 0.5f;
float amount = time / ____jumpDuration;
____localPosition.y = Mathf.Lerp(____localPosition.y, ____localPosition.y / 2f + Config.centeringBaseY, Mathf.Clamp01(amount * 10f));
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
//if (tick++ % 9 == 0) Logger.log.Debug($"NoteJumpManualUpdate: num2={num2}, __result={__result}, ____startPos={____startPos}, ____endPos={____endPos}");
if (Config.vacuum)
{
if (_saberManager == null)
{
_saberManager = Object.FindObjectsOfType <SaberManager>().FirstOrDefault();
}
if (_saberManager != null)
{
float time = ____audioTimeSyncController.songTime - ____beatTime + ____jumpDuration * 0.5f;
float amount = time / ____jumpDuration;
amount = Mathf.Clamp01(amount * 2);
if (amount > 0.7f)
{
Vector3 endPos = _saberManager.rightSaber.saberBladeTopPos;
float t = (amount - 0.5f) * 2;
t = t * t * t * t;
____localPosition.x = Mathf.Lerp(____localPosition.x, endPos.x, t);
____localPosition.y = Mathf.Lerp(____localPosition.y, endPos.y, t);
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
}
}
if (Config.feet)
{
____localPosition.y = Config.feetNotesY;
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
Transform noteCube = __instance.transform.Find("NoteCube");
if (noteCube != null)
{
foreach (Transform noteCubeChild in noteCube)
{
if (noteCubeChild.name.StartsWith("customNote"))
{
foreach (Transform noteCubeGrandChild in noteCubeChild)
{
if (noteCubeGrandChild.name.StartsWith("Feet"))
{
noteCubeGrandChild.rotation = ____middleRotation;
}
}
}
}
}
}
if (Config.topNotesToFeet || Config.middleNotesToFeet || Config.bottomNotesToFeet)
{
if (____startPos.y == Config.feetNotesY)
{
____localPosition.y = Config.feetNotesY;
__result = ____worldRotation * ____localPosition;
__instance.transform.position = __result;
}
}
}
private static void Postfix(NoteController __instance, NoteData noteData, NoteMovement ____noteMovement, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos, float endRotation)
{
if (__instance is MultiplayerConnectedPlayerNoteController)
{
return;
}
NoodleNoteData noodleData = (NoodleNoteData)NoodleObjectDatas[noteData];
Quaternion?cutQuaternion = noodleData.CutQuaternion;
NoteJump noteJump = _noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = _noteFloorMovementAccessor(ref ____noteMovement);
if (cutQuaternion.HasValue)
{
Quaternion quatVal = cutQuaternion.Value;
_endRotationAccessor(ref noteJump) = quatVal;
Vector3 vector = quatVal.eulerAngles;
vector += _randomRotationsAccessor(ref noteJump)[_randomRotationIdxAccessor(ref noteJump)] * 20;
Quaternion midrotation = Quaternion.Euler(vector);
_middleRotationAccessor(ref noteJump) = midrotation;
}
Quaternion?worldRotationQuaternion = noodleData.WorldRotationQuaternion;
Quaternion?localRotationQuaternion = noodleData.LocalRotationQuaternion;
Transform transform = __instance.transform;
Quaternion localRotation = _quaternionIdentity;
if (worldRotationQuaternion.HasValue || localRotationQuaternion.HasValue)
{
if (localRotationQuaternion.HasValue)
{
localRotation = localRotationQuaternion.Value;
}
if (worldRotationQuaternion.HasValue)
{
Quaternion quatVal = worldRotationQuaternion.Value;
Quaternion inverseWorldRotation = Quaternion.Inverse(quatVal);
_worldRotationJumpAccessor(ref noteJump) = quatVal;
_inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
_worldRotationFloorAccessor(ref floorMovement) = quatVal;
_inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
quatVal *= localRotation;
transform.localRotation = quatVal;
}
else
{
transform.localRotation *= localRotation;
}
}
if (transform.localScale != Vector3.one)
{
transform.localScale = Vector3.one; // This is a fix for animation due to notes being recycled
}
Track track = noodleData.Track;
if (track != null && ParentObject.Controller != null)
{
ParentObject parentObject = ParentObject.Controller.GetParentObjectTrack(track);
if (parentObject != null)
{
parentObject.ParentToObject(transform);
}
else
{
ParentObject.ResetTransformParent(transform);
}
}
else
{
ParentObject.ResetTransformParent(transform);
}
noodleData.EndRotation = endRotation;
noodleData.MoveStartPos = moveStartPos;
noodleData.MoveEndPos = moveEndPos;
noodleData.JumpEndPos = jumpEndPos;
noodleData.WorldRotation = __instance.worldRotation;
noodleData.LocalRotation = localRotation;
}
private static void Prefix(NoteController __instance, NoteData ____noteData, NoteMovement ____noteMovement)
{
if (__instance is MultiplayerConnectedPlayerNoteController)
{
NoodleData = null;
return;
}
NoodleData = NoodleObjectDatas[____noteData];
NoodleNoteData noodleData = (NoodleNoteData)NoodleData;
Track track = noodleData.Track;
NoodleObjectData.AnimationObjectData animationObject = noodleData.AnimationObject;
if (track != null || animationObject != null)
{
NoteJump noteJump = NoteControllerInit._noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = NoteControllerInit._noteFloorMovementAccessor(ref ____noteMovement);
// idk i just copied base game time
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (____noteData.time - (jumpDuration * 0.5f));
elapsedTime = NoteJumpManualUpdate.NoteJumpTimeAdjust(elapsedTime, jumpDuration);
float normalTime = elapsedTime / jumpDuration;
AnimationHelper.GetObjectOffset(animationObject, track, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?dissolveArrow, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 moveStartPos = noodleData.MoveStartPos;
Vector3 moveEndPos = noodleData.MoveEndPos;
Vector3 jumpEndPos = noodleData.JumpEndPos;
Vector3 offset = positionOffset.Value;
_floorStartPosAccessor(ref floorMovement) = moveStartPos + offset;
_floorEndPosAccessor(ref floorMovement) = moveEndPos + offset;
_jumpStartPosAccessor(ref noteJump) = moveEndPos + offset;
_jumpEndPosAccessor(ref noteJump) = jumpEndPos + offset;
}
Transform transform = __instance.transform;
if (rotationOffset.HasValue || localRotationOffset.HasValue)
{
Quaternion worldRotation = noodleData.WorldRotation;
Quaternion localRotation = noodleData.LocalRotation;
Quaternion worldRotationQuatnerion = worldRotation;
if (rotationOffset.HasValue)
{
worldRotationQuatnerion *= rotationOffset.Value;
Quaternion inverseWorldRotation = Quaternion.Inverse(worldRotationQuatnerion);
NoteControllerInit._worldRotationJumpAccessor(ref noteJump) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
NoteControllerInit._worldRotationFloorAccessor(ref floorMovement) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
CutoutEffect cutoutEffect = noodleData.CutoutEffect;
if (cutoutEffect == null)
{
BaseNoteVisuals baseNoteVisuals = __instance.gameObject.GetComponent <BaseNoteVisuals>();
CutoutAnimateEffect cutoutAnimateEffect = _noteCutoutAnimateEffectAccessor(ref baseNoteVisuals);
CutoutEffect[] cutoutEffects = _cutoutEffectAccessor(ref cutoutAnimateEffect);
cutoutEffect = cutoutEffects.First(n => n.name != "NoteArrow"); // 1.11 NoteArrow has been added to the CutoutAnimateEffect and we don't want that
noodleData.CutoutEffect = cutoutEffect;
}
cutoutEffect.SetCutout(1 - dissolve.Value);
}
if (dissolveArrow.HasValue && __instance.noteData.colorType != ColorType.None)
{
MonoBehaviour disappearingArrowController = noodleData.DisappearingArrowController;
if (disappearingArrowController == null)
{
disappearingArrowController = __instance.gameObject.GetComponent <DisappearingArrowControllerBase <GameNoteController> >();
if (disappearingArrowController == null)
{
disappearingArrowController = __instance.gameObject.GetComponent <DisappearingArrowControllerBase <MultiplayerConnectedPlayerGameNoteController> >();
}
noodleData.DisappearingArrowController = disappearingArrowController;
noodleData.DisappearingArrowMethod = GetSetArrowTransparency(disappearingArrowController.GetType());
}
// gross nasty reflection
noodleData.DisappearingArrowMethod.Invoke(disappearingArrowController, new object[] { dissolveArrow.Value });
}
if (cuttable.HasValue)
{
bool enabled = cuttable.Value >= 1;
switch (__instance)
{
case GameNoteController gameNoteController:
BoxCuttableBySaber[] bigCuttableBySaberList = _gameNoteBigCuttableAccessor(ref gameNoteController);
foreach (BoxCuttableBySaber bigCuttableBySaber in bigCuttableBySaberList)
{
if (bigCuttableBySaber.canBeCut != enabled)
{
bigCuttableBySaber.canBeCut = enabled;
}
}
BoxCuttableBySaber[] smallCuttableBySaberList = _gameNoteSmallCuttableAccessor(ref gameNoteController);
foreach (BoxCuttableBySaber smallCuttableBySaber in smallCuttableBySaberList)
{
if (smallCuttableBySaber.canBeCut != enabled)
{
smallCuttableBySaber.canBeCut = enabled;
}
}
break;
case BombNoteController bombNoteController:
CuttableBySaber boxCuttableBySaber = _bombNoteCuttableAccessor(ref bombNoteController);
if (boxCuttableBySaber.canBeCut != enabled)
{
boxCuttableBySaber.canBeCut = enabled;
}
break;
}
}
}
}
private static void Postfix(NoteController __instance, NoteData noteData, NoteMovement ____noteMovement, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos, float endRotation)
{
NoodleNoteData?noodleData = TryGetObjectData <NoodleNoteData>(noteData);
if (noodleData == null)
{
return;
}
Quaternion?cutQuaternion = noodleData.CutQuaternion;
NoteJump noteJump = _noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = _noteFloorMovementAccessor(ref ____noteMovement);
if (cutQuaternion.HasValue)
{
Quaternion quatVal = cutQuaternion.Value;
_endRotationAccessor(ref noteJump) = quatVal;
Vector3 vector = quatVal.eulerAngles;
vector += _randomRotationsAccessor(ref noteJump)[_randomRotationIdxAccessor(ref noteJump)] * 20;
Quaternion midrotation = Quaternion.Euler(vector);
_middleRotationAccessor(ref noteJump) = midrotation;
}
Quaternion?worldRotationQuaternion = noodleData.WorldRotationQuaternion;
Quaternion?localRotationQuaternion = noodleData.LocalRotationQuaternion;
Transform transform = __instance.transform;
Quaternion localRotation = Quaternion.identity;
if (worldRotationQuaternion.HasValue || localRotationQuaternion.HasValue)
{
if (localRotationQuaternion.HasValue)
{
localRotation = localRotationQuaternion.Value;
}
if (worldRotationQuaternion.HasValue)
{
Quaternion quatVal = worldRotationQuaternion.Value;
Quaternion inverseWorldRotation = Quaternion.Inverse(quatVal);
_worldRotationJumpAccessor(ref noteJump) = quatVal;
_inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
_worldRotationFloorAccessor(ref floorMovement) = quatVal;
_inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
quatVal *= localRotation;
transform.localRotation = quatVal;
}
else
{
transform.localRotation *= localRotation;
}
}
if (transform.localScale != Vector3.one)
{
transform.localScale = Vector3.one; // This is a fix for animation due to notes being recycled
}
IEnumerable <Track>?tracks = noodleData.Track;
if (tracks != null)
{
foreach (Track track in tracks)
{
// add to gameobjects
track.AddGameObject(__instance.gameObject);
}
}
// how f*****g long has _zOffset existed???!??
float zOffset = _zOffsetAccessor(ref ____noteMovement);
moveStartPos.z += zOffset;
moveEndPos.z += zOffset;
jumpEndPos.z += zOffset;
noodleData.EndRotation = endRotation;
noodleData.MoveStartPos = moveStartPos;
noodleData.MoveEndPos = moveEndPos;
noodleData.JumpEndPos = jumpEndPos;
noodleData.WorldRotation = __instance.worldRotation;
noodleData.LocalRotation = localRotation;
}
private static void Prefix(NoteController __instance, NoteData ____noteData, NoteMovement ____noteMovement)
{
NoodleData = TryGetObjectData <NoodleObjectData>(____noteData);
if (NoodleData == null)
{
return;
}
NoodleNoteData noodleData = (NoodleNoteData)NoodleData;
IEnumerable <Track>?tracks = noodleData.Track;
NoodleObjectData.AnimationObjectData?animationObject = noodleData.AnimationObject;
if (tracks != null || animationObject != null)
{
NoteJump noteJump = NoteControllerInit._noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = NoteControllerInit._noteFloorMovementAccessor(ref ____noteMovement);
// idk i just copied base game time
float jumpDuration = _jumpDurationAccessor(ref noteJump);
float elapsedTime = _audioTimeSyncControllerAccessor(ref noteJump).songTime - (____noteData.time - (jumpDuration * 0.5f));
elapsedTime = NoteJumpManualUpdate.NoteJumpTimeAdjust(elapsedTime, jumpDuration);
float normalTime = elapsedTime / jumpDuration;
Animation.AnimationHelper.GetObjectOffset(animationObject, tracks, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?dissolveArrow, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 moveStartPos = noodleData.MoveStartPos;
Vector3 moveEndPos = noodleData.MoveEndPos;
Vector3 jumpEndPos = noodleData.JumpEndPos;
Vector3 offset = positionOffset.Value;
_floorStartPosAccessor(ref floorMovement) = moveStartPos + offset;
_floorEndPosAccessor(ref floorMovement) = moveEndPos + offset;
_jumpStartPosAccessor(ref noteJump) = moveEndPos + offset;
_jumpEndPosAccessor(ref noteJump) = jumpEndPos + offset;
}
Transform transform = __instance.transform;
if (rotationOffset.HasValue || localRotationOffset.HasValue)
{
Quaternion worldRotation = noodleData.WorldRotation;
Quaternion localRotation = noodleData.LocalRotation;
Quaternion worldRotationQuatnerion = worldRotation;
if (rotationOffset.HasValue)
{
worldRotationQuatnerion *= rotationOffset.Value;
Quaternion inverseWorldRotation = Quaternion.Inverse(worldRotationQuatnerion);
NoteControllerInit._worldRotationJumpAccessor(ref noteJump) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
NoteControllerInit._worldRotationFloorAccessor(ref floorMovement) = worldRotationQuatnerion;
NoteControllerInit._inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
if (CutoutManager.NoteCutoutEffects.TryGetValue(__instance, out CutoutEffectWrapper cutoutEffect))
{
cutoutEffect.SetCutout(dissolve.Value);
}
}
if (dissolveArrow.HasValue && __instance.noteData.colorType != ColorType.None)
{
if (CutoutManager.NoteDisappearingArrowWrappers.TryGetValue(__instance, out DisappearingArrowWrapper disappearingArrowWrapper))
{
disappearingArrowWrapper.SetCutout(dissolveArrow.Value);
}
}
if (cuttable.HasValue)
{
bool enabled = cuttable.Value >= 1;
switch (__instance)
{
case GameNoteController gameNoteController:
BoxCuttableBySaber[] bigCuttableBySaberList = _gameNoteBigCuttableAccessor(ref gameNoteController);
foreach (BoxCuttableBySaber bigCuttableBySaber in bigCuttableBySaberList)
{
if (bigCuttableBySaber.canBeCut != enabled)
{
bigCuttableBySaber.canBeCut = enabled;
}
}
BoxCuttableBySaber[] smallCuttableBySaberList = _gameNoteSmallCuttableAccessor(ref gameNoteController);
foreach (BoxCuttableBySaber smallCuttableBySaber in smallCuttableBySaberList)
{
if (smallCuttableBySaber.canBeCut != enabled)
{
smallCuttableBySaber.canBeCut = enabled;
}
}
break;
case BombNoteController bombNoteController:
CuttableBySaber boxCuttableBySaber = _bombNoteCuttableAccessor(ref bombNoteController);
if (boxCuttableBySaber.canBeCut != enabled)
{
boxCuttableBySaber.canBeCut = enabled;
}
break;
}
}
}
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Postfix(NoteController __instance, NoteData noteData, NoteMovement ____noteMovement, Vector3 moveStartPos, Vector3 moveEndPos, Vector3 jumpEndPos)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
if (noteData is CustomNoteData customData)
{
dynamic dynData = customData.customData;
float?cutDir = (float?)Trees.at(dynData, CUTDIRECTION);
NoteJump noteJump = _noteJumpAccessor(ref ____noteMovement);
NoteFloorMovement floorMovement = _noteFloorMovementAccessor(ref ____noteMovement);
if (cutDir.HasValue)
{
Quaternion cutQuaternion = Quaternion.Euler(0, 0, cutDir.Value);
_endRotationAccessor(ref noteJump) = cutQuaternion;
Vector3 vector = cutQuaternion.eulerAngles;
vector += _randomRotationsAccessor(ref noteJump)[_randomRotationIdxAccessor(ref noteJump)] * 20;
Quaternion midrotation = Quaternion.Euler(vector);
_middleRotationAccessor(ref noteJump) = midrotation;
}
dynamic rotation = Trees.at(dynData, ROTATION);
IEnumerable <float> localrot = ((List <object>)Trees.at(dynData, LOCALROTATION))?.Select(n => Convert.ToSingle(n));
Transform transform = __instance.transform;
Quaternion localRotation = _quaternionIdentity;
if (rotation != null || localRotation != null)
{
if (localrot != null)
{
localRotation = Quaternion.Euler(localrot.ElementAt(0), localrot.ElementAt(1), localrot.ElementAt(2));
}
Quaternion worldRotationQuatnerion;
if (rotation != null)
{
if (rotation is List <object> list)
{
IEnumerable <float> rot = list?.Select(n => Convert.ToSingle(n));
worldRotationQuatnerion = Quaternion.Euler(rot.ElementAt(0), rot.ElementAt(1), rot.ElementAt(2));
}
else
{
worldRotationQuatnerion = Quaternion.Euler(0, (float)rotation, 0);
}
Quaternion inverseWorldRotation = Quaternion.Euler(-worldRotationQuatnerion.eulerAngles);
_worldRotationJumpAccessor(ref noteJump) = worldRotationQuatnerion;
_inverseWorldRotationJumpAccessor(ref noteJump) = inverseWorldRotation;
_worldRotationFloorAccessor(ref floorMovement) = worldRotationQuatnerion;
_inverseWorldRotationFloorAccessor(ref floorMovement) = inverseWorldRotation;
worldRotationQuatnerion *= localRotation;
transform.localRotation = worldRotationQuatnerion;
}
else
{
transform.localRotation *= localRotation;
}
}
transform.localScale = Vector3.one; // This is a fix for animation due to notes being recycled
Track track = AnimationHelper.GetTrack(dynData);
if (track != null && ParentObject.Controller != null)
{
ParentObject parentObject = ParentObject.Controller.GetParentObjectTrack(track);
if (parentObject != null)
{
parentObject.ParentToObject(transform);
}
else
{
ParentObject.ResetTransformParent(transform);
}
}
else
{
ParentObject.ResetTransformParent(transform);
}
dynData.moveStartPos = moveStartPos;
dynData.moveEndPos = moveEndPos;
dynData.jumpEndPos = jumpEndPos;
dynData.worldRotation = __instance.worldRotation;
dynData.localRotation = localRotation;
}
if (__instance is GameNoteController)
{
_gameNoteControllerUpdate.Invoke(__instance, null);
}
else
{
_noteControllerUpdate.Invoke(__instance, null);
}
}
public GameObject GetPooledRedNote(bool isAny = false)
{
if (!isAny)
{
for (int i = 0; i < PooledRedNotes.Count; i++)
{
if (!PooledRedNotes[i].activeInHierarchy)
{
Component[] objs = PooledRedNotes[i].GetComponents(typeof(Component));
foreach (Component comp in objs)
{
if (comp.GetType() == typeof(NoteJump))
{
NoteJump test = comp as NoteJump;
Destroy(test);
}
}
Transform[] ts = PooledRedNotes[i].transform.GetComponentsInChildren <Transform>(true);
foreach (Transform t in ts)
{
if (t.gameObject.name == "Box")
{
t.gameObject.transform.localRotation = Quaternion.identity;
}
}
PooledRedNotes[i].transform.localRotation = Quaternion.identity;
return(PooledRedNotes[i]);
}
}
GameObject newRed = Instantiate(redPrefab, mainManager.gameManager.NotesParent.transform);
newRed.SetActive(false);
PooledRedNotes.Add(newRed);
return(newRed);
}
else
{
for (int i = 0; i < PooledAnyRedNotes.Count; i++)
{
if (!PooledAnyRedNotes[i].activeInHierarchy)
{
Component[] objs = PooledAnyRedNotes[i].GetComponents(typeof(Component));
foreach (Component comp in objs)
{
if (comp.GetType() == typeof(NoteJump))
{
NoteJump test = comp as NoteJump;
Destroy(test);
}
}
Transform[] ts = PooledAnyRedNotes[i].transform.GetComponentsInChildren <Transform>(true);
foreach (Transform t in ts)
{
if (t.gameObject.name == "Box")
{
t.gameObject.transform.localRotation = Quaternion.identity;
}
}
PooledAnyRedNotes[i].transform.localRotation = Quaternion.identity;
return(PooledAnyRedNotes[i]);
}
}
GameObject newRed = Instantiate(redAnyPrefab, mainManager.gameManager.NotesParent.transform);
newRed.SetActive(false);
PooledAnyRedNotes.Add(newRed);
return(newRed);
}
}
