v2.9.6 Release Commit...

* Added new sprites for hotshot enemies. Thanks to Lynceus for the
spritework!
* Added new April Fools day thing. Code checks system date for this so
if you missed it, sorry gotta wait till next year! :P

ExpandAssets/Assets/AssetBundles/AssetBundles.manifest

@@ -1,5 +1,5 @@
 ManifestFileVersion: 0
-CRC: 4058077172
+CRC: 1216126238
 AssetBundleManifest:
   AssetBundleInfos:
     Info_0:

ExpandAssets/Assets/AssetBundles/expandsharedauto.manifest

@@ -1,9 +1,9 @@
 ManifestFileVersion: 0
-CRC: 1595023069
+CRC: 4037480594
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: 600f3d66294f2bd443446ad1a73e7fb0
+    Hash: a7168a278c52302407b96741ddf7f159
   TypeTreeHash:
     serializedVersion: 2
     Hash: 2241b0dac22d22b9de2222ad79842819
@@ -172,6 +172,7 @@ Assets:
 - Assets/ExpandRooms/RoomFactoryData/Expand_Mines_Regular17.bytes
 - Assets/ExpandTextures/SpriteCollections/AIActors/RedBulletShotgunMan.png
 - Assets/ExpandRooms/RoomFactoryData/Expand_Mines_Regular12.bytes
+- Assets/ExpandPrefabs/Misc/Expand_FakePastChest.prefab
 - Assets/ExpandRooms/RoomFactoryData/Belly/Expand_Belly_Pirate14.bytes
 - Assets/ExpandRooms/RoomFactoryData/BulletHell/BHell_TheReunion.bytes
 - Assets/ExpandRooms/RoomBuilderData/Creepy_Glitched_Room_Layout.png

ExpandAssets/Assets/ExpandPrefabs/Misc/Expand_FakePastChest.prefab

@@ -0,0 +1,186 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1001 &100100000
+Prefab:
+  m_ObjectHideFlags: 1
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications: []
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 0}
+  m_RootGameObject: {fileID: 1534394655964746}
+  m_IsPrefabParent: 1
+--- !u!1 &1004481727282074
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4813058835647352}
+  m_Layer: 22
+  m_Name: G_Poof
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &1433707108095996
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4141678177101742}
+  m_Layer: 22
+  m_Name: Spawn
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &1534394655964746
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4754520842572610}
+  m_Layer: 22
+  m_Name: Expand_FakePastChest
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &1714619534945694
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4730672467038604}
+  m_Layer: 22
+  m_Name: G_Shadow
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &1779151215579228
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4500040361409878}
+  m_Layer: 22
+  m_Name: G_Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!1 &1790356745287710
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4772515673894926}
+  m_Layer: 22
+  m_Name: G_Lid
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4141678177101742
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1433707108095996}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 2.9375, y: 1.25, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4754520842572610}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!4 &4500040361409878
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1779151215579228}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4754520842572610}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!4 &4730672467038604
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1714619534945694}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -0.099998474}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4754520842572610}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!4 &4754520842572610
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1534394655964746}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4772515673894926}
+  - {fileID: 4730672467038604}
+  - {fileID: 4813058835647352}
+  - {fileID: 4141678177101742}
+  - {fileID: 4500040361409878}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!4 &4772515673894926
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1790356745287710}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -0.05000305}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4754520842572610}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!4 &4813058835647352
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1004481727282074}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0.099998474}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4754520842572610}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

ExpandTheGungeon/ExpandComponents/ExpandArkController.cs

@@ -0,0 +1,531 @@
+using System;
+using System.Collections;
+using Dungeonator;
+using UnityEngine;
+using ExpandTheGungeon.ExpandPrefab;
+
+namespace ExpandTheGungeon.ExpandComponents {
+
+    public class ExpandArkController : BraveBehaviour, IPlaceConfigurable, IPlayerInteractable {
+
+        public ExpandArkController() {
+            LidAnimator = gameObject.transform.Find("G_Lid").gameObject.GetComponent<tk2dSpriteAnimator>();
+            ChestAnimator = gameObject.GetComponent<tk2dSpriteAnimator>();
+            PoofAnimator = gameObject.transform.Find("G_Poof").gameObject.GetComponent<tk2dSpriteAnimator>();
+            LightSpriteBeam = gameObject.transform.Find("G_Light").gameObject.GetComponent<tk2dSprite>();
+            HellCrackSprite = null;
+            GunSpawnPoint = gameObject.transform.Find("Spawn");
+            GunPrefab = ExpandObjectDatabase.EndTimesChest.GetComponent<ArkController>().GunPrefab;
+            HeldGunPrefab = ExpandObjectDatabase.EndTimesChest.GetComponent<ArkController>().HeldGunPrefab;
+            IsTrollChest = true;
+        }
+
+        public tk2dSpriteAnimator LidAnimator;
+        public tk2dSpriteAnimator ChestAnimator;
+        public tk2dSpriteAnimator PoofAnimator;
+        public tk2dSprite LightSpriteBeam;
+        public tk2dSprite HellCrackSprite;
+        public Transform GunSpawnPoint;
+        public GameObject GunPrefab;
+        public GameObject HeldGunPrefab;
+        
+        public bool IsTrollChest;
+        public static bool IsResettingPlayers = false;
+
+        [NonSerialized]
+        public RoomHandler ParentRoom;
+
+        [NonSerialized]
+        private Transform m_heldPastGun;
+        [NonSerialized]
+        private GameObject minimapIconInstance;
+
+        private bool m_hasBeenInteracted;
+        protected bool m_isLocalPointing;
+
+        
+
+        private IEnumerator Start() {
+            if (!IsTrollChest) {
+                ParentRoom = GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(transform.position.IntXY(VectorConversions.Floor));
+                yield return null;
+                RoomHandler.unassignedInteractableObjects.Add(this);
+            }
+            yield break;
+        }
+
+        private void Update() { }
+
+        public float GetDistanceToPoint(Vector2 point) {
+            if (m_hasBeenInteracted) { return 100000f; }
+            return Vector2.Distance(point, specRigidbody.UnitCenter) / 2f;
+        }
+
+        public void OnEnteredRange(PlayerController interactor) {
+            SpriteOutlineManager.AddOutlineToSprite(sprite, Color.white);
+            SpriteOutlineManager.AddOutlineToSprite(LidAnimator.sprite, Color.white);
+        }
+
+        public void OnExitRange(PlayerController interactor) {
+            SpriteOutlineManager.RemoveOutlineFromSprite(sprite, true);
+            SpriteOutlineManager.RemoveOutlineFromSprite(LidAnimator.sprite, true);
+        }
+
+        public void Interact(PlayerController interactor) {
+            SpriteOutlineManager.RemoveOutlineFromSprite(sprite, false);
+            SpriteOutlineManager.RemoveOutlineFromSprite(LidAnimator.sprite, false);
+            if (!m_hasBeenInteracted) { m_hasBeenInteracted = true; }
+            for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++) { GameManager.Instance.AllPlayers[i].RemoveBrokenInteractable(this); }
+            BraveInput.DoVibrationForAllPlayers(Vibration.Time.Normal, Vibration.Strength.Medium);
+            if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER) {
+                PlayerController otherPlayer = GameManager.Instance.GetOtherPlayer(interactor);
+                float num = Vector2.Distance(otherPlayer.CenterPosition, interactor.CenterPosition);
+                if (num > 8f || num < 0.75f) {
+                    Vector2 a = Vector2.right;
+                    if (interactor.CenterPosition.x < ChestAnimator.sprite.WorldCenter.x) { a = Vector2.left; }
+                    otherPlayer.WarpToPoint(otherPlayer.transform.position.XY() + a * 2f, true, false);
+                }
+            }
+            StartCoroutine(Open(interactor));
+        }
+
+        private IEnumerator HandleLightSprite() {
+            yield return new WaitForSeconds(0.5f);
+            float elapsed = 0f;
+            float duration = 1f;
+            LightSpriteBeam.renderer.enabled = true;
+            while (elapsed < duration) {
+                elapsed += BraveTime.DeltaTime;
+                float t = Mathf.SmoothStep(0f, 1f, elapsed / duration);
+                LightSpriteBeam.transform.localScale = new Vector3(1f, Mathf.Lerp(0f, 1f, t), 1f);
+                LightSpriteBeam.transform.localPosition = new Vector3(0f, Mathf.Lerp(1.375f, 0f, t), 0f);
+                LightSpriteBeam.UpdateZDepth();
+                yield return null;
+            }
+            yield break;
+        }
+
+        private IEnumerator Open(PlayerController interactor) {
+            if (IsTrollChest) { DeregisterChestOnMinimap(); }
+            for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++) {
+                if (GameManager.Instance.AllPlayers[i].healthHaver.IsAlive) { GameManager.Instance.AllPlayers[i].SetInputOverride("fakeArk"); }
+            }
+            LidAnimator.Play();
+            ChestAnimator.Play();
+            PoofAnimator.PlayAndDisableObject(string.Empty, null);
+            specRigidbody.Reinitialize();
+            GameManager.Instance.MainCameraController.OverrideRecoverySpeed = 2f;
+            GameManager.Instance.MainCameraController.OverridePosition = ChestAnimator.sprite.WorldCenter + new Vector2(0f, 2f);
+            GameManager.Instance.MainCameraController.SetManualControl(true, true);
+            StartCoroutine(HandleLightSprite());
+            while (LidAnimator.IsPlaying(LidAnimator.CurrentClip)) { yield return null; }
+            yield return StartCoroutine(HandleGun(interactor));
+            yield return new WaitForSeconds(0.5f);
+            Pixelator.Instance.DoFinalNonFadedLayer = true;
+            yield return StartCoroutine(HandleClockhair(interactor));
+            interactor.ClearInputOverride("fakeArk");
+            yield break;
+        }
+
+        private Vector2 GetTargetClockhairPosition(BraveInput input, Vector2 currentClockhairPosition) {
+            Vector2 rhs;
+            if (input.IsKeyboardAndMouse(false)) {
+                rhs = GameManager.Instance.MainCameraController.Camera.ScreenToWorldPoint(Input.mousePosition).XY() + new Vector2(0.375f, -0.25f);
+            } else {
+                rhs = currentClockhairPosition + input.ActiveActions.Aim.Vector * 10f * BraveTime.DeltaTime;
+            }
+            rhs = Vector2.Max(GameManager.Instance.MainCameraController.MinVisiblePoint, rhs);
+            return Vector2.Min(GameManager.Instance.MainCameraController.MaxVisiblePoint, rhs);
+        }
+
+        private void UpdateCameraPositionDuringClockhair(Vector2 targetPosition) {
+            float num = Vector2.Distance(targetPosition, ChestAnimator.sprite.WorldCenter);
+            if (num > 8f) { targetPosition = ChestAnimator.sprite.WorldCenter; }
+            Vector2 vector = GameManager.Instance.MainCameraController.OverridePosition;
+            if (Vector2.Distance(vector, targetPosition) > 10f) { vector = GameManager.Instance.MainCameraController.transform.position.XY(); }
+            GameManager.Instance.MainCameraController.OverridePosition = Vector3.MoveTowards(vector, targetPosition, BraveTime.DeltaTime);
+        }
+
+        private bool CheckPlayerTarget(PlayerController target, Transform clockhairTransform) {
+            Vector2 a = clockhairTransform.position.XY() + new Vector2(-0.375f, 0.25f);
+            return Vector2.Distance(a, target.CenterPosition) < 0.625f;
+        }
+
+        private bool CheckHellTarget(tk2dBaseSprite hellTarget, Transform clockhairTransform) {
+            if (hellTarget == null) { return false; }
+            Vector2 a = clockhairTransform.position.XY() + new Vector2(-0.375f, 0.25f);
+            return Vector2.Distance(a, hellTarget.WorldCenter) < 0.625f;
+        }
+
+        public void HandleHeldGunSpriteFlip(bool flipped) {
+            tk2dSprite component = m_heldPastGun.GetComponent<tk2dSprite>();
+            if (flipped) {
+                if (!component.FlipY) { component.FlipY = true; }
+            } else if (component.FlipY) {
+                component.FlipY = false;
+            }
+            Transform transform = m_heldPastGun.Find("PrimaryHand");
+            m_heldPastGun.localPosition = -transform.localPosition;
+            if (flipped) {
+                m_heldPastGun.localPosition = Vector3.Scale(m_heldPastGun.localPosition, new Vector3(1f, -1f, 1f));
+            }
+            m_heldPastGun.localPosition = BraveUtility.QuantizeVector(m_heldPastGun.localPosition, 16f);
+            component.ForceRotationRebuild();
+            component.UpdateZDepth();
+        }
+
+        private void PointGunAtClockhair(PlayerController interactor, Transform clockhairTransform) {
+            Vector2 centerPosition = interactor.CenterPosition;
+            Vector2 vector = clockhairTransform.position.XY() - centerPosition;
+            if (m_isLocalPointing && vector.sqrMagnitude > 9f) {
+                m_isLocalPointing = false;
+            } else if (m_isLocalPointing || vector.sqrMagnitude < 4f) {
+                m_isLocalPointing = true;
+                float t = vector.sqrMagnitude / 4f - 0.05f;
+                vector = Vector2.Lerp(Vector2.right, vector, t);
+            }
+            float num = BraveMathCollege.Atan2Degrees(vector);
+            num = num.Quantize(3f);
+            interactor.GunPivot.rotation = Quaternion.Euler(0f, 0f, num);
+            interactor.ForceIdleFacePoint(vector, false);
+            HandleHeldGunSpriteFlip(interactor.SpriteFlipped);
+        }
+
+        private IEnumerator HandleClockhair(PlayerController interactor) {
+            Transform clockhairTransform = Instantiate(BraveResources.Load<GameObject>("Clockhair", ".prefab")).transform;
+            ClockhairController clockhair = clockhairTransform.GetComponent<ClockhairController>();
+            float elapsed = 0f;
+            float duration = clockhair.ClockhairInDuration;
+            Vector3 clockhairTargetPosition = interactor.CenterPosition;
+            Vector3 clockhairStartPosition = clockhairTargetPosition + new Vector3(-20f, 5f, 0f);
+            clockhair.renderer.enabled = true;
+            clockhair.spriteAnimator.alwaysUpdateOffscreen = true;
+            clockhair.spriteAnimator.Play("clockhair_intro");
+            clockhair.hourAnimator.Play("hour_hand_intro");
+            clockhair.minuteAnimator.Play("minute_hand_intro");
+            clockhair.secondAnimator.Play("second_hand_intro");
+            BraveInput currentInput = BraveInput.GetInstanceForPlayer(interactor.PlayerIDX);
+            while (elapsed < duration) {
+                UpdateCameraPositionDuringClockhair(interactor.CenterPosition);
+                if (GameManager.INVARIANT_DELTA_TIME == 0f) { elapsed += 0.05f; }
+                elapsed += GameManager.INVARIANT_DELTA_TIME;
+                float t = elapsed / duration;
+                float smoothT = Mathf.SmoothStep(0f, 1f, t);
+                clockhairTargetPosition = GetTargetClockhairPosition(currentInput, clockhairTargetPosition);
+                Vector3 currentPosition = Vector3.Slerp(clockhairStartPosition, clockhairTargetPosition, smoothT);
+                clockhairTransform.position = currentPosition.WithZ(0f);
+                if (t > 0.5f) {
+                    clockhair.renderer.enabled = true;
+                }
+                if (t > 0.75f) {
+                    clockhair.hourAnimator.GetComponent<Renderer>().enabled = true;
+                    clockhair.minuteAnimator.GetComponent<Renderer>().enabled = true;
+                    clockhair.secondAnimator.GetComponent<Renderer>().enabled = true;
+                    GameCursorController.CursorOverride.SetOverride("fakeArk", true, null);
+                }
+                clockhair.sprite.UpdateZDepth();
+                PointGunAtClockhair(interactor, clockhairTransform);
+                yield return null;
+            }
+            clockhair.SetMotionType(1f);
+            float shotTargetTime = 0f;
+            float holdDuration = 4f;
+            PlayerController shotPlayer = null;
+            bool didShootHellTrigger = false;
+            Vector3 lastJitterAmount = Vector3.zero;
+            bool m_isPlayingChargeAudio = false;
+            for (;;) {
+                UpdateCameraPositionDuringClockhair(interactor.CenterPosition);
+                clockhair.transform.position = clockhair.transform.position - lastJitterAmount;
+                clockhair.transform.position = GetTargetClockhairPosition(currentInput, clockhair.transform.position.XY());
+                clockhair.sprite.UpdateZDepth();
+                bool isTargetingValidTarget = CheckPlayerTarget(GameManager.Instance.PrimaryPlayer, clockhairTransform);
+                shotPlayer = GameManager.Instance.PrimaryPlayer;
+                if (!isTargetingValidTarget && GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER) {
+                    isTargetingValidTarget = CheckPlayerTarget(GameManager.Instance.SecondaryPlayer, clockhairTransform);
+                    shotPlayer = GameManager.Instance.SecondaryPlayer;
+                }
+                if (!isTargetingValidTarget && GameStatsManager.Instance.AllCorePastsBeaten()) {
+                    isTargetingValidTarget = CheckHellTarget(HellCrackSprite, clockhairTransform);
+                    didShootHellTrigger = isTargetingValidTarget;
+                }
+                if (isTargetingValidTarget) { clockhair.SetMotionType(-10f); } else { clockhair.SetMotionType(1f); }
+                if ((currentInput.ActiveActions.ShootAction.IsPressed || currentInput.ActiveActions.InteractAction.IsPressed) && isTargetingValidTarget) {
+                    if (!m_isPlayingChargeAudio) {
+                        m_isPlayingChargeAudio = true;
+                        AkSoundEngine.PostEvent("Play_OBJ_pastkiller_charge_01", gameObject);
+                    }
+                    shotTargetTime += BraveTime.DeltaTime;
+                } else {
+                    shotTargetTime = Mathf.Max(0f, shotTargetTime - BraveTime.DeltaTime * 3f);
+                    if (m_isPlayingChargeAudio) {
+                        m_isPlayingChargeAudio = false;
+                        AkSoundEngine.PostEvent("Stop_OBJ_pastkiller_charge_01", gameObject);
+                    }
+                }
+                if ((currentInput.ActiveActions.ShootAction.WasReleased || currentInput.ActiveActions.InteractAction.WasReleased) && isTargetingValidTarget && shotTargetTime > holdDuration && !GameManager.Instance.IsPaused) {
+                    break;
+                }
+                if (shotTargetTime > 0f) {
+                    float distortionPower = Mathf.Lerp(0f, 0.35f, shotTargetTime / holdDuration);
+                    float distortRadius = 0.5f;
+                    float edgeRadius = Mathf.Lerp(4f, 7f, shotTargetTime / holdDuration);
+                    clockhair.UpdateDistortion(distortionPower, distortRadius, edgeRadius);
+                    float desatRadiusUV = Mathf.Lerp(2f, 0.25f, shotTargetTime / holdDuration);
+                    clockhair.UpdateDesat(true, desatRadiusUV);
+                    shotTargetTime = Mathf.Min(holdDuration + 0.25f, shotTargetTime + BraveTime.DeltaTime);
+                    float d = Mathf.Lerp(0f, 0.5f, (shotTargetTime - 1f) / (holdDuration - 1f));
+                    Vector3 vector = (UnityEngine.Random.insideUnitCircle * d).ToVector3ZUp(0f);
+                    BraveInput.DoSustainedScreenShakeVibration(shotTargetTime / holdDuration * 0.8f);
+                    clockhair.transform.position = clockhair.transform.position + vector;
+                    lastJitterAmount = vector;
+                    clockhair.SetMotionType(Mathf.Lerp(-10f, -2400f, shotTargetTime / holdDuration));
+                } else {
+                    lastJitterAmount = Vector3.zero;
+                    clockhair.UpdateDistortion(0f, 0f, 0f);
+                    clockhair.UpdateDesat(false, 0f);
+                    shotTargetTime = 0f;
+                    BraveInput.DoSustainedScreenShakeVibration(0f);
+                }
+                PointGunAtClockhair(interactor, clockhairTransform);
+                yield return null;
+            }
+            BraveInput.DoSustainedScreenShakeVibration(0f);
+            BraveInput.DoVibrationForAllPlayers(Vibration.Time.Normal, Vibration.Strength.Hard);
+            clockhair.StartCoroutine(clockhair.WipeoutDistortionAndFade(0.5f));
+            clockhair.gameObject.SetLayerRecursively(LayerMask.NameToLayer("Unoccluded"));
+            Pixelator.Instance.FadeToColor(1f, Color.white, true, 0.2f);
+            Pixelator.Instance.DoRenderGBuffer = false;
+            clockhair.spriteAnimator.Play("clockhair_fire");
+            clockhair.hourAnimator.GetComponent<Renderer>().enabled = false;
+            clockhair.minuteAnimator.GetComponent<Renderer>().enabled = false;
+            clockhair.secondAnimator.GetComponent<Renderer>().enabled = false;
+            yield return null;
+            if (IsTrollChest) {
+                Destroy(m_heldPastGun.gameObject);
+                interactor.ToggleGunRenderers(true, "fakeArk");
+                GameCursorController.CursorOverride.RemoveOverride("fakeArk");
+                Pixelator.Instance.LerpToLetterbox(0.35f, 0.25f);
+                yield return StartCoroutine(HandleGameOver(shotPlayer));
+                yield break;
+            }
+            yield return null;
+            TimeTubeCreditsController ttcc = new TimeTubeCreditsController();
+            bool isShortTunnel = didShootHellTrigger || shotPlayer.characterIdentity == PlayableCharacters.CoopCultist || CharacterStoryComplete(shotPlayer.characterIdentity);
+            Destroy(m_heldPastGun.gameObject);
+            interactor.ToggleGunRenderers(true, "fakeArk");
+            GameCursorController.CursorOverride.RemoveOverride("fakeArk");
+            Pixelator.Instance.LerpToLetterbox(0.35f, 0.25f);
+            yield return StartCoroutine(ttcc.HandleTimeTubeCredits(clockhair.sprite.WorldCenter, isShortTunnel, clockhair.spriteAnimator, (!didShootHellTrigger) ? shotPlayer.PlayerIDX : 0, false));
+            if (!IsTrollChest) {
+                if (isShortTunnel) {
+                    Pixelator.Instance.FadeToBlack(1f, false, 0f);
+                    yield return new WaitForSeconds(1f);
+                }
+                if (didShootHellTrigger) {
+                    GameManager.DoMidgameSave(GlobalDungeonData.ValidTilesets.HELLGEON);
+                    GameManager.Instance.LoadCustomLevel("tt_bullethell");
+                } else if (shotPlayer.characterIdentity == PlayableCharacters.CoopCultist) {
+                    GameManager.IsCoopPast = true;
+                    ResetPlayers(false);
+                    GameManager.Instance.LoadCustomLevel("fs_coop");
+                } else if (CharacterStoryComplete(shotPlayer.characterIdentity) && shotPlayer.characterIdentity == PlayableCharacters.Gunslinger) {
+                    GameManager.DoMidgameSave(GlobalDungeonData.ValidTilesets.FINALGEON);
+                    GameManager.IsGunslingerPast = true;
+                    ResetPlayers(true);
+                    GameManager.Instance.LoadCustomLevel("tt_bullethell");
+                } else if (CharacterStoryComplete(shotPlayer.characterIdentity)) {
+                    bool flag = false;
+                    GameManager.DoMidgameSave(GlobalDungeonData.ValidTilesets.FINALGEON);
+                    switch (shotPlayer.characterIdentity) {
+                        case PlayableCharacters.Pilot:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_pilot");
+                            break;
+                        case PlayableCharacters.Convict:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_convict");
+                            break;
+                        case PlayableCharacters.Robot:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_robot");
+                            break;
+                        case PlayableCharacters.Soldier:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_soldier");
+                            break;
+                        case PlayableCharacters.Guide:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_guide");
+                            break;
+                        case PlayableCharacters.Bullet:
+                            flag = true;
+                            ResetPlayers(false);
+                            GameManager.Instance.LoadCustomLevel("fs_bullet");
+                            break;
+                    }
+                    if (!flag) {
+                        AmmonomiconController.Instance.OpenAmmonomicon(true, true);
+                    } else {
+                        GameUIRoot.Instance.ToggleUICamera(false);
+                    }
+                } else {
+                    AmmonomiconController.Instance.OpenAmmonomicon(true, true);
+                }
+            }
+            
+            for (;;) { yield return null; }
+            // yield break;
+        }
+
+        private void ResetPlayers(bool isGunslingerPast = false) {
+            IsResettingPlayers = true;
+            for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++) {
+                if (GameManager.Instance.AllPlayers[i].healthHaver.IsAlive) {
+                    if (!isGunslingerPast) {
+                        GameManager.Instance.AllPlayers[i].ResetToFactorySettings(true, true, false);
+                    }
+                    if (!isGunslingerPast) {
+                        GameManager.Instance.AllPlayers[i].CharacterUsesRandomGuns = false;
+                    }
+                    GameManager.Instance.AllPlayers[i].IsVisible = true;
+                    GameManager.Instance.AllPlayers[i].ClearInputOverride("fakeArk");
+                    GameManager.Instance.AllPlayers[i].ClearAllInputOverrides();
+                }
+            }
+            IsResettingPlayers = false;
+        }
+
+        private void DestroyPlayers() {
+            for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++) { Destroy(GameManager.Instance.AllPlayers[i].gameObject); }
+        }
+
+        private bool CharacterStoryComplete(PlayableCharacters shotCharacter) {
+            return GameStatsManager.Instance.GetFlag(GungeonFlags.BLACKSMITH_BULLET_COMPLETE) && GameManager.Instance.PrimaryPlayer.PastAccessible;
+        }
+
+        private void SpawnVFX(string vfxResourcePath, Vector2 pos) {
+            GameObject original = (GameObject)BraveResources.Load(vfxResourcePath, typeof(GameObject), ".prefab");
+            GameObject gameObject = Instantiate(original);
+            tk2dSprite component = gameObject.GetComponent<tk2dSprite>();
+            component.PlaceAtPositionByAnchor(pos, tk2dBaseSprite.Anchor.MiddleCenter);
+            component.UpdateZDepth();
+        }
+
+        private IEnumerator HandleGun(PlayerController interactor) {
+            interactor.ToggleGunRenderers(false, "fakeArk");
+            GameObject instanceGun = Instantiate(GunPrefab, GunSpawnPoint.position, Quaternion.identity);
+            Material gunMaterial = instanceGun.transform.Find("GunThatCanKillThePast").GetComponent<MeshRenderer>().sharedMaterial;
+            tk2dSprite instanceGunSprite = instanceGun.transform.Find("GunThatCanKillThePast").GetComponent<tk2dSprite>();
+            instanceGunSprite.HeightOffGround = 5f;
+            gunMaterial.SetColor("_OverrideColor", Color.white);
+            float elapsed = 0f;
+            float raiseTime = 4f;
+            Vector3 targetMidHeightPosition = GunSpawnPoint.position + new Vector3(0f, 6.5f, 0f);
+            interactor.ForceIdleFacePoint(new Vector2(1f, -1f), false);
+            while (elapsed < raiseTime) {
+                elapsed += BraveTime.DeltaTime;
+                float t = Mathf.Clamp01(elapsed / raiseTime);
+                t = BraveMathCollege.LinearToSmoothStepInterpolate(0f, 1f, t);
+                instanceGun.transform.position = Vector3.Lerp(GunSpawnPoint.position, targetMidHeightPosition, t);
+                instanceGun.transform.localScale = Vector3.Lerp(Vector3.one, Vector3.one * 2f, t);
+                yield return null;
+            }
+            yield return new WaitForSeconds(1f);
+            while (instanceGunSprite.spriteAnimator.CurrentFrame != 0) { yield return null; }
+            instanceGunSprite.spriteAnimator.Pause();
+            Pixelator.Instance.FadeToColor(0.2f, Color.white, true, 0.2f);
+            yield return new WaitForSeconds(0.1f);
+            Transform burstObject = instanceGun.transform.Find("GTCKTP_Burst");
+            if (burstObject != null) { burstObject.gameObject.SetActive(true); }
+            BraveInput.DoVibrationForAllPlayers(Vibration.Time.Slow, Vibration.Strength.Medium);
+            yield return new WaitForSeconds(0.2f);
+            instanceGunSprite.spriteAnimator.Resume();
+            elapsed = 0f;
+            float fadeTime = 1f;
+            while (elapsed < fadeTime) {
+                elapsed += BraveTime.DeltaTime;
+                float t2 = Mathf.Clamp01(elapsed / fadeTime);
+                gunMaterial.SetColor("_OverrideColor", Color.Lerp(Color.white, new Color(1f, 1f, 1f, 0f), t2));
+                yield return null;
+            }
+            yield return new WaitForSeconds(2f);
+            elapsed = 0f;
+            float reraiseTime = 2f;
+            while (elapsed < reraiseTime) {
+                elapsed += BraveTime.DeltaTime;
+                float t3 = Mathf.Clamp01(elapsed / reraiseTime);
+                t3 = BraveMathCollege.SmoothStepToLinearStepInterpolate(0f, 1f, t3);
+                instanceGun.transform.position = Vector3.Lerp(targetMidHeightPosition, interactor.CenterPosition.ToVector3ZUp(targetMidHeightPosition.z - 10f), t3);
+                instanceGun.transform.localScale = Vector3.Lerp(Vector3.one * 2f, Vector3.one, t3);
+                yield return null;
+            }
+            GameObject pickupVFXPrefab = ResourceCache.Acquire("Global VFX/VFX_Item_Pickup") as GameObject;
+            interactor.PlayEffectOnActor(pickupVFXPrefab, Vector3.zero, true, false, false);
+            GameObject instanceEquippedGun = Instantiate(HeldGunPrefab);
+            AkSoundEngine.PostEvent("Play_OBJ_weapon_pickup_01", gameObject);
+            tk2dSprite instanceEquippedSprite = instanceEquippedGun.GetComponent<tk2dSprite>();
+            instanceEquippedSprite.HeightOffGround = 2f;
+            instanceEquippedSprite.attachParent = interactor.sprite;
+            m_heldPastGun = instanceEquippedGun.transform;
+            m_heldPastGun.parent = interactor.GunPivot;
+            Transform primaryHandXform = m_heldPastGun.Find("PrimaryHand");
+            m_heldPastGun.localRotation = Quaternion.identity;
+            m_heldPastGun.localPosition = -primaryHandXform.localPosition;
+            instanceEquippedSprite.UpdateZDepth();
+            Destroy(instanceGun);
+            yield break;
+        }
+
+        private IEnumerator HandleGameOver(PlayerController interactor) {
+            interactor.healthHaver.lastIncurredDamageSource = "HaHa April Fools!";
+            interactor.healthHaver.ForceSetCurrentHealth(0);
+            interactor.healthHaver.Armor = 0;
+            interactor.healthHaver.Die(Vector2.zero);
+            while (interactor.healthHaver.IsDead) { yield return null; }
+            if (interactor.healthHaver.IsAlive) {
+                GameManager.Instance.MainCameraController.SetManualControl(false, true);
+                Pixelator.Instance.LerpToLetterbox(1, 0.25f);
+                Pixelator.Instance.DoFinalNonFadedLayer = false;
+                ResetPlayers(false);
+                Destroy(LightSpriteBeam.gameObject);
+                Destroy(this);
+            }
+            yield break;
+        }
+
+        public void RegisterChestOnMinimap(GameObject MinimapIconPrefab) {
+            if (ParentRoom != null) {
+                GameObject iconPrefab = MinimapIconPrefab ?? (BraveResources.Load("Global Prefabs/Minimap_Treasure_Icon", ".prefab") as GameObject);
+                minimapIconInstance = Minimap.Instance.RegisterRoomIcon(ParentRoom, iconPrefab, false);
+            }
+        }
+
+        public void DeregisterChestOnMinimap() {
+            if (minimapIconInstance && ParentRoom != null) { Minimap.Instance.DeregisterRoomIcon(ParentRoom, minimapIconInstance); }
+        }
+
+        public string GetAnimationState(PlayerController interactor, out bool shouldBeFlipped) {
+            shouldBeFlipped = false;
+            return string.Empty;
+        }
+
+        public float GetOverrideMaxDistance() { return -1f; }
+
+        protected override void OnDestroy() { base.OnDestroy(); }
+
+        public void ConfigureOnPlacement(RoomHandler room) {
+            if (IsTrollChest) {
+                ParentRoom = room;
+                ParentRoom.RegisterInteractable(this);
+                RegisterChestOnMinimap(GameManager.Instance.RewardManager.S_Chest.MinimapIconPrefab);
+            }
+        }
+    }
+}
+

ExpandTheGungeon/ExpandMain/ExpandSharedHooks.cs

@@ -1715,21 +1715,37 @@ public class ExpandSharedHooks {
                ) {
                 Vector2 ChestPosition = self.transform.position.IntXY(VectorConversions.Round).ToVector3();
                 GameObject chestOBJ;
-                if (UnityEngine.Random.value < 0.009f) {
-                    chestOBJ = UnityEngine.Object.Instantiate(ExpandPrefabs.RickRollChestObject, ChestPosition, Quaternion.identity);
+                bool spawnFakePastChest = false;
+                if (!ExpandSettings.HasSpawnedFakePastChest && DateTime.Today.Month == 4 && DateTime.Today.Day == 01) {
+                    ExpandSettings.HasSpawnedFakePastChest = true;
+                    spawnFakePastChest = true;
+                }
+                if (spawnFakePastChest) {
+                    chestOBJ = UnityEngine.Object.Instantiate(ExpandPrefabs.FakePastChest, (ChestPosition - new Vector2(1.95f,1.45f)), Quaternion.identity);
                 } else {
-                    chestOBJ = UnityEngine.Object.Instantiate(ExpandPrefabs.SurpriseChestObject, ChestPosition, Quaternion.identity);
+                    if (UnityEngine.Random.value < 0.009f) {
+                        chestOBJ = UnityEngine.Object.Instantiate(ExpandPrefabs.RickRollChestObject, ChestPosition, Quaternion.identity);
+                    } else {
+                        chestOBJ = UnityEngine.Object.Instantiate(ExpandPrefabs.SurpriseChestObject, ChestPosition, Quaternion.identity);
+                    }
+                }
+                if (spawnFakePastChest) {
+                    ExpandArkController m_ArkController = null;
+                    if (chestOBJ) { m_ArkController = chestOBJ.GetComponent<ExpandArkController>(); }
+                    if (m_ArkController) { m_ArkController.ConfigureOnPlacement(room); }
+                    UnityEngine.Object.Destroy(self.gameObject);
+                    return;
                 }
                 ExpandFakeChest fakeChest = null;
                 if (chestOBJ) { fakeChest = chestOBJ.GetComponent<ExpandFakeChest>(); }
                 if (fakeChest) {
                     if (self.CenterChestInRegion) {
-                        SpeculativeRigidbody component = fakeChest.gameObject.GetComponent<SpeculativeRigidbody>();
+                        SpeculativeRigidbody component = chestOBJ.GetComponent<SpeculativeRigidbody>();
                         if (component) {
-                            Vector2 Base = component.UnitCenter - fakeChest.gameObject.transform.position.XY();
-                            Vector2 Offset = self.transform.position.XY() + new Vector2(self.xPixelOffset / 16f, self.yPixelOffset / 16f) + new Vector2((float)self.placeableWidth / 2f, (float)self.placeableHeight / 2f);
+                            Vector2 Base = component.UnitCenter - chestOBJ.transform.position.XY();
+                            Vector2 Offset = self.transform.position.XY() + new Vector2(self.xPixelOffset / 16f, self.yPixelOffset / 16f) + new Vector2(self.placeableWidth / 2f, self.placeableHeight / 2f);
                             Vector2 Vector = (Offset - Base);
-                            fakeChest.gameObject.transform.position = Vector.ToVector3ZisY(0f).Quantize(0.0625f);
+                            chestOBJ.transform.position = Vector.ToVector3ZisY(0f).Quantize(0.0625f);
                             component.Reinitialize();
                         }
                     }

ExpandTheGungeon/ExpandPrefab/ExpandObjectDatabase.cs

@@ -97,6 +97,7 @@ public static class ExpandObjectDatabase {
         // public static GameObject GungeonWarpDoor;
         // public static GameObject CastleWarpDoor;
         public static readonly GameObject EndTimes;
+        public static readonly GameObject EndTimesChest;
         // R&G Floor Objects
         public static readonly GameObject TableHorizontalSteel;
         public static readonly GameObject TableVerticalSteel;
@@ -213,6 +214,8 @@ public static class ExpandObjectDatabase {
             // GungeonWarpDoor = gungeonDungeon.WarpWingDoorPrefab;
             // CastleWarpDoor = castleDungeon.WarpWingDoorPrefab;
             EndTimes = ExpandAssets.LoadOfficialAsset<GameObject>("EndTimes", ExpandAssets.AssetSource.BraveResources);
+            EndTimesChest = forgeDungeon.PatternSettings.flows[0].AllNodes[12].overrideExactRoom.placedObjects[0].nonenemyBehaviour.gameObject.transform.Find("EndTimes_Xform").Find("G_CacheOfTheAmmulich").gameObject;
+
 
             foreach (WeightedRoom wRoom in sewersDungeon.PatternSettings.flows[0].fallbackRoomTable.includedRooms.elements) {
                 if (wRoom.room != null && !string.IsNullOrEmpty(wRoom.room.name)) {

ExpandTheGungeon/ExpandPrefab/ExpandPrefabs.cs

@@ -276,6 +276,7 @@ public class ExpandPrefabs {
         public static GameObject RickRollAnimationObject;
         public static GameObject RickRollMusicSwitchObject;
         public static GameObject SurpriseChestObject;
+        public static GameObject FakePastChest;
         public static GameObject ExpandThunderstormPlaceable;
         public static GameObject Door_Horizontal_Jungle;
         public static GameObject Door_Vertical_Jungle;
@@ -2803,7 +2804,7 @@ public class ExpandPrefabs {
             ExpandUtility.AddAnimation(RickRollMusicSwitchObject.GetComponent<tk2dSpriteAnimator>(), EXTrapCollection.GetComponent<tk2dSpriteCollectionData>(), m_RickRollMusicSwitchTurnOnFrames, "RickRollSwitch_TurnOn", tk2dSpriteAnimationClip.WrapMode.Once, frameRate: 12);
             ExpandUtility.AddAnimation(RickRollMusicSwitchObject.GetComponent<tk2dSpriteAnimator>(), EXTrapCollection.GetComponent<tk2dSpriteCollectionData>(), m_RickRollMusicSwitchTurnOffFrames, "RickRollSwitch_TurnOff", tk2dSpriteAnimationClip.WrapMode.Once, frameRate: 12);
 
-            ETGModConsole.ModdedShrines.Add("RickRollChest", RickRollChestObject);
+            ETGModConsole.ModdedShrines.Add("EX:RickRollChest", RickRollChestObject);
 
             ExpandFakeChest RickRollChest_SwitchComponent = RickRollMusicSwitchObject.AddComponent<ExpandFakeChest>();
             RickRollChest_SwitchComponent.chestType = ExpandFakeChest.ChestType.MusicSwitch;
@@ -2889,13 +2890,36 @@ public class ExpandPrefabs {
             SurpriseChestComponent.openAnimName = "coop_chest_open";
 
 
-            ETGModConsole.ModdedShrines.Add("SurpriseChest", SurpriseChestObject);
+            ETGModConsole.ModdedShrines.Add("EX:SurpriseChest", SurpriseChestObject);
+            
+            FakePastChest = expandSharedAssets1.LoadAsset<GameObject>("Expand_FakePastChest");
+
+            ExpandUtility.DuplicateSprite(FakePastChest.AddComponent<tk2dSprite>(), ExpandObjectDatabase.EndTimesChest.GetComponent<tk2dSprite>());
+            ExpandUtility.DuplicateSprite(FakePastChest.transform.Find("G_Lid").gameObject.AddComponent<tk2dSprite>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Lid").gameObject.GetComponent<tk2dSprite>());
+            ExpandUtility.DuplicateSprite(FakePastChest.transform.Find("G_Shadow").gameObject.AddComponent<tk2dSprite>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Shadow").gameObject.GetComponent<tk2dSprite>());
+            ExpandUtility.DuplicateSprite(FakePastChest.transform.Find("G_Poof").gameObject.AddComponent<tk2dSprite>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Poof").gameObject.GetComponent<tk2dSprite>());
+            ExpandUtility.DuplicateSprite(FakePastChest.transform.Find("G_Light").gameObject.AddComponent<tk2dSprite>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Light").gameObject.GetComponent<tk2dSprite>());
+            FakePastChest.transform.Find("G_Light").gameObject.GetComponent<tk2dSprite>().renderer.enabled = false;
+            FakePastChest.transform.Find("G_Shadow").gameObject.GetComponent<tk2dSprite>().usesOverrideMaterial = true;
+            FakePastChest.transform.Find("G_Shadow").gameObject.GetComponent<tk2dSprite>().renderer.material.shader = GameManager.Instance.RewardManager.A_Chest.gameObject.transform.Find("Shadow").gameObject.GetComponent<tk2dSprite>().renderer.material.shader;
+
+
+            ExpandUtility.DuplicateSpriteAnimator(FakePastChest.AddComponent<tk2dSpriteAnimator>(), ExpandObjectDatabase.EndTimesChest.GetComponent<tk2dSpriteAnimator>());
+            ExpandUtility.DuplicateSpriteAnimator(FakePastChest.transform.Find("G_Lid").gameObject.AddComponent<tk2dSpriteAnimator>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Lid").gameObject.GetComponent<tk2dSpriteAnimator>());
+            ExpandUtility.DuplicateSpriteAnimator(FakePastChest.transform.Find("G_Shadow").gameObject.AddComponent<tk2dSpriteAnimator>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Shadow").gameObject.GetComponent<tk2dSpriteAnimator>());
+            ExpandUtility.DuplicateSpriteAnimator(FakePastChest.transform.Find("G_Poof").gameObject.AddComponent<tk2dSpriteAnimator>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Poof").gameObject.GetComponent<tk2dSpriteAnimator>());
+            ExpandUtility.DuplicateSpriteAnimator(FakePastChest.transform.Find("G_Light").gameObject.AddComponent<tk2dSpriteAnimator>(), ExpandObjectDatabase.EndTimesChest.transform.Find("G_Light").gameObject.GetComponent<tk2dSpriteAnimator>());
+
+            ExpandUtility.DuplicateRigidBody(FakePastChest.AddComponent<SpeculativeRigidbody>(), ExpandObjectDatabase.EndTimesChest.GetComponent<SpeculativeRigidbody>());
+
+            ExpandArkController m_ExpandArkController = FakePastChest.AddComponent<ExpandArkController>();
+
+            ETGModConsole.ModdedShrines.Add("EX:FakePastChest", FakePastChest);
 
             ExpandThunderstormPlaceable = expandSharedAssets1.LoadAsset<GameObject>("ExpandThunderStorm");
             ExpandThunderstormPlaceable.AddComponent<ExpandThunderStormPlacable>();
             
 
-
             Door_Horizontal_Jungle = UnityEngine.Object.Instantiate(ForgeDungeonPrefab.doorObjects.variantTiers[0].nonDatabasePlaceable);
             Door_Horizontal_Jungle.SetActive(false);
             Door_Vertical_Jungle = UnityEngine.Object.Instantiate(ForgeDungeonPrefab.doorObjects.variantTiers[1].nonDatabasePlaceable);
@@ -4361,7 +4385,7 @@ public class ExpandPrefabs {
             JsonUtility.FromJsonOverwrite(JsonUtility.ToJson(ExpandObjectDatabase.ChestBrownTwoItems.GetComponent<MajorBreakable>()), chestWestBreakable);
             chestWestBreakable.spriteNameToUseAtZeroHP = "chest_west_break_001";
 
-            ETGModConsole.ModdedChests.Add("West", m_chestWest);
+            ETGModConsole.ModdedChests.Add("EX:West", m_chestWest);
 
             EX_RedBalloon = expandSharedAssets1.LoadAsset<GameObject>("EX_RedBalloon");
             tk2dSprite m_RedBalloonSprite = SpriteSerializer.AddSpriteToObject(EX_RedBalloon, EXBalloonCollection, "redballoon_idle_001");

ExpandTheGungeon/ExpandSettings.cs

@@ -29,6 +29,7 @@ public static class ExpandSettings {
         public static bool HasSpawnedSecretBoss = false;
         public static float randomSeed = 0.5f;
         public static bool PlayingPunchoutArcade = false;
+        public static bool HasSpawnedFakePastChest = false;
         
         public static void LoadSettings() {
             if (File.Exists(Path.Combine(ETGMod.ResourcesDirectory, ExpandTheGungeon.ModSettingsFileName))) {

ExpandTheGungeon/ExpandTheGungeon.cs

@@ -24,7 +24,7 @@ public class ExpandTheGungeon : BaseUnityPlugin {
 
         public const string GUID = "ApacheThunder.etg.ExpandTheGungeon";
         public const string ModName = "ExpandTheGungeon";
-        public const string VERSION = "2.9.5";
+        public const string VERSION = "2.9.6";
         public static string ZipFilePath;
         public static string FilePath;
         public static string ResourcesPath;
@@ -280,7 +280,7 @@ private enum WaitType { ShotgunSecret, LanguageFix, DebugFlow };
             ETGModConsole.Commands.GetGroup(MainCommandName).AddUnit("list_items", ExpandCustomItemsInfo);
             ETGModConsole.Commands.GetGroup(MainCommandName).AddUnit("youtubemode", ExpandYouTubeSafeCommand);
             ETGModConsole.Commands.GetGroup(MainCommandName).AddUnit("savesettings", ExpandExportSettings);
-            // ETGModConsole.Commands.GetGroup(MainCommandName).AddUnit("test", ExpandTestCommand);
+            ETGModConsole.Commands.GetGroup(MainCommandName).AddUnit("test", ExpandTestCommand);
             return;
         }
 
@@ -504,8 +504,8 @@ private enum WaitType { ShotgunSecret, LanguageFix, DebugFlow };
             ETGModConsole.Log("[ExpandTheGungeon] Sprite collection successfully built and exported!");
         }
 
-        /*private void ExpandTestCommand(string[] consoleText) {
-            GameStatsManager.Instance.ClearStatValueGlobal(TrackedStats.META_CURRENCY);
+        private void ExpandTestCommand(string[] consoleText) {
+            /*GameStatsManager.Instance.ClearStatValueGlobal(TrackedStats.META_CURRENCY);
             GameStatsManager.Instance.SetStat(TrackedStats.META_CURRENCY, float.Parse(consoleText[0]));
             // GameStatsManager.Instance.RegisterStatChange(TrackedStats.META_CURRENCY_SPENT_AT_META_SHOP, 0);
             
@@ -514,10 +514,16 @@ private enum WaitType { ShotgunSecret, LanguageFix, DebugFlow };
                 GameStatsManager.Instance.RegisterStatChange(TrackedStats.META_CURRENCY, -int.Parse(consoleText[1]));
             } else if (consoleText[0].StartsWith("+")) {
                 GameStatsManager.Instance.RegisterStatChange(TrackedStats.META_CURRENCY, +int.Parse(consoleText[1]));
-            }
+            }*/
 
             //return;
-        }*/
+
+            // Tools.ExportTexture((GameManager.Instance.PrimaryPlayer.CurrentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.RoomClear)[0].sprite.Collection.materials[0].mainTexture as Texture2D).GetRW());
+            GameObject NewChestTest = Instantiate(ExpandObjectDatabase.EndTimesChest, (GameManager.Instance.PrimaryPlayer.transform.position + new Vector3(0,2,0)), Quaternion.identity);
+
+            GameManager.Instance.PrimaryPlayer.CurrentRoom.RegisterInteractable(NewChestTest.GetComponent<ArkController>());
+
+        }
     }
 }
 

ExpandTheGungeon/ExpandTheGungeon.csproj

@@ -105,6 +105,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ExpandComponents\ExpandArkController.cs" />
     <Compile Include="ExpandComponents\ExpandBalloonController.cs" />
     <Compile Include="ExpandComponents\ExpandCasinoGameController.cs" />
     <Compile Include="ExpandComponents\ExpandCasinoPropAnimationHandler.cs" />

ExpandTheGungeon/ItemAPI/Items/ClownBullets.cs

@@ -79,8 +79,129 @@ public class ClownBullets : PassiveItem {
                     clownbulletModifier.EnemyGuidsToIgnore = EnemyGuidsToIgnore;
                 }
             }
+            // obj.specRigidbody.OnPreTileCollision += OnPreTileCollision;
         }
 
+        /*public void OnPreTileCollision(SpeculativeRigidbody myRigidbody, PixelCollider myPixelCollider, PhysicsEngine.Tile tile, PixelCollider tilePixelCollider) {
+            if (IsDestroyingTileMap) { return; }
+            RoomHandler baseRoom = myRigidbody.gameObject.transform.position.GetAbsoluteRoom();
+            IntVector2 position = tile.Position;
+            CellData cellData = GameManager.Instance.Dungeon.data[position];
+            // if (cellData != null && cellData.isRoomInternal) {
+            if (cellData != null) {
+                cellData.breakable = true;
+                cellData.occlusionData.overrideOcclusion = true;
+                cellData.occlusionData.cellOcclusionDirty = true;
+                tk2dTileMap tilemap = GameManager.Instance.Dungeon.DestroyWallAtPosition(position.x, position.y, true);
+                baseRoom.Cells.Add(cellData.position);
+                baseRoom.CellsWithoutExits.Add(cellData.position);
+                baseRoom.RawCells.Add(cellData.position);
+                Pixelator.Instance.MarkOcclusionDirty();
+                Pixelator.Instance.ProcessOcclusionChange(baseRoom.Epicenter, 1f, baseRoom, false);
+                if (tilemap) { StartCoroutine(RebuildTilemap(tilemap, tk2dTileMap.BuildFlags.Default)); }
+                // if (tilemap) { RebuildTilemap2(tilemap, tk2dTileMap.BuildFlags.Default); }
+            }
+        }
+
+        public bool IsDestroyingTileMap = false;
+
+        public IEnumerator RebuildTilemap(tk2dTileMap targetTilemap, tk2dTileMap.BuildFlags buildFlags) {
+            IsDestroyingTileMap = true;
+            RenderMeshBuilder.CurrentCellXOffset = Mathf.RoundToInt(targetTilemap.renderData.transform.position.x);
+            RenderMeshBuilder.CurrentCellYOffset = Mathf.RoundToInt(targetTilemap.renderData.transform.position.y);
+            IEnumerator enumerator = targetTilemap.DeferredBuild(buildFlags);
+            while (enumerator.MoveNext()) { yield return null; }
+            targetTilemap.renderData.transform.position = new Vector3(RenderMeshBuilder.CurrentCellXOffset, RenderMeshBuilder.CurrentCellYOffset, RenderMeshBuilder.CurrentCellYOffset);
+            RenderMeshBuilder.CurrentCellXOffset = 0;
+            RenderMeshBuilder.CurrentCellYOffset = 0;
+            IsDestroyingTileMap = false;
+            yield break;
+        }
+
+        public void RebuildTilemap2(tk2dTileMap targetTilemap, tk2dTileMap.BuildFlags buildFlags) {
+            IsDestroyingTileMap = true;
+            RenderMeshBuilder.CurrentCellXOffset = Mathf.RoundToInt(targetTilemap.renderData.transform.position.x);
+            RenderMeshBuilder.CurrentCellYOffset = Mathf.RoundToInt(targetTilemap.renderData.transform.position.y);
+            IEnumerator enumerator = DeferredBuild(targetTilemap, tk2dTileMap.BuildFlags.Default);
+            while (enumerator.MoveNext()) { }
+            targetTilemap.renderData.transform.position = new Vector3(RenderMeshBuilder.CurrentCellXOffset, RenderMeshBuilder.CurrentCellYOffset, targetTilemap.renderData.transform.position.z);
+            RenderMeshBuilder.CurrentCellXOffset = 0;
+            RenderMeshBuilder.CurrentCellYOffset = 0;
+            IsDestroyingTileMap = false;
+        }
+
+        public IEnumerator DeferredBuild(tk2dTileMap tileMap, tk2dTileMap.BuildFlags buildFlags) {
+            if (tileMap.data != null && tileMap.Editor__SpriteCollection != null) {
+                int spriteCollectionKey = ReflectionHelpers.ReflectGetField<int>(typeof(tk2dTileMap), "spriteCollectionKey", tileMap); ;
+                Layer[] layers = ReflectionHelpers.ReflectGetField<Layer[]>(typeof(tk2dTileMap), "layers", tileMap); ;
+                ColorChannel colorChannel = ReflectionHelpers.ReflectGetField<ColorChannel>(typeof(tk2dTileMap), "colorChannel", tileMap);
+                if (tileMap.data.tilePrefabs == null) {
+                    tileMap.data.tilePrefabs = new GameObject[tileMap.SpriteCollectionInst.Count];
+                } else if (tileMap.data.tilePrefabs.Length != tileMap.SpriteCollectionInst.Count) {
+                    Array.Resize(ref tileMap.data.tilePrefabs, tileMap.SpriteCollectionInst.Count);
+                }
+                BuilderUtil.InitDataStore(tileMap);
+                if (tileMap.SpriteCollectionInst) { tileMap.SpriteCollectionInst.InitMaterialIds(); }
+                bool forceBuild = (buildFlags & tk2dTileMap.BuildFlags.ForceBuild) != tk2dTileMap.BuildFlags.Default;
+                if (tileMap.SpriteCollectionInst && tileMap.SpriteCollectionInst.buildKey != spriteCollectionKey) {
+                    forceBuild = true;
+                }
+                Dictionary<Layer, bool> layersActive = new Dictionary<Layer, bool>();
+                if (layers != null) {
+                    for (int i = 0; i < layers.Length; i++) {
+                        Layer layer = layers[i];
+                        if (layer != null && layer.gameObject != null) {
+                            layersActive[layer] = layer.gameObject.activeSelf;
+                        }
+                    }
+                }
+                if (forceBuild) { ReflectionHelpers.InvokeMethod(typeof(tk2dTileMap), "ClearSpawnedInstances", tileMap); }
+                BuilderUtil.CreateRenderData(tileMap, tileMap.AllowEdit, layersActive);
+                SpriteChunk.s_roomChunks = new Dictionary<LayerInfo, List<SpriteChunk>>();
+                if (Application.isPlaying && GameManager.Instance.Dungeon != null && GameManager.Instance.Dungeon.data != null && GameManager.Instance.Dungeon.MainTilemap == this) {
+                    List<RoomHandler> rooms = GameManager.Instance.Dungeon.data.rooms;
+                    if (rooms != null && rooms.Count > 0) {
+                        for (int j = 0; j < tileMap.data.Layers.Length; j++) {
+                            if (tileMap.data.Layers[j].overrideChunkable) {
+                                for (int k = 0; k < rooms.Count; k++) {
+                                    if (!SpriteChunk.s_roomChunks.ContainsKey(tileMap.data.Layers[j])) {
+                                        SpriteChunk.s_roomChunks.Add(tileMap.data.Layers[j], new List<SpriteChunk>());
+                                    }
+                                    SpriteChunk spriteChunk = new SpriteChunk(rooms[k].area.basePosition.x + tileMap.data.Layers[j].overrideChunkXOffset, rooms[k].area.basePosition.y + tileMap.data.Layers[j].overrideChunkYOffset, rooms[k].area.basePosition.x + rooms[k].area.dimensions.x + tileMap.data.Layers[j].overrideChunkXOffset, rooms[k].area.basePosition.y + rooms[k].area.dimensions.y + tileMap.data.Layers[j].overrideChunkYOffset);
+                                    spriteChunk.roomReference = rooms[k];
+                                    string prototypeRoomName = rooms[k].area.PrototypeRoomName;
+                                    tileMap.Layers[j].CreateOverrideChunk(spriteChunk);
+                                    BuilderUtil.CreateOverrideChunkData(spriteChunk, tileMap, j, prototypeRoomName);
+                                    spriteChunk.gameObject.transform.position = new Vector3(spriteChunk.gameObject.transform.position.x, spriteChunk.gameObject.transform.position.y, tileMap.renderData.transform.position.z);
+                                    SpriteChunk.s_roomChunks[tileMap.data.Layers[j]].Add(spriteChunk);
+                                }
+                            }
+                        }
+                    }
+                }
+                IEnumerator BuildTracker = RenderMeshBuilder.Build(tileMap, tileMap.AllowEdit, forceBuild);
+                while (BuildTracker.MoveNext()) { yield return null; }
+                if (!tileMap.AllowEdit && tileMap.isGungeonTilemap) { BuilderUtil.SpawnAnimatedTiles(tileMap, forceBuild); }
+                if (!tileMap.AllowEdit) {
+                    tk2dSpriteDefinition firstValidDefinition = tileMap.SpriteCollectionInst.FirstValidDefinition;
+                    if (firstValidDefinition != null && firstValidDefinition.physicsEngine == tk2dSpriteDefinition.PhysicsEngine.Physics2D) {
+                        ColliderBuilder2D.Build(tileMap, forceBuild);
+                    } else {
+                        ColliderBuilder3D.Build(tileMap, forceBuild);
+                    }
+                    BuilderUtil.SpawnPrefabs(tileMap, forceBuild);
+                }
+                foreach (Layer layer2 in layers) { layer2.ClearDirtyFlag(); }
+                if (colorChannel != null) { colorChannel.ClearDirtyFlag(); }
+                if (tileMap.SpriteCollectionInst) {
+                    FieldInfo m_spriteCollectionKey = typeof(tk2dTileMap).GetField("spriteCollectionKey", BindingFlags.NonPublic | BindingFlags.Instance);
+                    m_spriteCollectionKey.SetValue(tileMap, tileMap.SpriteCollectionInst.buildKey);
+                }
+                yield break;
+            }
+            yield break;
+        }*/
+
         public override DebrisObject Drop(PlayerController player) {
             DebrisObject debrisObject = base.Drop(player);
             m_player = null;

ExpandTheGungeon/Properties/AssemblyInfo.cs

@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.9.5")]
-[assembly: AssemblyFileVersion("2.9.5")]
+[assembly: AssemblyVersion("2.9.6")]
+[assembly: AssemblyFileVersion("2.9.6")]