Merge pull request #671 from FunkinCrew/lemz1/note-kind-scripts

[PUBLIC PR] Note Kind Scripts

assets

@@ -1 +1 @@
-Subproject commit 81e61c287670f6aa8b7faf2c27561df57361f1ad
+Subproject commit aa1231e8cf2990bb902eac3b37815c010fa9919a

source/funkin/InitState.hx

@@ -27,6 +27,7 @@ import funkin.data.dialogue.speaker.SpeakerRegistry;
 import funkin.data.freeplay.album.AlbumRegistry;
 import funkin.data.song.SongRegistry;
 import funkin.play.character.CharacterData.CharacterDataParser;
+import funkin.play.notes.notekind.NoteKindManager;
 import funkin.modding.module.ModuleHandler;
 import funkin.ui.title.TitleState;
 import funkin.util.CLIUtil;
@@ -176,6 +177,8 @@ class InitState extends FlxState
     // Move it to use a BaseRegistry.
     CharacterDataParser.loadCharacterCache();
 
+    NoteKindManager.loadScripts();
+
     ModuleHandler.buildModuleCallbacks();
     ModuleHandler.loadModuleCache();
     ModuleHandler.callOnCreate();

source/funkin/data/notestyle/NoteStyleData.hx

@@ -109,6 +109,14 @@ typedef NoteStyleAssetData<T> =
   @:optional
   var isPixel:Bool;
 
+  /**
+   * If true, animations will be played on the graphic.
+   * @default `false` to save performance.
+   */
+  @:default(false)
+  @:optional
+  var animated:Bool;
+
   /**
    * The structure of this data depends on the asset.
    */

source/funkin/data/song/SongData.hx

@@ -951,12 +951,18 @@ class SongNoteDataRaw implements ICloneable<SongNoteDataRaw>
     return this.kind = value;
   }
 
-  public function new(time:Float, data:Int, length:Float = 0, kind:String = '')
+  @:alias("p")
+  @:default([])
+  @:optional
+  public var params:Array<NoteParamData>;
+
+  public function new(time:Float, data:Int, length:Float = 0, kind:String = '', ?params:Array<NoteParamData>)
   {
     this.time = time;
     this.data = data;
     this.length = length;
     this.kind = kind;
+    this.params = params ?? [];
   }
 
   /**
@@ -1051,9 +1057,19 @@ class SongNoteDataRaw implements ICloneable<SongNoteDataRaw>
     _stepLength = null;
   }
 
+  public function cloneParams():Array<NoteParamData>
+  {
+    var params:Array<NoteParamData> = [];
+    for (param in this.params)
+    {
+      params.push(param.clone());
+    }
+    return params;
+  }
+
   public function clone():SongNoteDataRaw
   {
-    return new SongNoteDataRaw(this.time, this.data, this.length, this.kind);
+    return new SongNoteDataRaw(this.time, this.data, this.length, this.kind, cloneParams());
   }
 
   public function toString():String
@@ -1069,9 +1085,9 @@ class SongNoteDataRaw implements ICloneable<SongNoteDataRaw>
 @:forward
 abstract SongNoteData(SongNoteDataRaw) from SongNoteDataRaw to SongNoteDataRaw
 {
-  public function new(time:Float, data:Int, length:Float = 0, kind:String = '')
+  public function new(time:Float, data:Int, length:Float = 0, kind:String = '', ?params:Array<NoteParamData>)
   {
-    this = new SongNoteDataRaw(time, data, length, kind);
+    this = new SongNoteDataRaw(time, data, length, kind, params);
   }
 
   public static function buildDirectionName(data:Int, strumlineSize:Int = 4):String
@@ -1115,7 +1131,7 @@ abstract SongNoteData(SongNoteDataRaw) from SongNoteDataRaw to SongNoteDataRaw
       if (other.kind == '' || this.kind == null) return false;
     }
 
-    return this.time == other.time && this.data == other.data && this.length == other.length;
+    return this.time == other.time && this.data == other.data && this.length == other.length && this.params == other.params;
   }
 
   @:op(A != B)
@@ -1134,7 +1150,7 @@ abstract SongNoteData(SongNoteDataRaw) from SongNoteDataRaw to SongNoteDataRaw
       if (other.kind == '') return true;
     }
 
-    return this.time != other.time || this.data != other.data || this.length != other.length;
+    return this.time != other.time || this.data != other.data || this.length != other.length || this.params != other.params;
   }
 
   @:op(A > B)
@@ -1171,7 +1187,7 @@ abstract SongNoteData(SongNoteDataRaw) from SongNoteDataRaw to SongNoteDataRaw
 
   public function clone():SongNoteData
   {
-    return new SongNoteData(this.time, this.data, this.length, this.kind);
+    return new SongNoteData(this.time, this.data, this.length, this.kind, this.params);
   }
 
   /**
@@ -1183,3 +1199,30 @@ abstract SongNoteData(SongNoteDataRaw) from SongNoteDataRaw to SongNoteDataRaw
       + (this.kind != '' ? ' [kind: ${this.kind}])' : ')');
   }
 }
+
+class NoteParamData implements ICloneable<NoteParamData>
+{
+  @:alias("n")
+  public var name:String;
+
+  @:alias("v")
+  @:jcustomparse(funkin.data.DataParse.dynamicValue)
+  @:jcustomwrite(funkin.data.DataWrite.dynamicValue)
+  public var value:Dynamic;
+
+  public function new(name:String, value:Dynamic)
+  {
+    this.name = name;
+    this.value = value;
+  }
+
+  public function clone():NoteParamData
+  {
+    return new NoteParamData(this.name, this.value);
+  }
+
+  public function toString():String
+  {
+    return 'NoteParamData(${this.name}, ${this.value})';
+  }
+}

source/funkin/data/song/importer/FNFLegacyImporter.hx

@@ -199,6 +199,8 @@ class FNFLegacyImporter
       {
         // Handle the dumb logic for mustHitSection.
         var noteData = note.data;
+        if (noteData < 0) continue; // Exclude Psych event notes.
+        if (noteData > (STRUMLINE_SIZE * 2)) noteData = noteData % (2 * STRUMLINE_SIZE); // Handle other engine event notes.
 
         // Flip notes if mustHitSection is FALSE (not true lol).
         if (!mustHitSection)

source/funkin/modding/PolymodHandler.hx

@@ -7,6 +7,7 @@ import funkin.data.dialogue.speaker.SpeakerRegistry;
 import funkin.data.event.SongEventRegistry;
 import funkin.data.story.level.LevelRegistry;
 import funkin.data.notestyle.NoteStyleRegistry;
+import funkin.play.notes.notekind.NoteKindManager;
 import funkin.data.song.SongRegistry;
 import funkin.data.freeplay.player.PlayerRegistry;
 import funkin.data.stage.StageRegistry;
@@ -387,6 +388,7 @@ class PolymodHandler
     StageRegistry.instance.loadEntries();
 
     CharacterDataParser.loadCharacterCache(); // TODO: Migrate characters to BaseRegistry.
+    NoteKindManager.loadScripts();
     ModuleHandler.loadModuleCache();
   }
 }

source/funkin/play/PlayState.hx

@@ -49,6 +49,7 @@ import funkin.play.notes.NoteSprite;
 import funkin.play.notes.notestyle.NoteStyle;
 import funkin.play.notes.Strumline;
 import funkin.play.notes.SustainTrail;
+import funkin.play.notes.notekind.NoteKindManager;
 import funkin.play.scoring.Scoring;
 import funkin.play.song.Song;
 import funkin.play.stage.Stage;
@@ -1164,6 +1165,9 @@ class PlayState extends MusicBeatSubState
     // super.dispatchEvent(event) dispatches event to module scripts.
     super.dispatchEvent(event);
 
+    // Dispatch event to note kind scripts
+    NoteKindManager.callEvent(event);
+
     // Dispatch event to stage script.
     ScriptEventDispatcher.callEvent(currentStage, event);
 
@@ -1175,8 +1179,6 @@ class PlayState extends MusicBeatSubState
 
     // Dispatch event to conversation script.
     ScriptEventDispatcher.callEvent(currentConversation, event);
-
-    // TODO: Dispatch event to note scripts
   }
 
   /**

source/funkin/play/character/BaseCharacter.hx

@@ -521,6 +521,9 @@ class BaseCharacter extends Bopper
   {
     super.onNoteHit(event);
 
+    // If another script cancelled the event, don't do anything.
+    if (event.eventCanceled) return;
+
     if (event.note.noteData.getMustHitNote() && characterType == BF)
     {
       // If the note is from the same strumline, play the sing animation.
@@ -553,6 +556,9 @@ class BaseCharacter extends Bopper
   {
     super.onNoteMiss(event);
 
+    // If another script cancelled the event, don't do anything.
+    if (event.eventCanceled) return;
+
     if (event.note.noteData.getMustHitNote() && characterType == BF)
     {
       // If the note is from the same strumline, play the sing animation.

source/funkin/play/notes/NoteSprite.hx

@@ -1,6 +1,7 @@
 package funkin.play.notes;
 
 import funkin.data.song.SongData.SongNoteData;
+import funkin.data.song.SongData.NoteParamData;
 import funkin.play.notes.notestyle.NoteStyle;
 import flixel.graphics.frames.FlxAtlasFrames;
 import flixel.FlxSprite;
@@ -65,6 +66,22 @@ class NoteSprite extends FunkinSprite
     return this.noteData.kind = value;
   }
 
+  /**
+   * An array of custom parameters for this note
+   */
+  public var params(get, set):Array<NoteParamData>;
+
+  function get_params():Array<NoteParamData>
+  {
+    return this.noteData?.params ?? [];
+  }
+
+  function set_params(value:Array<NoteParamData>):Array<NoteParamData>
+  {
+    if (this.noteData == null) return value;
+    return this.noteData.params = value;
+  }
+
   /**
    * The data of the note (i.e. the direction.)
    */
@@ -74,7 +91,7 @@ class NoteSprite extends FunkinSprite
   {
     if (frames == null) return value;
 
-    animation.play(DIRECTION_COLORS[value] + 'Scroll');
+    playNoteAnimation(value);
 
     this.direction = value;
     return this.direction;
@@ -135,19 +152,37 @@ class NoteSprite extends FunkinSprite
     this.hsvShader = new HSVShader();
 
     setupNoteGraphic(noteStyle);
-
-    // Disables the update() function for performance.
-    this.active = false;
   }
 
-  function setupNoteGraphic(noteStyle:NoteStyle):Void
+  /**
+   * Creates frames and animations
+   * @param noteStyle The `NoteStyle` instance
+   */
+  public function setupNoteGraphic(noteStyle:NoteStyle):Void
   {
     noteStyle.buildNoteSprite(this);
 
-    setGraphicSize(Strumline.STRUMLINE_SIZE);
-    updateHitbox();
-
     this.shader = hsvShader;
+
+    // `false` disables the update() function for performance.
+    this.active = noteStyle.isNoteAnimated();
+  }
+
+  /**
+   * Retrieve the value of the param with the given name
+   * @param name Name of the param
+   * @return Null<Dynamic>
+   */
+  public function getParam(name:String):Null<Dynamic>
+  {
+    for (param in params)
+    {
+      if (param.name == name)
+      {
+        return param.value;
+      }
+    }
+    return null;
   }
 
   #if FLX_DEBUG
@@ -173,6 +208,11 @@ class NoteSprite extends FunkinSprite
   }
   #end
 
+  function playNoteAnimation(value:Int):Void
+  {
+    animation.play(DIRECTION_COLORS[value] + 'Scroll');
+  }
+
   public function desaturate():Void
   {
     this.hsvShader.saturation = 0.2;

source/funkin/play/notes/Strumline.hx

@@ -16,6 +16,7 @@ import funkin.data.song.SongData.SongNoteData;
 import funkin.ui.options.PreferencesMenu;
 import funkin.util.SortUtil;
 import funkin.modding.events.ScriptEvent;
+import funkin.play.notes.notekind.NoteKindManager;
 
 /**
  * A group of sprites which handles the receptor, the note splashes, and the notes (with sustains) for a given player.
@@ -708,11 +709,15 @@ class Strumline extends FlxSpriteGroup
 
     if (noteSprite != null)
     {
+      var noteKindStyle:NoteStyle = NoteKindManager.getNoteStyle(note.kind, this.noteStyle.id) ?? this.noteStyle;
+      noteSprite.setupNoteGraphic(noteKindStyle);
+
       noteSprite.direction = note.getDirection();
       noteSprite.noteData = note;
 
       noteSprite.x = this.x;
       noteSprite.x += getXPos(DIRECTIONS[note.getDirection() % KEY_COUNT]);
+      noteSprite.x -= (noteSprite.width - Strumline.STRUMLINE_SIZE) / 2; // Center it
       noteSprite.x -= NUDGE;
       // noteSprite.x += INITIAL_OFFSET;
       noteSprite.y = -9999;
@@ -727,6 +732,9 @@ class Strumline extends FlxSpriteGroup
 
     if (holdNoteSprite != null)
     {
+      var noteKindStyle:NoteStyle = NoteKindManager.getNoteStyle(note.kind, this.noteStyle.id) ?? this.noteStyle;
+      holdNoteSprite.setupHoldNoteGraphic(noteKindStyle);
+
       holdNoteSprite.parentStrumline = this;
       holdNoteSprite.noteData = note;
       holdNoteSprite.strumTime = note.time;

source/funkin/play/notes/SustainTrail.hx

@@ -99,7 +99,27 @@ class SustainTrail extends FlxSprite
    */
   public function new(noteDirection:NoteDirection, sustainLength:Float, noteStyle:NoteStyle)
   {
-    super(0, 0, noteStyle.getHoldNoteAssetPath());
+    super(0, 0);
+
+    // BASIC SETUP
+    this.sustainLength = sustainLength;
+    this.fullSustainLength = sustainLength;
+    this.noteDirection = noteDirection;
+
+    setupHoldNoteGraphic(noteStyle);
+
+    indices = new DrawData<Int>(12, true, TRIANGLE_VERTEX_INDICES);
+
+    this.active = true; // This NEEDS to be true for the note to be drawn!
+  }
+
+  /**
+   * Creates hold note graphic and applies correct zooming
+   * @param noteStyle The note style
+   */
+  public function setupHoldNoteGraphic(noteStyle:NoteStyle):Void
+  {
+    loadGraphic(noteStyle.getHoldNoteAssetPath());
 
     antialiasing = true;
 
@@ -109,13 +129,14 @@ class SustainTrail extends FlxSprite
       endOffset = bottomClip = 1;
       antialiasing = false;
     }
+    else
+    {
+      endOffset = 0.5;
+      bottomClip = 0.9;
+    }
+
+    zoom = 1.0;
     zoom *= noteStyle.fetchHoldNoteScale();
-
-    // BASIC SETUP
-    this.sustainLength = sustainLength;
-    this.fullSustainLength = sustainLength;
-    this.noteDirection = noteDirection;
-
     zoom *= 0.7;
 
     // CALCULATE SIZE
@@ -131,9 +152,6 @@ class SustainTrail extends FlxSprite
     updateColorTransform();
 
     updateClipping();
-    indices = new DrawData<Int>(12, true, TRIANGLE_VERTEX_INDICES);
-
-    this.active = true; // This NEEDS to be true for the note to be drawn!
   }
 
   function getBaseScrollSpeed()
@@ -195,6 +213,11 @@ class SustainTrail extends FlxSprite
    */
   public function updateClipping(songTime:Float = 0):Void
   {
+    if (graphic == null)
+    {
+      return;
+    }
+
     var clipHeight:Float = FlxMath.bound(sustainHeight(sustainLength - (songTime - strumTime), parentStrumline?.scrollSpeed ?? 1.0), 0, graphicHeight);
     if (clipHeight <= 0.1)
     {

source/funkin/play/notes/notekind/NoteKind.hx

@@ -0,0 +1,119 @@
+package funkin.play.notes.notekind;
+
+import funkin.modding.IScriptedClass.INoteScriptedClass;
+import funkin.modding.events.ScriptEvent;
+import flixel.math.FlxMath;
+
+/**
+ * Class for note scripts
+ */
+class NoteKind implements INoteScriptedClass
+{
+  /**
+   * The name of the note kind
+   */
+  public var noteKind:String;
+
+  /**
+   * Description used in chart editor
+   */
+  public var description:String;
+
+  /**
+   * Custom note style
+   */
+  public var noteStyleId:Null<String>;
+
+  /**
+   * Custom parameters for the chart editor
+   */
+  public var params:Array<NoteKindParam>;
+
+  public function new(noteKind:String, description:String = "", ?noteStyleId:String, ?params:Array<NoteKindParam>)
+  {
+    this.noteKind = noteKind;
+    this.description = description;
+    this.noteStyleId = noteStyleId;
+    this.params = params ?? [];
+  }
+
+  public function toString():String
+  {
+    return noteKind;
+  }
+
+  /**
+   * Retrieve all notes of this kind
+   * @return Array<NoteSprite>
+   */
+  function getNotes():Array<NoteSprite>
+  {
+    var allNotes:Array<NoteSprite> = PlayState.instance.playerStrumline.notes.members.concat(PlayState.instance.opponentStrumline.notes.members);
+    return allNotes.filter(function(note:NoteSprite) {
+      return note != null && note.noteData.kind == this.noteKind;
+    });
+  }
+
+  public function onScriptEvent(event:ScriptEvent):Void {}
+
+  public function onCreate(event:ScriptEvent):Void {}
+
+  public function onDestroy(event:ScriptEvent):Void {}
+
+  public function onUpdate(event:UpdateScriptEvent):Void {}
+
+  public function onNoteIncoming(event:NoteScriptEvent):Void {}
+
+  public function onNoteHit(event:HitNoteScriptEvent):Void {}
+
+  public function onNoteMiss(event:NoteScriptEvent):Void {}
+}
+
+/**
+ * Abstract for setting the type of the `NoteKindParam`
+ * This was supposed to be an enum but polymod kept being annoying
+ */
+abstract NoteKindParamType(String) from String to String
+{
+  public static final STRING:String = 'String';
+
+  public static final INT:String = 'Int';
+
+  public static final FLOAT:String = 'Float';
+}
+
+typedef NoteKindParamData =
+{
+  /**
+   * If `min` is null, there is no minimum
+   */
+  ?min:Null<Float>,
+
+  /**
+   * If `max` is null, there is no maximum
+   */
+  ?max:Null<Float>,
+
+  /**
+   * If `step` is null, it will use 1.0
+   */
+  ?step:Null<Float>,
+
+  /**
+   * If `precision` is null, there will be 0 decimal places
+   */
+  ?precision:Null<Int>,
+
+  ?defaultValue:Dynamic
+}
+
+/**
+ * Typedef for creating custom parameters in the chart editor
+ */
+typedef NoteKindParam =
+{
+  name:String,
+  description:String,
+  type:NoteKindParamType,
+  ?data:NoteKindParamData
+}

source/funkin/play/notes/notekind/NoteKindManager.hx

@@ -0,0 +1,121 @@
+package funkin.play.notes.notekind;
+
+import funkin.modding.events.ScriptEventDispatcher;
+import funkin.modding.events.ScriptEvent;
+import funkin.ui.debug.charting.util.ChartEditorDropdowns;
+import funkin.data.notestyle.NoteStyleRegistry;
+import funkin.play.notes.notestyle.NoteStyle;
+import funkin.play.notes.notekind.ScriptedNoteKind;
+import funkin.play.notes.notekind.NoteKind.NoteKindParam;
+
+class NoteKindManager
+{
+  static var noteKinds:Map<String, NoteKind> = [];
+
+  public static function loadScripts():Void
+  {
+    var scriptedClassName:Array<String> = ScriptedNoteKind.listScriptClasses();
+    if (scriptedClassName.length > 0)
+    {
+      trace('Instantiating ${scriptedClassName.length} scripted note kind(s)...');
+      for (scriptedClass in scriptedClassName)
+      {
+        try
+        {
+          var script:NoteKind = ScriptedNoteKind.init(scriptedClass, "unknown");
+          trace(' Initialized scripted note kind: ${script.noteKind}');
+          noteKinds.set(script.noteKind, script);
+          ChartEditorDropdowns.NOTE_KINDS.set(script.noteKind, script.description);
+        }
+        catch (e)
+        {
+          trace(' FAILED to instantiate scripted note kind: ${scriptedClass}');
+          trace(e);
+        }
+      }
+    }
+  }
+
+  /**
+   * Calls the given event for note kind scripts
+   * @param event The event
+   */
+  public static function callEvent(event:ScriptEvent):Void
+  {
+    // if it is a note script event,
+    // then only call the event for the specific note kind script
+    if (Std.isOfType(event, NoteScriptEvent))
+    {
+      var noteEvent:NoteScriptEvent = cast(event, NoteScriptEvent);
+
+      var noteKind:NoteKind = noteKinds.get(noteEvent.note.kind);
+
+      if (noteKind != null)
+      {
+        ScriptEventDispatcher.callEvent(noteKind, event);
+      }
+    }
+    else // call the event for all note kind scripts
+    {
+      for (noteKind in noteKinds.iterator())
+      {
+        ScriptEventDispatcher.callEvent(noteKind, event);
+      }
+    }
+  }
+
+  /**
+   * Retrieve the note style from the given note kind
+   * @param noteKind note kind name
+   * @param suffix Used for song note styles
+   * @return NoteStyle
+   */
+  public static function getNoteStyle(noteKind:String, ?suffix:String):Null<NoteStyle>
+  {
+    var noteStyleId:Null<String> = getNoteStyleId(noteKind, suffix);
+
+    if (noteStyleId == null)
+    {
+      return null;
+    }
+
+    return NoteStyleRegistry.instance.fetchEntry(noteStyleId);
+  }
+
+  /**
+   * Retrieve the note style id from the given note kind
+   * @param noteKind Note kind name
+   * @param suffix Used for song note styles
+   * @return Null<String>
+   */
+  public static function getNoteStyleId(noteKind:String, ?suffix:String):Null<String>
+  {
+    if (suffix == '')
+    {
+      suffix = null;
+    }
+
+    var noteStyleId:Null<String> = noteKinds.get(noteKind)?.noteStyleId;
+    if (noteStyleId != null && suffix != null)
+    {
+      noteStyleId = NoteStyleRegistry.instance.hasEntry('$noteStyleId-$suffix') ? '$noteStyleId-$suffix' : noteStyleId;
+    }
+
+    return noteStyleId;
+  }
+
+  /**
+   * Retrive custom params of the given note kind
+   * @param noteKind Name of the note kind
+   * @return Array<NoteKindParam>
+   */
+  public static function getParams(noteKind:Null<String>):Array<NoteKindParam>
+  {
+    if (noteKind == null)
+    {
+      return [];
+    }
+
+    return noteKinds.get(noteKind)?.params ?? [];
+  }
+}

source/funkin/play/notes/notekind/ScriptedNoteKind.hx

@@ -0,0 +1,9 @@
+package funkin.play.notes.notekind;
+
+/**
+ * A script that can be tied to a NoteKind.
+ * Create a scripted class that extends NoteKind,
+ * then call `super('noteKind')` in the constructor to use this.
+ */
+@:hscriptClass
+class ScriptedNoteKind extends NoteKind implements polymod.hscript.HScriptedClass {}

source/funkin/play/notes/notestyle/NoteStyle.hx

@@ -89,12 +89,14 @@ class NoteStyle implements IRegistryEntry<NoteStyleData>
 
     target.frames = atlas;
 
-    target.scale.x = _data.assets.note.scale;
-    target.scale.y = _data.assets.note.scale;
     target.antialiasing = !_data.assets.note.isPixel;
 
     // Apply the animations.
     buildNoteAnimations(target);
+
+    // Set the scale.
+    target.setGraphicSize(Strumline.STRUMLINE_SIZE * getNoteScale());
+    target.updateHitbox();
   }
 
   var noteFrames:FlxAtlasFrames = null;
@@ -156,6 +158,16 @@ class NoteStyle implements IRegistryEntry<NoteStyleData>
     target.animation.addByPrefix('redScroll', rightData.prefix, rightData.frameRate, rightData.looped, rightData.flipX, rightData.flipY);
   }
 
+  public function isNoteAnimated():Bool
+  {
+    return _data.assets.note.animated;
+  }
+
+  public function getNoteScale():Float
+  {
+    return _data.assets.note.scale;
+  }
+
   function fetchNoteAnimationData(dir:NoteDirection):AnimationData
   {
     var result:Null<AnimationData> = switch (dir)

source/funkin/play/stage/Bopper.hx

@@ -45,8 +45,8 @@ class Bopper extends StageProp implements IPlayStateScriptedClass
   public var idleSuffix(default, set):String = '';
 
   /**
-   * If this bopper is rendered with pixel art,
+   * If this bopper is rendered with pixel art, disable anti-aliasing.
-   * disable anti-aliasing and render at 6x scale.
+   * @default `false`
    */
   public var isPixel(default, set):Bool = false;
 

source/funkin/ui/debug/charting/ChartEditorState.hx

@@ -35,6 +35,7 @@ import funkin.data.song.SongData.SongEventData;
 import funkin.data.song.SongData.SongMetadata;
 import funkin.data.song.SongData.SongNoteData;
 import funkin.data.song.SongData.SongOffsets;
+import funkin.data.song.SongData.NoteParamData;
 import funkin.data.song.SongDataUtils;
 import funkin.data.song.SongRegistry;
 import funkin.data.stage.StageData;
@@ -45,6 +46,7 @@ import funkin.input.TurboActionHandler;
 import funkin.input.TurboButtonHandler;
 import funkin.input.TurboKeyHandler;
 import funkin.modding.events.ScriptEvent;
+import funkin.play.notes.notekind.NoteKindManager;
 import funkin.play.character.BaseCharacter.CharacterType;
 import funkin.play.character.CharacterData;
 import funkin.play.character.CharacterData.CharacterDataParser;
@@ -553,6 +555,11 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
    */
   var noteKindToPlace:Null<String> = null;
 
+  /**
+   * The note params to use for notes being placed in the chart. Defaults to `[]`.
+   */
+  var noteParamsToPlace:Array<NoteParamData> = [];
+
   /**
    * The event type to use for events being placed in the chart. Defaults to `''`.
    */
@@ -1416,7 +1423,9 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
   function get_currentSongNoteStyle():String
   {
-    if (currentSongMetadata.playData.noteStyle == null)
+    if (currentSongMetadata.playData.noteStyle == null
+      || currentSongMetadata.playData.noteStyle == ''
+      || currentSongMetadata.playData.noteStyle == 'item')
     {
       // Initialize to the default value if not set.
       currentSongMetadata.playData.noteStyle = Constants.DEFAULT_NOTE_STYLE;
@@ -2451,7 +2460,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
     gridGhostNote = new ChartEditorNoteSprite(this);
     gridGhostNote.alpha = 0.6;
-    gridGhostNote.noteData = new SongNoteData(0, 0, 0, "");
+    gridGhostNote.noteData = new SongNoteData(0, 0, 0, "", []);
     gridGhostNote.visible = false;
     add(gridGhostNote);
     gridGhostNote.zIndex = 11;
@@ -3599,6 +3608,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
         // The note sprite handles animation playback and positioning.
         noteSprite.noteData = noteData;
+        noteSprite.noteStyle = NoteKindManager.getNoteStyleId(noteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
         noteSprite.overrideStepTime = null;
         noteSprite.overrideData = null;
 
@@ -3622,6 +3632,8 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
           holdNoteSprite.setHeightDirectly(noteLengthPixels);
 
+          holdNoteSprite.noteStyle = NoteKindManager.getNoteStyleId(noteSprite.noteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
+
           holdNoteSprite.updateHoldNotePosition(renderedHoldNotes);
 
           trace(holdNoteSprite.x + ', ' + holdNoteSprite.y + ', ' + holdNoteSprite.width + ', ' + holdNoteSprite.height);
@@ -3684,9 +3696,10 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
         holdNoteSprite.noteData = noteData;
         holdNoteSprite.noteDirection = noteData.getDirection();
-
         holdNoteSprite.setHeightDirectly(noteLengthPixels);
 
+        holdNoteSprite.noteStyle = NoteKindManager.getNoteStyleId(noteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
+
         holdNoteSprite.updateHoldNotePosition(renderedHoldNotes);
 
         displayedHoldNoteData.push(noteData);
@@ -4584,7 +4597,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
             gridGhostHoldNote.noteData = currentPlaceNoteData;
             gridGhostHoldNote.noteDirection = currentPlaceNoteData.getDirection();
             gridGhostHoldNote.setHeightDirectly(dragLengthPixels, true);
-
+            gridGhostHoldNote.noteStyle = NoteKindManager.getNoteStyleId(currentPlaceNoteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
             gridGhostHoldNote.updateHoldNotePosition(renderedHoldNotes);
           }
           else
@@ -4741,7 +4754,8 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
                 else
                 {
                   // Create a note and place it in the chart.
-                  var newNoteData:SongNoteData = new SongNoteData(cursorSnappedMs, cursorColumn, 0, noteKindToPlace);
+                  var newNoteData:SongNoteData = new SongNoteData(cursorSnappedMs, cursorColumn, 0, noteKindToPlace,
+                    ChartEditorState.cloneNoteParams(noteParamsToPlace));
 
                   performCommand(new AddNotesCommand([newNoteData], FlxG.keys.pressed.CONTROL));
 
@@ -4900,12 +4914,15 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
 
             if (gridGhostNote == null) throw "ERROR: Tried to handle cursor, but gridGhostNote is null! Check ChartEditorState.buildGrid()";
 
-            var noteData:SongNoteData = gridGhostNote.noteData != null ? gridGhostNote.noteData : new SongNoteData(cursorMs, cursorColumn, 0, noteKindToPlace);
+            var noteData:SongNoteData = gridGhostNote.noteData != null ? gridGhostNote.noteData : new SongNoteData(cursorMs, cursorColumn, 0, noteKindToPlace,
+              ChartEditorState.cloneNoteParams(noteParamsToPlace));
 
-            if (cursorColumn != noteData.data || noteKindToPlace != noteData.kind)
+            if (cursorColumn != noteData.data || noteKindToPlace != noteData.kind || noteParamsToPlace != noteData.params)
             {
               noteData.kind = noteKindToPlace;
+              noteData.params = noteParamsToPlace;
               noteData.data = cursorColumn;
+              gridGhostNote.noteStyle = NoteKindManager.getNoteStyleId(noteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
               gridGhostNote.playNoteAnimation();
             }
             noteData.time = cursorSnappedMs;
@@ -5175,7 +5192,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
     if (notesAtPos.length == 0 && !removeNoteInstead)
     {
       trace('Placing note. ${column}');
-      var newNoteData:SongNoteData = new SongNoteData(playheadPosSnappedMs, column, 0, noteKindToPlace);
+      var newNoteData:SongNoteData = new SongNoteData(playheadPosSnappedMs, column, 0, noteKindToPlace, ChartEditorState.cloneNoteParams(noteParamsToPlace));
       performCommand(new AddNotesCommand([newNoteData], FlxG.keys.pressed.CONTROL));
       currentLiveInputPlaceNoteData[column] = newNoteData;
     }
@@ -5261,6 +5278,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
         ghostHold.visible = true;
         ghostHold.alpha = 0.6;
         ghostHold.setHeightDirectly(0);
+        ghostHold.noteStyle = NoteKindManager.getNoteStyleId(ghostHold.noteData.kind, currentSongNoteStyle) ?? currentSongNoteStyle;
         ghostHold.updateHoldNotePosition(renderedHoldNotes);
       }
 
@@ -5627,6 +5645,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
     FlxG.watch.addQuick('musicTime', audioInstTrack?.time ?? 0.0);
 
     FlxG.watch.addQuick('noteKindToPlace', noteKindToPlace);
+    FlxG.watch.addQuick('noteParamsToPlace', noteParamsToPlace);
     FlxG.watch.addQuick('eventKindToPlace', eventKindToPlace);
 
     FlxG.watch.addQuick('scrollPosInPixels', scrollPositionInPixels);
@@ -6490,6 +6509,16 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
     }
     return input;
   }
+
+  public static function cloneNoteParams(paramsToClone:Array<NoteParamData>):Array<NoteParamData>
+  {
+    var params:Array<NoteParamData> = [];
+    for (param in paramsToClone)
+    {
+      params.push(param.clone());
+    }
+    return params;
+  }
 }
 
 /**

source/funkin/ui/debug/charting/components/ChartEditorHoldNoteSprite.hx

@@ -2,6 +2,7 @@ package funkin.ui.debug.charting.components;
 
 import funkin.play.notes.Strumline;
 import funkin.data.notestyle.NoteStyleRegistry;
+import funkin.play.notes.notestyle.NoteStyle;
 import flixel.FlxObject;
 import flixel.FlxSprite;
 import flixel.graphics.frames.FlxFramesCollection;
@@ -15,6 +16,7 @@ import flixel.math.FlxMath;
  * A sprite that can be used to display the trail of a hold note in a chart.
  * Designed to be used and reused efficiently. Has no gameplay functionality.
  */
+@:access(funkin.ui.debug.charting.ChartEditorState)
 @:nullSafety
 class ChartEditorHoldNoteSprite extends SustainTrail
 {
@@ -23,6 +25,22 @@ class ChartEditorHoldNoteSprite extends SustainTrail
    */
   public var parentState:ChartEditorState;
 
+  @:isVar
+  public var noteStyle(get, set):Null<String>;
+
+  function get_noteStyle():Null<String>
+  {
+    return this.noteStyle ?? this.parentState.currentSongNoteStyle;
+  }
+
+  @:nullSafety(Off)
+  function set_noteStyle(value:Null<String>):Null<String>
+  {
+    this.noteStyle = value;
+    this.updateHoldNoteGraphic();
+    return value;
+  }
+
   public function new(parent:ChartEditorState)
   {
     var noteStyle = NoteStyleRegistry.instance.fetchDefault();
@@ -30,14 +48,50 @@ class ChartEditorHoldNoteSprite extends SustainTrail
     super(0, 100, noteStyle);
 
     this.parentState = parent;
+  }
+
+  @:nullSafety(Off)
+  function updateHoldNoteGraphic():Void
+  {
+    var bruhStyle:Null<NoteStyle> = NoteStyleRegistry.instance.fetchEntry(noteStyle);
+    if (bruhStyle == null) bruhStyle = NoteStyleRegistry.instance.fetchDefault();
+    setupHoldNoteGraphic(bruhStyle);
+  }
+
+  override function setupHoldNoteGraphic(noteStyle:NoteStyle):Void
+  {
+    loadGraphic(noteStyle.getHoldNoteAssetPath());
+
+    antialiasing = true;
+
+    this.isPixel = noteStyle.isHoldNotePixel();
+    if (isPixel)
+    {
+      endOffset = bottomClip = 1;
+      antialiasing = false;
+    }
+    else
+    {
+      endOffset = 0.5;
+      bottomClip = 0.9;
+    }
 
     zoom = 1.0;
     zoom *= noteStyle.fetchHoldNoteScale();
     zoom *= 0.7;
     zoom *= ChartEditorState.GRID_SIZE / Strumline.STRUMLINE_SIZE;
 
+    graphicWidth = graphic.width / 8 * zoom; // amount of notes * 2
+    graphicHeight = sustainLength * 0.45; // sustainHeight
+
     flipY = false;
 
+    alpha = 1.0;
+
+    updateColorTransform();
+
+    updateClipping();
+
     setup();
   }
 

source/funkin/ui/debug/charting/components/ChartEditorNoteSprite.hx

@@ -7,7 +7,11 @@ import flixel.graphics.frames.FlxAtlasFrames;
 import flixel.graphics.frames.FlxFrame;
 import flixel.graphics.frames.FlxTileFrames;
 import flixel.math.FlxPoint;
+import funkin.data.animation.AnimationData;
 import funkin.data.song.SongData.SongNoteData;
+import funkin.data.notestyle.NoteStyleRegistry;
+import funkin.play.notes.notestyle.NoteStyle;
+import funkin.play.notes.NoteDirection;
 
 /**
  * A sprite that can be used to display a note in a chart.
@@ -36,7 +40,8 @@ class ChartEditorNoteSprite extends FlxSprite
   /**
    * The name of the note style currently in use.
    */
-  public var noteStyle(get, never):String;
+  @:isVar
+  public var noteStyle(get, set):Null<String>;
 
   public var overrideStepTime(default, set):Null<Float> = null;
 
@@ -66,72 +71,80 @@ class ChartEditorNoteSprite extends FlxSprite
 
     this.parentState = parent;
 
+    var entries:Array<String> = NoteStyleRegistry.instance.listEntryIds();
+
     if (noteFrameCollection == null)
     {
-      initFrameCollection();
+      buildEmptyFrameCollection();
+
+      for (entry in entries)
+      {
+        addNoteStyleFrames(fetchNoteStyle(entry));
+      }
     }
 
     if (noteFrameCollection == null) throw 'ERROR: Could not initialize note sprite animations.';
 
     this.frames = noteFrameCollection;
 
-    // Initialize all the animations, not just the one we're going to use immediately,
+    for (entry in entries)
-    // so that later we can reuse the sprite without having to initialize more animations during scrolling.
+    {
-    this.animation.addByPrefix('tapLeftFunkin', 'purple instance');
+      addNoteStyleAnimations(fetchNoteStyle(entry));
-    this.animation.addByPrefix('tapDownFunkin', 'blue instance');
+    }
-    this.animation.addByPrefix('tapUpFunkin', 'green instance');
-    this.animation.addByPrefix('tapRightFunkin', 'red instance');
-
-    this.animation.addByPrefix('holdLeftFunkin', 'LeftHoldPiece');
-    this.animation.addByPrefix('holdDownFunkin', 'DownHoldPiece');
-    this.animation.addByPrefix('holdUpFunkin', 'UpHoldPiece');
-    this.animation.addByPrefix('holdRightFunkin', 'RightHoldPiece');
-
-    this.animation.addByPrefix('holdEndLeftFunkin', 'LeftHoldEnd');
-    this.animation.addByPrefix('holdEndDownFunkin', 'DownHoldEnd');
-    this.animation.addByPrefix('holdEndUpFunkin', 'UpHoldEnd');
-    this.animation.addByPrefix('holdEndRightFunkin', 'RightHoldEnd');
-
-    this.animation.addByPrefix('tapLeftPixel', 'pixel4');
-    this.animation.addByPrefix('tapDownPixel', 'pixel5');
-    this.animation.addByPrefix('tapUpPixel', 'pixel6');
-    this.animation.addByPrefix('tapRightPixel', 'pixel7');
   }
 
   static var noteFrameCollection:Null<FlxFramesCollection> = null;
 
-  /**
+  function fetchNoteStyle(noteStyleId:String):NoteStyle
-   * We load all the note frames once, then reuse them.
-   */
-  static function initFrameCollection():Void
   {
-    buildEmptyFrameCollection();
+    var result = NoteStyleRegistry.instance.fetchEntry(noteStyleId);
-    if (noteFrameCollection == null) return;
+    if (result != null) return result;
+    return NoteStyleRegistry.instance.fetchDefault();
+  }
 
-    // TODO: Automatically iterate over the list of note skins.
+  @:access(funkin.play.notes.notestyle.NoteStyle)
+  @:nullSafety(Off)
+  static function addNoteStyleFrames(noteStyle:NoteStyle):Void
+  {
+    var prefix:String = noteStyle.id.toTitleCase();
 
-    // Normal notes
+    var frameCollection:FlxAtlasFrames = Paths.getSparrowAtlas(noteStyle.getNoteAssetPath(), noteStyle.getNoteAssetLibrary());
-    var frameCollectionNormal:FlxAtlasFrames = Paths.getSparrowAtlas('NOTE_assets');
+    if (frameCollection == null)
-
-    for (frame in frameCollectionNormal.frames)
     {
-      noteFrameCollection.pushFrame(frame);
+      trace('Could not retrieve frame collection for ${noteStyle}: ${Paths.image(noteStyle.getNoteAssetPath(), noteStyle.getNoteAssetLibrary())}');
+      FlxG.log.error('Could not retrieve frame collection for ${noteStyle}: ${Paths.image(noteStyle.getNoteAssetPath(), noteStyle.getNoteAssetLibrary())}');
+      return;
     }
-
+    for (frame in frameCollection.frames)
-    // Pixel notes
-    var graphicPixel = FlxG.bitmap.add(Paths.image('weeb/pixelUI/arrows-pixels', 'week6'), false, null);
-    if (graphicPixel == null) trace('ERROR: Could not load graphic: ' + Paths.image('weeb/pixelUI/arrows-pixels', 'week6'));
-    var frameCollectionPixel = FlxTileFrames.fromGraphic(graphicPixel, new FlxPoint(17, 17));
-    for (i in 0...frameCollectionPixel.frames.length)
     {
-      var frame:Null<FlxFrame> = frameCollectionPixel.frames[i];
+      // cloning the frame because else
-      if (frame == null) continue;
+      // we will fuck up the frame data used in game
-
+      var clonedFrame:FlxFrame = frame.copyTo();
-      frame.name = 'pixel' + i;
+      clonedFrame.name = '$prefix${clonedFrame.name}';
-      noteFrameCollection.pushFrame(frame);
+      noteFrameCollection.pushFrame(clonedFrame);
     }
   }
 
+  @:access(funkin.play.notes.notestyle.NoteStyle)
+  @:nullSafety(Off)
+  function addNoteStyleAnimations(noteStyle:NoteStyle):Void
+  {
+    var prefix:String = noteStyle.id.toTitleCase();
+    var suffix:String = noteStyle.id.toTitleCase();
+
+    var leftData:AnimationData = noteStyle.fetchNoteAnimationData(NoteDirection.LEFT);
+    this.animation.addByPrefix('tapLeft$suffix', '$prefix${leftData.prefix}', leftData.frameRate, leftData.looped, leftData.flipX, leftData.flipY);
+
+    var downData:AnimationData = noteStyle.fetchNoteAnimationData(NoteDirection.DOWN);
+    this.animation.addByPrefix('tapDown$suffix', '$prefix${downData.prefix}', downData.frameRate, downData.looped, downData.flipX, downData.flipY);
+
+    var upData:AnimationData = noteStyle.fetchNoteAnimationData(NoteDirection.UP);
+    this.animation.addByPrefix('tapUp$suffix', '$prefix${upData.prefix}', upData.frameRate, upData.looped, upData.flipX, upData.flipY);
+
+    var rightData:AnimationData = noteStyle.fetchNoteAnimationData(NoteDirection.RIGHT);
+    this.animation.addByPrefix('tapRight$suffix', '$prefix${rightData.prefix}', rightData.frameRate, rightData.looped, rightData.flipX, rightData.flipY);
+  }
+
   @:nullSafety(Off)
   static function buildEmptyFrameCollection():Void
   {
@@ -185,12 +198,24 @@ class ChartEditorNoteSprite extends FlxSprite
     }
   }
 
-  function get_noteStyle():String
+  function get_noteStyle():Null<String>
   {
-    // Fall back to Funkin' if it's not a valid note style.
+    if (this.noteStyle == null)
-    return if (NOTE_STYLES.contains(this.parentState.currentSongNoteStyle)) this.parentState.currentSongNoteStyle else 'funkin';
+    {
+      var result = this.parentState.currentSongNoteStyle;
+      return result;
+    }
+    return this.noteStyle;
   }
 
+  function set_noteStyle(value:Null<String>):Null<String>
+  {
+    this.noteStyle = value;
+    this.playNoteAnimation();
+    return value;
+  }
+
+  @:nullSafety(Off)
   public function playNoteAnimation():Void
   {
     if (this.noteData == null) return;
@@ -200,6 +225,7 @@ class ChartEditorNoteSprite extends FlxSprite
 
     // Play the appropriate animation for the type, direction, and skin.
     var dirName:String = overrideData != null ? SongNoteData.buildDirectionName(overrideData) : this.noteData.getDirectionName();
+    var noteStyleSuffix:String = this.noteStyle?.toTitleCase() ?? Constants.DEFAULT_NOTE_STYLE.toTitleCase();
     var animationName:String = '${baseAnimationName}${dirName}${this.noteStyle.toTitleCase()}';
 
     this.animation.play(animationName);
@@ -209,12 +235,12 @@ class ChartEditorNoteSprite extends FlxSprite
     switch (baseAnimationName)
     {
       case 'tap':
-        this.setGraphicSize(0, ChartEditorState.GRID_SIZE);
+        this.setGraphicSize(ChartEditorState.GRID_SIZE, 0);
+        this.updateHitbox();
     }
-    this.updateHitbox();
 
-    // TODO: Make this an attribute of the note skin.
+    var bruhStyle:NoteStyle = fetchNoteStyle(this.noteStyle);
-    this.antialiasing = (this.parentState.currentSongNoteStyle != 'Pixel');
+    this.antialiasing = !bruhStyle._data?.assets?.note?.isPixel ?? true;
   }
 
   /**

source/funkin/ui/debug/charting/toolboxes/ChartEditorNoteDataToolbox.hx

@@ -2,8 +2,16 @@ package funkin.ui.debug.charting.toolboxes;
 
 import haxe.ui.components.DropDown;
 import haxe.ui.components.TextField;
+import haxe.ui.components.Label;
+import haxe.ui.components.NumberStepper;
+import haxe.ui.containers.Grid;
+import haxe.ui.core.Component;
 import haxe.ui.events.UIEvent;
 import funkin.ui.debug.charting.util.ChartEditorDropdowns;
+import funkin.play.notes.notekind.NoteKindManager;
+import funkin.play.notes.notekind.NoteKind.NoteKindParam;
+import funkin.play.notes.notekind.NoteKind.NoteKindParamType;
+import funkin.data.song.SongData.NoteParamData;
 
 /**
  * The toolbox which allows modifying information like Note Kind.
@@ -12,8 +20,22 @@ import funkin.ui.debug.charting.util.ChartEditorDropdowns;
 @:build(haxe.ui.ComponentBuilder.build("assets/exclude/data/ui/chart-editor/toolboxes/note-data.xml"))
 class ChartEditorNoteDataToolbox extends ChartEditorBaseToolbox
 {
+  // 100 is the height used in note-data.xml
+  static final DIALOG_HEIGHT:Int = 100;
+
+  // toolboxNotesGrid.height + 45
+  // this is what i found out by printing this.height and grid.height
+  // and then seeing that this.height is 100 and grid.height is 55
+  static final HEIGHT_OFFSET:Int = 45;
+
+  // minimizing creates a gray bar the bottom, which would obscure the components,
+  // which is why we use an extra offset of 20
+  static final MINIMIZE_FIX:Int = 20;
+
+  var toolboxNotesGrid:Grid;
   var toolboxNotesNoteKind:DropDown;
   var toolboxNotesCustomKind:TextField;
+  var toolboxNotesParams:Array<ToolboxNoteKindParam> = [];
 
   var _initializing:Bool = true;
 
@@ -54,12 +76,35 @@ class ChartEditorNoteDataToolbox extends ChartEditorBaseToolbox
         toolboxNotesCustomKind.value = chartEditorState.noteKindToPlace;
       }
 
+      createNoteKindParams(noteKind);
+
       if (!_initializing && chartEditorState.currentNoteSelection.length > 0)
       {
-        // Edit the note data of any selected notes.
         for (note in chartEditorState.currentNoteSelection)
         {
+          // Edit the note data of any selected notes.
           note.kind = chartEditorState.noteKindToPlace;
+          note.params = ChartEditorState.cloneNoteParams(chartEditorState.noteParamsToPlace);
+
+          // update note sprites
+          for (noteSprite in chartEditorState.renderedNotes.members)
+          {
+            if (noteSprite.noteData == note)
+            {
+              noteSprite.noteStyle = NoteKindManager.getNoteStyleId(note.kind) ?? chartEditorState.currentSongNoteStyle;
+              break;
+            }
+          }
+
+          // update hold note sprites
+          for (holdNoteSprite in chartEditorState.renderedHoldNotes.members)
+          {
+            if (holdNoteSprite.noteData == note)
+            {
+              holdNoteSprite.noteStyle = NoteKindManager.getNoteStyleId(note.kind) ?? chartEditorState.currentSongNoteStyle;
+              break;
+            }
+          }
         }
         chartEditorState.saveDataDirty = true;
         chartEditorState.noteDisplayDirty = true;
@@ -94,6 +139,8 @@ class ChartEditorNoteDataToolbox extends ChartEditorBaseToolbox
 
     toolboxNotesNoteKind.value = ChartEditorDropdowns.lookupNoteKind(chartEditorState.noteKindToPlace);
     toolboxNotesCustomKind.value = chartEditorState.noteKindToPlace;
+
+    createNoteKindParams(chartEditorState.noteKindToPlace);
   }
 
   function showCustom():Void
@@ -108,8 +155,149 @@ class ChartEditorNoteDataToolbox extends ChartEditorBaseToolbox
     toolboxNotesCustomKind.hidden = true;
   }
 
+  function createNoteKindParams(noteKind:Null<String>):Void
+  {
+    clearNoteKindParams();
+
+    var setParamsToPlace:Bool = false;
+    if (!_initializing)
+    {
+      for (note in chartEditorState.currentNoteSelection)
+      {
+        if (note.kind == chartEditorState.noteKindToPlace)
+        {
+          chartEditorState.noteParamsToPlace = ChartEditorState.cloneNoteParams(note.params);
+          setParamsToPlace = true;
+          break;
+        }
+      }
+    }
+
+    var noteKindParams:Array<NoteKindParam> = NoteKindManager.getParams(noteKind);
+
+    for (i in 0...noteKindParams.length)
+    {
+      var param:NoteKindParam = noteKindParams[i];
+
+      var paramLabel:Label = new Label();
+      paramLabel.value = param.description;
+      paramLabel.verticalAlign = "center";
+      paramLabel.horizontalAlign = "right";
+
+      var paramComponent:Component = null;
+
+      switch (param.type)
+      {
+        case NoteKindParamType.INT | NoteKindParamType.FLOAT:
+          var paramStepper:NumberStepper = new NumberStepper();
+          paramStepper.value = (setParamsToPlace ? chartEditorState.noteParamsToPlace[i].value : param.data?.defaultValue) ?? 0.0;
+          paramStepper.percentWidth = 100;
+          paramStepper.step = param.data?.step ?? 1;
+
+          // this check should be unnecessary but for some reason
+          // even when these are null it will set it to 0
+          if (param.data?.min != null)
+          {
+            paramStepper.min = param.data.min;
+          }
+          if (param.data?.max != null)
+          {
+            paramStepper.max = param.data.max;
+          }
+          if (param.data?.precision != null)
+          {
+            paramStepper.precision = param.data.precision;
+          }
+          paramComponent = paramStepper;
+
+        case NoteKindParamType.STRING:
+          var paramTextField:TextField = new TextField();
+          paramTextField.value = (setParamsToPlace ? chartEditorState.noteParamsToPlace[i].value : param.data?.defaultValue) ?? '';
+          paramTextField.percentWidth = 100;
+          paramComponent = paramTextField;
+      }
+
+      if (paramComponent == null)
+      {
+        continue;
+      }
+
+      paramComponent.onChange = function(event:UIEvent) {
+        chartEditorState.noteParamsToPlace[i].value = paramComponent.value;
+
+        for (note in chartEditorState.currentNoteSelection)
+        {
+          if (note.params.length != noteKindParams.length)
+          {
+            break;
+          }
+
+          if (note.params[i].name == param.name)
+          {
+            note.params[i].value = paramComponent.value;
+          }
+        }
+      }
+
+      addNoteKindParam(paramLabel, paramComponent);
+    }
+
+    if (!setParamsToPlace)
+    {
+      var noteParamData:Array<NoteParamData> = [];
+      for (i in 0...noteKindParams.length)
+      {
+        noteParamData.push(new NoteParamData(noteKindParams[i].name, toolboxNotesParams[i].component.value));
+      }
+      chartEditorState.noteParamsToPlace = noteParamData;
+    }
+  }
+
+  function addNoteKindParam(label:Label, component:Component):Void
+  {
+    toolboxNotesParams.push({label: label, component: component});
+    toolboxNotesGrid.addComponent(label);
+    toolboxNotesGrid.addComponent(component);
+
+    this.height = Math.max(DIALOG_HEIGHT, DIALOG_HEIGHT - 30 + toolboxNotesParams.length * 30);
+  }
+
+  function clearNoteKindParams():Void
+  {
+    for (param in toolboxNotesParams)
+    {
+      toolboxNotesGrid.removeComponent(param.component);
+      toolboxNotesGrid.removeComponent(param.label);
+    }
+    toolboxNotesParams = [];
+    this.height = DIALOG_HEIGHT;
+  }
+
+  override function update(elapsed:Float):Void
+  {
+    super.update(elapsed);
+
+    // current dialog is minimized, dont change the height
+    if (this.minimized)
+    {
+      return;
+    }
+
+    var heightToSet:Int = Std.int(Math.max(DIALOG_HEIGHT, (toolboxNotesGrid?.height ?? 50) + HEIGHT_OFFSET)) + MINIMIZE_FIX;
+    if (this.height != heightToSet)
+    {
+      this.height = heightToSet;
+    }
+  }
+
   public static function build(chartEditorState:ChartEditorState):ChartEditorNoteDataToolbox
   {
     return new ChartEditorNoteDataToolbox(chartEditorState);
   }
 }
+
+typedef ToolboxNoteKindParam =
+{
+  var label:Label;
+  var component:Component;
+}

source/funkin/ui/debug/charting/util/ChartEditorDropdowns.hx

@@ -135,6 +135,14 @@ class ChartEditorDropdowns
       var noteStyle:Null<NoteStyle> = NoteStyleRegistry.instance.fetchEntry(noteStyleId);
       if (noteStyle == null) continue;
 
+      // check if the note style has all necessary assets (strums, notes, holdNotes)
+      if (noteStyle._data?.assets?.noteStrumline == null
+        || noteStyle._data?.assets?.note == null
+        || noteStyle._data?.assets?.holdNote == null)
+      {
+        continue;
+      }
+
       var value = {id: noteStyleId, text: noteStyle.getName()};
       if (startingStyleId == noteStyleId) returnValue = value;
 
@@ -146,7 +154,7 @@ class ChartEditorDropdowns
     return returnValue;
   }
 
-  static final NOTE_KINDS:Map<String, String> = [
+  public static final NOTE_KINDS:Map<String, String> = [
     // Base
     "" => "Default",
     "~CUSTOM~" => "Custom",
@@ -187,11 +195,11 @@ class ChartEditorDropdowns
   {
     dropDown.dataSource.clear();
 
-    var returnValue:DropDownEntry = lookupNoteKind('~CUSTOM');
+    var returnValue:DropDownEntry = lookupNoteKind('');
 
     for (noteKindId in NOTE_KINDS.keys())
     {
-      var noteKind:String = NOTE_KINDS.get(noteKindId) ?? 'Default';
+      var noteKind:String = NOTE_KINDS.get(noteKindId) ?? 'Unknown';
 
       var value:DropDownEntry = {id: noteKindId, text: noteKind};
       if (startingKindId == noteKindId) returnValue = value;
@@ -208,7 +216,7 @@ class ChartEditorDropdowns
   {
     if (noteKindId == null) return lookupNoteKind('');
     if (!NOTE_KINDS.exists(noteKindId)) return {id: '~CUSTOM~', text: 'Custom'};
-    return {id: noteKindId ?? '', text: NOTE_KINDS.get(noteKindId) ?? 'Default'};
+    return {id: noteKindId ?? '', text: NOTE_KINDS.get(noteKindId) ?? 'Unknown'};
   }
 
   /**