EEEEEEP.

Author: Yuta12342

source/archipelago/APItem.hx

@@ -477,6 +477,73 @@ class APrilFools extends APItem {
             });
         });
 
+        options.set(8, function() {
+            APItem.createCustomItem("April Fools - BF Disappearing Act", ConditionHelper.PlayState(), function() {
+            if (Std.is(FlxG.state, archipelago.APPlayState)) {
+                var playState:archipelago.APPlayState = cast FlxG.state;
+
+                // // Check if an equivalent function already exists
+                // if (playState.updateFunctions.exists(function(obj) return Reflect.compareMethods(obj.fn, function() {}))) {
+                // return;
+                // }
+
+                var bfDisappearFn = {
+                func: function() {
+                    if (playState.boyfriend != null) {
+                        if (FlxG.keys.justPressed.ENTER) {
+                            playState.boyfriend.alpha = 1;
+                            return;
+                        }
+                        playState.boyfriend.alpha -= 0.01;
+                        if (playState.boyfriend.alpha <= 0) {
+                            try {
+                                FlxG.sound.pause();
+                            } catch (e:Dynamic) {
+                                trace("Error pausing sound: " + e);
+                            }
+                            try {
+                                FlxG.sound.music.pause();
+                            } catch (e:Dynamic) {
+                                trace("Error pausing music: " + e);
+                            }
+                            playState.paused = true;
+                            // throw "Null Object Reference";
+                            backend.COD.COD.COD = "BF ceased to exist";
+                            playState.die();
+                            for (camera in FlxG.cameras.list) {
+                                flixel.tweens.FlxTween.num(camera.alpha, 0, 0.001, function(value:Float) {
+                                    camera.alpha = value;
+                                    // Cut the sound again.
+                                    try {
+                                        FlxG.sound.pause();
+                                    } catch (e:Dynamic) {
+                                        trace("Error pausing sound: " + e);
+                                    }
+                                    try {
+                                        FlxG.sound.music.pause();
+                                    } catch (e:Dynamic) {
+                                        trace("Error pausing music: " + e);
+                                    }
+                                });
+                            }
+                        }
+                    }
+                },
+                keepOnRestart: true
+                };
+
+                if (!APPlayState.updateFunctions.map(function(obj) return Reflect.compareMethods(obj.func, bfDisappearFn.func)).contains(true)) {
+                    APPlayState.updateFunctions.push(bfDisappearFn);
+                } else {
+                    // If the function already exists, remove it first
+                    APPlayState.updateFunctions.remove(bfDisappearFn);
+                    // Then add it again to ensure it's the last one in the list
+                    APPlayState.updateFunctions.push(bfDisappearFn);
+                }
+            }
+            });
+        });
+
         // Windows Only, as notifications can't be sent this way on other platforms
         // We can do this because thanks to the conditional block it will only trigger on windows anyway
         #if windows

source/archipelago/APPlayState.hx

@@ -110,6 +110,8 @@ class APPlayState extends PlayState {
 	public var curEffect:Int = 0;
 
 	public var effectMap:Map<String, Void->Void>;
+    public static var updateFunctions:Array<{func: Void->Void, keepOnRestart:Bool, ?activated:Main.Boolean}> = [];
+
 	var effectendsin:FlxText;
 
     function generateGibberish(length:Int, exclude:String):String
@@ -169,6 +171,11 @@ class APPlayState extends PlayState {
 
         MaxHP += archipelago.APItem.maxHPUp / 2;
 
+        for (func in updateFunctions)
+        {
+            if (!func.keepOnRestart && (func.activated != null && func.activated)) updateFunctions.remove(func);
+        }
+
         effectMap = [
             'colorblind' => function() {
                 var ttl:Float = 16;
@@ -1991,6 +1998,11 @@ class APPlayState extends PlayState {
                 }
             }
         }
+        for (func in updateFunctions) {
+            if (func != null)
+                func.func();
+            func.activated = true;
+        }
         super.update(elapsed);
     }
 
@@ -2031,6 +2043,14 @@ class APPlayState extends PlayState {
         if (effectTimer != null && effectTimer.active)
 			effectTimer.cancel();
 
+        for (func in updateFunctions)
+        {
+            updateFunctions.remove(func);
+        }
+
+        updateFunctions.resize(0);
+        updateFunctions = [];
+
         if (ghostChat)
         {
             ghostChat = false;

source/yutautil/FreeMap.hx

@@ -0,0 +1,78 @@
+package yutautil;
+
+import haxe.ds.StringMap;
+
+import haxe.crypto.Sha1;
+
+enum IterationType {
+    Keys;
+    Values;
+    KeyValuePairs;
+}
+
+class FreeMap<K, V> {
+    private var internalMap: StringMap<V>;
+
+    public function new() {
+        internalMap = new StringMap<V>();
+    }
+
+    public function set(key: K, value: V): Void {
+        var stringKey = keyToString(key);
+        internalMap.set(stringKey, value);
+    }
+
+    public function get(key: K): Null<V> {
+        var stringKey = keyToString(key);
+        return internalMap.get(stringKey);
+    }
+
+    public function exists(key: K): Bool {
+        var stringKey = keyToString(key);
+        return internalMap.exists(stringKey);
+    }
+
+    public function remove(key: K): Bool {
+        var stringKey = keyToString(key);
+        return internalMap.remove(stringKey);
+    }
+
+    public function iterate(): Array<V> {
+        var result = [];
+        var it = internalMap.iterator();
+        while (it.hasNext()) {
+            result.push(it.next());
+        }
+        return result;
+    }
+
+    public function iterateFor(type: IterationType): Iterable<Dynamic> {
+        return switch (type) {
+            case IterationType.Keys:
+                internalMap.keys();
+            case IterationType.Values:
+                internalMap.iterator();
+            case IterationType.KeyValuePairs:
+                var mapping = {};
+                for (key in internalMap.keys()) {
+                    mapping[key] = internalMap.get(key);
+                }
+                mapping;
+        };
+    }
+
+    private function keyToString(key: K): String {
+        switch (key) {
+            case true: 
+                return "true-" + Std.string(Lambda.array(internalMap.keys().toArray()).filter(k -> k.startsWith("true-")).length);
+            case false: 
+                return "false-" + Std.string(Lambda.array(internalMap.keys().toArray()).filter(k -> k.startsWith("false-")).length);
+            case _: 
+                if (Std.is(key, String) || Std.is(key, Int) || Std.is(key, Float) || Std.is(key, Bool)) {
+                    return Std.string(key);
+                } else {
+                    return Sha1.encode(haxe.Json.stringify(key));
+                }
+        }
+    }
+}