private static void Postfix(Transform ____rotatedObject)
{
NoodleNoteData noodleData = (NoodleNoteData)NoteControllerUpdate.NoodleData;
if (noodleData != null && noodleData.DisableLook)
{
____rotatedObject.localRotation = Quaternion.Euler(0, 0, noodleData.EndRotation);
}
}
internal static bool GetCuttable(NoteData noteData)
{
NoodleNoteData noodleData = (NoodleNoteData)NoodleObjectDatas[noteData];
bool? cuttable = noodleData.Cuttable;
if (cuttable.HasValue && !cuttable.Value)
{
return(false);
}
return(true);
}
internal static bool GetFakeNote(NoteController noteController)
{
NoodleNoteData noodleData = (NoodleNoteData)NoodleObjectDatas[noteController.noteData];
bool? fake = noodleData.Fake;
if (fake.HasValue && fake.Value)
{
return(false);
}
return(true);
}
// Performs all note look rotation from world space
// Never want to touch this again....
private static void DoNoteLook(
float num2,
Quaternion startRotation,
Quaternion middleRotation,
Quaternion endRotation,
PlayerTransforms playerTransforms,
Transform rotatedObject,
Transform baseTransform,
Quaternion inverseWorldRotation)
{
NoodleNoteData noodleData = (NoodleNoteData)NoteControllerUpdate.NoodleData;
if (noodleData != null && noodleData.DisableLook)
{
rotatedObject.localRotation = endRotation;
return;
}
Quaternion a;
if (num2 < 0.125f)
{
a = Quaternion.Slerp(baseTransform.rotation * startRotation, baseTransform.rotation * middleRotation, Mathf.Sin(num2 * Mathf.PI * 4f));
}
else
{
a = Quaternion.Slerp(baseTransform.rotation * middleRotation, baseTransform.rotation * endRotation, Mathf.Sin((num2 - 0.125f) * Mathf.PI * 2f));
}
Vector3 vector = playerTransforms.headWorldPos;
// idk whats happening anymore
Quaternion worldRot = inverseWorldRotation;
if (baseTransform.parent != null)
{
// Handle parenting
worldRot *= Quaternion.Inverse(baseTransform.parent.rotation);
}
// This line but super complicated so that "y" = "originTransform.up"
// vector.y = Mathf.Lerp(vector.y, this._localPosition.y, 0.8f);
Transform headTransform = _headTransformAccessor(ref playerTransforms);
Quaternion inverse = Quaternion.Inverse(worldRot);
Vector3 upVector = inverse * Vector3.up;
float baseUpMagnitude = Vector3.Dot(worldRot * baseTransform.position, Vector3.up);
float headUpMagnitude = Vector3.Dot(worldRot * headTransform.position, Vector3.up);
float mult = Mathf.Lerp(headUpMagnitude, baseUpMagnitude, 0.8f) - headUpMagnitude;
vector += upVector * mult;
// more wtf
Vector3 normalized = baseTransform.rotation * (worldRot * (baseTransform.position - vector).normalized);
Quaternion b = Quaternion.LookRotation(normalized, rotatedObject.up);
rotatedObject.rotation = Quaternion.Lerp(a, b, num2 * 2f);
}
private static float GetFlipYSide(NoteData noteData, float @default)
{
float output = @default;
if (NoodleObjectDatas.TryGetValue(noteData, out NoodleObjectData noodleObjectData))
{
NoodleNoteData noodleData = (NoodleNoteData)noodleObjectData;
float? flipYSide = noodleData.FlipYSideInternal;
if (flipYSide.HasValue)
{
output = flipYSide.Value;
}
}
return(output);
}
private static void Postfix(BeatmapObjectSpawnMovementData __instance, Vector3 ____centerPos, float ____jumpDuration, NoteData noteData, ref BeatmapObjectSpawnMovementData.NoteSpawnData __result)
{
if (!NoodleObjectDatas.TryGetValue(noteData, out NoodleObjectData noodleObjectData))
{
return;
}
NoodleNoteData noodleData = (NoodleNoteData)noodleObjectData;
float?flipLineIndex = noodleData.FlipLineIndexInternal;
float?njs = noodleData.NJS;
float?spawnoffset = noodleData.SpawnOffset;
float?startlinelayer = noodleData.StartNoteLineLayerInternal;
bool gravityOverride = noodleData.DisableGravity;
float?startRow = noodleData.StartX;
float?startHeight = noodleData.StartY;
float jumpDuration = ____jumpDuration;
////Vector3 moveStartPos = __result.moveStartPos;
////Vector3 moveEndPos = __result.moveEndPos;
////Vector3 jumpEndPos = __result.jumpEndPos;
float jumpGravity = __result.jumpGravity;
Vector3 noteOffset = GetNoteOffset(noteData, startRow, startlinelayer ?? (float)noteData.startNoteLineLayer);
if (startRow.HasValue || startHeight.HasValue || flipLineIndex.HasValue || njs.HasValue || spawnoffset.HasValue || startlinelayer.HasValue || gravityOverride)
{
GetNoteJumpValues(njs, spawnoffset, out float localJumpDuration, out float localJumpDistance, out Vector3 localMoveStartPos, out Vector3 localMoveEndPos, out Vector3 localJumpEndPos);
jumpDuration = localJumpDuration;
float localNoteJumpMovementSpeed = njs ?? NoteJumpMovementSpeed;
float startLayerLineYPos = LineYPosForLineLayer(noteData, startlinelayer ?? (float)noteData.startNoteLineLayer);
float lineYPos = LineYPosForLineLayer(noteData, startHeight);
// Magic numbers below found with linear regression y=mx+b using existing HighestJumpPosYForLineLayer values
float highestJump = startHeight.HasValue ? (0.875f * lineYPos) + 0.639583f + JumpOffsetY :
__instance.HighestJumpPosYForLineLayer(noteData.noteLineLayer);
jumpGravity = 2f * (highestJump - (gravityOverride ? lineYPos : startLayerLineYPos)) /
Mathf.Pow(localJumpDistance / localNoteJumpMovementSpeed * 0.5f, 2f);
Vector3 jumpEndPos = localJumpEndPos + noteOffset;
// IsBasicNote() check is skipped so bombs can flip too
Vector3 noteOffset2 = GetNoteOffset(noteData, flipLineIndex ?? startRow, gravityOverride ? startHeight : startlinelayer ?? (float)noteData.startNoteLineLayer);
Vector3 moveStartPos = localMoveStartPos + noteOffset2;
Vector3 moveEndPos = localMoveEndPos + noteOffset2;
__result = new BeatmapObjectSpawnMovementData.NoteSpawnData(moveStartPos, moveEndPos, jumpEndPos, jumpGravity, __result.moveDuration, jumpDuration);
}
// DEFINITE POSITION IS WEIRD, OK?
// ty reaxt
float startVerticalVelocity = jumpGravity * jumpDuration * 0.5f;
float num = jumpDuration * 0.5f;
float yOffset = (startVerticalVelocity * num) - (jumpGravity * num * num * 0.5f);
noodleData.NoteOffset = ____centerPos + noteOffset + new Vector3(0, yOffset, 0);
}
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 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;
}
}
}
}
