Copy-paste Speed-Based Music Param Trigger and Blackhole w/ Custom Colors from max480's Helping Hand

... I am max480 and gave permission for this.

Author: maddie480

Ahorn/effects/blackholeCustomColors.jl

@@ -0,0 +1,14 @@
+module SpringCollab2020BlackholeCustomColors
+
+using ..Ahorn, Maple
+
+@mapdef Effect "SpringCollab2020/BlackholeCustomColors" BlackholeCustomColors(only::String="*", exclude::String="", colorsMild::String="6e3199,851f91,3026b0", colorsWild::String="ca4ca7,b14cca,ca4ca7",
+    bgColorInner::String="000000", bgColorOuterMild::String="512a8b", bgColorOuterWild::String="bd2192", alpha::Number=1.0)
+
+placements = BlackholeCustomColors
+
+function Ahorn.canFgBg(effect::BlackholeCustomColors)
+    return true, true
+end
+
+end

Ahorn/lang/en_gb.lang

@@ -313,9 +313,11 @@ placements.triggers.SpringCollab2020/ColorGradeFadeTrigger.tooltips.direction=Th
 
 # Speed-Based Music Param Trigger
 placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.paramName=The name of the music parameter to change.
-placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.minSpeed=The minimum value the music parameter can take.
-placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.maxSpeed=The maximum value the music parameter can take.
-placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.activate=If ticked, the trigger will start adjusting the music parameter to match the player's speed.\nIf unticked, the trigger will stop adjusting that music parameter, and set it to minSpeed.
+placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.minSpeed=The minimum speed at which the music parameter will change.
+placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.maxSpeed=The maximum speed at which the music parameter will change.
+placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.minParamValue=The value the music parameter will take when the player speed is "Min Speed" or below.
+placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.maxParamValue=The value the music parameter will take when the player speed is "Max Speed" or above.
+placements.triggers.SpringCollab2020/SpeedBasedMusicParamTrigger.tooltips.activate=If ticked, the trigger will start adjusting the music parameter to match the player's speed.\nIf unticked, the trigger will stop adjusting that music parameter, and set it to the "Min Param Value".
 
 # Foreground Reflection Tentacles
 placements.entities.SpringCollab2020/ForegroundReflectionTentacles.tooltips.slide_until=Changes how far tentacles fall back when Madeline comes into fear distance.
@@ -336,3 +338,10 @@ placements.effects.SpringCollab2020/CustomSnow.tooltips.colors=Comma-separated l
 
 # Change Theme Trigger
 placements.triggers.SpringCollab2020/ChangeThemeTrigger.tooltips.enable=Whether the theme is enabled when entering this zone.
+
+# Blackhole with Custom Colors
+placements.effects.SpringCollab2020/BlackholeCustomColors.tooltips.colorsMild=Colors of the shapes going towards the center of the screen when the blackhole strength is Mild.\nThere should be as many colors defined in Colors Mild and in Colors Wild for both to work.
+placements.effects.SpringCollab2020/BlackholeCustomColors.tooltips.colorsWild=Colors of the shapes going towards the center of the screen when the blackhole strength is Wild.\nThere should be as many colors defined in Colors Mild and in Colors Wild for both to work.
+placements.effects.SpringCollab2020/BlackholeCustomColors.tooltips.bgColorInner=The color used for the background at the center of the screen.
+placements.effects.SpringCollab2020/BlackholeCustomColors.tooltips.bgColorOuterMild=The color used for the background at the edges of the screen, when the blackhole strength is Mild.
+placements.effects.SpringCollab2020/BlackholeCustomColors.tooltips.bgColorOuterWild=The color used for the background at the edges of the screen, when the blackhole strength is Wild.

Ahorn/triggers/speedBasedMusicParamTrigger.jl

@@ -3,7 +3,7 @@ module SpringCollab2020SpeedBasedMusicParamTrigger
 using ..Ahorn, Maple
 
 @mapdef Trigger "SpringCollab2020/SpeedBasedMusicParamTrigger" SpeedBasedMusicParamTrigger(x::Integer, y::Integer, width::Integer=Maple.defaultTriggerWidth, height::Integer=Maple.defaultTriggerHeight,
-    paramName::String="fade", minSpeed::Number=0.0, maxSpeed::Number=1.0, activate::Bool=true)
+    paramName::String="fade", minSpeed::Number=0.0, maxSpeed::Number=90.0, minParamValue::Number=0.0, maxParamValue::Number=1.0, activate::Bool=true)
 
 const placements = Ahorn.PlacementDict(
     "Speed-Based Music Param (Spring Collab 2020)" => Ahorn.EntityPlacement(
@@ -12,4 +12,6 @@ const placements = Ahorn.PlacementDict(
     )
 )
 
+Ahorn.editingOrder(entity::SpeedBasedMusicParamTrigger) = String["x", "y", "width", "height", "minSpeed", "maxSpeed", "minParamValue", "maxParamValue"]
+
 end

Effects/BlackholeCustomColors.cs

@@ -0,0 +1,75 @@
+using Microsoft.Xna.Framework;
+using Mono.Cecil.Cil;
+using Monocle;
+using MonoMod.Cil;
+using MonoMod.Utils;
+using System;
+
+namespace Celeste.Mod.SpringCollab2020.Effects {
+    /**
+     * Port of the blackhole with custom colors from max480's Helping Hand:
+     * https://github.com/max4805/MaxHelpingHand/blob/master/Effects/BlackholeCustomColors.cs
+     */
+    static class BlackholeCustomColors {
+        private static Color[] colorsMild;
+
+        public static void Load() {
+            IL.Celeste.BlackholeBG.ctor += onBlackholeConstructor;
+        }
+
+        public static void Unload() {
+            IL.Celeste.BlackholeBG.ctor -= onBlackholeConstructor;
+        }
+
+        private static void onBlackholeConstructor(ILContext il) {
+            ILCursor cursor = new ILCursor(il);
+
+            // we want to insert code at the beginning of the constructor, but after the variable initialization code,
+            // because colorsMild is used right in the constructor.
+            // the "first line" of the constructor is: bgTexture = GFX.Game["objects/temple/portal/portal"];
+            if (cursor.TryGotoNext(MoveType.Before,
+                instr => instr.MatchLdarg(0),
+                instr => instr.MatchLdsfld(typeof(GFX), "Game"))) {
+
+                Logger.Log("SpringCollab2020/BlackholeCustomColors", $"Replacing colorsMild at {cursor.Index} in IL code for BlackholeBG constructor");
+                cursor.Emit(OpCodes.Ldarg_0);
+                cursor.EmitDelegate<Action<BlackholeBG>>(self => {
+                    if (colorsMild != null) {
+                        new DynData<BlackholeBG>(self)["colorsMild"] = colorsMild;
+                        colorsMild = null;
+                    }
+                });
+            }
+        }
+
+        public static BlackholeBG CreateBlackholeWithCustomColors(BinaryPacker.Element effectData) {
+            // set up colorsMild for the hook above. we can't use DynData to pass this over, since the object does not exist yet!
+            colorsMild = parseColors(effectData.Attr("colorsMild", "6e3199,851f91,3026b0"));
+            for (int i = 0; i < colorsMild.Length; i++) {
+                colorsMild[i] *= 0.8f;
+            }
+
+            // build the blackhole: the hook will take care of setting colorsMild.
+            BlackholeBG blackhole = new BlackholeBG();
+
+            // ... now we've got to set everything else.
+            DynData<BlackholeBG> blackholeData = new DynData<BlackholeBG>(blackhole);
+            blackholeData["colorsWild"] = parseColors(effectData.Attr("colorsWild", "ca4ca7,b14cca,ca4ca7"));
+            blackholeData["bgColorInner"] = Calc.HexToColor(effectData.Attr("bgColorInner", "000000"));
+            blackholeData["bgColorOuterMild"] = Calc.HexToColor(effectData.Attr("bgColorOuterMild", "512a8b"));
+            blackholeData["bgColorOuterWild"] = Calc.HexToColor(effectData.Attr("bgColorOuterWild", "bd2192"));
+            blackhole.Alpha = effectData.AttrFloat("alpha", 1f);
+
+            return blackhole;
+        }
+
+        private static Color[] parseColors(string input) {
+            string[] colorsAsStrings = input.Split(',');
+            Color[] colors = new Color[colorsAsStrings.Length];
+            for (int i = 0; i < colors.Length; i++) {
+                colors[i] = Calc.HexToColor(colorsAsStrings[i]);
+            }
+            return colors;
+        }
+    }
+}

SpringCollab2020Module.cs

@@ -119,6 +119,9 @@ private Backdrop onLoadBackdrop(MapData map, BinaryPacker.Element child, BinaryP
 
                 return new CustomSnow(colors, child.AttrBool("foreground"));
             }
+            if (child.Name.Equals("SpringCollab2020/BlackholeCustomColors", StringComparison.OrdinalIgnoreCase)) {
+                return BlackholeCustomColors.CreateBlackholeWithCustomColors(child);
+            }
             return null;
         }
 

SpringCollab2020Session.cs

@@ -23,6 +23,8 @@ public class MultiRoomStrawberrySeedInfo {
         public class SpeedBasedMusicParamInfo {
             public float MinimumSpeed { get; set; }
             public float MaximumSpeed { get; set; }
+            public float MinimumParamValue { get; set; }
+            public float MaximumParamValue { get; set; }
         }
 
         public Dictionary<string, SpeedBasedMusicParamInfo> ActiveSpeedBasedMusicParams = new Dictionary<string, SpeedBasedMusicParamInfo>();

Triggers/SpeedBasedMusicParamTrigger.cs

@@ -1,8 +1,13 @@
 using Celeste.Mod.Entities;
+using Monocle;
 using Microsoft.Xna.Framework;
 using System.Collections.Generic;
 
 namespace Celeste.Mod.SpringCollab2020.Triggers {
+    /**
+     * Port of the speed-based music param trigger from max480's Helping Hand:
+     * https://github.com/max4805/MaxHelpingHand/blob/master/Triggers/SpeedBasedMusicParamTrigger.cs
+     */
     [CustomEntity("SpringCollab2020/SpeedBasedMusicParamTrigger")]
     class SpeedBasedMusicParamTrigger : Trigger {
         public static void Load() {
@@ -24,7 +29,9 @@ private static void onPlayerUpdate(On.Celeste.Player.orig_Update orig, Player se
                 foreach (KeyValuePair<string, SpringCollab2020Session.SpeedBasedMusicParamInfo> musicParam
                     in SpringCollab2020Module.Instance.Session.ActiveSpeedBasedMusicParams) {
 
-                    audio.Music.Param(musicParam.Key, MathHelper.Clamp(playerSpeed, musicParam.Value.MinimumSpeed, musicParam.Value.MaximumSpeed));
+                    audio.Music.Param(musicParam.Key, Calc.ClampedMap(playerSpeed,
+                        musicParam.Value.MinimumSpeed, musicParam.Value.MaximumSpeed,
+                        musicParam.Value.MinimumParamValue, musicParam.Value.MaximumParamValue));
                 }
 
                 audio.Apply();
@@ -34,12 +41,16 @@ private static void onPlayerUpdate(On.Celeste.Player.orig_Update orig, Player se
         private string paramName;
         private float minSpeed;
         private float maxSpeed;
+        private float minParamValue;
+        private float maxParamValue;
         private bool activate;
 
         public SpeedBasedMusicParamTrigger(EntityData data, Vector2 offset) : base(data, offset) {
             paramName = data.Attr("paramName");
             minSpeed = data.Float("minSpeed");
             maxSpeed = data.Float("maxSpeed");
+            minParamValue = data.Float("minParamValue");
+            maxParamValue = data.Float("maxParamValue");
             activate = data.Bool("activate");
         }
 
@@ -50,14 +61,16 @@ public override void OnEnter(Player player) {
                 // register the speed-based music param as active to keep it updated.
                 SpringCollab2020Module.Instance.Session.ActiveSpeedBasedMusicParams[paramName] = new SpringCollab2020Session.SpeedBasedMusicParamInfo() {
                     MinimumSpeed = minSpeed,
-                    MaximumSpeed = maxSpeed
+                    MaximumSpeed = maxSpeed,
+                    MinimumParamValue = minParamValue,
+                    MaximumParamValue = maxParamValue
                 };
             } else {
                 // unregister the param, and set the music param to the minimum value.
                 SpringCollab2020Module.Instance.Session.ActiveSpeedBasedMusicParams.Remove(paramName);
 
                 AudioState audio = SceneAs<Level>().Session.Audio;
-                audio.Music.Param(paramName, minSpeed);
+                audio.Music.Param(paramName, minParamValue);
                 audio.Apply();
             }
         }