添加对 Core 的直接引用

RhythmBaseCore/Adofai/Events/ADAddDecoration.cs

@@ -0,0 +1,122 @@
+using System;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADAddDecoration : ADBaseTileEvent
+	{
+		public ADAddDecoration()
+		{
+			Type = ADEventType.AddDecoration;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string DecorationImage { get; set; }
+
+		public RDPointN Position { get; set; }
+
+		public ADDecorationRelativeTo RelativeTo { get; set; }
+
+		public RDSizeN PivotOffset { get; set; }
+
+		public float Rotation { get; set; }
+
+		public bool LockRotation { get; set; }
+
+		public RDSizeN Scale { get; set; }
+
+		public bool LockScale { get; set; }
+
+		public RDSizeN Tile { get; set; }
+
+		public RDColor Color { get; set; }
+
+		public float Opacity { get; set; }
+
+		public int Depth { get; set; }
+
+		public RDSizeN Parallax { get; set; }
+
+		public RDSizeN ParallaxOffset { get; set; }
+
+		public string Tag { get; set; }
+
+		public bool ImageSmoothing { get; set; }
+
+		public BlendModes BlendMode { get; set; }
+
+		public MaskingTypes MaskingType { get; set; }
+
+		public bool UseMaskingDepth { get; set; }
+
+		public int MaskingFrontDepth { get; set; }
+
+		public int MaskingBackDepth { get; set; }
+
+		public HitboxTypes Hitbox { get; set; }
+
+		public string HitboxEventTag { get; set; }
+
+		public FailHitboxTypes FailHitboxType { get; set; }
+
+		public RDSizeN FailHitboxScale { get; set; }
+
+		public RDSizeN FailHitboxOffset { get; set; }
+
+		public int FailHitboxRotation { get; set; }
+
+		public string Components { get; set; }
+
+		public enum BlendModes
+		{
+			None,
+			Darken,
+			Multiply,
+			ColorBurn,
+			LinearBurn,
+			DarkerColor,
+			Lighten,
+			Screen,
+			ColorDodge,
+			LinearDodge,
+			LighterColor,
+			Overlay,
+			SoftLight,
+			HardLight,
+			VividLight,
+			LinearLight,
+			PinLight,
+			HardMix,
+			Difference,
+			Exclusion,
+			Subtract,
+			Divide,
+			Hue,
+			Saturation,
+			Color,
+			Luminosity
+		}
+
+		public enum MaskingTypes
+		{
+			None,
+			Mask,
+			VisibleInsideMask,
+			VisibleOutsideMask
+		}
+
+		public enum HitboxTypes
+		{
+			None,
+			Kill,
+			Event
+		}
+
+		public enum FailHitboxTypes
+		{
+			Box,
+			Circle,
+			Capsule
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADAddObject.cs

@@ -0,0 +1,95 @@
+using System;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADAddObject : ADBaseEvent
+	{
+		public ADAddObject()
+		{
+			Type = ADEventType.AddObject;
+		}
+
+		public override ADEventType Type { get; }
+
+		public ObjectTypes ObjectType { get; set; }
+
+		public PlanetColorTypes PlanetColorType { get; set; }
+
+		public RDColor PlanetColor { get; set; }
+
+		public RDColor PlanetTailColor { get; set; }
+
+		public TrackTypes TrackType { get; set; }
+
+		public float TrackAngle { get; set; }
+
+		public ADTrackColorTypes TrackColorType { get; set; }
+
+		public RDColor TrackColor { get; set; }
+
+		public RDColor SecondaryTrackColor { get; set; }
+
+		public float TrackColorAnimDuration { get; set; }
+
+		public float TrackOpacity { get; set; }
+
+		public ADTrackStyles TrackStyle { get; set; }
+
+		public string TrackIcon { get; set; }
+
+		public float TrackIconAngle { get; set; }
+
+		public bool TrackRedSwirl { get; set; }
+
+		public bool TrackGraySetSpeedIcon { get; set; }
+
+		public float TrackSetSpeedIconBpm { get; set; }
+
+		public bool TrackGlowEnabled { get; set; }
+
+		public RDColor TrackGlowColor { get; set; }
+
+		public RDPointN Position { get; set; }
+
+		public ADCameraRelativeTo RelativeTo { get; set; }
+
+		public RDSizeN PivotOffset { get; set; }
+
+		public float Rotation { get; set; }
+
+		public bool LockRotation { get; set; }
+
+		public RDSizeN Scale { get; set; }
+
+		public bool LockScale { get; set; }
+
+		public int Depth { get; set; }
+
+		public RDSizeN Parallax { get; set; }
+
+		public RDSizeN ParallaxOffset { get; set; }
+
+		public string Tag { get; set; }
+
+		public enum ObjectTypes
+		{
+			Floor,
+			Planet
+		}
+
+		public enum PlanetColorTypes
+		{
+			DefaultRed,
+			planetColorType,
+			Gold,
+			Overseer,
+			Custom
+		}
+
+		public enum TrackTypes
+		{
+			Normal,
+			Midspin
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADAddText.cs

@@ -0,0 +1,44 @@
+using System;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADAddText : ADBaseEvent
+	{
+		public ADAddText()
+		{
+			Type = ADEventType.AddText;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string DecText { get; set; }
+
+		public string Font { get; set; }
+
+		public RDPointN Position { get; set; }
+
+		public ADCameraRelativeTo RelativeTo { get; set; }
+
+		public RDSizeN PivotOffset { get; set; }
+
+		public float Rotation { get; set; }
+
+		public bool LockRotation { get; set; }
+
+		public RDSizeN Scale { get; set; }
+
+		public bool LockScale { get; set; }
+
+		public RDColor Color { get; set; }
+
+		public float Opacity { get; set; }
+
+		public int Depth { get; set; }
+
+		public RDSizeN Parallax { get; set; }
+
+		public RDSizeN ParallaxOffset { get; set; }
+
+		public string Tag { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADAnimateTrack.cs

@@ -0,0 +1,47 @@
+using System;
+using Newtonsoft.Json;
+namespace RhythmBase.Adofai.Events
+{
+	[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+	public class ADAnimateTrack : ADBaseTileEvent
+	{
+		public ADAnimateTrack()
+		{
+			Type = ADEventType.AnimateTrack;
+		}
+
+		public override ADEventType Type { get; }
+
+		public TrackAnimations? TrackAnimation { get; set; }
+
+		public TrackDisappearAnimations? TrackDisappearAnimation { get; set; }
+
+		public int BeatsAhead { get; set; }
+
+		public int BeatsBehind { get; set; }
+
+		public enum TrackAnimations
+		{
+			None,
+			Assemble,
+			Assemble_Far,
+			Extend,
+			Grow,
+			Grow_Spin,
+			Fade,
+			Drop,
+			Rise
+		}
+
+		public enum TrackDisappearAnimations
+		{
+			None,
+			Scatter,
+			Scatter_Far,
+			Retract,
+			Shrink,
+			Shrink_Spin,
+			Fade
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADAutoPlayTiles.cs

@@ -0,0 +1,19 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADAutoPlayTiles : ADBaseTileEvent
+	{
+		public ADAutoPlayTiles()
+		{
+			Type = ADEventType.AutoPlayTiles;
+		}
+
+		public override ADEventType Type { get; }
+
+		public bool Enabled { get; set; }
+
+		public bool ShowStatusText { get; set; }
+
+		public bool SafetyTiles { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADBaseEvent.cs

@@ -0,0 +1,10 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public abstract class ADBaseEvent
+	{
+		public abstract ADEventType Type { get; }
+
+		public override string ToString() => Type.ToString();
+	}
+}

RhythmBaseCore/Adofai/Events/ADBaseTaggedTileAction.cs

@@ -0,0 +1,10 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public abstract class ADBaseTaggedTileAction : ADBaseTileEvent
+	{
+		public float AngleOffset { get; set; }
+
+		public string EventTag { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADBaseTileEvent.cs

@@ -0,0 +1,12 @@
+using System;
+using Newtonsoft.Json;
+namespace RhythmBase.Adofai.Events
+{
+	public abstract class ADBaseTileEvent : ADBaseEvent
+	{
+		[JsonIgnore]
+		public ADTile Parent { get; set; }
+
+		public override string ToString() => string.Format("{0}", Type);
+	}
+}

RhythmBaseCore/Adofai/Events/ADBloom.cs

@@ -0,0 +1,28 @@
+using System;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADBloom : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADBloom()
+		{
+			Type = ADEventType.Bloom;
+		}
+
+		public override ADEventType Type { get; }
+
+		public bool Enabled { get; set; }
+
+		public int Threshold { get; set; }
+
+		public int Intensity { get; set; }
+
+		public RDColor Color { get; set; }
+
+		public float Duration { get; set; }
+
+		public EaseType Ease { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADBookmark.cs

@@ -0,0 +1,13 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADBookmark : ADBaseTileEvent
+	{
+		public ADBookmark()
+		{
+			Type = ADEventType.Bookmark;
+		}
+
+		public override ADEventType Type { get; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADCameraRelativeTo.cs

@@ -0,0 +1,12 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADCameraRelativeTo
+	{
+		Player,
+		Tile,
+		Global,
+		LastPosition,
+		LastPositionNoRotation
+	}
+}

RhythmBaseCore/Adofai/Events/ADCheckpoint.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADCheckpoint : ADBaseTileEvent
+	{
+		public ADCheckpoint()
+		{
+			Type = ADEventType.Checkpoint;
+		}
+
+		public override ADEventType Type { get; }
+
+		public int TileOffset { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADColorTrack.cs

@@ -0,0 +1,34 @@
+using RhythmBase.Components;
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADColorTrack : ADBaseTileEvent
+	{
+		public ADColorTrack()
+		{
+			Type = ADEventType.ColorTrack;
+		}
+
+		public override ADEventType Type { get; }
+
+		public ADTrackColorTypes TrackColorType { get; set; }
+
+		public RDColor TrackColor { get; set; }
+
+		public RDColor SecondaryTrackColor { get; set; }
+
+		public float TrackColorAnimDuration { get; set; }
+
+		public ADTrackColorPulses TrackColorPulse { get; set; }
+
+		public float TrackPulseLength { get; set; }
+
+		public ADTrackStyles TrackStyle { get; set; }
+
+		public string TrackTexture { get; set; }
+
+		public float TrackTextureScale { get; set; }
+
+		public float TrackGlowIntensity { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADCustomBackground.cs

@@ -0,0 +1,39 @@
+using System;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADCustomBackground : ADBaseTaggedTileAction
+	{
+		public ADCustomBackground()
+		{
+			Type = ADEventType.CustomBackground;
+		}
+
+		public override ADEventType Type { get; }
+
+		public RDColor Color { get; set; }
+
+		public string BgImage { get; set; }
+
+		public RDColor ImageColor { get; set; }
+
+		public RDPoint Parallax { get; set; }
+
+		public BgDisplayModes BgDisplayMode { get; set; }
+
+		public bool ImageSmoothing { get; set; }
+
+		public bool LockRot { get; set; }
+
+		public bool LoopBG { get; set; }
+
+		public float ScalingRatio { get; set; }
+
+		public enum BgDisplayModes
+		{
+			FitToScreen,
+			Unscaled,
+			Tiled
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADCustomEvent.cs

@@ -0,0 +1,28 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADCustomEvent : ADBaseEvent
+	{
+		public ADCustomEvent()
+		{
+			Type = ADEventType.CustomEvent;
+		}
+
+		public override ADEventType Type { get; }
+
+		[JsonIgnore]
+		public string ActureType
+		{
+			get
+			{
+				return Data["eventType"].ToString();
+			}
+		}
+
+		public JObject Data { get; set; }
+
+		public override string ToString() => ActureType;
+	}
+}

RhythmBaseCore/Adofai/Events/ADCustomTileEvent.cs

@@ -0,0 +1,28 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADCustomTileEvent : ADBaseTileEvent
+	{
+		public ADCustomTileEvent()
+		{
+			Type = ADEventType.CustomTileEvent;
+		}
+
+		public override ADEventType Type { get; }
+
+		[JsonIgnore]
+		public string ActureType
+		{
+			get
+			{
+				return Data["eventType"].ToString();
+			}
+		}
+
+		public JObject Data { get; set; }
+
+		public override string ToString() => string.Format("{0}({1}): {2}", Parent.Index, Parent.Angle, ActureType);
+	}
+}

RhythmBaseCore/Adofai/Events/ADDecorationRelativeTo.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADDecorationRelativeTo
+	{
+		Tile,
+		Global,
+		RedPlanet,
+		BluePlanet,
+		GreenPlanet,
+		Camera,
+		CameraAspect,
+		LastPosition
+	}
+}

RhythmBaseCore/Adofai/Events/ADEasePartBehaviors.cs

@@ -0,0 +1,9 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADEasePartBehaviors
+	{
+		Repeat,
+		Mirror
+	}
+}

RhythmBaseCore/Adofai/Events/ADEditorComment.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADEditorComment : ADBaseTileEvent
+	{
+		public ADEditorComment()
+		{
+			Type = ADEventType.EditorComment;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string Comment { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADEventType.cs

@@ -0,0 +1,52 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADEventType
+	{
+		AddDecoration,
+		AddObject,
+		AddText,
+		AnimateTrack,
+		AutoPlayTiles,
+		Bloom,
+		Bookmark,
+		Checkpoint,
+		ColorTrack,
+		CustomBackground,
+		CustomEvent,
+		CustomTileEvent,
+		EditorComment,
+		Flash,
+		FreeRoam,
+		FreeRoamRemove,
+		FreeRoamTwirl,
+		HallOfMirrors,
+		Hide,
+		Hold,
+		MoveCamera,
+		MoveDecorations,
+		MoveTrack,
+		MultiPlanet,
+		Pause,
+		PlaySound,
+		PositionTrack,
+		RecolorTrack,
+		RepeatEvents,
+		ScaleMargin,
+		ScalePlanets,
+		ScaleRadius,
+		ScreenScroll,
+		ScreenTile,
+		SetConditionalEvents,
+		SetDefaultText,
+		SetFilter,
+		SetHitsound,
+		SetHoldSound,
+		SetObject,
+		SetPlanetRotation,
+		SetSpeed,
+		SetText,
+		ShakeScreen,
+		Twirl
+	}
+}

RhythmBaseCore/Adofai/Events/ADFlash.cs

@@ -0,0 +1,30 @@
+using System;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADFlash : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADFlash()
+		{
+			Type = ADEventType.Flash;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public string Plane { get; set; }
+
+		public RDColor StartColor { get; set; }
+
+		public float StartOpacity { get; set; }
+
+		public RDColor EndColor { get; set; }
+
+		public float EndOpacity { get; set; }
+
+		public EaseType Ease { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADFreeRoam.cs

@@ -0,0 +1,26 @@
+using System;
+using Newtonsoft.Json;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADFreeRoam : ADBaseTileEvent, IEaseEvent
+	{
+		public ADFreeRoam()
+		{
+			Type = ADEventType.FreeRoam;
+		}
+		public override ADEventType Type { get; }
+		public float Duration { get; set; }
+		public int Size { get; set; }
+		public int PositionOffset { get; set; }
+		public int OutTime { get; set; }
+		[JsonProperty("OutEase")]
+		public EaseType Ease { get; set; }
+		public string HitsoundOnBeats { get; set; }
+		public string HitsoundOffBeats { get; set; }
+		public int CountdownTicks { get; set; }
+		public int AngleCorrectionDir { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADFreeRoamRemove.cs

@@ -0,0 +1,12 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADFreeRoamRemove : ADBaseTileEvent
+	{
+		public override ADEventType Type { get; }
+
+		public int Position { get; set; }
+
+		public int Size { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADFreeRoamTwirl.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADFreeRoamTwirl : ADBaseTileEvent
+	{
+		public ADFreeRoamTwirl()
+		{
+			Type = ADEventType.FreeRoamTwirl;
+		}
+
+		public override ADEventType Type { get; }
+
+		public int Position { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADHallOfMirrors.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADHallOfMirrors : ADBaseTaggedTileAction
+	{
+		public ADHallOfMirrors()
+		{
+			Type = ADEventType.HallOfMirrors;
+		}
+
+		public override ADEventType Type { get; }
+
+		public bool Enabled { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADHide.cs

@@ -0,0 +1,17 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADHide : ADBaseTileEvent
+	{
+		public ADHide()
+		{
+			Type = ADEventType.Hide;
+		}
+
+		public override ADEventType Type { get; }
+
+		public bool HideJudgment { get; set; }
+
+		public bool HideTileIcon { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADHold.cs

@@ -0,0 +1,19 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADHold : ADBaseTileEvent
+	{
+		public ADHold()
+		{
+			Type = ADEventType.Hold;
+		}
+
+		public override ADEventType Type { get; }
+
+		public int Duration { get; set; }
+
+		public int DistanceMultiplier { get; set; }
+
+		public bool LandingAnimation { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADMoveCamera.cs

@@ -0,0 +1,34 @@
+using System;
+using Newtonsoft.Json;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+	public class ADMoveCamera : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADMoveCamera()
+		{
+			Type = ADEventType.MoveCamera;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public bool DontDisable { get; set; }
+
+		public bool MinVfxOnly { get; set; }
+
+		public ADCameraRelativeTo RelativeTo { get; set; }
+
+		public RDPoint? Position { get; set; }
+
+		public float Rotation { get; set; }
+
+		public float Zoom { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADMoveDecorations.cs

@@ -0,0 +1,64 @@
+using System;
+using Newtonsoft.Json;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+	public class ADMoveDecorations : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADMoveDecorations()
+		{
+			Type = ADEventType.MoveDecorations;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public string Tag { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public RDPoint? PositionOffset { get; set; }
+
+		public RDPoint? ParallaxOffset { get; set; }
+
+		public bool? Visible { get; set; }
+
+		public ADDecorationRelativeTo? RelativeTo { get; set; }
+
+		public string DecorationImage { get; set; }
+
+		public RDSize? PivotOffset { get; set; }
+
+		public float? RotationOffset { get; set; }
+
+		public RDSize? Scale { get; set; }
+
+		public RDColor? Color { get; set; }
+
+		public float? Opacity { get; set; }
+
+		public int? Depth { get; set; }
+
+		public RDPoint? Parallax { get; set; }
+
+		public MaskingTypes? MaskingType { get; set; }
+
+		public bool? UseMaskingDepth { get; set; }
+
+		public int? MaskingFrontDepth { get; set; }
+
+		public int? MaskingBackDepth { get; set; }
+
+		public enum MaskingTypes
+		{
+			None,
+			Mask,
+			VisibleInsideMask,
+			VisibleOutsideMask
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADMoveTrack.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Runtime.CompilerServices;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADMoveTrack : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADMoveTrack()
+		{
+			Type = ADEventType.MoveTrack;
+		}
+
+		public override ADEventType Type { get; }
+
+		public object StartTile
+		{
+			[CompilerGenerated]
+			get
+			{
+				return StartTile;
+			}
+			[CompilerGenerated]
+			set
+			{
+				StartTile = RuntimeHelpers.GetObjectValue(value);
+			}
+		}
+
+		public object EndTile
+		{
+			[CompilerGenerated]
+			get
+			{
+				return EndTile;
+			}
+			[CompilerGenerated]
+			set
+			{
+				EndTile = RuntimeHelpers.GetObjectValue(value);
+			}
+		}
+
+		public int GapLength { get; set; }
+
+		public float Duration { get; set; }
+
+		public RDPoint PositionOffset { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public bool MaxVfxOnly { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADMultiPlanet.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADMultiPlanet : ADBaseTileEvent
+	{
+		public ADMultiPlanet()
+		{
+			Type = ADEventType.MultiPlanet;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string Planets { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADPause.cs

@@ -0,0 +1,19 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADPause : ADBaseTileEvent
+	{
+		public ADPause()
+		{
+			Type = ADEventType.Pause;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public int CountdownTicks { get; set; }
+
+		public int AngleCorrectionDir { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADPlaySound.cs

@@ -0,0 +1,17 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADPlaySound : ADBaseTaggedTileAction
+	{
+		public ADPlaySound()
+		{
+			Type = ADEventType.PlaySound;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string Hitsound { get; set; }
+
+		public int HitsoundVolume { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADPositionTrack.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Runtime.CompilerServices;
+using Newtonsoft.Json;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADPositionTrack : ADBaseTileEvent
+	{
+		public ADPositionTrack()
+		{
+			Type = ADEventType.PositionTrack;
+		}
+
+		public override ADEventType Type { get; }
+
+		public RDPoint PositionOffset { get; set; }
+
+		public object RelativeTo
+		{
+			[CompilerGenerated]
+			get
+			{
+				return RelativeTo;
+			}
+			[CompilerGenerated]
+			set
+			{
+				RelativeTo = RuntimeHelpers.GetObjectValue(value);
+			}
+		}
+
+		public float Rotation { get; set; }
+
+		public float Scale { get; set; }
+
+		public float Opacity { get; set; }
+
+		public bool JustThisTile { get; set; }
+
+		public bool SditorOnly { get; set; }
+
+		[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+		public bool? StickToFloors { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADRecolorTrack.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Runtime.CompilerServices;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADRecolorTrack : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADRecolorTrack()
+		{
+			Type = ADEventType.RecolorTrack;
+		}
+
+		public override ADEventType Type { get; }
+
+		public object StartTile
+		{
+			[CompilerGenerated]
+			get
+			{
+				return StartTile;
+			}
+			[CompilerGenerated]
+			set
+			{
+				StartTile = RuntimeHelpers.GetObjectValue(value);
+			}
+		}
+
+		public object EndTile
+		{
+			[CompilerGenerated]
+			get
+			{
+				return EndTile;
+			}
+			[CompilerGenerated]
+			set
+			{
+				EndTile = RuntimeHelpers.GetObjectValue(value);
+			}
+		}
+
+		public int GapLength { get; set; }
+
+		public float Duration { get; set; }
+
+		public ADTrackColorTypes TrackColorType { get; set; }
+
+		public RDColor TrackColor { get; set; }
+
+		public RDColor SecondaryTrackColor { get; set; }
+
+		public float TrackColorAnimDuration { get; set; }
+
+		public ADTrackColorPulses TrackColorPulse { get; set; }
+
+		public float TrackPulseLength { get; set; }
+
+		public ADTrackStyles TrackStyle { get; set; }
+
+		public float TrackGlowIntensity { get; set; }
+
+		public EaseType Ease { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADRepeatEvents.cs

@@ -0,0 +1,31 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADRepeatEvents : ADBaseTileEvent
+	{
+		public ADRepeatEvents()
+		{
+			Type = ADEventType.RepeatEvents;
+		}
+
+		public override ADEventType Type { get; }
+
+		public RepeatTypes RepeatType { get; set; }
+
+		public int Repetitions { get; set; }
+
+		public int FloorCount { get; set; }
+
+		public float Interval { get; set; }
+
+		public bool ExecuteOnCurrentFloor { get; set; }
+
+		public string Tag { get; set; }
+
+		public enum RepeatTypes
+		{
+			Beat,
+			Floor
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADScaleMargin.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADScaleMargin : ADBaseTileEvent
+	{
+		public ADScaleMargin()
+		{
+			Type = ADEventType.ScaleMargin;
+		}
+
+		public override ADEventType Type { get; }
+
+		public int Scale { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADScalePlanets.cs

@@ -0,0 +1,31 @@
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADScalePlanets : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADScalePlanets()
+		{
+			Type = ADEventType.ScalePlanets;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public TargetPlanets TargetPlanet { get; set; }
+
+		[EaseProperty]
+		public int Scale { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public enum TargetPlanets
+		{
+			FirePlanet,
+			IcePlanet,
+			GreenPlanet,
+			All
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADScaleRadius.cs

@@ -0,0 +1,15 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADScaleRadius : ADBaseTileEvent
+	{
+		public ADScaleRadius()
+		{
+			Type = ADEventType.ScaleRadius;
+		}
+
+		public override ADEventType Type { get; }
+
+		public int Scale { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADScreenScroll.cs

@@ -0,0 +1,16 @@
+using System;
+using RhythmBase.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADScreenScroll : ADBaseTaggedTileAction
+	{
+		public ADScreenScroll()
+		{
+			Type = ADEventType.ScreenScroll;
+		}
+
+		public override ADEventType Type { get; }
+
+		public RDSizeN Scroll { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADScreenTile.cs

@@ -0,0 +1,22 @@
+using System;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADScreenTile : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADScreenTile()
+		{
+			Type = ADEventType.ScreenTile;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public RDPoint Tile { get; set; }
+
+		public EaseType Ease { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetConditionalEvents.cs

@@ -0,0 +1,37 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetConditionalEvents : ADBaseTileEvent
+	{
+		public ADSetConditionalEvents()
+		{
+			Type = ADEventType.SetConditionalEvents;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string PerfectTag { get; set; }
+
+		public string HitTag { get; set; }
+
+		public string EarlyPerfectTag { get; set; }
+
+		public string LatePerfectTag { get; set; }
+
+		public string BarelyTag { get; set; }
+
+		public string VeryEarlyTag { get; set; }
+
+		public string VeryLateTag { get; set; }
+
+		public string MissTag { get; set; }
+
+		public string TooEarlyTag { get; set; }
+
+		public string TooLateTag { get; set; }
+
+		public string LossTag { get; set; }
+
+		public string OnCheckpointTag { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetDefaultText.cs

@@ -0,0 +1,34 @@
+using System;
+using Newtonsoft.Json;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+	public class ADSetDefaultText : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADSetDefaultText()
+		{
+			Type = ADEventType.SetDefaultText;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public RDColor? DefaultTextColor { get; set; }
+
+		public RDColor? DefaultTextShadowColor { get; set; }
+
+		public RDPoint? LevelTitlePosition { get; set; }
+
+		public string LevelTitleText { get; set; }
+
+		public string CongratsText { get; set; }
+
+		public string PerfectText { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetFilter.cs

@@ -0,0 +1,73 @@
+using System;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetFilter : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADSetFilter()
+		{
+			Type = ADEventType.SetFilter;
+		}
+
+		public override ADEventType Type { get; }
+
+		public Filters Filter { get; set; }
+
+		public string Enabled { get; set; }
+
+		public int Intensity { get; set; }
+
+		public float Duration { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public string DisableOthers { get; set; }
+
+		public enum Filters
+		{
+			Grayscale,
+			Sepia,
+			Invert,
+			VHS,
+			EightiesTV,
+			FiftiesTV,
+			Arcade,
+			LED,
+			Rain,
+			Blizzard,
+			PixelSnow,
+			Compression,
+			Glitch,
+			Pixelate,
+			Waves,
+			Static,
+			Grain,
+			MotionBlur,
+			Fisheye,
+			Aberration,
+			Drawing,
+			Neon,
+			Handheld,
+			NightVision,
+			Funk,
+			Tunnel,
+			Weird3D,
+			Blur,
+			BlurFocus,
+			GaussianBlur,
+			HexagonBlack,
+			Posterize,
+			Sharpen,
+			Contrast,
+			EdgeBlackLine,
+			OilPaint,
+			SuperDot,
+			WaterDrop,
+			LightWater,
+			Petals,
+			PetalsInstant
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetHitsound.cs

@@ -0,0 +1,25 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetHitsound : ADBaseTileEvent
+	{
+		public ADSetHitsound()
+		{
+			Type = ADEventType.SetHitsound;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string GameSound { get; set; }
+
+		public string Hitsound { get; set; }
+
+		public int HitsoundVolume { get; set; }
+
+		public enum GameSounds
+		{
+			Hitsound,
+			Midspin
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetHoldSound.cs

@@ -0,0 +1,29 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetHoldSound : ADBaseTileEvent
+	{
+		public ADSetHoldSound()
+		{
+			Type = ADEventType.SetHoldSound;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string HoldStartSound { get; set; }
+
+		public string HoldLoopSound { get; set; }
+
+		public string HoldEndSound { get; set; }
+
+		public string HoldMidSound { get; set; }
+
+		public string HoldMidSoundType { get; set; }
+
+		public float HoldMidSoundDelay { get; set; }
+
+		public string HoldMidSoundTimingRelativeTo { get; set; }
+
+		public int HoldSoundVolume { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetObject.cs

@@ -0,0 +1,34 @@
+using Newtonsoft.Json;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+	public class ADSetObject : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADSetObject()
+		{
+			Type = ADEventType.SetObject;
+		}
+		public override ADEventType Type { get; }
+		public float Duration { get; set; }
+		public string Tag { get; set; }
+		public EaseType Ease { get; set; }
+		public RDColor? PlanetColor { get; set; }
+		public RDColor? PlanetTailColor { get; set; }
+		public float? TrackAngle { get; set; }
+		public ADTrackColorTypes? TrackColorType { get; set; }
+		public RDColor? TrackColor { get; set; }
+		public RDColor? SecondaryTrackColor { get; set; }
+		public float? TrackColorAnimDuration { get; set; }
+		public float? TrackOpacity { get; set; }
+		public ADTrackStyles? TrackStyle { get; set; }
+		public string TrackIcon { get; set; }
+		public float? TrackIconAngle { get; set; }
+		public bool? TrackRedSwirl { get; set; }
+		public bool? TrackGraySetSpeedIcon { get; set; }
+		public bool? TrackGlowEnabled { get; set; }
+		public RDColor? TrackGlowColor { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetPlanetRotation.cs

@@ -0,0 +1,19 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetPlanetRotation : ADBaseTileEvent
+	{
+		public ADSetPlanetRotation()
+		{
+			Type = ADEventType.SetPlanetRotation;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string Ease { get; set; }
+
+		public int EaseParts { get; set; }
+
+		public ADEasePartBehaviors EasePartBehavior { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetSpeed.cs

@@ -0,0 +1,25 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetSpeed : ADBaseTaggedTileAction
+	{
+		public ADSetSpeed()
+		{
+			Type = ADEventType.SetSpeed;
+		}
+
+		public override ADEventType Type { get; }
+
+		public SpeedTypes SpeedType { get; set; }
+
+		public float BeatsPerMinute { get; set; }
+
+		public float BpmMultiplier { get; set; }
+
+		public enum SpeedTypes
+		{
+			Bpm,
+			Multiplier
+		}
+	}
+}

RhythmBaseCore/Adofai/Events/ADSetText.cs

@@ -0,0 +1,17 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADSetText : ADBaseTaggedTileAction
+	{
+		public ADSetText()
+		{
+			Type = ADEventType.SetText;
+		}
+
+		public override ADEventType Type { get; }
+
+		public string DecText { get; set; }
+
+		public string Tag { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADShakeScreen.cs

@@ -0,0 +1,26 @@
+using System;
+using RhythmBase.Components;
+using RhythmBase.Components.Easing;
+using RhythmBase.Events;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADShakeScreen : ADBaseTaggedTileAction, IEaseEvent
+	{
+		public ADShakeScreen()
+		{
+			Type = ADEventType.ShakeScreen;
+		}
+
+		public override ADEventType Type { get; }
+
+		public float Duration { get; set; }
+
+		public float Strength { get; set; }
+
+		public float Intensity { get; set; }
+
+		public EaseType Ease { get; set; }
+
+		public float FadeOut { get; set; }
+	}
+}

RhythmBaseCore/Adofai/Events/ADTile.cs

@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+using RhythmBase.Adofai.Components;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADTile : ADTypedList<ADBaseTileEvent>
+	{
+		public float Angle
+		{
+			get => _angle;
+			set => _angle = value is > (-360f) and < 360f ? ((value + 540f) % 360f) - 180f : -999f;
+		}
+		public bool IsMidSpin => _angle < -180f || _angle > 180f;
+		public ADBeat Beat => new(Parent?.Calculator!, Index + (_angle / 180f));
+		[JsonIgnore]
+		public ADLevel? Parent { get; set; }
+		public ADTile() { }
+		public ADTile(IEnumerable<ADBaseTileEvent> actions)
+		{
+			foreach (ADBaseTileEvent i in actions)
+			{
+				i.Parent = this;
+				Add(i);
+			}
+		}
+		public int Index => Parent?.IndexOf(this) ?? -1;
+		public override string ToString() => string.Format("[{0}]{1}<{2}>{3}",
+			[
+				Index,
+				Beat,
+				IsMidSpin ? "MS".PadRight(4) : _angle.ToString().PadLeft(4),
+				((IEnumerable<ADBaseTileEvent>)this).Any<ADBaseTileEvent>() ? string.Format(", Count = {0}", ((IEnumerable<ADBaseTileEvent>)this).Count<ADBaseTileEvent>()) : string.Empty
+			]);
+		private float _angle = 0;
+	}
+}

RhythmBaseCore/Adofai/Events/ADTileRelativeTo.cs

@@ -0,0 +1,10 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADTileRelativeTo
+	{
+		ThisTile,
+		Start,
+		End
+	}
+}

RhythmBaseCore/Adofai/Events/ADTrackColorPulses.cs

@@ -0,0 +1,10 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADTrackColorPulses
+	{
+		None,
+		Forward,
+		Backward
+	}
+}

RhythmBaseCore/Adofai/Events/ADTrackColorTypes.cs

@@ -0,0 +1,14 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADTrackColorTypes
+	{
+		Single,
+		Stripes,
+		Glow,
+		Blink,
+		Switch,
+		Rainbow,
+		Volume
+	}
+}

RhythmBaseCore/Adofai/Events/ADTrackStyles.cs

@@ -0,0 +1,13 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public enum ADTrackStyles
+	{
+		Standard,
+		Neon,
+		NeonLight,
+		Basic,
+		Gems,
+		Minimal
+	}
+}

RhythmBaseCore/Adofai/Events/ADTwirl.cs

@@ -0,0 +1,13 @@
+using System;
+namespace RhythmBase.Adofai.Events
+{
+	public class ADTwirl : ADBaseTileEvent
+	{
+		public ADTwirl()
+		{
+			Type = ADEventType.Twirl;
+		}
+
+		public override ADEventType Type { get; }
+	}
+}