Merge remote-tracking branch 'upstream/main'

source/funkin/backend/FunkinSprite.hx

@@ -75,24 +75,34 @@ class FunkinSprite extends FlxSkewedSprite implements IBeatReceiver implements I
 		moves = false;
 	}
 
-	public static function copyFrom(source:FunkinSprite)
+	/**
+	 * Gets the graphics and copies other properties from another sprite (Works both for `FlxSprite` and `FunkinSprite`!).
+	 */
+	public static function copyFrom(source:FlxSprite):FunkinSprite
 	{
 		var spr = new FunkinSprite();
+		var casted:FunkinSprite = null;
+		if (source is FunkinSprite)
+			casted = cast source;
+
 		@:privateAccess {
 			spr.setPosition(source.x, source.y);
 			spr.frames = source.frames;
-			if (source.animateAtlas != null && source.atlasPath != null)
-				spr.loadSprite(source.atlasPath);
+			if (casted != null && casted.animateAtlas != null && casted.atlasPath != null)
+				spr.loadSprite(casted.atlasPath);
 			spr.animation.copyFrom(source.animation);
 			spr.visible = source.visible;
 			spr.alpha = source.alpha;
 			spr.antialiasing = source.antialiasing;
 			spr.scale.set(source.scale.x, source.scale.y);
 			spr.scrollFactor.set(source.scrollFactor.x, source.scrollFactor.y);
-			spr.skew.set(source.skew.x, source.skew.y);
-			spr.transformMatrix = source.transformMatrix;
-			spr.matrixExposed = source.matrixExposed;
-			spr.animOffsets = source.animOffsets.copy();
+
+			if (casted != null) {
+				spr.skew.set(casted.skew.x, casted.skew.y);
+				spr.transformMatrix = casted.transformMatrix;
+				spr.matrixExposed = casted.matrixExposed;
+				spr.animOffsets = casted.animOffsets.copy();
+			}
 		}
 		return spr;
 	}

source/funkin/backend/assets/AssetsLibraryList.hx

@@ -63,7 +63,7 @@ class AssetsLibraryList extends AssetLibrary {
 			if (l is IModsAssetLibrary) {
 				var lib = cast(l, IModsAssetLibrary);
 				for(e in lib.getFiles(folder))
-					content.push(e);
+					content.pushOnce(e);
 			}
 			#end
 		}

source/funkin/backend/assets/Paths.hx

@@ -194,6 +194,29 @@ class Paths
 		return tempFramesCache[key] = loadFrames(assetsPath ? key : Paths.image(key, library, true, ext), false, null, false, ext);
 	}
 
+	/**
+	 * Checks if the images needed for using getFrames() exist.
+	 * @param key Path to the image
+	 * @param checkAtlas Whenever to check for the Animation.json file (used in FlxAnimate)
+	 * @param assetsPath Whenever to use the raw path or to pass it through Paths.image()
+	 * @param library (Additional) library to load the frames from.
+	 * @return True if the images exist, false otherwise.
+	**/
+	public static function framesExists(key:String, checkAtlas:Bool = false, checkMulti:Bool = true, assetsPath:Bool = false, ?library:String) {
+		var path = assetsPath ? key : Paths.image(key, library, true);
+		var noExt = Path.withoutExtension(path);
+		if(checkAtlas && Assets.exists('$noExt/Animation.json'))
+			return true;
+		if(checkMulti && Assets.exists('$noExt/1.png'))
+			return true;
+		if(Assets.exists('$noExt.xml'))
+			return true;
+		if(Assets.exists('$noExt.txt'))
+			return true;
+		if(Assets.exists('$noExt.json'))
+			return true;
+		return false;
+	}
 
 	/**
 	 * Loads frames from a specific image path. Supports Sparrow Atlases, Packer Atlases, and multiple spritesheets.

source/funkin/backend/scripting/HScript.hx

@@ -128,6 +128,10 @@ class HScript extends Script {
 			interp.execute(expr);
 			call("new", []);
 		}
+		
+		#if GLOBAL_SCRIPT
+		funkin.backend.scripting.GlobalScript.call("onScriptSetup", [this, "hscript"]);
+		#end
 	}
 
 	public override function reload() {

source/funkin/backend/scripting/events/healthicon/HealthIconChangeEvent.hx

@@ -1,10 +1,12 @@
 package funkin.backend.scripting.events.healthicon;
 
+import flixel.util.typeLimit.OneOfTwo;
+
 final class HealthIconChangeEvent extends CancellableEvent {
 	/**
-	 * Amount
+	 * Animation State
 	 */
-	public var amount:Int;
+	public var anim:OneOfTwo<String, Int>;
 
 	/**
 	 * The health icon

source/funkin/backend/scripting/events/note/NoteHitEvent.hx

@@ -1,6 +1,7 @@
 package funkin.backend.scripting.events.note;
 
 import funkin.game.Character;
+import funkin.game.HealthIcon;
 import funkin.game.Note;
 
 final class NoteHitEvent extends CancellableEvent {
@@ -113,6 +114,10 @@ final class NoteHitEvent extends CancellableEvent {
 	 * Whenever the animation should be forced to play (if it's null it will be forced based on the sprite's data xml, if it has one).
 	 */
 	public var forceAnim:Null<Bool> = true;
+	/**
+	 * The attached healthIcon used distinction for icons amongst others
+	 */
+	public var healthIcon:HealthIcon;
 
 	/**
 	 * Prevents the default sing animation from being played.

source/funkin/backend/shaders/FunkinShader.hx

@@ -1,5 +1,6 @@
 package funkin.backend.shaders;
 
+import flixel.graphics.FlxGraphic;
 import flixel.system.FlxAssets.FlxShader;
 import flixel.util.FlxSignal.FlxTypedSignal;
 import haxe.Exception;
@@ -555,34 +556,44 @@ class FunkinShader extends FlxShader implements IHScriptCustomBehaviour {
 			return val;
 		}
 
-		var field:Dynamic = Reflect.field(data, name);
-		var cl:String = Type.getClassName(Type.getClass(field));
+		var field = Reflect.field(data, name);
+		var cl = Type.getClassName(Type.getClass(field));
+		var isNotNull = val != null;
 		// cant do "field is ShaderInput" for some reason
 		if (cl.startsWith("openfl.display.ShaderParameter")) {
 			if (field.__length <= 1) {
-				if ((val is Array))
-					return field.value = val;
 				// that means we wait for a single number, instead of an array
-				if (field.__isInt && !(val is Int))
+				if (field.__isInt && isNotNull && !(val is Int)) {
 					throw new ShaderTypeException(name, Type.getClass(val), 'Int');
-				else if (field.__isBool && !(val is Bool))
+					return null;
+				} else
+				if (field.__isBool && isNotNull && !(val is Bool)) {
 					throw new ShaderTypeException(name, Type.getClass(val), 'Bool');
-				else if (field.__isFloat && !(val is Float))
+					return null;
+				} else
+				if (field.__isFloat && isNotNull && !(val is Float)) {
 					throw new ShaderTypeException(name, Type.getClass(val), 'Float');
-
-				return field.value = [val];
+					return null;
+				}
+				return field.value = isNotNull ? [val] : null;
 			} else {
-				if (!(val is Array))
+				if (isNotNull && !(val is Array)) {
 					throw new ShaderTypeException(name, Type.getClass(val), Array);
-
+					return null;
+				}
 				return field.value = val;
 			}
 		} else if (cl.startsWith("openfl.display.ShaderInput")) {
 			// shader input!!
-			if (!(val is BitmapData)) {
+			var bitmap:BitmapData;
+			if (!isNotNull) bitmap = null;
+			else if (val is BitmapData) bitmap = val;
+			else if (val is FlxGraphic) bitmap = val.bitmap;
+			else {
 				throw new ShaderTypeException(name, Type.getClass(val), BitmapData);
+				return null;
 			}
-			field.input = cast val;
+			field.input = bitmap;
 		}
 
 		return val;