Merge pull request #161 from minenice55/new-properties

New Beatmap Format + Beatmap Properties

Assets/Scripts/BeatmapFormats.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 06e6e979954795a49824e8435a5298fc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/BeatmapFormats/Beatmap.cs

@@ -67,7 +67,7 @@ namespace HeavenStudio
                 return JsonConvert.DeserializeObject<Entity>(JsonConvert.SerializeObject(this));
             }
 
-            public object this[string propertyName]
+            public dynamic this[string propertyName]
             {
                 get
                 {

Assets/Scripts/BeatmapFormats/Beatmap.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 457977a51a5961a40b33da038cd88e9d
+guid: 9ec74fe21af663f4d9645852eb4cfb88
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Scripts/BeatmapFormats/DynamicBeatmap.cs

@@ -0,0 +1,391 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using UnityEngine;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+using HeavenStudio.Util;
+
+namespace HeavenStudio
+{
+    [Serializable]
+    public class DynamicBeatmap
+    {
+        public static int CurrentRiqVersion = 0;
+        public float bpm;
+
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        [DefaultValue(100)] public int musicVolume; // In percent (1-100)
+        
+        public Dictionary<string, object> properties = 
+            new Dictionary<string, object>() {
+                // software version (MajorMinorPatch, revision)
+                {"productversion", 000},
+                {"productsubversion", 0},
+                // file format version
+                {"riqversion", CurrentRiqVersion},
+                // mapper set properties? (future: use this to flash the button)
+                {"propertiesmodified", false},
+
+                ////// CATEGORY 1: SONG INFO
+                // general chart info
+                {"remixtitle", "New Remix"},        // chart name
+                {"remixauthor", "Your Name"},       // charter's name
+                {"remixdesc", "Remix Description"}, // chart description
+                {"remixlevel", 1},                  // chart difficulty (maybe offer a suggestion but still have the mapper determine it)
+                {"remixtempo", 120f},               // avg. chart tempo
+                {"remixtags", ""},                  // chart tags
+                {"icontype", 0},                    // chart icon (presets, custom - future)
+                {"iconurl", ""},                    // custom icon location (future)
+
+                // chart song info
+                {"idolgenre", "Song Genre"},        // song genre
+                {"idolsong", "Song Name"},          // song name
+                {"idolcredit", "Artist"},           // song artist
+
+                ////// CATEGORY 2: PROLOGUE AND EPILOGUE
+                // chart prologue
+                {"prologuetype", 0},                // prologue card animation (future)
+                {"prologuecaption", "Remix"},       // prologue card sub-title (future)
+
+                // chart results screen messages
+                {"resultcaption", "Rhythm League Notes"},                       // result screen header
+                {"resultcommon_hi", "Good rhythm."},                            // generic "Superb" message (one-liner, or second line for single-type)
+                {"resultcommon_ok", "Eh. Passable."},                           // generic "OK" message (one-liner, or second line for single-type)
+                {"resultcommon_ng", "Try harder next time."},                   // generic "Try Again" message (one-liner, or second line for single-type)
+
+                    // the following are shown / hidden in-editor depending on the tags of the games used
+                {"resultnormal_hi", "You show strong fundamentals."},           // "Superb" message for normal games (two-liner)
+                {"resultnormal_ng", "Work on your fundamentals."},              // "Try Again" message for normal games (two-liner)
+
+                {"resultkeep_hi", "You kept the beat well."},                   // "Superb" message for keep-the-beat games (two-liner)
+                {"resultkeep_ng", "You had trouble keeping the beat."},         // "Try Again" message for keep-the-beat games (two-liner)
+
+                {"resultaim_hi", "You had great aim."},                         // "Superb" message for aim games (two-liner)
+                {"resultaim_ng", "Your aim was a little shaky."},               // "Try Again" message for aim games (two-liner)
+
+                {"resultrepeat_hi", "You followed the example well."},          // "Superb" message for call-and-response games (two-liner)
+                {"resultrepeat_ng", "Next time, follow the example better."},   // "Try Again" message for call-and-response games (two-liner)
+        };
+
+        public List<DynamicEntity> entities = new List<DynamicEntity>();
+        public List<TempoChange> tempoChanges = new List<TempoChange>();
+        public List<VolumeChange> volumeChanges = new List<VolumeChange>();
+        public List<ChartSection> beatmapSections = new List<ChartSection>();
+        public float firstBeatOffset;
+
+        [Serializable]
+        public class DynamicEntity : ICloneable
+        {
+            public float beat;
+            public int track;
+            [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)] public float length;
+            [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)] public float swing;
+            public Dictionary<string, dynamic> DynamicData = new Dictionary<string, dynamic>();
+
+            public string datamodel;
+            [JsonIgnore] public Editor.Track.TimelineEventObj eventObj;
+
+            public object Clone()
+            {
+                return this.MemberwiseClone();
+            }
+
+            public DynamicEntity DeepCopy()
+            {
+                DynamicEntity copy = (DynamicEntity)this.MemberwiseClone();
+                copy.DynamicData = new Dictionary<string, dynamic>(this.DynamicData);
+                return copy;
+            }
+
+            public dynamic this[string propertyName]
+            {
+                get
+                {
+                    switch (propertyName)
+                    {
+                        case "beat":
+                            return beat;
+                        case "track":
+                            return track;
+                        case "length":
+                            return length;
+                        case "swing":
+                            return swing;
+                        case "datamodel":
+                            return datamodel;
+                        default:
+                            if (DynamicData.ContainsKey(propertyName))
+                                return DynamicData[propertyName];
+                            else
+                            {
+                                Minigames.Minigame game = EventCaller.instance.GetMinigame(datamodel.Split(0));
+                                Minigames.Param param = EventCaller.instance.GetGameParam(game, datamodel.Split(1), propertyName);
+                                return param.parameter;
+                            }
+                    }
+                }
+                set
+                {
+                    switch (propertyName)
+                    {
+                        case "beat":
+                        case "track":
+                        case "length":
+                        case "swing":
+                        case "datamodel":
+                            UnityEngine.Debug.LogWarning($"Property name {propertyName} is reserved and cannot be set.");
+                            break;
+                        default:
+                            if (DynamicData.ContainsKey(propertyName))
+                                DynamicData[propertyName] = value;
+                            else
+                                UnityEngine.Debug.LogError($"This entity does not have a property named {propertyName}! Attempted to insert value of type {value.GetType()}");
+                            break;
+                    }
+                    
+                }
+            }
+
+            public void CreateProperty(string name, dynamic defaultValue)
+            {
+                if (!DynamicData.ContainsKey(name))
+                    DynamicData.Add(name, defaultValue);
+            }
+        }
+
+        [Serializable]
+        public class TempoChange : ICloneable
+        {
+            public float beat;
+            public float length;
+            public float tempo;
+
+            public object Clone()
+            {
+                return this.MemberwiseClone();
+            }
+        }
+
+        [Serializable]
+        public class VolumeChange : ICloneable
+        {
+            public float beat;
+            public float length;
+            public float volume;
+
+            public object Clone()
+            {
+                return this.MemberwiseClone();
+            }
+        }
+
+        [Serializable]
+        public class ChartSection : ICloneable
+        {
+            public float beat;
+            public bool startPerfect;
+            public string sectionName;
+            public bool isCheckpoint;   // really don't think we need this but who knows
+
+            public object Clone()
+            {
+                return this.MemberwiseClone();
+            }
+        }
+
+        public dynamic this[string propertyName]
+        {
+            get
+            {
+                return properties[propertyName] ?? null;
+            }
+            set
+            {
+                if (properties.ContainsKey(propertyName))
+                {
+                    properties[propertyName] = value;
+                }
+                else
+                {
+                    UnityEngine.Debug.LogError($"This beatmap does not have a property named {propertyName}! Attempted to insert value of type {value.GetType()}");
+                }
+            }
+        }
+
+        /// <summary>
+        /// converts from the old "rhmania" / "tengoku" format to the new "riq" format
+        /// </summary>
+        /// <param name="beatmap">a deserialized .rhmania or .tengoku beatmap</param>
+        /// <returns>a .riq beatmap</returns>
+        public static DynamicBeatmap BeatmapConverter(Beatmap beatmap)
+        {
+            DynamicBeatmap dynamicBeatmap = new DynamicBeatmap();
+            dynamicBeatmap.bpm = beatmap.bpm;
+            dynamicBeatmap.musicVolume = beatmap.musicVolume;
+            dynamicBeatmap.firstBeatOffset = beatmap.firstBeatOffset;
+
+            Minigames.Minigame game;
+            Minigames.GameAction action;
+            System.Type type, pType;
+            foreach (var e in beatmap.entities)
+            {
+                game = EventCaller.instance.GetMinigame(e.datamodel.Split(0));
+                action = EventCaller.instance.GetGameAction(game, e.datamodel.Split(1));
+
+                // Debug.Log($"{game.name} {action.displayName} @ beat {e.beat}");
+
+                Dictionary<string, dynamic> dynamicData = new Dictionary<string, dynamic>();
+                //check each param of the action
+                if (action.parameters != null)
+                {
+                    foreach (var param in action.parameters)
+                    {
+                        type = param.parameter.GetType();
+                        pType = e[param.propertyName].GetType();
+                        // Debug.Log($"adding parameter {param.propertyName} of type {type}");
+                        if (!dynamicData.ContainsKey(param.propertyName))
+                        {
+                            if (pType == type)
+                            {
+                                dynamicData.Add(param.propertyName, e[param.propertyName]);
+                            }
+                            else
+                            {
+                                if (type == typeof(EntityTypes.Integer))
+                                    dynamicData.Add(param.propertyName, (int) e[param.propertyName]);
+                                else if (type == typeof(EntityTypes.Float))
+                                    dynamicData.Add(param.propertyName, (float) e[param.propertyName]);
+                                else if (type.IsEnum && param.propertyName != "ease")
+                                    dynamicData.Add(param.propertyName, (int) e[param.propertyName]);
+                                else if (pType == typeof(Newtonsoft.Json.Linq.JObject))
+                                    dynamicData.Add(param.propertyName, e[param.propertyName].ToObject(type));
+                                else
+                                    dynamicData.Add(param.propertyName, Convert.ChangeType(e[param.propertyName], type));
+                            }
+                        }
+                        else
+                        {
+                            Debug.LogWarning($"Property {param.propertyName} already exists in the entity's dynamic data! Skipping...");
+                        }
+                    }
+                }
+
+                dynamicBeatmap.entities.Add(new DynamicEntity()
+                {
+                    beat = e.beat,
+                    track = e.track,
+                    length = e.length,
+                    swing = e.swing,
+                    datamodel = e.datamodel,
+                    DynamicData = dynamicData
+                });
+            }
+            foreach (var tempoChange in beatmap.tempoChanges)
+            {
+                dynamicBeatmap.tempoChanges.Add(new TempoChange()
+                {
+                    beat = tempoChange.beat,
+                    length = tempoChange.length,
+                    tempo = tempoChange.tempo
+                });
+            }
+            foreach (var volumeChange in beatmap.volumeChanges)
+            {
+                dynamicBeatmap.volumeChanges.Add(new VolumeChange()
+                {
+                    beat = volumeChange.beat,
+                    length = volumeChange.length,
+                    volume = volumeChange.volume
+                });
+            }
+            return dynamicBeatmap;
+        }
+
+        /// <summary>
+        /// FUTURE: converts from a karateka mania chart ("bor") to the "riq" format
+        /// </summary>
+        /// <param name="bor">a rawtext .bor chart</param>
+        /// <returns>a .riq beatmap</returns>
+        /// <remarks>not implemented yet</remarks>
+        public static DynamicBeatmap KManiaBorConverter(String bor)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// updates an "riq" beatmap
+        /// </summary>
+        /// <param name="beatmap">old beatmap</param>
+        /// <param name="version">version of old beatmap</param>
+        /// <returns>updated beatmap</returns>
+        /// <remarks>not implemented yet</remarks>
+        public static DynamicBeatmap BeatmapUpdater(DynamicBeatmap beatmap, int version)
+        {
+            return beatmap;
+        }
+
+        /// <summary>
+        /// processes an riq beatmap after it is loaded
+        /// </summary>
+        public void PostProcess()
+        {
+            DynamicBeatmap beatmapModel = new DynamicBeatmap();
+            Minigames.Minigame game;
+            Minigames.GameAction action;
+            System.Type type, pType;
+            foreach (var e in entities)
+            {
+                game = EventCaller.instance.GetMinigame(e.datamodel.Split(0));
+                action = EventCaller.instance.GetGameAction(game, e.datamodel.Split(1));
+                Dictionary<string, dynamic> dynamicData = new Dictionary<string, dynamic>();
+                //check each param of the action
+                if (action.parameters != null)
+                {
+                    foreach (var param in action.parameters)
+                    {
+                        if (!dynamicData.ContainsKey(param.propertyName))
+                        {
+                            type = param.parameter.GetType();
+                            pType = e[param.propertyName].GetType();
+                            if (pType == type)
+                            {
+                                dynamicData.Add(param.propertyName, e[param.propertyName]);
+                            }
+                            else
+                            {
+                                if (type == typeof(EntityTypes.Integer))
+                                    dynamicData.Add(param.propertyName, (int)e[param.propertyName]);
+                                else if (type == typeof(EntityTypes.Float))
+                                    dynamicData.Add(param.propertyName, (float)e[param.propertyName]);
+                                else if (type == typeof(EasingFunction.Ease) && pType == typeof(string))
+                                    dynamicData.Add(param.propertyName, Enum.Parse(typeof(EasingFunction.Ease), (string)e[param.propertyName]));
+                                else if (type.IsEnum)
+                                    dynamicData.Add(param.propertyName, (int)e[param.propertyName]);
+                                else if (pType == typeof(Newtonsoft.Json.Linq.JObject))
+                                    dynamicData.Add(param.propertyName, e[param.propertyName].ToObject(type));
+                                else
+                                    dynamicData.Add(param.propertyName, Convert.ChangeType(e[param.propertyName], type));
+                            }
+                        }
+                        else
+                        {
+                            Debug.LogWarning($"Property {param.propertyName} already exists in the entity's dynamic data! Skipping...");
+                        }
+                    }
+                }
+                e.DynamicData = dynamicData;
+            }
+            //go thru each property of the model beatmap and add any missing keyvalue pair
+            foreach (var prop in beatmapModel.properties)
+            {
+                if (!properties.ContainsKey(prop.Key))
+                {
+                    properties.Add(prop.Key, prop.Value);
+                }
+            }
+        }
+    }
+}

Assets/Scripts/BeatmapFormats/DynamicBeatmap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ca2149f692fc3d84ba6526d33c132822
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Conductor.cs

@@ -245,9 +245,17 @@ namespace HeavenStudio
             return tempoChanges;
         }
 
+        private List<DynamicBeatmap.TempoChange> GetSortedTempoChanges(DynamicBeatmap chart)
+        {
+            //iterate over all tempo changes, adding to counter
+            List<DynamicBeatmap.TempoChange> tempoChanges = chart.tempoChanges;
+            tempoChanges.Sort((x, y) => x.beat.CompareTo(y.beat)); //sorts all tempo changes by ascending time (GameManager already does this but juste en cas...)
+            return tempoChanges;
+        }
+
         public float GetSongPosFromBeat(float beat)
         {
-            Beatmap chart = GameManager.instance.Beatmap;
+            var chart = GameManager.instance.Beatmap;
             SetBpm(chart.bpm);
 
             //initial counter
@@ -257,7 +265,7 @@ namespace HeavenStudio
             float lastTempoChangeBeat = 0f;
 
             //iterate over all tempo changes, adding to counter
-            List<Beatmap.TempoChange> tempoChanges = GetSortedTempoChanges(chart);
+            var tempoChanges = GetSortedTempoChanges(chart);
             foreach (var t in tempoChanges)
             {
                 if (t.beat > beat)
@@ -297,12 +305,12 @@ namespace HeavenStudio
             public float GetBeatFromSongPos(float seconds)
             {
                 // Debug.Log("Getting beat of seconds " + seconds);
-                Beatmap chart = GameManager.instance.Beatmap;
+                var chart = GameManager.instance.Beatmap;
                 float lastTempoChangeBeat = 0f;
                 float lastBpm = chart.bpm;
                 float counterSeconds = -firstBeatOffset;
                 
-                List<Beatmap.TempoChange> tempoChanges = GetSortedTempoChanges(chart);
+                var tempoChanges = GetSortedTempoChanges(chart);
                 foreach (var t in tempoChanges)
                 {
                     float beatToNext = t.beat - lastTempoChangeBeat;

Assets/Scripts/Datamodel.cs

@@ -10,5 +10,11 @@ namespace HeavenStudio
         {
             return s.Split('/')[index];
         }
+
+        public static string GetExtension(this string s)
+        {
+            string[] split = s.Split('.');
+            return split[split.Length - 1];
+        }
     }
 }

Assets/Scripts/DebugUI.cs

@@ -71,7 +71,6 @@ namespace HeavenStudio
 
                 SetText(currEvent, $"CurrentEvent: {GameManager.instance.Beatmap.entities[GameManager.instance.currentEvent - minus].datamodel}");
                 SetText(eventLength, $"Event Length: {GameManager.instance.Beatmap.entities[GameManager.instance.currentEvent - minus].length}");
-                SetText(eventType, $"Event Type: {GameManager.instance.Beatmap.entities[GameManager.instance.currentEvent - minus].type}");
             }
         }
 

Assets/Scripts/EventCaller.cs

@@ -9,16 +9,14 @@ namespace HeavenStudio
     public class EventCaller : MonoBehaviour
     {
         public Transform GamesHolder;
-        public Beatmap.Entity currentEntity = new Beatmap.Entity();
+        public DynamicBeatmap.DynamicEntity currentEntity = new DynamicBeatmap.DynamicEntity();
         public string currentSwitchGame;
 
         public delegate void EventCallback();
 
         public static EventCaller instance { get; private set; }
 
-        public List<Minigames.Minigame> minigames = new List<Minigames.Minigame>()
+        public List<Minigames.Minigame> minigames = new List<Minigames.Minigame>();
-        {
-        };
 
         public Minigames.Minigame GetMinigame(string gameName)
         {
@@ -30,11 +28,16 @@ namespace HeavenStudio
             return game.actions.Find(c => c.actionName == action);
         }
 
+        public Minigames.Param GetGameParam(Minigames.Minigame game, string action, string param)
+        {
+            return GetGameAction(game, action).parameters.Find(c => c.propertyName == param);
+        }
+
         public void Init()
         {
             instance = this;
 
-            currentEntity = new Beatmap.Entity();
+            currentEntity = new DynamicBeatmap.DynamicEntity();
 
             Minigames.Init(this);
 
@@ -60,7 +63,7 @@ namespace HeavenStudio
             
         }
 
-        public void CallEvent(Beatmap.Entity entity, bool gameActive)
+        public void CallEvent(DynamicBeatmap.DynamicEntity entity, bool gameActive)
         {
             string[] details = entity.datamodel.Split('/');
             Minigames.Minigame game = minigames.Find(c => c.name == details[0]);
@@ -86,10 +89,10 @@ namespace HeavenStudio
             }
         }
 
-        public static List<Beatmap.Entity> GetAllInGameManagerList(string gameName, string[] include)
+        public static List<DynamicBeatmap.DynamicEntity> GetAllInGameManagerList(string gameName, string[] include)
         {
-            List<Beatmap.Entity> temp1 = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel.Split('/')[0] == gameName);
+            List<DynamicBeatmap.DynamicEntity> temp1 = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel.Split('/')[0] == gameName);
-            List<Beatmap.Entity> temp2 = new List<Beatmap.Entity>();
+            List<DynamicBeatmap.DynamicEntity> temp2 = new List<DynamicBeatmap.DynamicEntity>();
             for (int i = 0; i < temp1.Count; i++)
             {
                 if (include.Any(temp1[i].datamodel.Split('/')[1].Contains))
@@ -100,10 +103,10 @@ namespace HeavenStudio
             return temp2;
         }
 
-        public static List<Beatmap.Entity> GetAllInGameManagerListExclude(string gameName, string[] exclude)
+        public static List<DynamicBeatmap.DynamicEntity> GetAllInGameManagerListExclude(string gameName, string[] exclude)
         {
-            List<Beatmap.Entity> temp1 = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel.Split('/')[0] == gameName);
+            List<DynamicBeatmap.DynamicEntity> temp1 = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel.Split('/')[0] == gameName);
-            List<Beatmap.Entity> temp2 = new List<Beatmap.Entity>();
+            List<DynamicBeatmap.DynamicEntity> temp2 = new List<DynamicBeatmap.DynamicEntity>();
             for (int i = 0; i < temp1.Count; i++)
             {
                 if (!exclude.Any(temp1[i].datamodel.Split('/')[1].Contains))
@@ -114,18 +117,18 @@ namespace HeavenStudio
             return temp2;
         }
 
-        public static List<Beatmap.Entity> GetAllPlayerEntities(string gameName)
+        public static List<DynamicBeatmap.DynamicEntity> GetAllPlayerEntities(string gameName)
         {
             return GameManager.instance.playerEntities.FindAll(c => c.datamodel.Split('/')[0] == gameName);
         }
 
-        public static List<Beatmap.Entity> GetAllPlayerEntitiesExcept(string gameName)
+        public static List<DynamicBeatmap.DynamicEntity> GetAllPlayerEntitiesExcept(string gameName)
         {
             return GameManager.instance.playerEntities.FindAll(c => c.datamodel.Split('/')[0] != gameName);
         }
 
         // elaborate as fuck, boy
-        public static List<Beatmap.Entity> GetAllPlayerEntitiesExceptBeforeBeat(string gameName, float beat)
+        public static List<DynamicBeatmap.DynamicEntity> GetAllPlayerEntitiesExceptBeforeBeat(string gameName, float beat)
         {
             return GameManager.instance.playerEntities.FindAll(c => c.datamodel.Split('/')[0] != gameName && c.beat < beat);
         }

Assets/Scripts/GameCamera.cs

@@ -12,10 +12,10 @@ namespace HeavenStudio
         public static GameCamera instance { get; private set; }
         public new Camera camera;
 
-        private List<Beatmap.Entity> positionEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> positionEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> rotationEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> rotationEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> scaleEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> scaleEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> shakeEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> shakeEvents = new List<DynamicBeatmap.DynamicEntity>();
 
         /**
             default cam position, for quick-resetting
@@ -125,15 +125,15 @@ namespace HeavenStudio
                 float prog = Conductor.instance.GetPositionFromBeat(e.beat, e.length);
                 if (prog >= 0f)
                 {
-                    EasingFunction.Function func = EasingFunction.GetEasingFunction(e.ease);
+                    EasingFunction.Function func = EasingFunction.GetEasingFunction((EasingFunction.Ease) e["ease"]);
-                    float dx = func(positionLast.x, e.valA, Mathf.Min(prog, 1f));
+                    float dx = func(positionLast.x, e["valA"], Mathf.Min(prog, 1f));
-                    float dy = func(positionLast.y, e.valB, Mathf.Min(prog, 1f));
+                    float dy = func(positionLast.y, e["valB"], Mathf.Min(prog, 1f));
-                    float dz = func(positionLast.z, -e.valC, Mathf.Min(prog, 1f));
+                    float dz = func(positionLast.z, -e["valC"], Mathf.Min(prog, 1f));
                     position = new Vector3(dx, dy, dz);
                 }
                 if (prog > 1f)
                 {
-                    positionLast = new Vector3(e.valA, e.valB, -e.valC);
+                    positionLast = new Vector3(e["valA"], e["valB"], -e["valC"]);
                 }
             }
         }
@@ -145,16 +145,16 @@ namespace HeavenStudio
                 float prog = Conductor.instance.GetPositionFromBeat(e.beat, e.length);
                 if (prog >= 0f)
                 {
-                    EasingFunction.Function func = EasingFunction.GetEasingFunction(e.ease);
+                    EasingFunction.Function func = EasingFunction.GetEasingFunction((EasingFunction.Ease) e["ease"]);
-                    float dx = func(rotEluerLast.x, e.valA, Mathf.Min(prog, 1f));
+                    float dx = func(rotEluerLast.x, e["valA"], Mathf.Min(prog, 1f));
-                    float dy = func(rotEluerLast.y, e.valB, Mathf.Min(prog, 1f));
+                    float dy = func(rotEluerLast.y, e["valB"], Mathf.Min(prog, 1f));
-                    float dz = func(-rotEluerLast.z, e.valC, Mathf.Min(prog, 1f));
+                    float dz = func(-rotEluerLast.z, e["valC"], Mathf.Min(prog, 1f));
                     rotEluer = new Vector3(dx, dy, dz);    //I'm stupid and forgot to negate the rotation gfd 😢
 
                 }
                 if (prog > 1f)
                 {
-                    rotEluerLast = new Vector3(e.valA, e.valB, -e.valC);
+                    rotEluerLast = new Vector3(e["valA"], e["valB"], -e["valC"]);
                 }
             }
         }
@@ -167,7 +167,7 @@ namespace HeavenStudio
                 if (prog >= 0f)
                 {
                     float fac = Mathf.Cos(Time.time * 80f) * 0.5f;
-                    shakeResult = new Vector3(fac * e.valA, fac * e.valB);
+                    shakeResult = new Vector3(fac * e["valA"], fac * e["valB"]);
                 }
                 if (prog > 1f)
                 {

Assets/Scripts/GameManager.cs

@@ -13,8 +13,8 @@ namespace HeavenStudio
     public class GameManager : MonoBehaviour
     {
         [Header("Lists")]
-        public Beatmap Beatmap = new Beatmap();
+        public DynamicBeatmap Beatmap = new DynamicBeatmap();
-        [HideInInspector] public List<Beatmap.Entity> playerEntities = new List<Beatmap.Entity>();
+        [HideInInspector] public List<DynamicBeatmap.DynamicEntity> playerEntities = new List<DynamicBeatmap.DynamicEntity>();
         private List<GameObject> preloadedGames = new List<GameObject>();
         public List<GameObject> SoundObjects = new List<GameObject>();
 
@@ -75,7 +75,7 @@ namespace HeavenStudio
             if (txt != null)
             {
                 string json = txt.text;
-                Beatmap = JsonConvert.DeserializeObject<Beatmap>(json);
+                Beatmap = JsonConvert.DeserializeObject<DynamicBeatmap>(json);
             }
             else
             {
@@ -116,25 +116,39 @@ namespace HeavenStudio
 
         public void NewRemix()
         {
-            Beatmap = new Beatmap();
+            Beatmap = new DynamicBeatmap();
             Beatmap.bpm = 120f;
             Beatmap.musicVolume = 100;
             Beatmap.firstBeatOffset = 0f;
             Conductor.instance.musicSource.clip = null;
         }
 
-        public void LoadRemix(string json = "")
+        public void LoadRemix(string json = "", string type = "riq", int version = 0)
         {
-            SortEventsList();
 
             if (json != "")
             {
-                Beatmap = JsonConvert.DeserializeObject<Beatmap>(json);
+                switch (type)
+                {
+                    case "tengoku":
+                    case "rhmania":
+                        Beatmap toConvert = JsonConvert.DeserializeObject<Beatmap>(json);
+                        Beatmap = DynamicBeatmap.BeatmapConverter(toConvert);
+                        break;
+                    case "riq":
+                        Beatmap = JsonConvert.DeserializeObject<DynamicBeatmap>(json);
+                        Beatmap.PostProcess();
+                        break;
+                    default:
+                        NewRemix();
+                        break;
+                }
             }
             else
             {
                 NewRemix();
             }
+            SortEventsList();
             Conductor.instance.SetBpm(Beatmap.bpm);
             Conductor.instance.SetVolume(Beatmap.musicVolume);
             Conductor.instance.firstBeatOffset = Beatmap.firstBeatOffset;
@@ -213,7 +227,7 @@ namespace HeavenStudio
                 // Debug.Log("Checking Tempo Change at " + tempoChanges[currentTempoEvent] + ", current beat " + Conductor.instance.songPositionInBeats);
                 if (Conductor.instance.songPositionInBeats >= tempoChanges[currentTempoEvent])
                 {
-                    // Debug.Log("Tempo Change at " + Conductor.instance.songPositionInBeats + " of bpm " + Beatmap.tempoChanges[currentTempoEvent].tempo);
+                    // Debug.Log("Tempo Change at " + Conductor.instance.songPositionInBeats + " of bpm " + DynamicBeatmap.tempoChanges[currentTempoEvent].tempo);
                     Conductor.instance.SetBpm(Beatmap.tempoChanges[currentTempoEvent].tempo);
                     Conductor.instance.timeSinceLastTempoChange = Time.time;
                     currentTempoEvent++;
@@ -323,6 +337,7 @@ namespace HeavenStudio
         {
             Beatmap.entities.Sort((x, y) => x.beat.CompareTo(y.beat));
             Beatmap.tempoChanges.Sort((x, y) => x.beat.CompareTo(y.beat));
+            Beatmap.volumeChanges.Sort((x, y) => x.beat.CompareTo(y.beat));
         }
 
         public void SetCurrentEventToClosest(float beat)

Assets/Scripts/Games/AirRally/AirRally.cs

@@ -16,26 +16,45 @@ namespace HeavenStudio.Games.Loaders
         {
             return new Minigame("airRally", "Air Rally", "008c97", false, false, new List<GameAction>()
             {
-                new GameAction("set distance",                    delegate { AirRally.instance.SetDistance(e.currentEntity.type); }, .5f, false, new List<Param>()
+                new GameAction("set distance", "Set Distance")
+                {
+                    function = delegate { AirRally.instance.SetDistance(e.currentEntity["type"]); }, 
+                    defaultLength = .5f, 
+                    parameters = new List<Param>()
                     {
                         new Param("type", AirRally.DistanceSound.close, "Type", "How far is Forthington?")
-                }),
+                    }
+                },
                 //new GameAction("start rally",                    delegate { AirRally.instance.StartRally(true); }, .5f, false),
-                new GameAction("rally",                    delegate { AirRally.instance.Rally(e.currentEntity.beat, e.currentEntity.toggle, e.currentEntity.length); }, 2f, true, new List<Param>()
+                new GameAction("rally", "Rally")
+                {
+                    function = delegate { AirRally.instance.Rally(e.currentEntity.beat, e.currentEntity["toggle"], e.currentEntity.length); }, 
+                    defaultLength = 2f, 
+                    resizable = true, 
+                    parameters = new List<Param>()
                     { 
                         new Param("toggle", false, "Silent", "Make Forthington Silent"),
-                }),
+                    }
-                new GameAction("ba bum bum bum",                    delegate { AirRally.instance.BaBumBumBum(e.currentEntity.beat, e.currentEntity.toggle, e.currentEntity.type); }, 7f, false, new List<Param>()
+                },
+                new GameAction("ba bum bum bum", "Ba Bum Bum Bum")
+                {
+                    function = delegate { AirRally.instance.BaBumBumBum(e.currentEntity.beat, e.currentEntity["toggle"], e.currentEntity["type"]); }, 
+                    defaultLength = 7f, 
+                    parameters = new List<Param>()
                     { 
                         new Param("toggle", false, "Count", "Make Forthington Count"),
                         new Param("type", AirRally.DistanceSound.close, "Type", "How far is Forthington?")
-                }),
+                    }
-                new GameAction("forthington voice lines",                    delegate { AirRally.instance.ForthVoice(e.currentEntity.type, e.currentEntity.type2); }, 1f, false, new List<Param>()
+                },
+                new GameAction("forthington voice lines", "Forthington Voice Lines")
+                {
+                    function = delegate { AirRally.instance.ForthVoice(e.currentEntity["type"], e.currentEntity["type2"]); }, 
+                    parameters = new List<Param>()
                     { 
                         new Param("type", AirRally.CountSound.one, "Type", "The number Forthington will say"),
                         new Param("type", AirRally.DistanceSound.close, "Type", "How far is Forthington?")
-                }),
+                    }
-                
+                }
             });
         }
     }

Assets/Scripts/Games/BlueBear/BlueBear.cs

@@ -13,8 +13,16 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("blueBear", "Blue Bear", "B4E6F6", false, false, new List<GameAction>()
             {
-                new GameAction("donut",                 delegate { BlueBear.instance.SpawnTreat(eventCaller.currentEntity.beat, false); }, 3, false),
+                new GameAction("donut", "Donut")
-                new GameAction("cake",                  delegate { BlueBear.instance.SpawnTreat(eventCaller.currentEntity.beat, true); }, 4, false),
+                {
+                    function = delegate { BlueBear.instance.SpawnTreat(eventCaller.currentEntity.beat, false); }, 
+                    defaultLength = 3,
+                },
+                new GameAction("cake", "Cake")
+                {
+                    function = delegate { BlueBear.instance.SpawnTreat(eventCaller.currentEntity.beat, true); }, 
+                    defaultLength = 4,
+                },
             });
         }
     }

Assets/Scripts/Games/BuiltToScaleDS/BuiltToScaleDS.cs

@@ -15,11 +15,19 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("builtToScaleDS", "Built To Scale (DS)", "00BB00", true, false, new List<GameAction>()
             {
-                new GameAction("spawn blocks",          delegate { }, 1f, true),
+                new GameAction("spawn blocks", "Spawn Blocks")
-                new GameAction("play piano",            delegate { BuiltToScaleDS.instance.PlayPiano(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity.type); }, 1f, true, new List<Param>() 
+                {
+                    resizable = true
+                },
+                new GameAction("play piano", "Play Note")
+                {
+                    function = delegate { BuiltToScaleDS.instance.PlayPiano(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["type"]); }, 
+                    resizable = true, 
+                    parameters = new List<Param>() 
                     {
                         new Param("type", new EntityTypes.Integer(-24, 24, 0), "Semitones", "The number of semitones up or down this note should be pitched")
-                } ),
+                    } 
+                },
             });
         }
     }
@@ -79,7 +87,7 @@ namespace HeavenStudio.Games
             elevatorAnim.Play("MakeRod", 0, 1f);
         }
 
-        List<Beatmap.Entity> spawnedBlockEvents = new List<Beatmap.Entity>();
+        List<DynamicBeatmap.DynamicEntity> spawnedBlockEvents = new List<DynamicBeatmap.DynamicEntity>();
         void Update()
         {
             if (!Conductor.instance.isPlaying && !Conductor.instance.isPaused)

Assets/Scripts/Games/ClappyTrio/ClappyTrio.cs

@@ -12,18 +12,38 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("clappyTrio", "The Clappy Trio", "29E7FF", false, false, new List<GameAction>()
             {
-                new GameAction("clap",                  delegate { ClappyTrio.instance.Clap(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 1, true),
+                new GameAction("clap", "Clap")
-                new GameAction("bop",                   delegate { ClappyTrio.instance.Bop(eventCaller.currentEntity.beat); } ),
+                {
-                new GameAction("prepare",               delegate { ClappyTrio.instance.Prepare(eventCaller.currentEntity.toggle ? 3 : 0); }, parameters: new List<Param>()
+                    function = delegate { ClappyTrio.instance.Clap(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 
+                    resizable = true
+                },
+                new GameAction("bop", "Bop")
+                {
+                    function = delegate { ClappyTrio.instance.Bop(eventCaller.currentEntity.beat); } 
+                },
+                new GameAction("prepare", "Prepare Stance")
+                {
+                    function = delegate { ClappyTrio.instance.Prepare(eventCaller.currentEntity["toggle"] ? 3 : 0); }, 
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Alt", "Whether or not the alternate version should be played")
-                }),
+                    }
-                new GameAction("change lion count",     delegate { ClappyTrio.instance.ChangeLionCount((int)eventCaller.currentEntity.valA); }, 0.5f, false, new List<Param>()
+                },
+                new GameAction("change lion count", "Change Lion Count")
+                {
+                    function = delegate { ClappyTrio.instance.ChangeLionCount((int)eventCaller.currentEntity["valA"]); }, 
+                    defaultLength = 0.5f,  
+                    parameters = new List<Param>()
                     {
                         new Param("valA", new EntityTypes.Integer(3, 8, 3), "Lion Count", "The amount of lions")
-                }),
+                    }
+                },
                 // This is still here for backwards-compatibility but is hidden in the editor
-                new GameAction("prepare_alt",           delegate { ClappyTrio.instance.Prepare(3); }, hidden: true),
+                new GameAction("prepare_alt", "")
+                {
+                    function = delegate { ClappyTrio.instance.Prepare(3); }, 
+                    hidden = true
+                },
             });
         }
     }
@@ -59,7 +79,7 @@ namespace HeavenStudio.Games
         }
         public override void OnGameSwitch(float beat)
         {
-            Beatmap.Entity changeLion = GameManager.instance.Beatmap.entities.FindLast(c => c.datamodel == "clappyTrio/change lion count" && c.beat <= beat);
+            DynamicBeatmap.DynamicEntity changeLion = GameManager.instance.Beatmap.entities.FindLast(c => c.datamodel == "clappyTrio/change lion count" && c.beat <= beat);
             if(changeLion != null)
             {
                 EventCaller.instance.CallEvent(changeLion, true);

Assets/Scripts/Games/CoinToss/CoinToss.cs

@@ -14,40 +14,63 @@ namespace HeavenStudio.Games.Loaders
         {
             return new Minigame("coinToss", "Coin Toss", "B4E6F6", false, false, new List<GameAction>()
             {
-                new GameAction("toss",                 delegate { CoinToss.instance.TossCoin(eventCaller.currentEntity.beat, eventCaller.currentEntity.toggle); }, 7, false, parameters: new List<Param>()
+                new GameAction("toss", "Toss Coin")
+                {
+                    function = delegate { CoinToss.instance.TossCoin(eventCaller.currentEntity.beat, eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = 7, 
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Audience Reaction", "Enable Audience Reaction"),
-                }),
+                    }
-
+                },
-                new GameAction("set background color",  delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e.colorA, 0f); CoinToss.instance.ChangeBackgroundColor(e.colorB, 0f, true); }, 0.5f, false, new List<Param>()
+                new GameAction("set background color", "Set Background Color")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e["colorA"], 0f); CoinToss.instance.ChangeBackgroundColor(e["colorB"], 0f, true); }, 
+                    defaultLength = 0.5f,  
+                    parameters = new List<Param>()
                     {
                         new Param("colorA", CoinToss.defaultBgColor, "Background Color", "The background color to change to"),
                         new Param("colorB", CoinToss.defaultFgColor, "Foreground Color", "The foreground color to change to")
-                } ),
+                    } 
-                new GameAction("fade background color", delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length); CoinToss.instance.FadeBackgroundColor(e.colorC, e.colorD, e.length, true); }, 1f, true, new List<Param>()
+                },
+                new GameAction("fade background color", "Fade Background Color")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length); CoinToss.instance.FadeBackgroundColor(e["colorC"], e["colorD"], e.length, true); },
+                    resizable = true, 
+                    parameters = new List<Param>()
                     {
                         new Param("colorA", Color.white, "BG Start Color", "The starting color in the fade"),
                         new Param("colorB", CoinToss.defaultBgColor, "BG End Color", "The ending color in the fade"),
                         new Param("colorC", Color.white, "FG Start Color", "The starting color in the fade"),
                         new Param("colorD", CoinToss.defaultFgColor, "FG End Color", "The ending color in the fade")
-                } ),
+                    } 
-
+                },
-                
 
                 //left in for backwards-compatibility, but cannot be placed
-
+                new GameAction("set foreground color", "")
-                new GameAction("set foreground color", delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e.colorA, 0f, true); }, 0.5f, false, new List<Param>
+                {
+                    function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e["colorA"], 0f, true); }, 
+                    defaultLength = 0.5f, 
+                    parameters = new List<Param>
             
                     {
                         new Param("colorA", CoinToss.defaultFgColor, "Foreground Color", "The foreground color to change to")
 
-                }, hidden: true ),
+                    }, 
+                    hidden = true 
+                },
 
-                new GameAction("fade foreground color", delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length, true); }, 1f, true, new List<Param>()
+                new GameAction("fade foreground color", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length, true); },
+                    resizable = true, 
+                    parameters = new List<Param>()
                     {
                         new Param("colorA", Color.white, "Start Color", "The starting color in the fade"),
                         new Param("colorB", CoinToss.defaultFgColor, "End Color", "The ending color in the fade")
-                }, hidden: true ),
+                    }, 
+                    hidden = true 
+                },
             },
             new List<string>() {"ntr", "aim"},
             "ntrcoin", "en",

Assets/Scripts/Games/CropStomp/CropStomp.cs

@@ -13,9 +13,21 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("cropStomp", "Crop Stomp", "BFDEA6", false, false, new List<GameAction>()
             {
-                new GameAction("start marching",        delegate { CropStomp.instance.StartMarching(eventCaller.currentEntity.beat); }, 2f, false, inactiveFunction: delegate { CropStomp.MarchInactive(eventCaller.currentEntity.beat); }),
+                new GameAction("start marching", "Start Marching")
-                new GameAction("veggies",               delegate { }, 4f, true),
+                {
-                new GameAction("mole",               delegate { }, 2f, false),
+                    function = delegate { CropStomp.instance.StartMarching(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2f,
+                    inactiveFunction = delegate { CropStomp.MarchInactive(eventCaller.currentEntity.beat); }
+                },
+                new GameAction("veggies", "Veggies")
+                {
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("mole", "Mole")
+                {
+                    defaultLength = 2f
+                },
             });
         }
     }
@@ -162,7 +174,7 @@ namespace HeavenStudio.Games
             }
         }
 
-        List<Beatmap.Entity> cuedMoleSounds = new List<Beatmap.Entity>();
+        List<DynamicBeatmap.DynamicEntity> cuedMoleSounds = new List<DynamicBeatmap.DynamicEntity>();
         private void Update()
         {
             var cond = Conductor.instance;
@@ -317,7 +329,7 @@ namespace HeavenStudio.Games
                 return;
             }
             inactiveStart = beat;
-            Beatmap.Entity gameSwitch = GameManager.instance.Beatmap.entities.Find(c => c.beat >= beat && c.datamodel == "gameManager/switchGame/cropStomp");
+            DynamicBeatmap.DynamicEntity gameSwitch = GameManager.instance.Beatmap.entities.Find(c => c.beat >= beat && c.datamodel == "gameManager/switchGame/cropStomp");
             if (gameSwitch == null)
                 return;
             int length = Mathf.CeilToInt((gameSwitch.beat - beat)/2);

Assets/Scripts/Games/DJSchool/DJSchool.cs

@@ -12,39 +12,65 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("djSchool", "DJ School", "008c97", false, false, new List<GameAction>()
             {
-                //new GameAction("bop",                   delegate { DJSchool.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length);  }, 0.5f, true),
+                new GameAction("bop", "Bop")
-                new GameAction("bop",                   delegate { DJSchool.instance.Bop(eventCaller.currentEntity.toggle);  }, 0.5f, false, new List<Param>()
+                {
+                    function = delegate { DJSchool.instance.Bop(eventCaller.currentEntity["toggle"]);  }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Bop", "Whether both will bop to the beat or not")
-                }),
+                    }
-                new GameAction("and stop ooh",          delegate { var e = eventCaller.currentEntity; DJSchool.instance.AndStop(e.beat, e.toggle);  }, 2.5f, false,
+                },
-                inactiveFunction: delegate { var e = eventCaller.currentEntity; DJSchool.WarnAndStop(e.beat, e.toggle);  },
+                new GameAction("and stop ooh", "And Stop!")
-                parameters: new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; DJSchool.instance.AndStop(e.beat, e["toggle"]);  }, 
+                    defaultLength = 2.5f, 
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnAndStop(e.beat, e["toggle"]);  },
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played")
-                }),
+                    }
-                new GameAction("break c'mon ooh",       delegate { var e = eventCaller.currentEntity; DJSchool.instance.BreakCmon(e.beat, e.type, e.toggle);  }, 3f, false, 
+                },
-                inactiveFunction: delegate { var e = eventCaller.currentEntity; DJSchool.WarnBreakCmon(e.beat, e.type, e.toggle); },
+                new GameAction("break c'mon ooh", "Break, C'mon!")
-                parameters: new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; DJSchool.instance.BreakCmon(e.beat, e["type"], e["toggle"]);  }, 
+                    defaultLength = 3f,
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnBreakCmon(e.beat, e["type"], e["toggle"]); },
+                    parameters = new List<Param>()
                     {
                         new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"),
                         new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played")
-                }),
+                    }
-                new GameAction("scratch-o hey",         delegate { DJSchool.instance.ScratchoHey(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, eventCaller.currentEntity.toggle);  }, 3f, false, new List<Param>()
+                },
+                new GameAction("scratch-o hey", "Scratch-o")
+                {
+                    function = delegate { DJSchool.instance.ScratchoHey(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"], eventCaller.currentEntity["toggle"]);  }, 
+                    defaultLength = 3f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"),
                         new Param("toggle", false, "Fast Hey", "Activate Remix 4 (DS) beat")
-                }),
+                    }
-                new GameAction("dj voice lines",         delegate { DJSchool.instance.voiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type);  }, 2f, false,
+                },
-                inactiveFunction: delegate { DJSchool.WarnDJVoiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type);  },
+                new GameAction("dj voice lines", "DJ Yellow Banter")
-                parameters: new List<Param>()
+                {
+                    function = delegate { DJSchool.instance.voiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"]);  }, 
+                    defaultLength = 2f,
+                    inactiveFunction = delegate { DJSchool.WarnDJVoiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"]);  },
+                    parameters = new List<Param>()
                     {
                         new Param("type", DJSchool.DJVoiceLines.CheckItOut, "Voice Lines", "The voice line to play"),
-                }),
+                    }
-                new GameAction("sound FX",         delegate { DJSchool.instance.soundFX(eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>()
+                },
+                new GameAction("sound FX", "Scratchy Music")
+                {
+                    function = delegate { DJSchool.instance.soundFX(eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Radio FX", "Toggle on and off for Radio Effects")
-                })
+                    }
+                }
             },
             new List<string>() {"ntr", "normal"},
             "ntrdj", "en",

Assets/Scripts/Games/DrummingPractice/DrummingPractice.cs

@@ -14,25 +14,44 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("drummingPractice", "Drumming Practice", "2BCF33", false, false, new List<GameAction>()
             {
-                new GameAction("bop",                   delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.SetBop(e.beat, e.length); }, 0.5f, true),
+                new GameAction("bop", "Bop")
-                new GameAction("drum",                  delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.Prepare(e.beat, e.toggle); }, 2f, parameters: new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.SetBop(e.beat, e.length); }, 
+                    defaultLength = 0.5f, 
+                    resizable = true
+                },
+                new GameAction("drum", "Hit Drum")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.Prepare(e.beat, e["toggle"]); }, 
+                    defaultLength = 2f, 
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Applause", "Whether or not an applause should be played on a successful hit")
-                }),
+                    }
-                new GameAction("set mii",               delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.SetMiis(e.type, e.type2, e.type3, e.toggle); }, 0.5f, parameters: new List<Param>()
+                },
+                new GameAction("set mii", "Set Miis")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; DrummingPractice.instance.SetMiis(e["type"], e["type2"], e["type3"], e["toggle"]); }, 
+                    defaultLength = 0.5f, 
+                    parameters = new List<Param>()
                     {
                         new Param("type", DrummingPractice.MiiType.Random, "Player Mii", "The Mii that the player will control"),
                         new Param("type2", DrummingPractice.MiiType.Random, "Left Mii", "The Mii on the left"),
                         new Param("type3", DrummingPractice.MiiType.Random, "Right Mii", "The Mii on the right"),
                         new Param("toggle", false, "Set All to Player", "Sets all Miis to the Player's Mii")
-                }),
+                    }
-                new GameAction("set background color",  delegate {var e = eventCaller.currentEntity; DrummingPractice.instance.SetBackgroundColor(e.colorA, e.colorB, e.colorC); }, 0.5f, false, new List<Param>()
+                },
+                new GameAction("set background color", "Set Background Color")
+                {
+                    function = delegate {var e = eventCaller.currentEntity; DrummingPractice.instance.SetBackgroundColor(e["colorA"], e["colorB"], e["colorC"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("colorA", new Color(43/255f, 207/255f, 51/255f), "Color A", "The top-most color of the background gradient"),
                         new Param("colorB", new Color(1, 1, 1), "Color B", "The bottom-most color of the background gradient"),
                         new Param("colorC", new Color(1, 247/255f, 0), "Streak Color", "The color of streaks that appear on a successful hit")
-                })
+                    }
-
+                }
             });
         }
     }
@@ -81,7 +100,7 @@ namespace HeavenStudio.Games
         
         public override void OnGameSwitch(float beat)
         {
-            Beatmap.Entity changeMii = GameManager.instance.Beatmap.entities.FindLast(c => c.datamodel == "drummingPractice/set mii" && c.beat <= beat);
+            var changeMii = GameManager.instance.Beatmap.entities.FindLast(c => c.datamodel == "drummingPractice/set mii" && c.beat <= beat);
             if(changeMii != null)
             {
                 EventCaller.instance.CallEvent(changeMii, true);

Assets/Scripts/Games/FanClub/FanClub.cs

@@ -13,49 +13,76 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("fanClub", "Fan Club", "FDFD00", false, false, new List<GameAction>()
                 {
-                    new GameAction("bop",                   delegate { var e = eventCaller.currentEntity; FanClub.instance.Bop(e.beat, e.length, e.type); }, 0.5f, true, parameters: new List<Param>()
+                    new GameAction("bop", "Bop")
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.Bop(e.beat, e.length, e["type"]); }, 
+                        defaultLength = 0.5f, 
+                        resizable = true, 
+                        parameters = new List<Param>()
                         {
                             new Param("type", FanClub.IdolBopType.Both, "Bop target", "Who to make bop"),
-                    }),
+                        }
-
+                    },
-                    new GameAction("yeah, yeah, yeah",      delegate { var e = eventCaller.currentEntity; FanClub.instance.CallHai(e.beat, e.toggle); }, 8, false, parameters: new List<Param>()
+                    new GameAction("yeah, yeah, yeah", "Yeah, Yeah, Yeah!")
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallHai(e.beat, e["toggle"]); }, 
+                        defaultLength = 8,
+                        parameters = new List<Param>()
                         {
                             new Param("toggle", false, "Disable call", "Disable the idol's call")
                         },
-                        inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e.toggle);}
+                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e["toggle"]);}
-                    ),
+                    },
-
+                    new GameAction("I suppose", "I Suppose!")
-                    new GameAction("I suppose",             delegate { var e = eventCaller.currentEntity; FanClub.instance.CallKamone(e.beat, e.toggle, 0, e.type); }, 6, false, parameters: new List<Param>()
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallKamone(e.beat, e["toggle"], 0, e["type"]); }, 
+                        defaultLength = 6, 
+                        parameters = new List<Param>()
                         {
                             new Param("type", FanClub.KamoneResponseType.Through, "Response type", "Type of response to use"),
                             new Param("toggle", false, "Disable call", "Disable the idol's call")
                         },
-                        inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e.toggle, 0, e.type);}
+                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e["toggle"], 0, e["type"]);}
-                    ),
+                    },
-
+                    new GameAction("double clap", "Double Clap")
-                    new GameAction("double clap",           delegate { var e = eventCaller.currentEntity; FanClub.instance.CallBigReady(e.beat, e.toggle); }, 4, false, parameters: new List<Param>()
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallBigReady(e.beat, e["toggle"]); }, 
+                        defaultLength = 4,
+                        parameters = new List<Param>()
                         {
                             new Param("toggle", false, "Disable call", "Disable the call")
                         },
-                        inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e.toggle); }
+                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e["toggle"]); }
-                    ),
+                    },
-
+                    new GameAction("play idol animation", "Idol Coreography")
-                    new GameAction("play idol animation",   delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnim(e.beat, e.length, e.type); }, 1, true, parameters: new List<Param>()
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnim(e.beat, e.length, e["type"]); },
+                        resizable = true, 
+                        parameters = new List<Param>()
                         {
                             new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Animation to play")
-                    }),
+                        }
-
+                    },
-                    new GameAction("play stage animation",   delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnimStage(e.beat, e.type); }, 1, true, parameters: new List<Param>()
+                    new GameAction("play stage animation", "Stage Coreography")
+                    {
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnimStage(e.beat, e["type"]); }, 
+                        resizable = true, 
+                        parameters = new List<Param>()
                         {
                             new Param("type", FanClub.StageAnimations.Flash, "Animation", "Animation to play")
-                    }),
+                        }
+                    },
+                    new GameAction("set performance type", "Coreography Type")
+                    {
 
-                    new GameAction("set performance type",   delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type);}, 0.5f, false, parameters: new List<Param>()
+                        function = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e["type"]);},
+                        defaultLength = 0.5f,
+                        parameters = new List<Param>()
                         {
                             new Param("type", FanClub.IdolPerformanceType.Normal, "Performance Type", "Set of animations for the idol to use")
                         },
-                        inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type); }
+                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e["type"]); }
-                    ),
+                    },
                 },
                 new List<string>() {"ntr", "normal"},
                 "ntridol", "jp",

Assets/Scripts/Games/FirstContact/FirstContact.cs

@@ -11,28 +11,60 @@ namespace HeavenStudio.Games.Loaders
         {
             return new Minigame("firstContact", "First Contact", "008c97", false, false, new List<GameAction>()
             {
-                new GameAction("beat intervals",                   delegate { FirstContact.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length);  }, 4f, true),
+                new GameAction("beat intervals", "Start Interval")
-                new GameAction("alien speak",                   delegate { FirstContact.instance.alienSpeak(eventCaller.currentEntity.beat, eventCaller.currentEntity.valA);  }, 0.5f, false, new List<Param>()
+                {
+                    function = delegate { FirstContact.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length);  }, 
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("alien speak", "Alien Speak")
+                {
+                    function = delegate { FirstContact.instance.alienSpeak(eventCaller.currentEntity.beat, eventCaller.currentEntity["valA"]);  }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("valA", new EntityTypes.Float(.8f, 1.5f, 1f), "Pitch")
-                }),
+                    }
-                new GameAction("alien turnover",                   delegate { FirstContact.instance.alienTurnOver(eventCaller.currentEntity.beat);  }, 0.5f, false),
+                },
-                new GameAction("alien success",                   delegate { FirstContact.instance.alienSuccess(eventCaller.currentEntity.beat);  }, 1f, false),
+                new GameAction("alien turnover", "Alien Turnover")
-                new GameAction("mission control",                   delegate { FirstContact.instance.missionControlDisplay(eventCaller.currentEntity.beat, eventCaller.currentEntity.toggle, eventCaller.currentEntity.length);  }, 1f, true, new List<Param>
+                {
+                    function = delegate { FirstContact.instance.alienTurnOver(eventCaller.currentEntity.beat);  }, 
+                    defaultLength = 0.5f,
+                },
+                new GameAction("alien success", "Confirm Response")
+                {
+                    function = delegate { FirstContact.instance.alienSuccess(eventCaller.currentEntity.beat);  }, 
+                },
+                new GameAction("mission control", "Show Mission Control")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; FirstContact.instance.missionControlDisplay(e.beat, e["toggle"], e.length);  }, 
+                    resizable = true, 
+                    parameters = new List<Param>
                     {
                         new Param("toggle", false, "Stay", "If it's the end of the remix/song")
-                }),
+                    }
-                new GameAction("look at",                   delegate { FirstContact.instance.lookAtDirection(eventCaller.currentEntity.type, eventCaller.currentEntity.type);  }, .5f, false, new List<Param>()
+                },
+                new GameAction("look at", "Look At")
+                {
+                    function = delegate { FirstContact.instance.lookAtDirection(eventCaller.currentEntity["type"], eventCaller.currentEntity["type"]);  }, 
+                    defaultLength = .5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", FirstContact.alienLookAt.lookAtTranslator, "alien look at what", "[Alien] will look at what"),
                         new Param("type", FirstContact.translatorLookAt.lookAtAlien, "translator look at what", "[Translator] will look at what"),
-                }),
+                    }
-                new GameAction("live bar beat",                   delegate { FirstContact.instance.liveBarBeat(eventCaller.currentEntity.toggle);  }, .5f, false, new List<Param>()
+                },
+                new GameAction("live bar beat", "Live Bar Beat")
+                {
+                    function = delegate { FirstContact.instance.liveBarBeat(eventCaller.currentEntity["toggle"]);  }, 
+                    defaultLength = .5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "On Beat", "If the live bar animation will be on beat or not")
-                }),
+                    }
+                },
                 
-                //new GameAction("Version of First Contact",                   delegate { FirstContact.instance.versionOfFirstContact(eventCaller.currentEntity.type);  }, .5f, false, new List<Param>
+                //new GameAction("Version of First Contact",                   delegate { FirstContact.instance.versionOfFirstContact(eventCaller.currentEntity["type"]);  }, .5f, false, new List<Param>
                 //{
                 //    new Param("type", FirstContact.VersionOfContact.FirstContact, "Version", "Version of First Contact to play"),
                 //}),

Assets/Scripts/Games/ForkLifter/ForkLifter.cs

@@ -14,18 +14,54 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("forkLifter", "Fork Lifter", "FFFFFF", false, false, new List<GameAction>()
             {
-                new GameAction("flick",                 delegate { var e = eventCaller.currentEntity; ForkLifter.instance.Flick(e.beat, e.type); }, 3, false, new List<Param>()
+                new GameAction("flick", "Flick Food")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.Flick(e.beat, e["type"]); }, 
+                    defaultLength = 3,
+                    parameters = new List<Param>()
                     {
                         new Param("type", ForkLifter.FlickType.Pea, "Object", "The object to be flicked")
-                }),
+                    }
-                new GameAction("prepare",               delegate { ForkLifter.instance.ForkLifterHand.Prepare(); }, 0.5f),
+                },
-                new GameAction("gulp",                  delegate { ForkLifter.playerInstance.Eat(); }),
+                new GameAction("prepare", "Prepare Hand")
-                new GameAction("sigh",                  delegate { Jukebox.PlayOneShot("games/forkLifter/sigh"); }),
+                {
+                    function = delegate { ForkLifter.instance.ForkLifterHand.Prepare(); }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("gulp", "Swallow")
+                {
+                    function = delegate { ForkLifter.playerInstance.Eat(); }
+                },
+                new GameAction("sigh", "Sigh")
+                {
+
+                    function = delegate { Jukebox.PlayOneShot("games/forkLifter/sigh"); }
+                },
                 // These are still here for backwards-compatibility but are hidden in the editor
-                new GameAction("pea",                   delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 0); }, 3, hidden: true),
+                new GameAction("pea", "")
-                new GameAction("topbun",                delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 1); }, 3, hidden: true),
+                {
-                new GameAction("burger",                delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 2); }, 3, hidden: true),
+                    function = delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 0); }, 
-                new GameAction("bottombun",             delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 3); }, 3, hidden: true),
+                    defaultLength = 3, 
+                    hidden = true
+                },
+                new GameAction("topbun", "")
+                {
+                    function = delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 1); }, 
+                    defaultLength = 3, 
+                    hidden = true
+                },
+                new GameAction("burger", "")
+                {
+                    function = delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 2); }, 
+                    defaultLength = 3, 
+                    hidden = true
+                },
+                new GameAction("bottombun", "")
+                {
+                    function = delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 3); }, 
+                    defaultLength = 3, 
+                    hidden = true
+                },
             });
         }
     }

Assets/Scripts/Games/Global/Flash.cs

@@ -22,7 +22,7 @@ namespace HeavenStudio.Games.Global
 
         [SerializeField] private Color currentCol;
 
-        private List<Beatmap.Entity> allFadeEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> allFadeEvents = new List<DynamicBeatmap.DynamicEntity>();
 
         private void Awake()
         {
@@ -64,7 +64,7 @@ namespace HeavenStudio.Games.Global
 
             if (allFadeEvents.Count > 0)
             {
-                Beatmap.Entity startEntity = null;
+                DynamicBeatmap.DynamicEntity startEntity = null;
 
                 for (int i = 0; i < allFadeEvents.Count; i++)
                 {
@@ -85,14 +85,14 @@ namespace HeavenStudio.Games.Global
                 {
                     if (!override_)
                     {
-                        Color colA = startEntity.colorA;
+                        Color colA = startEntity["colorA"];
-                        Color colB = startEntity.colorB;
+                        Color colB = startEntity["colorB"];
 
-                        startCol = new Color(colA.r, colA.g, colA.b, startEntity.valA);
+                        startCol = new Color(colA.r, colA.g, colA.b, startEntity["valA"]);
-                        endCol = new Color(colB.r, colB.g, colB.b, startEntity.valB);
+                        endCol = new Color(colB.r, colB.g, colB.b, startEntity["valB"]);
                     }
 
-                    SetFade(startEntity.beat, startEntity.length, startCol, endCol, startEntity.ease);
+                    SetFade(startEntity.beat, startEntity.length, startCol, endCol, (EasingFunction.Ease) startEntity["ease"]);
                 }
             }
         }

Assets/Scripts/Games/Global/Textbox.cs

@@ -27,10 +27,10 @@ namespace HeavenStudio.Games.Global
             Bottom,
         }
 
-        private List<Beatmap.Entity> textboxEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> textboxEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> openCaptionsEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> openCaptionsEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> idolEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> idolEvents = new List<DynamicBeatmap.DynamicEntity>();
-        private List<Beatmap.Entity> closedCaptionsEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> closedCaptionsEvents = new List<DynamicBeatmap.DynamicEntity>();
 
         Textbox instance;
 
@@ -114,11 +114,11 @@ namespace HeavenStudio.Games.Global
                 if (prog >= 0f && prog <= 1f)
                 {
                     TextboxEnabler.SetActive(true);
-                    TextboxObject.SetText(e.text1);
+                    TextboxObject.SetText(e["text1"]);
-                    TextboxObject.Resize(e.valA, e.valB);
+                    TextboxObject.Resize(e["valA"], e["valB"]);
 
                     // ouch
-                    switch (e.type)
+                    switch (e["type"])
                     {
                         case (int) TextboxAnchor.TopLeft:
                             TextboxEnabler.transform.localPosition = new Vector3(-XAnchor, YAnchor);
@@ -170,12 +170,12 @@ namespace HeavenStudio.Games.Global
                 if (prog >= 0f && prog <= 1f)
                 {
                     OpenCaptionsEnabler.SetActive(true);
-                    OpenCaptionsLabel.text = e.text1;
+                    OpenCaptionsLabel.text = e["text1"];
 
-                    OpenCaptionsLabelRect.sizeDelta = new Vector2(18f * e.valA, 2.5f * e.valB);
+                    OpenCaptionsLabelRect.sizeDelta = new Vector2(18f * e["valA"], 2.5f * e["valB"]);
 
                     // ouch
-                    switch (e.type)
+                    switch (e["type"])
                     {
                         case (int) TextboxAnchor.TopLeft:
                             OpenCaptionsEnabler.transform.localPosition = new Vector3(-XAnchor, YAnchor);
@@ -228,8 +228,8 @@ namespace HeavenStudio.Games.Global
                 if (prog >= 0f && prog <= 1f)
                 {
                     float inp = cond.GetPositionFromBeat(e.beat, 1);
-                    IdolSongLabel.text = e.text1;
+                    IdolSongLabel.text = e["text1"];
-                    IdolArtistLabel.text = e.text2;
+                    IdolArtistLabel.text = e["text2"];
 
                     IdolAnimator.Play("IdolShow", -1, Mathf.Min(inp, 1));
                     IdolAnimator.speed = 0;
@@ -264,18 +264,18 @@ namespace HeavenStudio.Games.Global
                 if (prog >= 0f && prog <= 1f)
                 {
                     ClosedCaptionsEnabler.SetActive(true);
-                    ClosedCaptionsLabel.text = e.text1;
+                    ClosedCaptionsLabel.text = e["text1"];
 
-                    ClosedCaptionsLabelRect.sizeDelta = new Vector2(9f, e.valA);
+                    ClosedCaptionsLabelRect.sizeDelta = new Vector2(9f, e["valA"]);
-                    ClosedCaptionsBgRect.sizeDelta = new Vector2(9f, e.valA);
+                    ClosedCaptionsBgRect.sizeDelta = new Vector2(9f, e["valA"]);
 
-                    switch (e.type)
+                    switch (e["type"])
                     {
                         case (int) ClosedCaptionsAnchor.Bottom:
-                            ClosedCaptionsEnabler.transform.localPosition = new Vector3(0, -2.5f + e.valA/2);
+                            ClosedCaptionsEnabler.transform.localPosition = new Vector3(0, -2.5f + e["valA"]/2);
                             break;
                         default:
-                            ClosedCaptionsEnabler.transform.localPosition = new Vector3(0, 2.5f - e.valA/2);
+                            ClosedCaptionsEnabler.transform.localPosition = new Vector3(0, 2.5f - e["valA"]/2);
                             break;
                     }
 

Assets/Scripts/Games/KarateMan/KarateMan.cs

@@ -13,58 +13,97 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("karateman", "Karate Man", "70A8D8", false, false, new List<GameAction>()
             {
-                new GameAction("bop",                   delegate { KarateMan.instance.ToggleBop(eventCaller.currentEntity.toggle); }, 0.5f, false, new List<Param>()
+                new GameAction("bop", "Bop")
+                {
+                    function = delegate { KarateMan.instance.ToggleBop(eventCaller.currentEntity["toggle"]); },
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Bop", "Whether to bop to the beat or not")
                     },
-                    inactiveFunction: delegate { KarateMan.ToggleBopUnloaded(eventCaller.currentEntity.toggle); }
+                    inactiveFunction = delegate { KarateMan.ToggleBopUnloaded(eventCaller.currentEntity["toggle"]); }
-                ),
+                },
-                new GameAction("hit",                   delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateItem(e.beat, e.type, e.type2); }, 2, false, 
+                new GameAction("hit", "Toss Object") {
-                    new List<Param>()
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateItem(e.beat, e["type"], e["type2"]); }, 
+                    defaultLength = 2,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.HitType.Pot, "Object", "The object to fire"),
                         new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit")
-                    }),
+                    }
-                new GameAction("bulb",                  delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateBulbSpecial(e.beat, e.type, e.colorA, e.type2); }, 2, false, 
+                },
-                    new List<Param>()
+                new GameAction("bulb", "Toss Lightbulb")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateBulbSpecial(e.beat, e["type"], e["colorA"], e["type2"]); }, 
+                    defaultLength = 2,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.LightBulbType.Normal, "Type", "The preset bulb type. Yellow is used for kicks while Blue is used for combos"),
                         new Param("colorA", new Color(1f,1f,1f), "Custom Color", "The color to use when the bulb type is set to Custom"),
                         new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit")
-                    }),
+                    },
-                new GameAction("kick",                  delegate { var e = eventCaller.currentEntity; KarateMan.instance.Kick(e.beat, e.toggle, e.type); }, 4f, false,
+                },
-                    new List<Param>()
+                new GameAction("kick", "Special: Kick")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Kick(e.beat, e["toggle"], e["type"]); }, 
+                    defaultLength = 4f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Contains Ball", "Barrel contains a ball instead of a bomb?"),
                         new Param("type", KarateMan.KarateManFaces.Smirk, "Success Expression", "The facial expression to set Joe to on hit")
                     }
-                ),
+                },
-                new GameAction("combo",                 delegate { var e = eventCaller.currentEntity; KarateMan.instance.Combo(e.beat, e.type); }, 4f, false,
+                new GameAction("combo", "Special: Combo")
-                    new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Combo(e.beat, e["type"]); }, 
+                    defaultLength = 4,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.KarateManFaces.Happy, "Success Expression", "The facial expression to set Joe to on hit")
                     }
-                ),
+                },
-                new GameAction("hitX",                  delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); }, 1f, false, 
+                new GameAction("hitX", "Warnings")
-                    new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e["type"]); }, 
+                    defaultLength = 1f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show")
                     },
-                    inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.DoWordSound(e.beat, e.type); }
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.DoWordSound(e.beat, e["type"]); }
-                ),
+                },
-                new GameAction("special camera",               delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); }, 8f, true, new List<Param>()
+                new GameAction("special camera", "Special Camera")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e["toggle"]); }, 
+                    defaultLength = 8f, 
+                    resizable = true, 
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Return Camera", "Camera zooms back in?"),
                     },
-                    inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); }    
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e["toggle"]); }    
-                ),
+                },
-                new GameAction("prepare",               delegate { var e = eventCaller.currentEntity; KarateMan.instance.Prepare(e.beat, e.length);}, 1f, true),
+                new GameAction("prepare", "Preparation Stance")
-                new GameAction("set gameplay modifiers",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetGameplayMods(e.beat, e.type, e.toggle); }, 0.5f, false, new List<Param>()
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Prepare(e.beat, e.length);}, 
+                    resizable = true
+                },
+                new GameAction("set gameplay modifiers", "Gameplay Modifiers")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetGameplayMods(e.beat, e["type"], e["toggle"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.NoriMode.None, "Flow Bar type", "The type of Flow bar to use"),
                         new Param("toggle", true, "Enable Combos", "Allow the player to combo? (Contextual combos will still be allowed even when off)"),
-                }),
+                    }
-                new GameAction("set background effects",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3); KarateMan.instance.SetBgTexture(e.type4, e.type5, e.colorC, e.colorD); }, 0.5f, true, new List<Param>()
+                },
+                new GameAction("set background effects", "Background Appearance")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e["type"], e["type2"], e["colorA"], e["colorB"], e["type3"]); KarateMan.instance.SetBgTexture(e["type4"], e["type5"], e["colorC"], e["colorD"]); }, 
+                    defaultLength = 0.5f, 
+                    resizable = true, 
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"),
                         new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"),
@@ -77,43 +116,96 @@ namespace HeavenStudio.Games.Loaders
                         new Param("colorD", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"),
 
                     },
-                    inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.SetBgEffectsUnloaded(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3, e.type4, e.type5, e.colorC, e.colorD); }
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.SetBgEffectsUnloaded(e.beat, e.length, e["type"], e["type2"], e["colorA"], e["colorB"], e["type3"], e["type4"], e["type5"], e["colorC"], e["colorD"]); }
-                ),
+                },
-                new GameAction("set object colors",    delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); }, 0.5f, false, new List<Param>()
+                new GameAction("set object colors", "Object Colors")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e["colorA"], e["colorB"], e["colorC"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("colorA", new Color(1,1,1,1), "Joe Body Color", "The color to use for Karate Joe's body"),
                         new Param("colorB", new Color(0.81f,0.81f,0.81f,1), "Joe Highlight Color", "The color to use for Karate Joe's highlights"),
                         new Param("colorC", new Color(1,1,1,1), "Item Color", "The color to use for the thrown items"),
                     },
-                    inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); }
+                    inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e["colorA"], e["colorB"], e["colorC"]); }
-                ),
+                },
-                new GameAction("particle effects",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetParticleEffect(e.beat, e.type, e.valA, e.valB); }, 0.5f, false, new List<Param>()
+                new GameAction("particle effects", "Particle Effects")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetParticleEffect(e.beat, e["type"], e["valA"], e["valB"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.ParticleType.None, "Particle Type", "The type of particle effect to spawn. Using \"None\" will stop all effects"),
                         new Param("valA", new EntityTypes.Float(0f, 64f, 1f), "Wind Strength", "The strength of the particle wind"),
                         new Param("valB", new EntityTypes.Float(1f, 16f, 1f), "Particle Intensity", "The intensity of the particle effect")
-                }),
+                    }
-                new GameAction("force facial expression",  delegate { KarateMan.instance.SetFaceExpression(eventCaller.currentEntity.type); }, 0.5f, false, new List<Param>()
+                },
+                new GameAction("force facial expression", "Set Facial Expression")
+                {
+                    function = delegate { KarateMan.instance.SetFaceExpression(eventCaller.currentEntity["type"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.KarateManFaces.Normal, "Facial Expression", "The facial expression to force Joe to. Special moves may override this")
-                }),
+                    }
+                },
 
                 // These are still here for backwards-compatibility but are hidden in the editor
-                new GameAction("pot",                   delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Pot); }, 2, hidden: true),
+                new GameAction("pot", "")
-                new GameAction("rock",                  delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Rock); }, 2, hidden: true),
+                {
-                new GameAction("ball",                  delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Ball); }, 2, hidden: true),
+                    function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Pot); }, 
-                new GameAction("tacobell",              delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.TacoBell); }, 2, hidden: true),
+                    defaultLength = 2, 
-                new GameAction("hit4",                  delegate { KarateMan.instance.DoWord(eventCaller.currentEntity.beat, (int) KarateMan.HitThree.HitFour); }, hidden: true),
+                    hidden = true
-                new GameAction("bgfxon",                delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.Sunburst, e.beat, e.length); }, hidden: true),
+                },
-                new GameAction("bgfxoff",               delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.None, e.beat, e.length); }, hidden: true),
+                new GameAction("rock", "")
-                new GameAction("hit3",                  delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); }, 1f, false, 
+                {
-                    new List<Param>()
+                    function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Rock); }, 
+                    defaultLength = 2, 
+                    hidden = true
+                },
+                new GameAction("ball", "")
+                {
+                    function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Ball); }, 
+                    defaultLength = 2, 
+                    hidden = true
+                },
+                new GameAction("tacobell", "")
+                {
+                    function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.TacoBell); }, 
+                    defaultLength = 2, 
+                    hidden = true
+                },
+                new GameAction("bgfxon", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.Sunburst, e.beat, e.length); }, 
+                    hidden = true
+                },
+                new GameAction("bgfxoff", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.None, e.beat, e.length); }, 
+                    hidden = true
+                },
+                new GameAction("hit3", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e["type"]); },
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show")
                     }, 
-                hidden: true),
+                    hidden = true
-                new GameAction("set background color",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, (int) KarateMan.currentBgEffect); }, 0.5f, false, 
+                },
-                    new List<Param>()
+                new GameAction("hit4", "")
+                {
+                    function = delegate { KarateMan.instance.DoWord(eventCaller.currentEntity.beat, (int) KarateMan.HitThree.HitFour); },
+                    hidden = true
+                },
+                new GameAction("set background color", "")
+                {
+
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e["type"], e["type2"], e["colorA"], e["colorB"], (int) KarateMan.currentBgEffect); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"),
                         new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"),
@@ -121,22 +213,32 @@ namespace HeavenStudio.Games.Loaders
                         new Param("colorB", new Color(), "Custom Shadow Color", "The shadow color to use when shadow type is set to Custom"),
 
                     },
-                hidden: true),
+                    hidden = true
-                new GameAction("set background fx",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx(e.type, e.beat, e.length); }, 0.5f, false, new List<Param>()
+                },
+                new GameAction("set background fx", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx(e["type"], e.beat, e.length); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.BackgroundFXType.None, "FX Type", "The background effect to be displayed")
                     },
-                hidden: true),
+                    hidden = true
+                },
 
-                 new GameAction("set background texture",  delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgTexture(e.type, e.type2, e.colorA, e.colorB); }, 0.5f, false, new List<Param>()
+                new GameAction("set background texture", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgTexture(e["type"], e["type2"], e["colorA"], e["colorB"]); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>()
                     {
                         new Param("type", KarateMan.BackgroundTextureType.Plain, "Texture", "The type of background texture to use"),
                         new Param("type2", KarateMan.ShadowType.Tinted, "Color Filter Type", "The method used to apply colour to the texture"),
                         new Param("colorA", new Color(), "Custom Filter Color", "The filter color to use when color filter type is set to Custom"),
                         new Param("colorB", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"),
                     },
-                hidden: true),
+                    hidden = true
-
+                },
             },
             new List<string>() {"agb", "ntr", "rvl", "ctr", "pco", "normal"},
             "karate", "en",
@@ -440,8 +542,8 @@ namespace HeavenStudio.Games
             BGEffect.transform.position = new Vector3(GameCamera.instance.transform.position.x, GameCamera.instance.transform.position.y, 0);
         }
 
-        static List<Beatmap.Entity> allHits = new List<Beatmap.Entity>();
+        static List<DynamicBeatmap.DynamicEntity> allHits = new List<DynamicBeatmap.DynamicEntity>();
-        static List<Beatmap.Entity> allEnds = new List<Beatmap.Entity>();
+        static List<DynamicBeatmap.DynamicEntity> allEnds = new List<DynamicBeatmap.DynamicEntity>();
         public static int CountHitsToEnd(float fromBeat)
         {
             allHits = EventCaller.GetAllInGameManagerList("karateman", new string[] { "hit", "bulb", "kick", "combo" });
@@ -452,7 +554,7 @@ namespace HeavenStudio.Games
             float endBeat = Single.MaxValue;
 
             //get the beat of the closest end event
-            foreach (Beatmap.Entity end in allEnds)
+            foreach (var end in allEnds)
             {
                 if (end.beat > fromBeat)
                 {
@@ -467,7 +569,7 @@ namespace HeavenStudio.Games
             string type;
             for (int i = 0; i < allHits.Count; i++)
             {
-                Beatmap.Entity h = allHits[i];
+                var h = allHits[i];
                 if (h.beat >= fromBeat)
                 {
                     if (h.beat < endBeat)
@@ -704,8 +806,8 @@ namespace HeavenStudio.Games
                 var e = bgfx[i];
                 if (e.beat > beat)
                     break;
-                SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3);
+                SetBgAndShadowCol(e.beat, e.length, e["type"], e["type2"], e["colorA"], e["colorB"], e["type3"]);
-                SetBgTexture(e.type4, e.type5, e.colorC, e.colorD);
+                SetBgTexture(e["type4"], e["type5"], e["colorC"], e["colorD"]);
             }
             var camfx = GameManager.instance.Beatmap.entities.FindAll(en => en.datamodel == "karateman/special camera");
             for (int i = 0; i < camfx.Count; i++)
@@ -713,7 +815,7 @@ namespace HeavenStudio.Games
                 var e = camfx[i];
                 if (e.beat > beat)
                     break;
-                DoSpecialCamera(e.beat, e.length, e.toggle);
+                DoSpecialCamera(e.beat, e.length, e["toggle"]);
             }
             // has issues when creating a new hitx entity so this is deactivated for now
             // var hitx = GameManager.instance.Beatmap.entities.FindAll(en => en.datamodel == "karateman/hitX");
@@ -723,7 +825,7 @@ namespace HeavenStudio.Games
             //     if (e.beat > beat)
             //         break;
             //     Debug.Log("hitx");
-            //     DoWord(e.beat, e.type, false);
+            //     DoWord(e.beat, e["type"], false);
             // }
             
         }

Assets/Scripts/Games/KarateMan/KarateManNoriController.cs

@@ -37,6 +37,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
         static float PeriodHigh = 15 / 60f;
 
         int noriMode = (int)KarateMan.NoriMode.None;
+        bool playedJust = false;
 
         int inputsToSwitch = 0;
         //takes 12% of inputs to fill the nori bar
@@ -69,6 +70,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
                     NoriHolder = NoriHolderTengoku;
                     NoriManiaInk00.SetActive(false);
                     NoriManiaInk01.SetActive(false);
+                    playedJust = false;
                     break;
                 case (int) KarateMan.NoriMode.Mania:
                     MaxNori = 10;
@@ -77,6 +79,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
                     NoriHolder = NoriHolderMania00;
                     NoriManiaInk00.SetActive(true);
                     NoriManiaInk01.SetActive(false);
+                    playedJust = false;
 
                     inputsToSwitch = KarateMan.CountHitsToEnd(fromBeat);
                     break;
@@ -85,6 +88,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
                     Nori = 0;
                     NoriManiaInk00.SetActive(false);
                     NoriManiaInk01.SetActive(false);
+                    playedJust = false;
                     return;
             }
 
@@ -136,8 +140,9 @@ namespace HeavenStudio.Games.Scripts_KarateMan
                         NoriHeartAnimators[i].Play("NoriFull", -1, (Time.time * PeriodHigh) % 1f);
                 }
             }
-            if (KarateMan.instance.NoriPerformance >= 0.6f && oldNori / MaxNori < 0.6f)
+            if (KarateMan.instance.NoriPerformance >= 0.6f && oldNori / MaxNori < 0.6f && !playedJust)
             {
+                playedJust = true;
                 Jukebox.PlayOneShotGame("karateman/nori_just");
             }
             UpdateHeartColours();
@@ -176,6 +181,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
             }
             if (KarateMan.instance.NoriPerformance < 0.6f && oldNori / MaxNori >= 0.6f)
             {
+                playedJust = false;
                 Jukebox.PlayOneShotGame("karateman/nori_ng");
             }
             UpdateHeartColours();
@@ -189,6 +195,7 @@ namespace HeavenStudio.Games.Scripts_KarateMan
             {
                 if (Nori >= MaxNori)
                     Jukebox.PlayOneShotGame("karateman/nori_through");
+                playedJust = false;
                 Nori = 0;
                 foreach (Animator anim in NoriHeartAnimators)
                 {
@@ -215,6 +222,8 @@ namespace HeavenStudio.Games.Scripts_KarateMan
                     }
                 }
             }
+            if (KarateMan.instance.NoriPerformance < 0.6f)
+                playedJust = false;
             UpdateHeartColours();
         }
 

Assets/Scripts/Games/MrUpbeat/MrUpbeat.cs

@@ -15,12 +15,28 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("mrUpbeat", "Mr. Upbeat", "FFFFFF", false, false, new List<GameAction>()
             {
-                new GameAction("prepare",               delegate { MrUpbeat.instance.SetInterval(eventCaller.currentEntity.beat); }, 0.5f, true, inactiveFunction: delegate { MrUpbeat.Beep(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }),
+                new GameAction("prepare", "Prepare")
-                new GameAction("go",                    delegate { MrUpbeat.instance.Go(eventCaller.currentEntity.beat);  }, 4f, true),
+                {
-                new GameAction("ding!",                 delegate { MrUpbeat.instance.Ding(eventCaller.currentEntity.toggle); }, 0.5f, parameters: new List<Param>()
+                    function = delegate { MrUpbeat.instance.SetInterval(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 0.5f, 
+                    resizable = true, 
+                    inactiveFunction = delegate { MrUpbeat.Beep(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }
+                },
+                new GameAction("go", "Start Stepping")
+                {
+                    function = delegate { MrUpbeat.instance.Go(eventCaller.currentEntity.beat);  }, 
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("ding!", "Finish Stepping")
+                {
+                    function = delegate { MrUpbeat.instance.Ding(eventCaller.currentEntity["toggle"]); },
+                    defaultLength = 0.5f, 
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Applause")
-                }),
+                    }
+                },
             });
         }
     }
@@ -66,7 +82,7 @@ namespace HeavenStudio.Games
 
         private void Update()
         {
-            List<Beatmap.Entity> gos = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "mrUpbeat/go");
+            List<DynamicBeatmap.DynamicEntity> gos = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "mrUpbeat/go");
             for (int i = 0; i < gos.Count; i++)
             {
                 if ((gos[i].beat - 0.15f) <= Conductor.instance.songPositionInBeats && (gos[i].beat + gos[i].length) - 0.15f > Conductor.instance.songPositionInBeats)
@@ -102,7 +118,7 @@ namespace HeavenStudio.Games
 
         public override void OnGameSwitch(float beat)
         {
-            foreach (Beatmap.Entity entity in GameManager.instance.Beatmap.entities)
+            foreach (var entity in GameManager.instance.Beatmap.entities)
             {
                 if (entity.beat > beat) //the list is sorted based on the beat of the entity, so this should work fine.
                 {

Assets/Scripts/Games/PajamaParty/PajamaParty.cs

@@ -15,25 +15,38 @@ namespace HeavenStudio.Games.Loaders
             return new Minigame("pajamaParty", "Pajama Party", "965076", false, false, new List<GameAction>()
                 {
                     // both same timing
-                    new GameAction("jump (side to middle)",     delegate {PajamaParty.instance.DoThreeJump(eventCaller.currentEntity.beat);}, 4f, false, 
+                    new GameAction("jump (side to middle)", "Side to Middle Jumps")
-                        inactiveFunction: delegate {PajamaParty.WarnThreeJump(eventCaller.currentEntity.beat);}
+                    {
-                    ),
+                        function = delegate {PajamaParty.instance.DoThreeJump(eventCaller.currentEntity.beat);},
-                    new GameAction("jump (back to front)",      delegate {PajamaParty.instance.DoFiveJump(eventCaller.currentEntity.beat);}, 4f, false, 
+                        defaultLength = 4f,
-                        inactiveFunction: delegate {PajamaParty.WarnFiveJump(eventCaller.currentEntity.beat);}
+                        inactiveFunction = delegate {PajamaParty.WarnThreeJump(eventCaller.currentEntity.beat);}
-                        ),
+                    },
+                    new GameAction("jump (back to front)", "Back to Front Jumps")
+                    {
+                        function =delegate {PajamaParty.instance.DoFiveJump(eventCaller.currentEntity.beat);}, 
+                        defaultLength = 4f, 
+                        inactiveFunction = delegate {PajamaParty.WarnFiveJump(eventCaller.currentEntity.beat);}
+                    },
                     //idem
-                    new GameAction("slumber",                   delegate {var e = eventCaller.currentEntity; PajamaParty.instance.DoSleepSequence(e.beat, e.toggle, e.type);}, 8f, false, parameters: new List<Param>()
+                    new GameAction("slumber", "Slumber")
+                    {
+                        function = delegate {var e = eventCaller.currentEntity; PajamaParty.instance.DoSleepSequence(e.beat, e["toggle"], e["type"]);}, 
+                        defaultLength = 8f,
+                        parameters = new List<Param>()
                         {
                             new Param("type", PajamaParty.SleepType.Normal, "Sleep Type", "Type of sleep action to use"),
                             new Param("toggle", false, "Alt. Animation", "Use an alternate animation for Mako")
                         }, 
-                        inactiveFunction: delegate {var e = eventCaller.currentEntity; PajamaParty.WarnSleepSequence(e.beat, e.toggle);}
+                        inactiveFunction = delegate {var e = eventCaller.currentEntity; PajamaParty.WarnSleepSequence(e.beat, e["toggle"]);}
-                    ),
+                    },
-                    new GameAction("throw",                     delegate {PajamaParty.instance.DoThrowSequence(eventCaller.currentEntity.beat);}, 8f, false, 
+                    new GameAction("throw", "Throw Pillows")
-                        inactiveFunction: delegate {PajamaParty.WarnThrowSequence(eventCaller.currentEntity.beat);}
+                    {
-                    ),
+                        function = delegate {PajamaParty.instance.DoThrowSequence(eventCaller.currentEntity.beat);}, 
-                    //cosmetic
+                        defaultLength = 8f,
-                    // new GameAction("open / close background",   delegate { }, 2f, true),
+                        inactiveFunction = delegate {PajamaParty.WarnThrowSequence(eventCaller.currentEntity.beat);}
+                    },
+                    // todo cosmetic crap
+                    // background stuff
                     // do shit with mako's face? (talking?)
                 },
                 new List<string>() {"ctr", "normal"},

Assets/Scripts/Games/RhythmRally/RhythmRally.cs

@@ -14,24 +14,65 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("rhythmRally", "Rhythm Rally", "FFFFFF", true, false, new List<GameAction>()
             {
-                new GameAction("bop",                   delegate { RhythmRally.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 0.5f, true),
+                new GameAction("bop", "Bop")
-                new GameAction("whistle",               delegate { RhythmRally.instance.PlayWhistle(); }, 0.5f),
+                {
-                new GameAction("toss ball",             delegate { RhythmRally.instance.Toss(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, 6f, true); }, 2f),
+                    function = delegate { RhythmRally.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 
-                new GameAction("rally",                 delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Normal); }, 4f, true),
+                    defaultLength = 0.5f, 
-                new GameAction("slow rally",            delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Slow); }, 8f, true),
+                    resizable = true
-                new GameAction("fast rally",            delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Fast); }, 6f),
+                },
-                new GameAction("superfast rally",       delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.SuperFast); }, 12f),
+                new GameAction("whistle", "Whistle")
-                new GameAction("pose",                  delegate { RhythmRally.instance.Pose(); }, 0.5f),
+                {
-                new GameAction("camera",                delegate {
+                    function = delegate { RhythmRally.instance.PlayWhistle(); },
+                    defaultLength = 0.5f
+                },
+                new GameAction("toss ball", "Toss Ball")
+                {
+                    function = delegate { RhythmRally.instance.Toss(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, 6f, true); }, 
+                    defaultLength = 2f
+                },
+                new GameAction("rally", "Rally")
+                {
+                    function = delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Normal); }, 
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("slow rally", "Slow Rally")
+                {
+                    function = delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Slow); }, 
+                    defaultLength = 8f, 
+                    resizable = true
+                },
+                new GameAction("fast rally", "Fast Rally")
+                {
+                    function = delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Fast); }, 
+                    defaultLength = 6f
+                },
+                new GameAction("superfast rally", "Superfast Rally")
+                {
+                    function = delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.SuperFast); }, 
+                    defaultLength = 12f
+                },
+                new GameAction("pose", "End Pose")
+                {
+                    function = delegate { RhythmRally.instance.Pose(); }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("camera", "Camera Controls")
+                {
+                    function = delegate {
                         var e = eventCaller.currentEntity;
-                    var rotation = new Vector3(0, e.valA, 0);
+                        var rotation = new Vector3(0, e["valA"], 0);
-                    RhythmRally.instance.ChangeCameraAngle(rotation, e.valB, e.length, (Ease)e.type, (RotateMode)e.type2);
+                        RhythmRally.instance.ChangeCameraAngle(rotation, e["valB"], e.length, (Ease)e["type"], (RotateMode)e["type2"]);
-                }, 4, true, new List<Param>() {
+                    }, 
+                    defaultLength = 4, 
+                    resizable = true, 
+                    parameters = new List<Param>() {
                         new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Angle", "The rotation of the camera around the center of the table"),
                         new Param("valB", new EntityTypes.Float(0.5f, 4f, 1), "Zoom", "The camera's level of zoom (Lower value = Zoomed in)"),
                         new Param("type", Ease.Linear, "Ease", "The easing function to use"),
                         new Param("type2", RotateMode.Fast, "Rotation Mode", "The rotation mode to use")
-                } ),
+                    } 
+                },
             });
         }
     }
@@ -218,7 +259,7 @@ namespace HeavenStudio.Games
                 // Check if the opponent should swing.
                 if (!served && timeBeforeNextHit <= 0f)
                 {
-                    List<Beatmap.Entity> rallies = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "rhythmRally/rally" || c.datamodel == "rhythmRally/slow rally");
+                    var rallies = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "rhythmRally/rally" || c.datamodel == "rhythmRally/slow rally");
                     for (int i = 0; i < rallies.Count; i++)
                     {
                         var rally = rallies[i];

Assets/Scripts/Games/RhythmSomen/RhythmSomen.cs

@@ -11,10 +11,25 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("rhythmSomen", "Rhythm Sōmen", "000000", false, false, new List<GameAction>()
             {
-                new GameAction("crane (far)",                   delegate { RhythmSomen.instance.DoFarCrane(eventCaller.currentEntity.beat); }, 4.0f, false),
+                new GameAction("crane (far)", "Far Crane")
-                new GameAction("crane (close)",                   delegate { RhythmSomen.instance.DoCloseCrane(eventCaller.currentEntity.beat); }, 3.0f, false),
+                {
-                new GameAction("crane (both)",                   delegate { RhythmSomen.instance.DoBothCrane(eventCaller.currentEntity.beat); }, 4.0f, false),
+                    function = delegate { RhythmSomen.instance.DoFarCrane(eventCaller.currentEntity.beat); }, 
-                new GameAction("offbeat bell",                   delegate { RhythmSomen.instance.DoBell(eventCaller.currentEntity.beat); }, 1.0f, false),
+                    defaultLength = 4.0f, 
+                },
+                new GameAction("crane (close)", "Close Crane")
+                {
+                    function = delegate { RhythmSomen.instance.DoCloseCrane(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 3.0f, 
+                },
+                new GameAction("crane (both)", "Both Cranes")
+                {
+                    function = delegate { RhythmSomen.instance.DoBothCrane(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 4.0f, 
+                },
+                new GameAction("offbeat bell", "Offbeat Warning")
+                {
+                    function = delegate { RhythmSomen.instance.DoBell(eventCaller.currentEntity.beat); },
+                },
             });
         }
     }

Assets/Scripts/Games/RhythmTweezers/RhythmTweezers.cs

@@ -15,32 +15,74 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("rhythmTweezers", "Rhythm Tweezers", "98b389", false, false, new List<GameAction>()
             {
-                new GameAction("start interval",        delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 4f, true),
+                new GameAction("start interval", "Start Interval")
-                new GameAction("short hair",            delegate { RhythmTweezers.instance.SpawnHair(eventCaller.currentEntity.beat); }, 0.5f),
+                {
-                new GameAction("long hair",             delegate { RhythmTweezers.instance.SpawnLongHair(eventCaller.currentEntity.beat); }, 0.5f),
+                    function = delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 
-                new GameAction("next vegetable",        delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.NextVegetable(e.beat, e.type, e.colorA, e.colorB); }, 0.5f, false, new List<Param>() 
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("short hair", "Short Hair")
+                {
+
+                    function = delegate { RhythmTweezers.instance.SpawnHair(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("long hair", "Curly Hair")
+                {
+                    function = delegate { RhythmTweezers.instance.SpawnLongHair(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("next vegetable", "Swap Vegetable")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.NextVegetable(e.beat, e["type"], e["colorA"], e["colorB"]); }, 
+                    defaultLength = 0.5f, 
+                    parameters = new List<Param>() 
                     {
                         new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "The vegetable to switch to"),
                         new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "The color of the onion"),
                         new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "The color of the potato")
-                } ),
+                    } 
-                new GameAction("change vegetable",      delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeVegetableImmediate(e.type, e.colorA, e.colorB); }, 0.5f, false, new List<Param>() 
+                },
+                new GameAction("change vegetable", "Change Vegetable (Instant)")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeVegetableImmediate(e["type"], e["colorA"], e["colorB"]); }, 
+                    defaultLength = 0.5f, 
+                    parameters = new List<Param>() 
                     {
                         new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "The vegetable to switch to"),
                         new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "The color of the onion"),
                         new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "The color of the potato")
-                } ),
+                    }
-                new GameAction("set tweezer delay",     delegate { RhythmTweezers.instance.tweezerBeatOffset = eventCaller.currentEntity.length; }, 1f, true),
+                },
-                new GameAction("reset tweezer delay",   delegate { RhythmTweezers.instance.tweezerBeatOffset = 0f; }, 0.5f),
+                new GameAction("set tweezer delay", "Offset Tweezer")
-                new GameAction("set background color",  delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e.colorA, 0f); }, 0.5f, false, new List<Param>() 
+                {
+                    function = delegate { RhythmTweezers.instance.tweezerBeatOffset = eventCaller.currentEntity.length; },
+                    resizable = true
+                },
+                new GameAction("reset tweezer delay", "Reset Tweezer Offset")
+                {
+                    function = delegate { RhythmTweezers.instance.tweezerBeatOffset = 0f; }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("set background color", "Background Colour")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e["colorA"], 0f); }, 
+                    defaultLength = 0.5f,
+                    parameters = new List<Param>() 
                     {
                         new Param("colorA", RhythmTweezers.defaultBgColor, "Background Color", "The background color to change to")
-                } ),
+                    } 
-                new GameAction("fade background color", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length); }, 1f, true, new List<Param>() 
+                },
+                new GameAction("fade background color", "Background Fade")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length); },
+                    resizable = true, 
+                    parameters = new List<Param>() 
                     {
                         new Param("colorA", Color.white, "Start Color", "The starting color in the fade"),
                         new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "The ending color in the fade")
-                } ),
+                    } 
+                }
             });
         }
     }

Assets/Scripts/Games/SamuraiSliceNtr/SamuraiSliceNtr.cs

@@ -14,15 +14,19 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("samuraiSliceNtr", "Samurai Slice (DS)", "00165D", false, false, new List<GameAction>()
             {
-                new GameAction("spawn object",                   delegate
+                new GameAction("spawn object", "Toss Object")
                 {
-                    SamuraiSliceNtr.instance.ObjectIn(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, (int) eventCaller.currentEntity.valA);
+                    function = delegate
-                }, 8, false, new List<Param>()
+                    {
+                        SamuraiSliceNtr.instance.ObjectIn(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"], (int) eventCaller.currentEntity["valA"]);
+                    }, 
+                    defaultLength = 8,
+                    parameters = new List<Param>()
                     {
                         new Param("type", SamuraiSliceNtr.ObjectType.Melon, "Object", "The object to spawn"),
                         new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the object spills out when sliced"),
-                }),
+                    }
-                //new GameAction("start bopping",                   delegate { SamuraiSliceNtr.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 1),
+                },
             },
             new List<string>() {"ntr", "normal"},
             "ntrsamurai", "en",

Assets/Scripts/Games/SpaceDance/SpaceDance.cs

@@ -11,10 +11,25 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("spaceDance", "Space Dance \n<color=#eb5454>[WIP don't use]</color>", "000000", false, false, new List<GameAction>()
             {
-                new GameAction("turn right",                 delegate { SpaceDance.instance.DoTurnRight(eventCaller.currentEntity.beat); }, 2.0f, false),
+                new GameAction("turn right", "Turn Right")
-                new GameAction("sit down",                   delegate { SpaceDance.instance.DoSitDown(eventCaller.currentEntity.beat); }, 2.0f, false),
+                {
-                new GameAction("punch",                      delegate { SpaceDance.instance.DoPunch(eventCaller.currentEntity.beat); }, 2.0f, false),
+                    function = delegate { SpaceDance.instance.DoTurnRight(eventCaller.currentEntity.beat); }, 
-                new GameAction("bop",                      delegate { SpaceDance.instance.Bop(eventCaller.currentEntity.beat); }, 1.0f, false),
+                    defaultLength = 2.0f, 
+                },
+                new GameAction("sit down", "Sit Down")
+                {
+                    function = delegate { SpaceDance.instance.DoSitDown(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2.0f, 
+                },
+                new GameAction("punch", "Punch")
+                {
+                    function = delegate { SpaceDance.instance.DoPunch(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2.0f, 
+                },
+                new GameAction("bop", "Bop")
+                {
+                    function = delegate { SpaceDance.instance.Bop(eventCaller.currentEntity.beat); },
+                },
             });
         }
     }

Assets/Scripts/Games/SpaceSoccer/Ball.cs

@@ -47,7 +47,7 @@ namespace HeavenStudio.Games.Scripts_SpaceSoccer
                 return;
             }
 
-            List<Beatmap.Entity> highKicks = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "spaceSoccer/high kick-toe!");
+            var highKicks = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "spaceSoccer/high kick-toe!");
             int numHighKicks = 0;
             //determine what state the ball was in for the previous kick.
             for(int i = 0; i < highKicks.Count; i++)

Assets/Scripts/Games/SpaceSoccer/Kicker.cs

@@ -183,7 +183,7 @@ namespace HeavenStudio.Games.Scripts_SpaceSoccer
             //     }
             // }
 
-            List<Beatmap.Entity> highKicks = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "spaceSoccer/high kick-toe!");
+            var highKicks = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "spaceSoccer/high kick-toe!");
             for (int i = 0; i < highKicks.Count; i++)
             {
                 if ((highKicks[i].beat - 0.15f) <= Conductor.instance.songPositionInBeats && highKicks[i].beat + 1f > Conductor.instance.songPositionInBeats)

Assets/Scripts/Games/SpaceSoccer/SpaceSoccer.cs

@@ -12,17 +12,30 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("spaceSoccer", "Space Soccer", "B888F8", false, false, new List<GameAction>()
             {
-                new GameAction("ball dispense",         delegate { SpaceSoccer.instance.Dispense(eventCaller.currentEntity.beat, !eventCaller.currentEntity.toggle); }, 2f,
+                new GameAction("ball dispense", "Ball Dispense")
-                parameters: new List<Param>()
+                {
+                    function = delegate { SpaceSoccer.instance.Dispense(eventCaller.currentEntity.beat, !eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = 2f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Disable Sound", "Disables the dispense sound")
                     },
-                inactiveFunction: delegate { if (!eventCaller.currentEntity.toggle) { SpaceSoccer.DispenseSound(eventCaller.currentEntity.beat); } }),
+                    inactiveFunction = delegate { if (!eventCaller.currentEntity["toggle"]) { SpaceSoccer.DispenseSound(eventCaller.currentEntity.beat); } }
-                new GameAction("high kick-toe!",        delegate { }, 3f, false, new List<Param>() 
+                },
+                new GameAction("high kick-toe!", "High Kick-Toe!")
+                {
+                    defaultLength = 3f, 
+                    parameters = new List<Param>() 
                     {
                         new Param("swing", new EntityTypes.Float(0, 1, 0.5f), "Swing", "The amount of swing") 
-                }),
+                    }
-                new GameAction("keep-up",               delegate { }, 4f, true, hidden: true),
+                },
+                // This is still here for "backwards-compatibility" but is hidden in the editor (it does absolutely nothing however)
+                new GameAction("keep-up", "")
+                {
+                    defaultLength = 4f, 
+                    resizable = true
+                },
             });
         }
     }
@@ -69,7 +82,7 @@ namespace HeavenStudio.Games
 
         public override void OnGameSwitch(float beat)
         {
-            foreach(Beatmap.Entity entity in GameManager.instance.Beatmap.entities)
+            foreach(var entity in GameManager.instance.Beatmap.entities)
             {
                 if(entity.beat > beat) //the list is sorted based on the beat of the entity, so this should work fine.
                 {

Assets/Scripts/Games/Spaceball/Spaceball.cs

@@ -12,25 +12,51 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("spaceball", "Spaceball", "00A518", false, false, new List<GameAction>()
             {
-                new GameAction("shoot",                 delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, false, eventCaller.currentEntity.type); }, 2, false, new List<Param>()
+                new GameAction("shoot", "Pitch Ball")
+                {
+                    function = delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, false, eventCaller.currentEntity["type"]); }, 
+                    defaultLength = 2, 
+                    parameters = new List<Param>()
                     {
                         new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot") 
-                } ),
+                    } 
-				new GameAction("shootHigh",             delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, true, eventCaller.currentEntity.type); }, 3, false, new List<Param>()
+                },
+				new GameAction("shootHigh", "Pitch High Ball")
+                {
+                    function = delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, true, eventCaller.currentEntity["type"]); }, 
+                    defaultLength = 3,
+                    parameters = new List<Param>()
                     {
                         new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot") 
-                } ),
+                    } 
-				new GameAction("costume",               delegate { Spaceball.instance.Costume(eventCaller.currentEntity.type); }, 1f, false, new List<Param>() 
+                },
+				new GameAction("costume", "Change Batter Costume")
+                {
+                    function = delegate { Spaceball.instance.Costume(eventCaller.currentEntity["type"]); },
+                    parameters = new List<Param>() 
                     {
                         new Param("type", Spaceball.CostumeType.Standard, "Type", "The costume to change to") 
-                } ),
+                    } 
-                new GameAction("alien",                 delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat); } ),
+                },
-                new GameAction("camera",                delegate { Spaceball.instance.OverrideCurrentZoom(); }, 4, true, new List<Param>() 
+                new GameAction("alien", "Show Alien")
+                {
+                    function = delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat); } 
+                },
+                new GameAction("camera", "Zoom Camera")
+                {
+                    function = delegate { Spaceball.instance.OverrideCurrentZoom(); }, 
+                    defaultLength = 4, 
+                    resizable = true, 
+                    parameters = new List<Param>() 
                     {
                         new Param("valA", new EntityTypes.Integer(1, 320, 10), "Zoom", "The camera's zoom level (Lower value = Zoomed in)"),
                         new Param("ease", EasingFunction.Ease.Linear, "Ease", "The easing function to use while zooming") 
-                } ),
+                    } 
-                new GameAction("prepare dispenser",     delegate { Spaceball.instance.PrepareDispenser(); }, 1 ),
+                },
+                new GameAction("prepare dispenser", "Dispenser Prepare")
+                {
+                    function = delegate { Spaceball.instance.PrepareDispenser(); }, 
+                },
             });
         }
     }
@@ -68,7 +94,7 @@ namespace HeavenStudio.Games
 
         public Sprite[] Balls;
 
-        private List<Beatmap.Entity> allCameraEvents = new List<Beatmap.Entity>();
+        private List<DynamicBeatmap.DynamicEntity> allCameraEvents = new List<DynamicBeatmap.DynamicEntity>();
 
         public Alien alien;
 
@@ -95,7 +121,7 @@ namespace HeavenStudio.Games
         {
             instance = this;
             var camEvents = EventCaller.GetAllInGameManagerList("spaceball", new string[] { "camera" });
-            List<Beatmap.Entity> tempEvents = new List<Beatmap.Entity>();
+            List<DynamicBeatmap.DynamicEntity> tempEvents = new List<DynamicBeatmap.DynamicEntity>();
             for (int i = 0; i < camEvents.Count; i++)
             {
                 if (camEvents[i].beat + camEvents[i].beat >= Conductor.instance.songPositionInBeats)
@@ -161,26 +187,26 @@ namespace HeavenStudio.Games
             if (currentZoomIndex < allCameraEvents.Count && currentZoomIndex >= 0)
             {
                 if (currentZoomIndex - 1 >= 0)
-                    lastCamDistance = allCameraEvents[currentZoomIndex - 1].valA * -1;
+                    lastCamDistance = allCameraEvents[currentZoomIndex - 1]["valA"] * -1;
                 else
                 {
                     if (currentZoomIndex == 0)
                         lastCamDistance = -10;
                     else
-                        lastCamDistance = allCameraEvents[0].valA * -1;
+                        lastCamDistance = allCameraEvents[0]["valA"] * -1;
                 }
 
                 currentZoomCamBeat = allCameraEvents[currentZoomIndex].beat;
                 currentZoomCamLength = allCameraEvents[currentZoomIndex].length;
 
-                float dist = allCameraEvents[currentZoomIndex].valA * -1;
+                float dist = allCameraEvents[currentZoomIndex]["valA"] * -1;
 
                 if (dist > 0)
                     currentZoomCamDistance = 0;
                 else
                     currentZoomCamDistance = dist;
 
-                lastEase = allCameraEvents[currentZoomIndex].ease;
+                lastEase = (EasingFunction.Ease) allCameraEvents[currentZoomIndex]["ease"];
             }
         }
 

Assets/Scripts/Games/TapTrial/TapTrial.cs

@@ -14,26 +14,72 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("tapTrial", "Tap Trial \n<color=#eb5454>[WIP]</color>", "93ffb3", false, false, new List<GameAction>()
             {
-                new GameAction("bop",                   delegate { TapTrial.instance.Bop(eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>()
+                new GameAction("bop", "Bop")
+                {
+                    function = delegate { TapTrial.instance.Bop(eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = .5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", true, "Bop", "Whether both will bop to the beat or not")
-                }),
+                    }
-                new GameAction("tap",                   delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); }, 2.0f, false),
+                },
-                new GameAction("double tap",            delegate { TapTrial.instance.DoubleTap(eventCaller.currentEntity.beat); }, 2.0f, false),
+                new GameAction("tap", "Tap")
-                new GameAction("triple tap",            delegate { TapTrial.instance.TripleTap(eventCaller.currentEntity.beat); }, 4.0f, false),
+                {
-                new GameAction("jump tap prep",            delegate { TapTrial.instance.JumpTapPrep(eventCaller.currentEntity.beat); }, 1.0f, false),
+
-                new GameAction("jump tap",              delegate { TapTrial.instance.JumpTap(eventCaller.currentEntity.beat); }, 2.0f, false),
+                    function = delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); }, 
-                new GameAction("final jump tap",        delegate { TapTrial.instance.FinalJumpTap(eventCaller.currentEntity.beat); }, 2.0f, false),
+                    defaultLength = 2.0f
-                new GameAction("scroll event",        delegate { TapTrial.instance.scrollEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>()
+                },
+                new GameAction("double tap", "Double Tap")
+                {
+
+                    function = delegate { TapTrial.instance.DoubleTap(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2.0f
+                },
+                new GameAction("triple tap", "Triple Tap")
+                {
+
+                    function = delegate { TapTrial.instance.TripleTap(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 4.0f
+                },
+                new GameAction("jump tap prep", "Prepare Stance")
+                {
+
+                    function = delegate { TapTrial.instance.JumpTapPrep(eventCaller.currentEntity.beat); }, 
+                },
+                new GameAction("jump tap", "Jump Tap")
+                {
+
+                    function = delegate { TapTrial.instance.JumpTap(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2.0f
+                },
+                new GameAction("final jump tap", "Final Jump Tap")
+                {
+
+                    function = delegate { TapTrial.instance.FinalJumpTap(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 2.0f
+                },
+                new GameAction("scroll event", "Scroll Background")
+                {
+
+                    function = delegate { TapTrial.instance.scrollEvent(eventCaller.currentEntity["toggle"], eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = .5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Scroll FX", "Will scroll"),
                         new Param("toggle", false, "Flash FX", "Will flash to white"),
-                }),
+                    }
-                new GameAction("giraffe events",        delegate { TapTrial.instance.giraffeEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>()
+                },
+                new GameAction("giraffe events", "Giraffe Animations")
+                {
+
+                    function = delegate { TapTrial.instance.giraffeEvent(eventCaller.currentEntity["toggle"], eventCaller.currentEntity["toggle"]); }, 
+                    defaultLength = .5f,
+                    parameters = new List<Param>()
                     {
                         new Param("toggle", false, "Enter", "Giraffe will enter the scene"),
                         new Param("toggle", false, "Exit", "Giraffe will exit the scene"),
-                })
+                    }
+                }
             });
         }
     }

Assets/Scripts/Games/Tram&Pauline/TramAndPauline.cs

@@ -12,11 +12,20 @@ namespace HeavenStudio.Games.Loaders
         {
             return new Minigame("tram&Pauline", "Tram & Pauline \n<color=#eb5454>[WIP]</color>", "000000", false, false, new List<GameAction>()
             {
-                new GameAction("curtains",          delegate { TramAndPauline.instance.Curtains(eventCaller.currentEntity.beat); }, 0.5f),
+                new GameAction("curtains", "Curtains")
-                new GameAction("SFX",          delegate { var e = eventCaller.currentEntity; TramAndPauline.instance.SFX(e.beat,  e.toggle);  }, 2.5f, false, new List<Param>()
+                {
+                    function = delegate { TramAndPauline.instance.Curtains(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 0.5f
+                },
+                new GameAction("SFX", "SFX")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; TramAndPauline.instance.SFX(e.beat,  e["toggle"]);  }, 
+                    defaultLength = 2.5f, 
+                    parameters = new List<Param>()
                     {
                         new Param("type", TramAndPauline.SoundEffects.Henge, "calls", "the sound effects to choose from"),
-                }),
+                    }
+                },
 
             });
         }

Assets/Scripts/Games/TrickClass/TrickClass.cs

@@ -15,14 +15,24 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("trickClass", "Trick on the Class", "C0171D", false, false, new List<GameAction>()
             {
-                new GameAction("toss",                  delegate
+                new GameAction("toss", "Toss Object")
                 {
-                    TrickClass.instance.TossObject(eventCaller.currentEntity.beat, eventCaller.currentEntity.type);
+                    function = delegate
-                }, 3, false, new List<Param>()
+                    {
+                        TrickClass.instance.TossObject(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"]);
+                    }, 
+                    defaultLength = 3,
+                    parameters = new List<Param>()
                     {
                         new Param("type", TrickClass.TrickObjType.Ball, "Object", "The object to toss")
-                }),
+                    }
-                new GameAction("bop",                   delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length); }, 1, true, hidden: true),
+                },
+                new GameAction("bop", "")
+                {
+                    function = delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length); },
+                    resizable = true, 
+                    hidden = true
+                },
             });
         }
     }
@@ -100,7 +110,7 @@ namespace HeavenStudio.Games
                 if (timeToEvent > 0f && timeToEvent <= 1f)
                 {
                     string anim = "WarnBall";
-                    switch (e.type)
+                    switch (e["type"])
                     {
                         case (int) TrickObjType.Plane:
                             anim = "WarnPlane";

Assets/Scripts/Games/WizardsWaltz/WizardsWaltz.cs

@@ -15,8 +15,17 @@ namespace HeavenStudio.Games.Loaders
         public static Minigame AddGame(EventCaller eventCaller) {
             return new Minigame("wizardsWaltz", "Wizard's Waltz \n<color=#adadad>(Mahou Tsukai)</color>", "FFEF9C", false, false, new List<GameAction>()
             {
-                new GameAction("start interval",        delegate { WizardsWaltz.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 4f, true),
+                new GameAction("start interval", "Start Interval")
-                new GameAction("plant",        delegate { WizardsWaltz.instance.SpawnFlower(eventCaller.currentEntity.beat); }, 0.5f, false),
+                {
+                    function = delegate { WizardsWaltz.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 
+                    defaultLength = 4f, 
+                    resizable = true
+                },
+                new GameAction("plant", "Plant")
+                {
+                    function = delegate { WizardsWaltz.instance.SpawnFlower(eventCaller.currentEntity.beat); }, 
+                    defaultLength = 0.5f,
+                },
             });
         }
     }
@@ -51,7 +60,7 @@ namespace HeavenStudio.Games
             instance = this;
             wizard.Init();
 
-            Beatmap.Entity nextStart = GameManager.instance.Beatmap.entities.Find(c => c.datamodel == "wizardsWaltz/start interval" && c.beat + c.length >= Conductor.instance.songPositionInBeats);
+            var nextStart = GameManager.instance.Beatmap.entities.Find(c => c.datamodel == "wizardsWaltz/start interval" && c.beat + c.length >= Conductor.instance.songPositionInBeats);
 
             if (nextStart != null)
             {

Assets/Scripts/LevelEditor/Commands/Block.cs

@@ -127,7 +127,7 @@ namespace HeavenStudio.Editor.Commands
             deletedObj = eventObj;
             Selections.instance.Deselect(eventObj);
             Timeline.instance.DestroyEventObject(eventObj.entity);
-            // Beatmap.Entity e = deletedObjs[i].entity;
+            // DynamicBeatmap.DynamicEntity e = deletedObjs[i].entity;
             // Timeline.instance.AddEventObject(e.datamodel, false, new Vector3(e.beat, -e.track * Timeline.instance.LayerHeight()), e, true, e.eventObj.eventObjID);
         }
     }
@@ -166,7 +166,7 @@ namespace HeavenStudio.Editor.Commands
         {
             for (int i = 0; i < deletedObjs.Count; i++)
             {
-                Beatmap.Entity e = deletedObjs[i].entity;
+                DynamicBeatmap.DynamicEntity e = deletedObjs[i].entity;
                 eventObjs[i] = Timeline.instance.AddEventObject(e.datamodel, false, new Vector3(e.beat, -e.track * Timeline.instance.LayerHeight()), e, true, e.eventObj.eventObjID);
             }
         }
@@ -190,7 +190,7 @@ namespace HeavenStudio.Editor.Commands
         {
             for (int i = 0; i < copiedObjs.Count; i++)
             {
-                Beatmap.Entity e = copiedObjs[i].entity;
+                DynamicBeatmap.DynamicEntity e = copiedObjs[i].entity;
                 eventObjs[i] = Timeline.instance.AddEventObject(e.datamodel, false, new Vector3(e.beat, -e.track * Timeline.instance.LayerHeight()), e, true, e.eventObj.eventObjID);
             }
         }

Assets/Scripts/LevelEditor/DialogHelpers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 37f86271d7b215d48a41243e6b22ae5b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/DialogHelpers/Dialog.cs

@@ -0,0 +1,28 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using HeavenStudio.Editor.Track;
+
+using TMPro;
+
+namespace HeavenStudio.Editor 
+{
+    public class Dialog : MonoBehaviour
+    {
+        [SerializeField] protected GameObject dialog;
+        public void ForceState(bool onoff = false)
+        {
+            Editor.instance.canSelect = onoff;
+            Editor.instance.inAuthorativeMenu = !onoff;
+            dialog.SetActive(onoff);
+        }
+
+        public static void ResetAllDialogs()
+        {
+            foreach(var dialog in FindObjectsOfType<Dialog>())
+            {
+                dialog.ForceState(false);
+            }
+        }
+    }
+}

Assets/Scripts/LevelEditor/DialogHelpers/Dialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e317d304732b562489c993ae93ce2265
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/DialogHelpers/TabsContent.cs

@@ -0,0 +1,15 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using HeavenStudio.Editor.Track;
+
+using TMPro;
+
+namespace HeavenStudio.Editor 
+{
+    public abstract class TabsContent : MonoBehaviour
+    {
+        public abstract void OnOpenTab();
+        public abstract void OnCloseTab();
+    }
+}

Assets/Scripts/LevelEditor/DialogHelpers/TabsContent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c95e3e333c0372d498ab6cdad5a6ac1d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/DialogHelpers/TabsManager.cs

@@ -15,10 +15,28 @@ namespace HeavenStudio.Editor
         {
             if (activeContent != null)
             {
+                activeContent.GetComponent<TabsContent>().OnCloseTab();
                 activeContent.SetActive(false);
             }
             activeContent = content;
             activeContent.SetActive(true);
+            activeContent.GetComponent<TabsContent>().OnOpenTab();
+        }
+
+        public void OpenContent()
+        {
+            if (activeContent != null)
+            {
+                activeContent.GetComponent<TabsContent>().OnOpenTab();
+            }
+        }
+
+        public void CloseContent()
+        {
+            if (activeContent != null)
+            {
+                activeContent.GetComponent<TabsContent>().OnCloseTab();
+            }
         }
     }
 }

Assets/Scripts/LevelEditor/Editor.cs

@@ -52,10 +52,14 @@ namespace HeavenStudio.Editor
         [SerializeField] private Button FullScreenBTN;
         [SerializeField] private Button TempoFinderBTN;
         [SerializeField] private Button SnapDiagBTN;
+        [SerializeField] private Button ChartParamBTN;
 
         [SerializeField] private Button EditorThemeBTN;
         [SerializeField] private Button EditorSettingsBTN;
 
+        [Header("Dialogs")]
+        [SerializeField] private Dialog[] Dialogs;
+
         [Header("Tooltip")]
         public TMP_Text tooltipText;
 
@@ -68,8 +72,11 @@ namespace HeavenStudio.Editor
         public bool discordDuringTesting = false;
         public bool canSelect = true;
         public bool editingInputField = false;
+        public bool inAuthorativeMenu = false;
         public bool isCursorEnabled = true;
 
+        public bool isShortcutsEnabled { get { return (!inAuthorativeMenu) && (!editingInputField); } }
+
         private byte[] MusicBytes;
 
         public static Editor instance { get; private set; }
@@ -111,6 +118,7 @@ namespace HeavenStudio.Editor
             Tooltip.AddTooltip(FullScreenBTN.gameObject, "Preview <color=#adadad>[Tab]</color>");
             Tooltip.AddTooltip(TempoFinderBTN.gameObject, "Tempo Finder");
             Tooltip.AddTooltip(SnapDiagBTN.gameObject, "Snap Settings");
+            Tooltip.AddTooltip(ChartParamBTN.gameObject, "Remix Properties");
 
             Tooltip.AddTooltip(EditorSettingsBTN.gameObject, "Editor Settings <color=#adadad>[Ctrl+Shift+O]</color>");
             UpdateEditorStatus(true);
@@ -119,7 +127,7 @@ namespace HeavenStudio.Editor
         public void LateUpdate()
         {
             #region Keyboard Shortcuts
-            if (!editingInputField)
+            if (isShortcutsEnabled)
             {
                 if (Input.GetKeyDown(KeyCode.Tab))
                 {
@@ -160,7 +168,7 @@ namespace HeavenStudio.Editor
                 {
                     if (Input.GetKeyDown(KeyCode.N))
                     {
-                        NewRemix();
+                        NewBTN.onClick.Invoke();
                     }
                     else if (Input.GetKeyDown(KeyCode.O))
                     {
@@ -299,18 +307,31 @@ namespace HeavenStudio.Editor
             try
             {
                 if (clip != null)
-                    MusicBytes = OggVorbis.VorbisPlugin.GetOggVorbis(Conductor.instance.musicSource.clip, 1);
+                    MusicBytes = OggVorbis.VorbisPlugin.GetOggVorbis(clip, 1);
                 else
                 {
                     MusicBytes = null;
                     Debug.LogWarning("Failed to load music file! The stream is currently empty.");
                 }
             }
-            catch (System.Exception)
+            catch (System.ArgumentNullException)
             {
+                clip = null;
                 MusicBytes = null;
                 Debug.LogWarning("Failed to load music file! The stream is currently empty.");
             }
+            catch (System.ArgumentOutOfRangeException)
+            {
+                clip = null;
+                MusicBytes = null;
+                Debug.LogWarning("Failed to load music file! The stream is malformed.");
+            }
+            catch (System.ArgumentException)
+            {
+                clip = null;
+                MusicBytes = null;
+                Debug.LogWarning("Failed to load music file! Only 1 or 2 channels are supported!.");
+            }
 
             return clip;
         }
@@ -339,7 +360,7 @@ namespace HeavenStudio.Editor
         {
             var extensions = new[]
             {
-                new ExtensionFilter("Heaven Studio Remix File", "tengoku")
+                new ExtensionFilter("Heaven Studio Remix File", "riq")
             };
             
             StandaloneFileBrowser.SaveFilePanelAsync("Save Remix As", "", "remix_level", extensions, (string path) =>
@@ -376,13 +397,17 @@ namespace HeavenStudio.Editor
 
         public void NewRemix()
         {
+            if (Timeline.instance != null)
+                Timeline.instance?.Stop(0);
+            else
+                GameManager.instance.Stop(0);
             MusicBytes = null;
             LoadRemix("");
         }
 
-        public void LoadRemix(string json = "")
+        public void LoadRemix(string json = "", string type = "riq")
         {
-            GameManager.instance.LoadRemix(json);
+            GameManager.instance.LoadRemix(json, type);
             Timeline.instance.LoadRemix();
             Timeline.instance.TempoInfo.UpdateStartingBPMText();
             Timeline.instance.VolumeInfo.UpdateStartingVolumeText();
@@ -396,7 +421,9 @@ namespace HeavenStudio.Editor
         {
             var extensions = new[]
             {
-                new ExtensionFilter("Heaven Studio Remix File", new string[] { "tengoku", "rhmania" })
+                new ExtensionFilter("All Supported Files ", new string[] { "riq", "tengoku", "rhmania" }),
+                new ExtensionFilter("Heaven Studio Remix File ", new string[] { "riq" }),
+                new ExtensionFilter("Legacy Heaven Studio Remix ", new string[] { "tengoku", "rhmania" })
             };
 
             StandaloneFileBrowser.OpenFilePanelAsync("Open Remix", "", extensions, false, (string[] paths) =>
@@ -405,6 +432,7 @@ namespace HeavenStudio.Editor
 
                 if (path == string.Empty) return;
                 loadedMusic = false;
+                string extension = path.GetExtension();
 
                 using var zipFile = File.Open(path, FileMode.Open);
                 using var archive = new ZipArchive(zipFile, ZipArchiveMode.Read);
@@ -416,7 +444,7 @@ namespace HeavenStudio.Editor
                         {
                             using var stream = entry.Open();
                             using var reader = new StreamReader(stream);
-                            LoadRemix(reader.ReadToEnd());
+                            LoadRemix(reader.ReadToEnd(), extension);
 
                             break;
                         }
@@ -435,7 +463,10 @@ namespace HeavenStudio.Editor
                     }
 
                 if (!loadedMusic)
+                {
                     Conductor.instance.musicSource.clip = null;
+                    MusicBytes = null;
+                }
 
                 currentRemixPath = path;
                 remixName = Path.GetFileName(path);

Assets/Scripts/LevelEditor/EventSelector/EventParameterManager.cs

@@ -20,7 +20,7 @@ namespace HeavenStudio.Editor
         [SerializeField] private GameObject ColorP;
         [SerializeField] private GameObject StringP;
 
-        public Beatmap.Entity entity;
+        public DynamicBeatmap.DynamicEntity entity;
 
         public bool active;
 
@@ -61,13 +61,13 @@ namespace HeavenStudio.Editor
             Editor.instance.SetGameEventTitle($"Select game event for {gridGameSelector.SelectedMinigame.Replace("\n", "")}");
         }
 
-        public void StartParams(Beatmap.Entity entity)
+        public void StartParams(DynamicBeatmap.DynamicEntity entity)
         {
             active = true;
             AddParams(entity);
         }
 
-        private void AddParams(Beatmap.Entity entity)
+        private void AddParams(DynamicBeatmap.DynamicEntity entity)
         {
             var minigame = EventCaller.instance.GetMinigame(entity.datamodel.Split(0));
             int actionIndex = minigame.actions.IndexOf(minigame.actions.Find(c => c.actionName == entity.datamodel.Split(1)));
@@ -99,46 +99,70 @@ namespace HeavenStudio.Editor
         private void AddParam(string propertyName, object type, string caption, string tooltip = "")
         {
             GameObject prefab = IntegerP;
+            GameObject input;
 
             var objType = type.GetType();
 
             if (objType == typeof(EntityTypes.Integer))
             {
                 prefab = IntegerP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<NumberPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
             }
             else if (objType == typeof(EntityTypes.Float))
             {
                 prefab = FloatP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<NumberPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
             }
             else if(type is bool)
             {
                 prefab = BooleanP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<BoolPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
             }
             else if (objType.IsEnum)
             {
                 prefab = DropdownP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<EnumPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
             }
             else if (objType == typeof(Color))
             {
                 prefab = ColorP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<ColorPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
             }
             else if(objType == typeof(string))
             {
                 prefab = StringP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<StringPropertyPrefab>();
+                property.SetProperties(propertyName, type, caption);
+            }
+            else
+            {
+                Debug.LogError("Can't make property interface of type: " + type.GetType());
+                return;
+            }
         }
 
+        private GameObject InitPrefab(GameObject prefab, string tooltip = "")
+        {
             GameObject input = Instantiate(prefab);
             input.transform.SetParent(this.gameObject.transform);
             input.SetActive(true);
             input.transform.localScale = Vector2.one;
 
-            if(tooltip != "")
+            if(tooltip != string.Empty)
-            {
                 Tooltip.AddTooltip(input, "", tooltip);
-            }
 
-            var property = input.GetComponent<EventPropertyPrefab>();
+            return input;
-            property.SetProperties(propertyName, type, caption);
         }
 
         private void DestroyParams()

Assets/Scripts/LevelEditor/EventSelector/EventPropertyPrefab.cs

@@ -14,188 +14,16 @@ namespace HeavenStudio.Editor
     public class EventPropertyPrefab : MonoBehaviour
     {
         public TMP_Text caption;
-        [SerializeField] private EventParameterManager parameterManager;
+        public EventParameterManager parameterManager;
+        public string propertyName;
 
-        [Header("Integer and Float")]
+        public void SetProperties(string propertyName, object type, string caption) {}
-        [Space(10)]
-        public Slider slider;
-        public TMP_InputField inputField;
 
-        [Header("Boolean")]
+        public void InitProperties(string propertyName, string caption)
-        [Space(10)]
-        public Toggle toggle;
-
-        [Header("Dropdown")]
-        [Space(10)]
-        public TMP_Dropdown dropdown;
-
-        [Header("Color")]
-        [Space(10)]
-        public Button ColorBTN;
-        public RectTransform ColorTable;
-        public bool colorTableActive;
-        public ColorPreview colorPreview;
-
-        [Header("String")]  //why wasn't this a thing before
-        [Space(10)]
-        public TMP_InputField inputFieldString;
-
-        private string propertyName;
-
-        public void SetProperties(string propertyName, object type, string caption)
         {
+            this.parameterManager = EventParameterManager.instance;
             this.propertyName = propertyName;
             this.caption.text = caption;
-
-            switch (type)
-            {
-                case EntityTypes.Integer integer:
-                    slider.minValue = integer.min;
-                    slider.maxValue = integer.max;
-
-                    slider.wholeNumbers = true;
-                    slider.value = Convert.ToSingle(parameterManager.entity[propertyName]);
-                    inputField.text = slider.value.ToString();
-
-                    slider.onValueChanged.AddListener(
-                        _ =>
-                        {
-                            inputField.text = slider.value.ToString();
-                            parameterManager.entity[propertyName] = (int) slider.value;
-                        }
-                    );
-
-                    inputField.onSelect.AddListener(
-                        _ =>
-                            Editor.instance.editingInputField = true
-                    );
-
-                    inputField.onEndEdit.AddListener(
-                        _ =>
-                        {
-                            slider.value = Convert.ToSingle(inputField.text);
-                            parameterManager.entity[propertyName] = (int) slider.value;
-                            Editor.instance.editingInputField = false;
-                        }
-                    );
-                    break;
-
-                case EntityTypes.Float fl:
-                    slider.minValue = fl.min;
-                    slider.maxValue = fl.max;
-
-                    slider.value = Convert.ToSingle(parameterManager.entity[propertyName]);
-                    inputField.text = slider.value.ToString("G");
-
-                    slider.onValueChanged.AddListener(
-                        _ =>
-                        {
-                            var newValue = (float) Math.Round(slider.value, 4);
-                            inputField.text = newValue.ToString("G");
-                            parameterManager.entity[propertyName] = newValue;
-                        }
-                    );
-
-                    inputField.onSelect.AddListener(
-                        _ =>
-                            Editor.instance.editingInputField = true
-                    );
-
-                    inputField.onEndEdit.AddListener(
-                        _ =>
-                        {
-                            slider.value = (float) Math.Round(Convert.ToSingle(inputField.text), 4);
-                            parameterManager.entity[propertyName] = slider.value;
-                            Editor.instance.editingInputField = false;
-                        }
-                    );
-                    break;
-
-                case bool _:
-                    // ' (bool)type ' always results in false
-                    toggle.isOn = Convert.ToBoolean(parameterManager.entity[propertyName]);
-
-                    toggle.onValueChanged.AddListener(
-                        _ => parameterManager.entity[propertyName] = toggle.isOn
-                    );
-                    break;
-
-                case Color _:
-                    colorPreview.colorPicker.onColorChanged += _ =>
-                        parameterManager.entity[propertyName] = colorPreview.colorPicker.color;
-
-                    var paramCol = (Color) parameterManager.entity[propertyName];
-
-                    ColorBTN.onClick.AddListener(
-                        () =>
-                        {
-                            ColorTable.gameObject.SetActive(true);
-                            colorTableActive = true;
-                            colorPreview.ChangeColor(paramCol);
-                        }
-                    );
-
-                    colorPreview.ChangeColor(paramCol);
-                    ColorTable.gameObject.SetActive(false);
-                    break;
-
-                case string _:
-                    inputFieldString.text = (string) parameterManager.entity[propertyName];
-
-                    inputFieldString.onSelect.AddListener(
-                        _ =>
-                            Editor.instance.editingInputField = true
-                    );
-                    inputFieldString.onEndEdit.AddListener(
-                        _ =>
-                        {;
-                            parameterManager.entity[propertyName] = inputFieldString.text;
-                            Editor.instance.editingInputField = false;
-                        }
-                    );
-                    break;
-
-                case Enum enumKind:
-                    var enumType = enumKind.GetType();
-                    var enumVals = Enum.GetValues(enumType);
-                    var enumNames = Enum.GetNames(enumType).ToList();
-
-                    // Can we assume non-holey enum?
-                    // If we can we can simplify to dropdown.value = (int) parameterManager.entity[propertyName]
-                    var currentlySelected = (int) parameterManager.entity[propertyName];
-                    var selected = enumVals
-                        .Cast<object>()
-                        .ToList()
-                        .FindIndex(val => (int) val == currentlySelected);
-
-                    dropdown.AddOptions(enumNames);
-                    dropdown.value = selected;
-
-                    dropdown.onValueChanged.AddListener(_ =>
-                        parameterManager.entity[propertyName] = (int) enumVals.GetValue(dropdown.value)
-                    );
-                    break;
-
-                default:
-                    throw new ArgumentOutOfRangeException(
-                        nameof(type), type, "I don't know how to make a property of this type!"
-                    );
-            }
-        }
-
-        private void Update()
-        {
-            if (colorTableActive)
-            {
-                if (!Editor.MouseInRectTransform(ColorTable))
-                {
-                    if (Input.GetMouseButtonDown(0))
-                    {
-                        ColorTable.gameObject.SetActive(false);
-                        colorTableActive = false;
-                    }
-                }
-            }
         }
     }
 }

Assets/Scripts/LevelEditor/EventSelector/GridGameSelector.cs

@@ -140,7 +140,7 @@ namespace HeavenStudio.Editor
             if (!EventCaller.FXOnlyGames().Contains(EventCaller.instance.GetMinigame(mg.name)))
             {
                 GameObject sg = Instantiate(EventRef, eventsParent);
-                sg.GetComponent<TMP_Text>().text = "switchGame";
+                sg.GetComponent<TMP_Text>().text = "Switch Game";
                 sg.SetActive(true);
                 sg.GetComponent<TMP_Text>().color = EditorTheme.theme.properties.EventSelectedCol.Hex2RGB();
             }
@@ -149,7 +149,7 @@ namespace HeavenStudio.Editor
             {
                 if (mg.actions[i].actionName == "switchGame" || mg.actions[i].hidden) continue;
                 GameObject g = Instantiate(EventRef, eventsParent);
-                g.GetComponent<TMP_Text>().text = mg.actions[i].actionName;
+                g.GetComponent<TMP_Text>().text = mg.actions[i].displayName;
                 g.SetActive(true);
             }
         }

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs copy.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 28745dfd251ff86468a98978665f553b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b86ddd3d47bb04e48a61db47242e02ed
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/BoolPropertyPrefab.cs

@@ -0,0 +1,37 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class BoolPropertyPrefab : EventPropertyPrefab
+    {
+        [Header("Boolean")]
+        [Space(10)]
+        public Toggle toggle;
+
+        new public void SetProperties(string propertyName, object type, string caption)
+        {
+            InitProperties(propertyName, caption);
+
+            // ' (bool)type ' always results in false
+            toggle.isOn = Convert.ToBoolean(parameterManager.entity[propertyName]);
+
+            toggle.onValueChanged.AddListener(
+                _ => parameterManager.entity[propertyName] = toggle.isOn
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/BoolPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9aa690f14ccbf9e4bb6bd339d500c3e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/ColorPropertyPrefab.cs

@@ -0,0 +1,61 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class ColorPropertyPrefab : EventPropertyPrefab
+    {
+        [Header("Color")]
+        [Space(10)]
+        public Button ColorBTN;
+        public RectTransform ColorTable;
+        public bool colorTableActive;
+        public ColorPreview colorPreview;
+
+        new public void SetProperties(string propertyName, object type, string caption)
+        {
+            InitProperties(propertyName, caption);
+
+            colorPreview.colorPicker.onColorChanged += _ =>
+                parameterManager.entity[propertyName] = colorPreview.colorPicker.color;
+
+            Color paramCol = parameterManager.entity[propertyName];
+
+            ColorBTN.onClick.AddListener(
+                () =>
+                {
+                    ColorTable.gameObject.SetActive(true);
+                    colorTableActive = true;
+                    colorPreview.ChangeColor(paramCol);
+                }
+            );
+
+            colorPreview.ChangeColor(paramCol);
+            ColorTable.gameObject.SetActive(false);
+        }
+
+        private void Update()
+        {
+            if (colorTableActive)
+            {
+                if (!Editor.MouseInRectTransform(ColorTable))
+                {
+                    if (Input.GetMouseButtonDown(0))
+                    {
+                        ColorTable.gameObject.SetActive(false);
+                        colorTableActive = false;
+                    }
+                }
+            }
+        }
+    }
+}

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/ColorPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c1c576a0586b70d4395de537078023d5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/EnumPropertyPrefab.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class EnumPropertyPrefab : EventPropertyPrefab
+    {
+        [Header("Dropdown")]
+        [Space(10)]
+        public TMP_Dropdown dropdown;
+
+        new public void SetProperties(string propertyName, object type, string caption)
+        {
+            InitProperties(propertyName, caption);
+
+            var enumType = type.GetType();
+            var enumVals = Enum.GetValues(enumType);
+            var enumNames = Enum.GetNames(enumType).ToList();
+
+            // Can we assume non-holey enum?
+            // If we can we can simplify to dropdown.value = (int) parameterManager.entity[propertyName]
+            var currentlySelected = (int) parameterManager.entity[propertyName];
+            var selected = enumVals
+                .Cast<object>()
+                .ToList()
+                .FindIndex(val => (int) val == currentlySelected);
+
+            dropdown.AddOptions(enumNames);
+            dropdown.value = selected;
+
+            dropdown.onValueChanged.AddListener(_ =>
+                parameterManager.entity[propertyName] = (int) enumVals.GetValue(dropdown.value)
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/EnumPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8ada001011e54c74b87c04d7186d5f3c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/NumberPropertyPrefab.cs

@@ -0,0 +1,101 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class NumberPropertyPrefab : EventPropertyPrefab
+    {
+        [Header("Integer and Float")]
+        [Space(10)]
+        public Slider slider;
+        public TMP_InputField inputField;
+
+        new public void SetProperties(string propertyName, object type, string caption)
+        {
+            InitProperties(propertyName, caption);
+
+            switch (type)
+            {
+                case EntityTypes.Integer integer:
+                    slider.minValue = integer.min;
+                    slider.maxValue = integer.max;
+
+                    slider.wholeNumbers = true;
+                    slider.value = Convert.ToSingle(parameterManager.entity[propertyName]);
+                    inputField.text = slider.value.ToString();
+
+                    slider.onValueChanged.AddListener(
+                        _ =>
+                        {
+                            inputField.text = slider.value.ToString();
+                            parameterManager.entity[propertyName] = (int) slider.value;
+                        }
+                    );
+
+                    inputField.onSelect.AddListener(
+                        _ =>
+                            Editor.instance.editingInputField = true
+                    );
+
+                    inputField.onEndEdit.AddListener(
+                        _ =>
+                        {
+                            slider.value = Convert.ToSingle(inputField.text);
+                            parameterManager.entity[propertyName] = (int) slider.value;
+                            Editor.instance.editingInputField = false;
+                        }
+                    );
+                    break;
+
+                case EntityTypes.Float fl:
+                    slider.minValue = fl.min;
+                    slider.maxValue = fl.max;
+
+                    slider.value = Convert.ToSingle(parameterManager.entity[propertyName]);
+                    inputField.text = slider.value.ToString("G");
+
+                    slider.onValueChanged.AddListener(
+                        _ =>
+                        {
+                            var newValue = (float) Math.Round(slider.value, 4);
+                            inputField.text = newValue.ToString("G");
+                            parameterManager.entity[propertyName] = newValue;
+                        }
+                    );
+
+                    inputField.onSelect.AddListener(
+                        _ =>
+                            Editor.instance.editingInputField = true
+                    );
+
+                    inputField.onEndEdit.AddListener(
+                        _ =>
+                        {
+                            slider.value = (float) Math.Round(Convert.ToSingle(inputField.text), 4);
+                            parameterManager.entity[propertyName] = slider.value;
+                            Editor.instance.editingInputField = false;
+                        }
+                    );
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(
+                        nameof(type), type, "I don't know how to make a property of this type!"
+                    );
+            }
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/NumberPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e9ad350a96f5644dbb1e4686a6bcaed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/StringPropertyPrefab.cs

@@ -0,0 +1,44 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class StringPropertyPrefab : EventPropertyPrefab
+    {
+        [Header("String")]  //why wasn't this a thing before
+        [Space(10)]
+        public TMP_InputField inputFieldString;
+
+        new public void SetProperties(string propertyName, object type, string caption)
+        {
+            InitProperties(propertyName, caption);
+
+            inputFieldString.text = (string) parameterManager.entity[propertyName];
+
+            inputFieldString.onSelect.AddListener(
+                _ =>
+                    Editor.instance.editingInputField = true
+            );
+            inputFieldString.onEndEdit.AddListener(
+                _ =>
+                {;
+                    parameterManager.entity[propertyName] = inputFieldString.text;
+                    Editor.instance.editingInputField = false;
+                }
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/EventSelector/PropertyPrefabs/StringPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c01fcc0bb14adee46a4869c1c009850e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/NewRemixDialog.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fb311ef0878d3e342bdfb042366b90e5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/NewRemixDialog/NewRemixDialog.cs

@@ -0,0 +1,26 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using HeavenStudio.Editor;
+
+public class NewRemixDialog : Dialog
+{
+    public void SwitchNewDialog()
+    {
+        if(dialog.activeSelf) {
+            dialog.SetActive(false);
+        } else {
+            ResetAllDialogs();
+            dialog.SetActive(true);
+        }
+    }
+
+    public void Confirm()
+    {
+        Editor.instance.NewRemix();
+        if(dialog.activeSelf) {
+            dialog.SetActive(false);
+        }
+    }
+}

Assets/Scripts/LevelEditor/NewRemixDialog/NewRemixDialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e1b2b36751952147bb6126f9ffd6086
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ad016dbf1f5b3ef4cad714464aaec76a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: eccea73a04818a844bc25e6308bc1d05
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/BoolChartPropertyPrefab.cs

@@ -0,0 +1,37 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class BoolChartPropertyPrefab : RemixPropertyPrefab
+    {
+        [Header("Boolean")]
+        [Space(10)]
+        public Toggle toggle;
+
+        new public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption)
+        {
+            InitProperties(diag, propertyName, caption);
+
+            // ' (bool)type ' always results in false
+            toggle.isOn = Convert.ToBoolean(parameterManager.chart[propertyName]);
+
+            toggle.onValueChanged.AddListener(
+                _ => parameterManager.chart[propertyName] = toggle.isOn
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/BoolChartPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5765785c18f751f4196e09d11dd30ff3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/ColorChartPropertyPrefab.cs

@@ -0,0 +1,61 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class ColorChartPropertyPrefab : RemixPropertyPrefab
+    {
+        [Header("Color")]
+        [Space(10)]
+        public Button ColorBTN;
+        public RectTransform ColorTable;
+        public bool colorTableActive;
+        public ColorPreview colorPreview;
+
+        new public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption)
+        {
+            InitProperties(diag, propertyName, caption);
+
+            colorPreview.colorPicker.onColorChanged += _ =>
+                parameterManager.chart[propertyName] = colorPreview.colorPicker.color;
+
+            Color paramCol = parameterManager.chart[propertyName];
+
+            ColorBTN.onClick.AddListener(
+                () =>
+                {
+                    ColorTable.gameObject.SetActive(true);
+                    colorTableActive = true;
+                    colorPreview.ChangeColor(paramCol);
+                }
+            );
+
+            colorPreview.ChangeColor(paramCol);
+            ColorTable.gameObject.SetActive(false);
+        }
+
+        private void Update()
+        {
+            if (colorTableActive)
+            {
+                if (!Editor.MouseInRectTransform(ColorTable))
+                {
+                    if (Input.GetMouseButtonDown(0))
+                    {
+                        ColorTable.gameObject.SetActive(false);
+                        colorTableActive = false;
+                    }
+                }
+            }
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/ColorChartPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 83f718678c662f9448813df185f1283f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/EnumChartPropertyPrefab.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class EnumChartPropertyPrefab : RemixPropertyPrefab
+    {
+        [Header("Dropdown")]
+        [Space(10)]
+        public TMP_Dropdown dropdown;
+
+        new public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption)
+        {
+            InitProperties(diag, propertyName, caption);
+
+            var enumType = type.GetType();
+            var enumVals = Enum.GetValues(enumType);
+            var enumNames = Enum.GetNames(enumType).ToList();
+
+            // Can we assume non-holey enum?
+            // If we can we can simplify to dropdown.value = (int) parameterManager.chart[propertyName]
+            var currentlySelected = (int) parameterManager.chart[propertyName];
+            var selected = enumVals
+                .Cast<object>()
+                .ToList()
+                .FindIndex(val => (int) val == currentlySelected);
+
+            dropdown.AddOptions(enumNames);
+            dropdown.value = selected;
+
+            dropdown.onValueChanged.AddListener(_ =>
+                parameterManager.chart[propertyName] = (int) enumVals.GetValue(dropdown.value)
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/EnumChartPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bddf1f894c08d91429a4a36f21a3c10e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/NumberChartPropertyPrefab.cs

@@ -0,0 +1,101 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class NumberChartPropertyPrefab : RemixPropertyPrefab
+    {
+        [Header("Integer and Float")]
+        [Space(10)]
+        public Slider slider;
+        public TMP_InputField inputField;
+
+        new public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption)
+        {
+            InitProperties(diag, propertyName, caption);
+
+            switch (type)
+            {
+                case EntityTypes.Integer integer:
+                    slider.minValue = integer.min;
+                    slider.maxValue = integer.max;
+
+                    slider.wholeNumbers = true;
+                    slider.value = Convert.ToSingle(parameterManager.chart[propertyName]);
+                    inputField.text = slider.value.ToString();
+
+                    slider.onValueChanged.AddListener(
+                        _ =>
+                        {
+                            inputField.text = slider.value.ToString();
+                            parameterManager.chart[propertyName] = (int) slider.value;
+                        }
+                    );
+
+                    inputField.onSelect.AddListener(
+                        _ =>
+                            Editor.instance.editingInputField = true
+                    );
+
+                    inputField.onEndEdit.AddListener(
+                        _ =>
+                        {
+                            slider.value = Convert.ToSingle(inputField.text);
+                            parameterManager.chart[propertyName] = (int) slider.value;
+                            Editor.instance.editingInputField = false;
+                        }
+                    );
+                    break;
+
+                case EntityTypes.Float fl:
+                    slider.minValue = fl.min;
+                    slider.maxValue = fl.max;
+
+                    slider.value = Convert.ToSingle(parameterManager.chart[propertyName]);
+                    inputField.text = slider.value.ToString("G");
+
+                    slider.onValueChanged.AddListener(
+                        _ =>
+                        {
+                            var newValue = (float) Math.Round(slider.value, 4);
+                            inputField.text = newValue.ToString("G");
+                            parameterManager.chart[propertyName] = newValue;
+                        }
+                    );
+
+                    inputField.onSelect.AddListener(
+                        _ =>
+                            Editor.instance.editingInputField = true
+                    );
+
+                    inputField.onEndEdit.AddListener(
+                        _ =>
+                        {
+                            slider.value = (float) Math.Round(Convert.ToSingle(inputField.text), 4);
+                            parameterManager.chart[propertyName] = slider.value;
+                            Editor.instance.editingInputField = false;
+                        }
+                    );
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(
+                        nameof(type), type, "I don't know how to make a property of this type!"
+                    );
+            }
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/NumberChartPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3541b2824368eef4b94655619c05c3bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/StringChartPropertyPrefab.cs

@@ -0,0 +1,44 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+using HeavenStudio.Editor;
+
+namespace HeavenStudio.Editor
+{
+    public class StringChartPropertyPrefab : RemixPropertyPrefab
+    {
+        [Header("String")]  //why wasn't this a thing before
+        [Space(10)]
+        public TMP_InputField inputFieldString;
+
+        new public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption)
+        {
+            InitProperties(diag, propertyName, caption);
+
+            inputFieldString.text = (string) parameterManager.chart[propertyName];
+
+            inputFieldString.onSelect.AddListener(
+                _ =>
+                    Editor.instance.editingInputField = true
+            );
+            inputFieldString.onEndEdit.AddListener(
+                _ =>
+                {;
+                    parameterManager.chart[propertyName] = inputFieldString.text;
+                    Editor.instance.editingInputField = false;
+                }
+            );
+        }
+
+        private void Update()
+        {
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/PropertyPrefabs/StringChartPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1d094b0b57b4a1945a8ca587d9478b75
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/RemixPropertiesDialog.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using HeavenStudio.Editor.Track;
+
+using TMPro;
+
+namespace HeavenStudio.Editor 
+{
+    public class RemixPropertiesDialog : Dialog
+    {
+        [Header("General References")]
+        [SerializeField] TabsManager tabsManager;
+
+        [Header("Containers")]
+        [SerializeField] ChartInfoProperties[] containers;
+
+        public DynamicBeatmap chart;
+
+        private void Start() { }
+
+        public void SwitchPropertiesDialog()
+        {
+            if (dialog.activeSelf)
+            {
+                tabsManager.CloseContent();
+                Editor.instance.canSelect = true;
+                Editor.instance.inAuthorativeMenu = false;
+                dialog.SetActive(false);
+            }
+            else
+            {
+                ResetAllDialogs();
+
+                foreach (var container in containers)
+                {
+                    container.Init(this);
+                }
+
+                tabsManager.OpenContent();
+                Editor.instance.canSelect = false;
+                Editor.instance.inAuthorativeMenu = true;
+                dialog.SetActive(true);
+
+                chart = GameManager.instance.Beatmap;
+                chart["propertiesmodified"] = true;
+            }
+        }
+
+        public void SetupDialog(PropertyTag[] tags, ChartInfoProperties container)
+        {
+            chart = GameManager.instance.Beatmap;
+            chart["propertiesmodified"] = true;
+
+            foreach (PropertyTag property in tags)
+            {
+                if (chart.properties.ContainsKey(property.tag))
+                {
+                    container.AddParam(this, property.tag, chart.properties[property.tag], property.label, property.isReadOnly);
+                }
+                else
+                {
+                    if (property.tag == "divider")
+                    {
+                        container.AddDivider(this);
+                    }
+                    else if (property.tag == "header")
+                    {
+                        container.AddHeader(this, property.label);
+                    }
+                    else if (property.tag == "subheader")
+                    {
+                        container.AddSubHeader(this, property.label);
+                    }
+                    else
+                    {
+                        Debug.LogWarning("Property Menu generation Warning: Property " + property.tag + " not found, skipping...");
+                    }
+                }
+            }
+        }
+
+        private void CleanDialog() {}
+
+        private void Update() {}
+
+        [Serializable]
+        public class PropertyTag
+        {
+            public string tag;
+            public string label;
+            public bool isReadOnly;
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/RemixPropertiesDialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eedc1c2d03f4b22478ebb914e36371d8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/RemixPropertyPrefab.cs

@@ -0,0 +1,29 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using TMPro;
+using Starpelly;
+
+using HeavenStudio.Util;
+
+namespace HeavenStudio.Editor
+{
+    public class RemixPropertyPrefab : MonoBehaviour
+    {
+        public TMP_Text caption;
+        public RemixPropertiesDialog parameterManager;
+        public string propertyName;
+
+        public void SetProperties(RemixPropertiesDialog diag, string propertyName, object type, string caption) {}
+
+        public void InitProperties(RemixPropertiesDialog diag, string propertyName, string caption)
+        {
+            this.parameterManager = diag;
+            this.propertyName = propertyName;
+            this.caption.text = caption;
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/RemixPropertyPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2483aa618d773c143857f608a2d2d32a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/Tabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 814063e92ed9584478db2112bd34ca75
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/RemixPropertiesDialog/Tabs/ChartInfoProperties.cs

@@ -0,0 +1,132 @@
+using UnityEngine;
+using UnityEngine.UI;
+using TMPro;
+
+namespace HeavenStudio.Editor 
+{
+    public class ChartInfoProperties : TabsContent
+    {
+        [Header("General References")]
+        [SerializeField] private GameObject propertyHolder;
+        RemixPropertiesDialog dialog;
+
+        [Header("Property Prefabs")]
+        [SerializeField] private GameObject IntegerP;
+        [SerializeField] private GameObject FloatP;
+        [SerializeField] private GameObject BooleanP;
+        [SerializeField] private GameObject DropdownP;
+        [SerializeField] private GameObject ColorP;
+        [SerializeField] private GameObject StringP;
+
+        [Header("Layout Prefabs")]
+        [SerializeField] private GameObject DividerP;
+        [SerializeField] private GameObject HeaderP;
+        [SerializeField] private GameObject SubHeaderP;
+
+        [Header("Editable Properties")]
+        [SerializeField] RemixPropertiesDialog.PropertyTag[] tags;
+
+        public void Init(RemixPropertiesDialog diag)
+        {
+            dialog = diag;
+        }
+
+        public void AddParam(RemixPropertiesDialog diag, string propertyName, object type, string caption, bool isReadOnly = false, string tooltip = "")
+        {
+            GameObject prefab = IntegerP;
+            GameObject input;
+
+            var objType = type.GetType();
+
+            if (objType == typeof(EntityTypes.Integer))
+            {
+                prefab = IntegerP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<NumberChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else if (objType == typeof(EntityTypes.Float))
+            {
+                prefab = FloatP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<NumberChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else if (type is bool)
+            {
+                prefab = BooleanP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<BoolChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else if (objType.IsEnum)
+            {
+                prefab = DropdownP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<EnumChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else if (objType == typeof(Color))
+            {
+                prefab = ColorP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<ColorChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else if (objType == typeof(string))
+            {
+                prefab = StringP;
+                input = InitPrefab(prefab, tooltip);
+                var property = input.GetComponent<StringChartPropertyPrefab>();
+                property.SetProperties(diag, propertyName, type, caption);
+            }
+            else
+            {
+                Debug.LogError("Can't make property interface of type: " + type.GetType());
+                return;
+            }
+        }
+
+        public void AddDivider(RemixPropertiesDialog diag)
+        {
+            InitPrefab(DividerP);
+        }
+
+        public void AddHeader(RemixPropertiesDialog diag, string text)
+        {
+            var input = InitPrefab(HeaderP);
+            input.GetComponent<RemixPropertyPrefab>().InitProperties(diag, "", text);
+        }
+
+        public void AddSubHeader(RemixPropertiesDialog diag, string text)
+        {
+            var input = InitPrefab(SubHeaderP);
+            input.GetComponent<RemixPropertyPrefab>().InitProperties(diag, "", text);
+        }
+        
+        private GameObject InitPrefab(GameObject prefab, string tooltip = "")
+        {
+            GameObject input = Instantiate(prefab);
+            input.transform.SetParent(propertyHolder.transform);
+            input.SetActive(true);
+            input.transform.localScale = Vector2.one;
+
+            if(tooltip != string.Empty)
+                Tooltip.AddTooltip(input, "", tooltip);
+
+            return input;
+        }
+
+        public override void OnOpenTab()
+        {
+            dialog.SetupDialog(tags, this);
+        }
+
+        public override void OnCloseTab()
+        {
+            foreach (Transform child in propertyHolder.transform) {
+                Destroy(child.gameObject);
+            }
+        }
+    }
+}

Assets/Scripts/LevelEditor/RemixPropertiesDialog/Tabs/ChartInfoProperties.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4567e0acf98a9ef48b747da3b836a1a2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LevelEditor/SettingsDialog/SettingsDialog.cs

@@ -7,19 +7,21 @@ using TMPro;
 
 namespace HeavenStudio.Editor 
 {
-    public class SettingsDialog : MonoBehaviour
+    public class SettingsDialog : Dialog
     {
-        [SerializeField] private GameObject settingsMenu;
-        //this may all be moved to a different script in the future
-
         private void Start() {}
 
         public void SwitchSettingsDialog()
         {
-            if(settingsMenu.activeSelf) {
+            if(dialog.activeSelf) {
-                settingsMenu.SetActive(false);
+                Editor.instance.canSelect = true;
+                Editor.instance.inAuthorativeMenu = false;
+                dialog.SetActive(false);
             } else {
-                settingsMenu.SetActive(true);
+                ResetAllDialogs();
+                Editor.instance.canSelect = false;
+                Editor.instance.inAuthorativeMenu = true;
+                dialog.SetActive(true);
             }
         }
 

Assets/Scripts/LevelEditor/SettingsDialog/Tabs/ControllerSettings.cs

@@ -12,7 +12,7 @@ using static JSL;
 
 namespace HeavenStudio.Editor 
 {
-    public class ControllerSettings : MonoBehaviour
+    public class ControllerSettings : TabsContent
     {
         [SerializeField] private TMP_Text numConnectedLabel;
         [SerializeField] private TMP_Text currentControllerLabel;
@@ -245,5 +245,13 @@ namespace HeavenStudio.Editor
             yield return new WaitForSeconds(0.25f);
             JslSetRumbleFrequency(controller.GetHandle(), 0f, 0f, 0f, 0f);
         }
+
+        public override void OnOpenTab()
+        {
+        }
+
+        public override void OnCloseTab()
+        {
+        }
     }
 }

Assets/Scripts/LevelEditor/SettingsDialog/Tabs/CreditsLegalSettings.cs

@@ -9,7 +9,7 @@ using TMPro;
 
 namespace HeavenStudio.Editor 
 {
-    public class CreditsLegalSettings : MonoBehaviour
+    public class CreditsLegalSettings : TabsContent
     {
         private int SecretCounter = 0;
         private bool SecretActive = false;
@@ -50,5 +50,13 @@ namespace HeavenStudio.Editor
             SecretActive = false;
             secretContent.CloseDanceWindow();
         }
+
+        public override void OnOpenTab()
+        {
+        }
+
+        public override void OnCloseTab()
+        {
+        }
     }
 }

Assets/Scripts/LevelEditor/SettingsDialog/Tabs/DispAudioSettings.cs

@@ -6,7 +6,7 @@ using TMPro;
 
 namespace HeavenStudio.Editor 
 {
-    public class DispAudioSettings : MonoBehaviour
+    public class DispAudioSettings : TabsContent
     {
         public TMP_Dropdown resolutionsDropdown;
         public GameObject customSetter;
@@ -71,5 +71,13 @@ namespace HeavenStudio.Editor
             volSlider.value = (float)System.Math.Round(System.Convert.ToSingle(volLabel.text) / 100f, 2);
             GlobalGameManager.ChangeMasterVolume(volSlider.value);
         }
+
+        public override void OnOpenTab()
+        {
+        }
+
+        public override void OnCloseTab()
+        {
+        }
     }
 }

Assets/Scripts/LevelEditor/SettingsDialog/Tabs/EditorSettings.cs

@@ -4,7 +4,7 @@ using TMPro;
 
 namespace HeavenStudio.Editor 
 {
-    public class EditorSettings : MonoBehaviour
+    public class EditorSettings : TabsContent
     {
         public Toggle cursorCheckbox;
 
@@ -16,5 +16,13 @@ namespace HeavenStudio.Editor
                 GameManager.instance.CursorCam.enabled = Editor.instance.isCursorEnabled;
             }
         }
+
+        public override void OnOpenTab()
+        {
+        }
+
+        public override void OnCloseTab()
+        {
+        }
     }
 }

Assets/Scripts/LevelEditor/SnapDialog/SnapDialog.cs

@@ -7,9 +7,8 @@ using TMPro;
 
 namespace HeavenStudio.Editor 
 {
-    public class SnapDialog : MonoBehaviour
+    public class SnapDialog : Dialog
     {
-        [SerializeField] private GameObject snapSetter;
         [SerializeField] private TMP_Text snapText;
         private Timeline timeline;
 
@@ -22,10 +21,11 @@ namespace HeavenStudio.Editor
 
         public void SwitchSnapDialog()
         {
-            if(snapSetter.activeSelf) {
+            if(dialog.activeSelf) {
-                snapSetter.SetActive(false);
+                dialog.SetActive(false);
             } else {
-                snapSetter.SetActive(true);
+                ResetAllDialogs();
+                dialog.SetActive(true);
             }
         }
 

Assets/Scripts/LevelEditor/TempoFinder/TempoFinder.cs

@@ -4,9 +4,8 @@ using UnityEngine;
 
 namespace HeavenStudio.Editor 
 {
-    public class TempoFinder : MonoBehaviour
+    public class TempoFinder : Dialog
     {
-        [SerializeField] private GameObject tempoFinder;
         private bool pressed;
         private float timePressed;
         [SerializeField] private BPMText bpmText;
@@ -17,12 +16,13 @@ namespace HeavenStudio.Editor
         }
         public void SwitchTempoDialog()
         {
-            if(tempoFinder.activeSelf) {
+            if(dialog.activeSelf) {
-                tempoFinder.SetActive(false);
+                dialog.SetActive(false);
                 timePressed = 0;
                 bpmText.ResetText();
             } else {
-                tempoFinder.SetActive(true);
+                ResetAllDialogs();
+                dialog.SetActive(true);
             }
         }
         public void TapBPM()

Assets/Scripts/LevelEditor/Timeline/TempoTimeline.cs

@@ -29,7 +29,7 @@ namespace HeavenStudio.Editor.Track
 
             for (int i = 0; i < GameManager.instance.Beatmap.tempoChanges.Count; i++)
             {
-                Beatmap.TempoChange tempoChange = GameManager.instance.Beatmap.tempoChanges[i];
+                DynamicBeatmap.TempoChange tempoChange = GameManager.instance.Beatmap.tempoChanges[i];
                 AddTempoChange(false, tempoChange);
             }
         }
@@ -140,7 +140,7 @@ namespace HeavenStudio.Editor.Track
             tempoTimelineObjs.Clear();
         }
 
-        public void AddTempoChange(bool create, Beatmap.TempoChange tempoChange_ = null)
+        public void AddTempoChange(bool create, DynamicBeatmap.TempoChange tempoChange_ = null)
         {      
             GameObject tempoChange = Instantiate(RefTempoChange.gameObject, this.transform);
 
@@ -157,7 +157,7 @@ namespace HeavenStudio.Editor.Track
                 tempoChange.transform.position = new Vector3(Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition).x + 0.08f, tempoChange.transform.position.y);
                 tempoChange.transform.localPosition = new Vector3(Starpelly.Mathp.Round2Nearest(tempoChange.transform.localPosition.x, Timeline.SnapInterval()), tempoChange.transform.localPosition.y);
 
-                Beatmap.TempoChange tempoC = new Beatmap.TempoChange();
+                DynamicBeatmap.TempoChange tempoC = new DynamicBeatmap.TempoChange();
                 tempoC.beat = tempoChange.transform.localPosition.x;
                 tempoC.tempo = GameManager.instance.Beatmap.bpm;
 

Assets/Scripts/LevelEditor/Timeline/TempoTimelineObj.cs

@@ -15,7 +15,7 @@ namespace HeavenStudio.Editor.Track
         [SerializeField] private TMP_Text tempoTXT;
         [SerializeField] private RectTransform raycastRect;
 
-        public Beatmap.TempoChange tempoChange;
+        public DynamicBeatmap.TempoChange tempoChange;
 
         private float startPosX;
         private bool moving = false;

Assets/Scripts/LevelEditor/Timeline/Timeline.cs

@@ -273,7 +273,7 @@ namespace HeavenStudio.Editor.Track
             SliderControl();
 
             #region Keyboard Shortcuts
-            if (!userIsEditingInputField)
+            if ((!userIsEditingInputField) && Editor.instance.isShortcutsEnabled)
             {
                 
                 if (Input.GetKeyDown(KeyCode.Space))
@@ -503,11 +503,13 @@ namespace HeavenStudio.Editor.Track
 
         #region Functions
 
-        public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), Beatmap.Entity entity = null, bool addEvent = false, string eventId = "")
+        public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), DynamicBeatmap.DynamicEntity entity = null, bool addEvent = false, string eventId = "")
         {
+            var game = EventCaller.instance.GetMinigame(eventName.Split(0));
+            var action = EventCaller.instance.GetGameAction(game, eventName.Split(1));
             GameObject g = Instantiate(TimelineEventObjRef.gameObject, TimelineEventObjRef.parent);
             g.transform.localPosition = pos;
-            g.transform.GetChild(3).GetComponent<TMP_Text>().text = eventName.Split('/')[1];
+            g.transform.GetChild(3).GetComponent<TMP_Text>().text = action.displayName;
 
             TimelineEventObj eventObj = g.GetComponent<TimelineEventObj>();
 
@@ -559,11 +561,11 @@ namespace HeavenStudio.Editor.Track
 
             if (addEvent)
             {
-                Beatmap.Entity tempEntity = entity;
+                DynamicBeatmap.DynamicEntity tempEntity = entity;
 
                 if (entity == null)
                 {
-                    Beatmap.Entity en = new Beatmap.Entity();
+                    DynamicBeatmap.DynamicEntity en = new DynamicBeatmap.DynamicEntity();
                     en.datamodel = eventName;
                     en.eventObj = eventObj;
 
@@ -572,9 +574,8 @@ namespace HeavenStudio.Editor.Track
 
                     tempEntity = en;
 
-                    // default param value
+                    // default param values
-                    var game = EventCaller.instance.GetMinigame(eventName.Split(0));
+                    var ep = action.parameters;
-                    var ep = EventCaller.instance.GetGameAction(game, eventName.Split(1)).parameters;
 
                     if (ep != null)
                     {
@@ -591,8 +592,13 @@ namespace HeavenStudio.Editor.Track
                             {
                                 returnVal = ((EntityTypes.Float)ep[i].parameter).val;
                             }
+                            else if (propertyType.IsEnum)
+                            {
+                                returnVal = (int) ep[i].parameter;
+                            }
 
-                            tempEntity[ep[i].propertyName] = returnVal;
+                            //tempEntity[ep[i].propertyName] = returnVal;
+                            tempEntity.CreateProperty(ep[i].propertyName, returnVal);
                         }
                     }
                 }
@@ -613,7 +619,7 @@ namespace HeavenStudio.Editor.Track
         private List<TimelineEventObj> duplicatedEventObjs = new List<TimelineEventObj>();
         public TimelineEventObj CopyEventObject(TimelineEventObj e)
         {
-            Beatmap.Entity clone = e.entity.DeepCopy();
+            DynamicBeatmap.DynamicEntity clone = e.entity.DeepCopy();
             TimelineEventObj dup = AddEventObject(clone.datamodel, false, new Vector3(clone.beat, -clone.track * Timeline.instance.LayerHeight()), clone, true, RandomID());
             duplicatedEventObjs.Add(dup);
 
@@ -626,7 +632,7 @@ namespace HeavenStudio.Editor.Track
             duplicatedEventObjs = new List<TimelineEventObj>();
         }
 
-        public void DestroyEventObject(Beatmap.Entity entity)
+        public void DestroyEventObject(DynamicBeatmap.DynamicEntity entity)
         {
             if (EventParameterManager.instance.entity == entity)
                 EventParameterManager.instance.Disable();