private static void Postfix(Vector3 ____centerPos, ObstacleData obstacleData, ref BeatmapObjectSpawnMovementData.ObstacleSpawnData __result)
{
if (!NoodleObjectDatas.TryGetValue(obstacleData, out NoodleObjectData noodleObjectData))
{
return;
}
NoodleObstacleData noodleData = (NoodleObstacleData)noodleObjectData;
float?njs = noodleData.NJS;
float?spawnoffset = noodleData.SpawnOffset;
float?startX = noodleData.StartX;
float?startY = noodleData.StartY;
float?height = noodleData.Height;
Vector3?finalNoteOffset = null;
Vector3 moveStartPos = __result.moveStartPos;
Vector3 moveEndPos = __result.moveEndPos;
Vector3 jumpEndPos = __result.jumpEndPos;
float obstacleHeight = __result.obstacleHeight;
GetNoteJumpValues(njs, spawnoffset, out float jumpDuration, out float _, out Vector3 localMoveStartPos, out Vector3 localMoveEndPos, out Vector3 localJumpEndPos);
// Actual wall stuff
if (startX.HasValue || startY.HasValue || njs.HasValue || spawnoffset.HasValue)
{
// Ripped from base game
Vector3 noteOffset = GetNoteOffset(obstacleData, startX, null);
noteOffset.y = startY.HasValue ? VerticalObstaclePosY + (startY.GetValueOrDefault(0) * NoteLinesDistance) : ((obstacleData.obstacleType == ObstacleType.Top)
? (TopObstaclePosY + JumpOffsetY) : VerticalObstaclePosY);
finalNoteOffset = noteOffset;
moveStartPos = localMoveStartPos + noteOffset;
moveEndPos = localMoveEndPos + noteOffset;
jumpEndPos = localJumpEndPos + noteOffset;
}
if (height.HasValue)
{
obstacleHeight = height.Value * NoteLinesDistance;
}
__result = new BeatmapObjectSpawnMovementData.ObstacleSpawnData(moveStartPos, moveEndPos, jumpEndPos, obstacleHeight, __result.moveDuration, jumpDuration, __result.noteLinesDistance);
if (!finalNoteOffset.HasValue)
{
Vector3 noteOffset = GetNoteOffset(obstacleData, startX, null);
noteOffset.y = (obstacleData.obstacleType == ObstacleType.Top) ? (TopObstaclePosY + JumpOffsetY) : VerticalObstaclePosY;
finalNoteOffset = noteOffset;
}
noodleData.NoteOffset = ____centerPos + finalNoteOffset.Value;
float?width = noodleData.Width;
noodleData.XOffset = ((width.GetValueOrDefault(obstacleData.lineIndex) / 2f) - 0.5f) * NoteLinesDistance;
}
private static float GetCustomLength(float @default, ObstacleData obstacleData)
{
if (NoodleObjectDatas.TryGetValue(obstacleData, out NoodleObjectData noodleObjectData))
{
NoodleObstacleData noodleData = (NoodleObstacleData)noodleObjectData;
float?length = noodleData.Length;
if (length.HasValue)
{
return(length.Value * NoteLinesDistance);
}
}
return(@default);
}
private static float GetCustomWidth(float @default, ObstacleData obstacleData)
{
if (NoodleObjectDatas.TryGetValue(obstacleData, out NoodleObjectData noodleObjectData))
{
NoodleObstacleData noodleData = (NoodleObstacleData)noodleObjectData;
float?width = noodleData.Width;
if (width.HasValue)
{
return(width.Value);
}
}
return(@default);
}
private static List <ObstacleController> ObstacleFakeCheck(List <ObstacleController> intersectingObstacles)
{
return(intersectingObstacles.Where(n =>
{
if (!(n is MultiplayerConnectedPlayerObstacleController))
{
NoodleObstacleData noodleData = (NoodleObstacleData)NoodleObjectDatas[n.obstacleData];
bool?fake = noodleData.Fake;
if (fake.HasValue && fake.Value)
{
return false;
}
}
return true;
}).ToList());
}
private static Quaternion GetWorldRotation(ObstacleData obstacleData, float @default)
{
Quaternion worldRotation = Quaternion.Euler(0, @default, 0);
if (NoodleObjectDatas.TryGetValue(obstacleData, out NoodleObjectData noodleObjectData))
{
NoodleObstacleData noodleData = (NoodleObstacleData)noodleObjectData;
Quaternion?worldRotationQuaternion = noodleData.WorldRotationQuaternion;
if (worldRotationQuaternion.HasValue)
{
worldRotation = worldRotationQuaternion.Value;
}
noodleData.WorldRotation = worldRotation;
}
return(worldRotation);
}
private static bool Prefix(
ref Vector3 __result,
ObstacleData ____obstacleData,
Vector3 ____startPos,
Vector3 ____midPos,
float ____move1Duration,
float ____move2Duration,
float ____obstacleDuration,
float time)
{
if (!NoodleObjectDatas.TryGetValue(____obstacleData, out NoodleObjectData noodleObjectData))
{
return(true);
}
NoodleObstacleData noodleData = (NoodleObstacleData)noodleObjectData;
float jumpTime = Mathf.Clamp((time - ____move1Duration) / (____move2Duration + ____obstacleDuration), 0, 1);
AnimationHelper.GetDefinitePositionOffset(noodleData.AnimationObject, noodleData.Track, jumpTime, out Vector3? position);
if (position.HasValue)
{
Vector3 noteOffset = noodleData.NoteOffset;
Vector3 definitePosition = position.Value + noteOffset;
definitePosition.x += noodleData.XOffset;
if (time < ____move1Duration)
{
__result = Vector3.LerpUnclamped(____startPos, ____midPos, time / ____move1Duration);
__result += definitePosition - ____midPos;
}
else
{
__result = definitePosition;
}
return(false);
}
return(true);
}
internal static void AssignTrack(IEnumerable <Track> tracks, Track parentTrack, Vector3?startPos, Quaternion?startRot, Quaternion?startLocalRot, Vector3?startScale)
{
if (Controller == null)
{
GameObject gameObject = new GameObject("ParentController");
Controller = gameObject.AddComponent <ParentController>();
}
GameObject parentGameObject = new GameObject("ParentObject");
ParentObject instance = parentGameObject.AddComponent <ParentObject>();
instance._origin = parentGameObject.transform;
instance._track = parentTrack;
Transform transform = instance.transform;
if (startPos.HasValue)
{
instance._startPos = startPos.Value;
transform.localPosition = instance._startPos * NoteLinesDistance;
}
if (startRot.HasValue)
{
instance._startRot = startRot.Value;
instance._startLocalRot = instance._startRot;
transform.localPosition = instance._startRot * transform.localPosition;
transform.localRotation = instance._startRot;
}
if (startLocalRot.HasValue)
{
instance._startLocalRot = instance._startRot * startLocalRot.Value;
transform.localRotation *= instance._startLocalRot;
}
if (startScale.HasValue)
{
instance._startScale = startScale.Value;
transform.localScale = instance._startScale;
}
foreach (ParentObject parentObject in Controller.ParentObjects)
{
if (parentObject.ChildrenTracks.Contains(parentTrack))
{
parentObject.ParentToObject(transform);
}
else
{
ResetTransformParent(transform);
}
}
foreach (Track track in tracks)
{
foreach (ParentObject parentObject in Controller.ParentObjects)
{
parentObject.ChildrenTracks.Remove(track);
if (parentObject._track == track)
{
instance.ParentToObject(parentObject.transform);
}
}
foreach (ObstacleController obstacleController in ObstaclePool.activeItems)
{
if (obstacleController?.obstacleData != null)
{
NoodleObstacleData noodleData = (NoodleObstacleData)NoodleObjectDatas[obstacleController.obstacleData];
Track obstacleTrack = noodleData.Track;
if (obstacleTrack == track)
{
instance.ParentToObject(obstacleController.transform);
}
}
}
instance.ChildrenTracks.Add(track);
}
Controller.ParentObjects.Add(instance);
}
private static void Postfix(ObstacleController __instance, Quaternion ____worldRotation, ObstacleData obstacleData, Vector3 ____startPos, Vector3 ____midPos, Vector3 ____endPos, ref Bounds ____bounds)
{
if (__instance is MultiplayerConnectedPlayerObstacleController)
{
return;
}
NoodleObstacleData noodleData = (NoodleObstacleData)NoodleObjectDatas[obstacleData];
Quaternion?localRotationQuaternion = noodleData.LocalRotationQuaternion;
Transform transform = __instance.transform;
Quaternion localRotation = _quaternionIdentity;
if (localRotationQuaternion.HasValue)
{
localRotation = localRotationQuaternion.Value;
transform.localRotation = ____worldRotation * localRotation;
}
if (transform.localScale != Vector3.one)
{
transform.localScale = Vector3.one; // This is a fix for animation due to obstacles 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);
}
bool?cuttable = noodleData.Cuttable;
if (cuttable.HasValue && !cuttable.Value)
{
____bounds.size = _vectorZero;
}
else
{
_activeObstacles.Add(__instance);
}
noodleData.StartPos = ____startPos;
noodleData.MidPos = ____midPos;
noodleData.EndPos = ____endPos;
noodleData.LocalRotation = localRotation;
noodleData.BoundsSize = ____bounds.size;
}
private static void Prefix(
ObstacleController __instance,
ObstacleData ____obstacleData,
AudioTimeSyncController ____audioTimeSyncController,
float ____startTimeOffset,
ref Vector3 ____startPos,
ref Vector3 ____midPos,
ref Vector3 ____endPos,
float ____move1Duration,
float ____move2Duration,
float ____obstacleDuration,
ref Quaternion ____worldRotation,
ref Quaternion ____inverseWorldRotation,
ref Bounds ____bounds)
{
if (__instance is MultiplayerConnectedPlayerObstacleController)
{
return;
}
NoodleObstacleData noodleData = (NoodleObstacleData)NoodleObjectDatas[____obstacleData];
Track track = noodleData.Track;
NoodleObjectData.AnimationObjectData animationObject = noodleData.AnimationObject;
if (track != null || animationObject != null)
{
// idk i just copied base game time
float elapsedTime = ____audioTimeSyncController.songTime - ____startTimeOffset;
float normalTime = (elapsedTime - ____move1Duration) / (____move2Duration + ____obstacleDuration);
AnimationHelper.GetObjectOffset(animationObject, track, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?_, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 startPos = noodleData.StartPos;
Vector3 midPos = noodleData.MidPos;
Vector3 endPos = noodleData.EndPos;
Vector3 offset = positionOffset.Value;
____startPos = startPos + offset;
____midPos = midPos + offset;
____endPos = endPos + 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);
____worldRotation = worldRotationQuatnerion;
____inverseWorldRotation = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
bool cuttableEnabled = true;
if (cuttable.HasValue)
{
cuttableEnabled = cuttable.Value >= 1;
if (cuttableEnabled)
{
if (____bounds.size != _vectorZero)
{
____bounds.size = _vectorZero;
}
}
else
{
Vector3 boundsSize = noodleData.BoundsSize;
if (____bounds.size != boundsSize)
{
____bounds.size = boundsSize;
}
}
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
CutoutAnimateEffect cutoutAnimateEffect = noodleData.CutoutAnimateEffect;
if (cutoutAnimateEffect == null)
{
ObstacleDissolve obstacleDissolve = __instance.gameObject.GetComponent <ObstacleDissolve>();
cutoutAnimateEffect = _obstacleCutoutAnimateEffectAccessor(ref obstacleDissolve);
noodleData.CutoutAnimateEffect = cutoutAnimateEffect;
}
cutoutAnimateEffect.SetCutout(1 - dissolve.Value);
}
}
if (noodleData.DoUnhide)
{
__instance.hide = false;
}
}
