HeavenStudioPlus/Assets/Scripts/Games/FreezeFrame/FreezeFrame.cs

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using HeavenStudio.Util;
using HeavenStudio.InputSystem;

using Jukebox;

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    public static class NtrFreezeFrameLoader
    {
        public static Minigame AddGame(EventCaller eventCaller)
        {
            return new Minigame("freezeFrame", "Freeze Frame", "8b93b4", false, false, new List<GameAction>()
            {
                new GameAction("bop", "Bop")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SetBopping(e.beat, e.length, e["bop"], e["autoBop"], e["blink"], e["autoBlink"]); },
                    defaultLength = 1f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("bop", false, "Bop", "Set the type of photo to use."),
                        new Param("autoBop", true, "Bop (Auto)", "Set the type of photo to use."),
                        new Param("blink", false, "Crosshair Blink", "Set the type of photo to use."),
                        new Param("autoBlink", true, "Crosshair Blink (Auto)", "Set the type of photo to use."),
                    }
                },
                // cues
                new GameAction("slowCar", "Slow Car")
                {
                    function = delegate
                    {
                        var e = eventCaller.currentEntity;
                        FreezeFrame.SlowCarCue(e.beat, e["variant"], e["mute"], e["clear"]);
                    },
                    inactiveFunction = delegate
                    {
                        var e = eventCaller.currentEntity;
                        if (!(bool)e["mute"]) FreezeFrame.SlowCarSFX();
                    },
                    defaultLength = 3f,
                    parameters = new List<Param>()
                    {
                        new Param("variant", FreezeFrame.PhotoType.Random, "Photo Variant", "Set the type of photo to use."),
                        new Param("mute", false, "Mute", "Mute the sound of the cue."),
                        new Param("clear", false, "Clear Previous Photos", "Dispose of all the photos taken before this one."),
                        new Param("autoShowPhotos", true, "Auto Show Photos", "Automagically show the photos after they're taken.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "gradeType", "audience" })
                        }),
                        new Param("gradeType", FreezeFrame.GradeType.Symbols, "Rating Type", "Choose whether to use the English or Japanese variant of the grading screen."),
                        new Param("audience", true, "Crowd Cheer", "Set whether or not the audience should cheer when the photos are shown."),
                    }
                },
                new GameAction("fastCar", "Fast Car")
                {
                    function = delegate
                    {
                        var e = eventCaller.currentEntity;
                        FreezeFrame.FastCarCue(e.beat, e["variant"], e["mute"], e["clear"]);
                    },
                    inactiveFunction = delegate
                    {
                        var e = eventCaller.currentEntity;
                        if (!(bool)e["mute"]) FreezeFrame.FastCarSFX();
                    },
                    defaultLength = 3f,
                    parameters = new List<Param>()
                    {
                        new Param("variant", FreezeFrame.PhotoType.Random, "Photo Variant", "Set the type of photo to use."),
                        new Param("mute", false, "Mute", "Mute the sound of the cue."),
                        new Param("clear", false, "Clear Previous Photos", "Dispose of all the photos taken before this one."),
                        new Param("autoShowPhotos", true, "Auto Show Photos", "Automagically show the photos after they're taken.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "gradeType", "audience" })
                        }),
                        new Param("gradeType", FreezeFrame.GradeType.Symbols, "Rating Type", "Choose whether to use the English or Japanese variant of the grading screen."),
                        new Param("audience", true, "Crowd Cheer", "Set whether or not the audience should cheer when the photos are shown."),
                    }
                },
                new GameAction("showPhotos", "Show Photos")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.ShowPhotos(e.beat, e.length, e["gradeType"], e["audience"], e["clearCache"]); },
                    defaultLength = 1,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("gradeType", FreezeFrame.GradeType.Symbols, "Rating Type", "Choose whether to use the English or Japanese variant of the grading screen."),
                        new Param("audience", true, "Crowd Cheer", "Set whether or not the audience should cheer when the photos are shown."),
                        new Param("clearCache", true, "Clear Photos", "Clears the photo cache after the photos are shown."),
                    }
                },
                // distractions
                new GameAction("spawnPerson", "Spawn Walker")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SummonWalker(e); },
                    defaultLength = 4f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("personType", FreezeFrame.PersonType.Dude1, "Walker Type", "Choose the type of walker to spawn."),
                        new Param("direction", FreezeFrame.PersonDirection.Random, "Direction", "Choose the direction from which to spawn the walker."),
                        new Param("layer", new EntityTypes.Integer(-10, 10, 0), "Layer", "The layer on which this walker should spawn (higher numbers are shown in front)."),
                    }
                },
                new GameAction("spawnCrowd", "Show/Hide Crowd")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.ToggleCrowd(e.beat, e["crowd"], e["customCrowd"], e["crowdFarLeft"], e["crowdLeft"], e["crowdRight"], e["crowdFarRight"], e["billboard"]); },
                    defaultLength = 0.5f,
                    parameters = new List<Param>()
                    {
                        new Param("crowd", true, "Show Crowd", "Choose whether to spawn or despawn the crowd."),
                        new Param("customCrowd", false, "Custom Crowd", "Select to customize the crowd.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "crowdFarLeft", "crowdLeft", "crowdRight", "crowdFarRight" })
                        }),
                        new Param("crowdFarLeft" , FreezeFrame.CustomCrowdType.PinkDancers,   "Far Left"    , "Select the graphic to display on the far left."),
                        new Param("crowdLeft"    , FreezeFrame.CustomCrowdType.YellowDancers, "Center Left" , "Select the graphic to display on the near left."),
                        new Param("crowdRight"   , FreezeFrame.CustomCrowdType.TealDancers,   "Center Right", "Select the graphic to display on the near right."),
                        new Param("crowdFarRight", FreezeFrame.CustomCrowdType.PinkDancers,   "Far Right"   , "Select the graphic to display on the far right."),
                        new Param("billboard", false, "Show Billboard", "Choose whether to show or hide the billboards."),
                    }
                },
                new GameAction("introSign", "Intro Sign")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.DoIntroSign(e.beat, e.length, e["enter"], e["ease"]); },
                    defaultLength = 4f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("enter", true, "Enter", "Choose whether the sign should enter or exit."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
                    }
                },
                new GameAction("introLights", "Intro Lights")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.IntroLightsAnim(e.beat, e.length, e["lightsOn"]); FreezeFrame.IntroLightsSound(e.beat, e.length, e["lightsOn"]); },
                    inactiveFunction = delegate { var e = eventCaller.currentEntity; FreezeFrame.IntroLightsSound(e.beat, e.length, e["lightsOn"]); },
                    defaultLength = 1f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("lightsOn", true, "Turn Lights On", "Choose whether to turn the lights on or off."),
                    }
                },
                // settings
                new GameAction("toggleOverlay", "Toggle Overlay")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.ToggleOverlay(e.beat, e["showOverlay"], e["showCameraMan"], e["followCamera"]); },
                    defaultLength = 0.5f,
                    parameters = new List<Param>()
                    {
                        new Param("showOverlay", true, "Show Overlay", "Choose whether or not to show the camera overlay."),
                        new Param("showCameraMan", true, "Show T.J.", "Choose whether or not to show the box containing T.J. Snapper."),
                        new Param("followCamera", true, "Follow Camera", "Choose whether or not the overlay should follow the camera."),
                    }
                },
                new GameAction("neoMoveCameraMan", "Move T.J.")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SetMoveCameraMan(e); },
                    defaultLength = 1f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("doMove", false, "Move", "Select this option if you want to move T.J.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "endMoveX", "endMoveY" } ),
                            new Param.CollapseParam((x, e) => (bool)x && (Util.EasingFunction.Ease)e["ease"] != Util.EasingFunction.Ease.Instant, new string[] { "startMoveX", "startMoveY" }),
                            new Param.CollapseParam((_, e) => (bool)e["doMove"] || (bool)e["doRotate"] || (bool)e["doScale"], new string[] { "ease" })
                        }),
                        new Param("startMoveX", new EntityTypes.Float(-20f, 20f, 0f), "Start X", "Set the X position from which to move."),
                        new Param("startMoveY", new EntityTypes.Float(-20f, 20f, 0f), "Start Y", "Set the Y position from which to move."),
                        new Param("endMoveX", new EntityTypes.Float(-20f, 20f, 0f), "End X", "Set the X position to move to."),
                        new Param("endMoveY", new EntityTypes.Float(-20f, 20f, 0f), "End Y", "Set the Y position to move to."),
                        new Param("doRotate", false, "Rotate", "Select this option if you want to rotate T.J.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "endRotDegrees" } ),
                            new Param.CollapseParam((x, e) => (bool)x && (Util.EasingFunction.Ease)e["ease"] != Util.EasingFunction.Ease.Instant, new string[] { "startRotDegrees" }),
                            new Param.CollapseParam((_, e) => (bool)e["doMove"] || (bool)e["doRotate"] || (bool)e["doScale"], new string[] { "ease" })
                        }),
                        new Param("startRotDegrees", new EntityTypes.Float(-360f, 360f, 0f), "Start Rotation", "Set the number of degrees at which to begin rotating."),
                        new Param("endRotDegrees", new EntityTypes.Float(-360f, 360f, 0f), "End Rotation", "Set the number of degrees at which to finish rotating."),
                        new Param("doScale", false, "Scale", "Select this option if you want to change T.J.'s scale.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (bool)x, new string[] { "endScaleX", "endScaleY" } ),
                            new Param.CollapseParam((x, e) => (bool)x && (Util.EasingFunction.Ease)e["ease"] != Util.EasingFunction.Ease.Instant, new string[] { "startScaleX", "startScaleY" }),
                            new Param.CollapseParam((_, e) => (bool)e["doMove"] || (bool)e["doRotate"] || (bool)e["doScale"], new string[] { "ease" })
                        }),
                        new Param("startScaleX", new EntityTypes.Float(-5f, 5f, 1f), "Start Scale X", "Set the desired scale on the X axis at which to start."),
                        new Param("startScaleY", new EntityTypes.Float(-5f, 5f, 1f), "Start Scale Y", "Set the desired scale on the Y axis at which to start."),
                        new Param("endScaleX", new EntityTypes.Float(-5f, 5f, 1f), "End Scale X", "Set the desired scale on the X axis at which to end."),
                        new Param("endScaleY", new EntityTypes.Float(-5f, 5f, 1f), "End Scale Y", "Set the desired scale on the Y axis at which to end."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing for the action.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, e) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant && (bool)e["doMove"], new string[] { "startMoveX", "startMoveY" }),
                            new Param.CollapseParam((x, e) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant && (bool)e["doRotate"], new string[] { "startRotDegrees" }),
                            new Param.CollapseParam((x, e) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant && (bool)e["doScale"], new string[] { "startScaleX", "startScaleY" }),
                        })
                    }
                },

                // DEPRECATED ACTIONS
                // DEPRECATED ACTIONS
                // DEPRECATED ACTIONS

                new GameAction("clearPhotos", "Clear Photo Cache (DEPRECATED)")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.ClearPhotos(); },
                    inactiveFunction = delegate { var e = eventCaller.currentEntity; FreezeFrame.ClearPhotos(); },
                    defaultLength = 0.5f,
                    parameters = new List<Param>()
                    {
                    },
                    hidden = true
                },
                new GameAction("moveCameraMan", "Move T.J. (DEPRECATED)")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SetMoveCameraMan_OLD(e.beat, e.length, e["startPosX"], e["startPosY"], e["endPosX"], e["endPosY"], e["ease"]); },
                    defaultLength = 1f,
                    resizable = true,
                    hidden = true,
                    parameters = new List<Param>()
                    {
                        new Param("startPosX", new EntityTypes.Float(-5.0f, 5.0f, 0.0f), "Start X Position", "X position at which to start."),
                        new Param("startPosY", new EntityTypes.Float(-5.0f, 5.0f, 0.0f), "Start Y Position", "Y position at which to start."),
                        new Param("endPosX"  , new EntityTypes.Float(-5.0f, 5.0f, 0.0f), "End X Position"  , "X position at which to end."),
                        new Param("endPosY"  , new EntityTypes.Float(-5.0f, 5.0f, 0.0f), "End Y Position"  , "Y position at which to end."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "startPosX", "startPosY" })
                        }),
                        //new Param("flipX", false, "Flip", "Set whether or not to flip T.J. horizontally."),
                    }
                },
                new GameAction("rotateCameraMan", "Rotate T.J. (DEPRECATED)")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SetRotateCameraMan_OLD(e.beat, e.length, e["startRot"], e["endRot"], e["ease"]); },
                    defaultLength = 1f,
                    resizable = true,
                    hidden = true,
                    parameters = new List<Param>()
                    {
                        new Param("startRot", new EntityTypes.Float(-360.0f, 360.0f, 0.0f), "Start Rotation", "Rotation degrees at which to start."),
                        new Param("endRot"  , new EntityTypes.Float(-360.0f, 360.0f, 0.0f), "End Rotation"  , "Rotation degrees position at which to end."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "startRot" })
                        }),
                    }
                },
                new GameAction("scaleCameraMan", "Scale T.J. (DEPRECATED)")
                {
                    function = delegate { var e = eventCaller.currentEntity; FreezeFrame.SetScaleCameraMan_OLD(e.beat, e.length, e["startSizeX"], e["startSizeY"], e["endSizeX"], e["endSizeY"], e["ease"]); },
                    defaultLength = 1f,
                    resizable = true,
                    hidden = true,
                    parameters = new List<Param>()
                    {
                        new Param("startSizeX", new EntityTypes.Float(-5.0f, 5.0f, 1.0f), "Start Scale X", "Horizontal scale at which to start."),
                        new Param("startSizeY", new EntityTypes.Float(-5.0f, 5.0f, 1.0f), "Start Scale Y", "Vertical scale at which to start."),
                        new Param("endSizeX",   new EntityTypes.Float(-5.0f, 5.0f, 1.0f), "End Scale X"  , "Horizontal scale at which to end."),
                        new Param("endSizeY",   new EntityTypes.Float(-5.0f, 5.0f, 1.0f), "End Scale Y"  , "Vertical scale at which to end."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new List<Param.CollapseParam>()
                        {
                            new Param.CollapseParam((x, _) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "startSizeX", "startSizeY" })
                        }),
                    }
                },
            },
            new List<string>() { "ntr", "normal" },
            "ntrcameraman", "en",
            chronologicalSortKey: 13
            );
        }
    }
}

namespace HeavenStudio.Games
{
    using HeavenStudio.Common;
    using Scripts_FreezeFrame;
    using UnityEngine.Rendering;

    public class FreezeFrame : Minigame
    {
        /*
        BIG LIST OF TODOS
        - finish sounds
        - make pitching and panning work
        - wait for upscale
        - make particles random sprites
        */

        public static FreezeFrame Instance
        {
            get
            {
                if (GameManager.instance.minigame is FreezeFrame instance)
                    return instance;
                return null;
            }
        }

        [SerializeField] Animator CameraMan;
        [SerializeField] Photograph[] Photographs;
        [SerializeField] Photograph Photograph1;
        [SerializeField] Photograph Photograph2;
        [SerializeField] Photograph Photograph3;
        [SerializeField] Animator Results;

        [SerializeField] Animator IntroSign;

        [SerializeField] GameObject Overlay;
        [SerializeField] GameObject Crosshair;
        [SerializeField] Animator Shutter;
        [SerializeField] GameObject DimRect;

        [SerializeField] StickyCanvas StickyLayer;

        [SerializeField] Transform FarCarSpawn;
        [SerializeField] GameObject FarCarPrefab;

        [SerializeField] Transform NearCarSpawn;
        [SerializeField] GameObject NearCarPrefab;

        [SerializeField] Transform WalkerSpawn;
        [SerializeField] GameObject WalkerPrefab;

        [SerializeField] Animator Crowd;
        [SerializeField] SpriteRenderer CrowdFarLeft;
        [SerializeField] SpriteRenderer CrowdLeft;
        [SerializeField] SpriteRenderer CrowdRight;
        [SerializeField] SpriteRenderer CrowdFarRight;
        [SerializeField] Sprite[] CrowdSprites;
        [SerializeField] GameObject Billboards;

        public bool DoAutoBop { get; set; } = true;
        public bool DoAutoCrosshairBlink { get; set; } = true;
        public bool ShowOverlay { get; set; } = true;
        public bool ShowCameraMan { get; set; } = true;
        public bool OverlayFollowCamera { get; set; } = true;
        public bool ShowCrowd { get; set; } = false;
        public bool ShowBillboard { get; set; } = false;

        public List<WalkerArgs> Walkers { get; set; } = new();

        public bool SignIsMoving { get; set; } = false;
        public SignMoveArgs CurrentSignArgs { get; set; }

        public static Vector3 CameraManStartPos { get; private set; }
        public bool CameraManMoving { get; set; } = false;
        public CameraManMoveArgs CurrentCameraManMoveArgs;
        public bool CameraManRotating { get; set; } = false;
        public CameraManRotateArgs CurrentCameraManRotateArgs;
        public bool CameraManScaling { get; set; } = false;
        public CameraManScaleArgs CurrentCameraManScaleArgs;

        public static List<PhotoArgs> PhotoList = new();
        public Dictionary<PlayerActionEvent, PhotoArgs> EventArgs = new();
        public bool IsShowingPhotos { get; set; } = false;

        public static Dictionary<RiqEntity, PersonDirection> WalkerDirections = new();

        // UNITY BUILTIN METHODS
        void Start()
        {
            if (conductor != null && !conductor.isPlaying && !conductor.isPaused)
            {
                ClearPhotos();
            }
            CameraManStartPos = CameraMan.transform.localPosition;
        }
        void Update()
        {
            if (conductor != null && !conductor.isPlaying && !conductor.isPaused)
            {
                CameraMan.Play("Idle");
                IsShowingPhotos = false;
            }

            if (PlayerInput.GetIsAction(InputAction_BasicPress) && !IsExpectingInputNow(InputAction_BasicPress) && !IsShowingPhotos)
            {
                CameraFlash();
                //ScoreMiss();
            }

            // sign
            if (SignIsMoving)
            {
                float normalizedBeat = conductor.GetPositionFromBeat(CurrentSignArgs.StartTime, CurrentSignArgs.Length);
                Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(CurrentSignArgs.Ease);
                float newPos = func(0f, 1f, normalizedBeat);
                IntroSign.DoNormalizedAnimation(CurrentSignArgs.AnimName, newPos, animLayer: 0);
                if (normalizedBeat >= 1f)
                    SignIsMoving = false;
            }

            // move TJ
            if (CameraManMoving)
            {
                float normalizedBeat = conductor.GetPositionFromBeat(CurrentCameraManMoveArgs.StartBeat, CurrentCameraManMoveArgs.Length);
                Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(CurrentCameraManMoveArgs.Ease);
                float newPos = func(0f, 1f, normalizedBeat);

                Vector3 diff = CurrentCameraManMoveArgs.EndPos - CurrentCameraManMoveArgs.StartPos;
                Vector3 diffPos = newPos * diff;
                CameraMan.transform.localPosition = CurrentCameraManMoveArgs.StartPos + diffPos;

                if (normalizedBeat >= 1f)
                {
                    CameraMan.transform.localPosition = CurrentCameraManMoveArgs.EndPos;
                    CameraManMoving = false;
                }
            }
            if (CameraManRotating)
            {
                float normalizedBeat = conductor.GetPositionFromBeat(CurrentCameraManRotateArgs.StartBeat, CurrentCameraManRotateArgs.Length);
                Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(CurrentCameraManRotateArgs.Ease);
                float newPos = func(0f, 1f, normalizedBeat);

                float diff = CurrentCameraManRotateArgs.EndRot - CurrentCameraManRotateArgs.StartRot;
                float diffPos = newPos * diff;
                CameraMan.transform.localEulerAngles = new Vector3(0, 0, CurrentCameraManRotateArgs.StartRot + diffPos);

                if (normalizedBeat >= 1f)
                {
                    CameraMan.transform.localEulerAngles = new Vector3(0, 0, CurrentCameraManRotateArgs.EndRot);
                    CameraManRotating = false;
                }
            }
            if (CameraManScaling)
            {
                float normalizedBeat = conductor.GetPositionFromBeat(CurrentCameraManScaleArgs.StartBeat, CurrentCameraManScaleArgs.Length);
                Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(CurrentCameraManScaleArgs.Ease);
                float newPos = func(0f, 1f, normalizedBeat);

                Vector3 diff = CurrentCameraManScaleArgs.EndScale - CurrentCameraManScaleArgs.StartScale;
                Vector3 diffPos = newPos * diff;
                CameraMan.transform.localScale = CurrentCameraManScaleArgs.StartScale + diffPos;

                if (normalizedBeat >= 1f)
                {
                    CameraMan.transform.localScale = CurrentCameraManScaleArgs.EndScale;
                    CameraManScaling = false;
                }
            }

            // boppers
            if (Walkers.Count > 0)
            {
                Walkers.RemoveAll(w => w.Walker == null || w.Walker.gameObject == null);
                foreach (WalkerArgs args in Walkers)
                {
                    float normalizedBeat = conductor.GetPositionFromBeat(args.StartTime, args.Length);
                    args.Walker.DoNormalizedAnimation(args.AnimName, normalizedBeat, animLayer: 1);
                    if (normalizedBeat >= 1f)
                        Destroy(args.Walker.gameObject);
                }
            }

            // car animations (deprecated)
            /*if (QueuedCars.Count > 0)
            {
                var beat = conductor.songPositionInBeats;
                if (beat >= 0)
                {
                    QueuedCars.RemoveAll(e => e.Beat < beat - 5); // could probably be smaller. 5 just to be safe
                    foreach (SpawnCarArgs args in QueuedCars.Where(e => e.Beat <= beat))
                    {
                        SpawnCar(args);
                    }
                    QueuedCars.RemoveAll(e => e.Beat <= beat);
                }
            }*/

            if (!IsShowingPhotos)
                Instance.Overlay.SetActive(ShowOverlay);

            Billboards.SetActive(ShowBillboard);
            Instance.CameraMan.gameObject.SetActive(ShowCameraMan);
            StickyLayer.Sticky = OverlayFollowCamera;
        }
        private void OnDestroy()
        {
            foreach (var evt in scheduledInputs)
            {
                evt.Disable();
            }
            //if (PhotoList.Count > 0) PhotoList.Clear();
        }

        // MINIGAME METHODS
        public override void OnBeatPulse(double beat)
        {
            if (BeatIsInBopRegion(beat))
            {
                if (DoAutoBop && !IsShowingPhotos)
                    Bop();

                if (DoAutoCrosshairBlink)
                    CrosshairBlink();
            }
        }
        public override void OnPlay(double beat)
        {
            if (PhotoList.Count > 0) PhotoList.Clear();
            OnGameSwitch(beat);
        }
        public override void OnGameSwitch(double beat)
        {
            Instance.Overlay.SetActive(ShowOverlay);
            Instance.CameraMan.gameObject.SetActive(ShowCameraMan);
            Instance.StickyLayer.Sticky = OverlayFollowCamera;

            // calculation
            CarbageCollection();
            CalculateAutoShowPhotos();
            CalculateCarSpawns();
            PreRandomizeWalkers();

            // setting local variables
            RiqEntity e = GetLastEntityOfType(beat, "bop");
            if (e is not null)
            {
                DoAutoBop = e["autoBop"];
                DoAutoCrosshairBlink = e["autoBlink"];
            }
            e = GetLastEntityOfType(beat, "toggleOverlay");
            if (e is not null)
            {
                ShowOverlay = e["showOverlay"];
                ShowCameraMan = e["showCameraMan"];
                OverlayFollowCamera = e["followCamera"];
            }
            e = GetLastEntityOfType(beat, "spawnCrowd");
            if (e is not null)
            {
                ToggleCrowd(e.beat, e["crowd"], e["customCrowd"], e["crowdFarLeft"], e["crowdLeft"], e["crowdRight"], e["crowdFarRight"], e["billboard"]);
            }

            //  walkers
            List<RiqEntity> eList = GetCurrentlyActiveEntities(beat, "spawnPerson");
            if (eList.Count > 0)
            {
                foreach (RiqEntity entity in eList)
                {
                    SummonWalker(entity);
                }
            }

            // bop entities
            eList = GetCurrentlyActiveEntities(beat, "bop");
            if (eList.Count > 0)
            {
                foreach (RiqEntity entity in eList)
                {
                    SetBopping(entity.beat, entity.length, entity["bop"], entity["autoBop"], entity["blink"], entity["autoBlink"], beat);
                }
            }

            // Intro
            e = GetLastEntityOfType(beat, "introSign");
            if (e is not null)
            {
                DoIntroSign(e.beat, e.length, e["enter"], e["ease"]);
            }
            e = GetLastEntityOfType(beat, "introLights");
            if (e is not null)
            {
                IntroLightsAnim(e.beat, e.length, e["lightsOn"]);
            }

            // Camera Man Movement
            foreach (RiqEntity entity in EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { "neoMoveCameraMan", "moveCameraMan", "rotateCameraMan", "scaleCameraMan" }).OrderBy(en => en.beat).Where(en => en.beat <= beat))
            {
                switch (entity.datamodel)
                {
                    case "freezeFrame/moveCameraMan":
                        SetMoveCameraMan_OLD(entity.beat, entity.length, entity["startPosX"], entity["startPosY"], entity["endPosX"], entity["endPosY"], entity["ease"]);
                        break;
                    case "freezeFrame/rotateCameraMan":
                        FreezeFrame.SetRotateCameraMan_OLD(entity.beat, entity.length, entity["startRot"], entity["endRot"], entity["ease"]);
                        break;
                    case "freezeFrame/scaleCameraMan":
                        SetScaleCameraMan_OLD(entity.beat, entity.length, entity["startSizeX"], entity["startSizeY"], entity["endSizeX"], entity["endSizeY"], entity["ease"]);
                        break;
                    case "freezeFrame/neoMoveCameraMan":
                    default:
                        SetMoveCameraMan(entity);
                        break;
                }
            }
            // Deprecated:
            /*e = GetLastEntityOfType(beat, "moveCameraMan");
            if (e is not null)
            {
                SetMoveCameraMan_OLD(e.beat, e.length, e["startPosX"], e["startPosY"], e["endPosX"], e["endPosY"], e["ease"]);
            }
            e = GetLastEntityOfType(beat, "rotateCameraMan");
            if (e is not null)
            {
                SetRotateCameraMan_OLD(e.beat, e.length, e["startRot"], e["endRot"], e["ease"]);
            }
            e = GetLastEntityOfType(beat, "scaleCameraMan");
            if (e is not null)
            {
                SetScaleCameraMan_OLD(e.beat, e.length, e["startSizeX"], e["startSizeY"], e["endSizeX"], e["endSizeY"], e["ease"]);
            }*/

            // cues
            eList = GetCurrentlyActiveEntities(beat, new string[] { "slowCar", "fastCar" });
            if (eList.Count > 0)
            {
                foreach (RiqEntity entity in eList)
                {
                    if (beat > entity.beat + 2 || beat <= entity.beat)
                        continue;
                    
                    if (entity.datamodel == "freezeFrame/slowCar")
                    {
                        SlowCarCue(entity.beat, entity["variant"], true, entity["clear"]);
                    }
                    if (entity.datamodel == "freezeFrame/fastCar")
                    {
                        FastCarCue(entity.beat, entity["variant"], true, entity["clear"]);
                    }
                }
            }
        }

        // CUE FUNCTIONS
        public static void SetBopping(double beat, float length, bool bop, bool autoBop, bool blink, bool autoBlink, double currentBeat = -1)
        {
            if (Instance == null) return;

            Instance.DoAutoBop = autoBop;
            Instance.DoAutoCrosshairBlink = autoBlink;

            if (bop || blink)
            {
                List<BeatAction.Action> actions = new List<BeatAction.Action>();
                for (int i = 0; i < length; i++) {
                    if (beat + i < currentBeat)
                        continue;
                    if (bop)
                        actions.Add(new(beat + i, delegate { Instance.Bop(); }));
                    if (blink)
                        actions.Add(new(beat + i, delegate { Instance.CrosshairBlink(); }));
                }
                BeatAction.New(Instance, actions);
            }
        }
        public static void SlowCarCue(double beat, int photoType, bool mute = false, bool clear = false)
        {
            if (!mute) SlowCarSFX();

            if (Instance == null) return;

            Instance.EventArgs.Add(
                Instance.ScheduleInput(beat, 2f, InputAction_BasicPress, Instance.PhotoSuccess, Instance.PhotoMiss, Instance.PhotoEmpty),
                new PhotoArgs(CarType.SlowCar, (PhotoType)photoType, 0f, clear)
            );
        }
        public static void SlowCarSFX()
        {
            SoundByte.PlayOneShotGame("freezeFrame/slowCarFar", forcePlay: true);
        }
        public static void FastCarCue(double beat, int photoType, bool mute = false, bool clear = false)
        {
            if (!mute) FastCarSFX();

            if (Instance == null) return;

            Instance.EventArgs.Add(
                Instance.ScheduleInput(beat, 2f, InputAction_BasicPress, Instance.PhotoSuccess, Instance.PhotoMiss, Instance.PhotoEmpty),
                new PhotoArgs(CarType.FastCar, (PhotoType)photoType, 0f, clear)
            );
            SoundByte.PlayOneShotGame("freezeFrame/fastCarNear", beat + 2);
        }
        public static void FastCarSFX()
        {
            SoundByte.PlayOneShotGame("freezeFrame/fastCarFar", forcePlay: true);
        }
        public static void ShowPhotos(double beat, float length, int gradeTypeI, bool audience, bool clearCache)
        {
            if (Instance == null) return;

            GradeType gradeType = (GradeType)gradeTypeI;

            if (PhotoList.Count <= 0)
                return;
            
            SoundByte.PlayOneShotGame("freezeFrame/pictureShow");

            // 2 = Hi
            // 1 = OK
            // 0 = Ng
            int goodScore = 2;
            foreach (PhotoArgs photo in PhotoList)
            {
                if (photo.State <= -2)
                {
                    goodScore = 0;
                    break;
                }
                if (goodScore == 2 && photo.State != 0)
                    goodScore = 1;
            }

            if (gradeType == GradeType.Symbols)
            {
                switch (goodScore)
                {
                    case 0:
                        Instance.Results.DoScaledAnimationAsync("Batsu", 0.5f);
                        break;

                    case 1:
                        Instance.Results.DoScaledAnimationAsync("Sankaku", 0.5f);
                        break;

                    case 2:
                    default:
                        Instance.Results.DoScaledAnimationAsync("Maru", 0.5f);
                        break;
                }
            }
            if (gradeType == GradeType.Thumbs)
            {
                switch (goodScore)
                {
                    case 0:
                        Instance.Results.DoScaledAnimationAsync("ThumbsDown", 0.5f);
                        break;

                    case 1:
                        Instance.Results.DoScaledAnimationAsync("ThumbsSide", 0.5f);
                        break;

                    case 2:
                    default:
                        Instance.Results.DoScaledAnimationAsync("ThumbsUp", 0.5f);
                        break;
                }
            }

            for (int i = 0; i < PhotoList.Count && i < Instance.Photographs.Length; i++)
            {
                Instance.Photographs[i].ShowPhoto(PhotoList[i]);
            }
            
            if (clearCache)
                PhotoList.Clear();

            Instance.Overlay.SetActive(false);
            Instance.DimRect.SetActive(true);
            Instance.IsShowingPhotos = true;

            // reactions sounds
            switch (goodScore)
            {
                case 2:
                    Instance.CameraMan.DoScaledAnimationAsync("Happy", 0.5f);
                    SoundByte.PlayOneShotGame("freezeFrame/result_Hi");
                    if (audience)
                        break;
                    break;
                case 1:
                    Instance.CameraMan.DoScaledAnimationAsync("Oops", 0.5f);
                    SoundByte.PlayOneShotGame("freezeFrame/result_Ok");
                    if (audience)
                        SoundByte.PlayOneShot("applause");
                    break;
                case 0:
                    Instance.CameraMan.DoScaledAnimationAsync("Cry", 0.5f);
                    SoundByte.PlayOneShotGame("freezeFrame/result_Ng");
                    if (audience)
                        break;
                    break;
                default:
                    break;
            }

            BeatAction.New(Instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + length, delegate { Instance.HidePhotos(beat + length); })
            });
        }
        public static void ClearPhotos()
        {
            PhotoList?.Clear();
        }
        public static void SummonWalker(RiqEntity e)
        {
            if (Instance == null) return;

            double beat = e.beat;
            double length = e.length;
            PersonType walkerType = (PersonType)e["personType"];
            PersonDirection direction = (PersonDirection)e["direction"];
            int layer = e["layer"];

            GameObject walker = Instantiate(Instance.WalkerPrefab, Instance.WalkerSpawn.transform);
            Animator animator = walker.GetComponent<Animator>();
            walker.GetComponent<SortingGroup>().sortingOrder = layer;

            switch (walkerType)
            {
                case PersonType.Girlfriend:
                    animator.DoScaledAnimationAsync("Girlfriend", animLayer: 2);
                    break;
                case PersonType.Dude2:
                    animator.DoScaledAnimationAsync("Dude2", animLayer: 2);
                    break;
                case PersonType.Dude1:
                default:
                    animator.DoScaledAnimationAsync("Dude1", animLayer: 2);
                    break;
            }

            if (direction == PersonDirection.Random)
            {
                if (WalkerDirections.ContainsKey(e))
                    direction = WalkerDirections[e];
                else
                    direction = PersonDirection.Right;
            }

            if (direction == PersonDirection.Left)
                Instance.Walkers.Add(new WalkerArgs(animator, beat, length, "EnterLeft"));
            else
                Instance.Walkers.Add(new WalkerArgs(animator, beat, length, "EnterRight"));

            double nextBeat = Math.Ceiling(beat);
            List<BeatAction.Action> actions = new();
            for (double i = nextBeat; i < beat + length; i += 1)
            {
                actions.Add(new(i, delegate { animator.DoScaledAnimationAsync("Bop", timeScale: 0.5f, animLayer: 0); }));
            }
            BeatAction.New(Instance, actions);
        }
        public static void ToggleCrowd(double beat, bool showCrowd, bool customCrowd, int crowdFarLeft, int crowdLeft, int crowdRight, int crowdFarRight, bool billboard)
        {
            if (Instance == null) return;

            Instance.ShowCrowd = showCrowd;
            if (Instance.ShowCrowd)
                Instance.Crowd.DoScaledAnimationAsync("Show", 0.5f);
            else
                Instance.Crowd.DoScaledAnimationAsync("Hide", 0.5f);
            
            if (customCrowd)
            {
                Instance.CrowdFarLeft.sprite  = Instance.GetCrowdSprite(crowdFarLeft);
                Instance.CrowdLeft.sprite     = Instance.GetCrowdSprite(crowdLeft);
                Instance.CrowdRight.sprite    = Instance.GetCrowdSprite(crowdRight);
                Instance.CrowdFarRight.sprite = Instance.GetCrowdSprite(crowdFarRight);
            }
            else
            {
                Instance.CrowdFarLeft.sprite  = Instance.GetCrowdSprite(2);
                Instance.CrowdLeft.sprite     = Instance.GetCrowdSprite(1);
                Instance.CrowdRight.sprite    = Instance.GetCrowdSprite(0);
                Instance.CrowdFarRight.sprite = Instance.GetCrowdSprite(2);
            }

            Instance.ShowBillboard = billboard;
        }
        public static void DoIntroSign(double beat, double length, bool enter, int easeIndex)
        {
            Util.EasingFunction.Ease ease = (Util.EasingFunction.Ease)easeIndex;
            Instance.SignIsMoving = true;
            if (enter)
                Instance.CurrentSignArgs = new("Enter", beat, length, ease);
            else
                Instance.CurrentSignArgs = new("Exit", beat, length, ease);
        }
        public static void IntroLightsAnim(double beat, double length, bool lightsOn)
        {
            if (!lightsOn)
            {
                Instance.IntroSign.DoScaledAnimationAsync("LightsOff", timeScale: 0.5f, animLayer: 1);
                return;
            }

            Instance.IntroSign.DoScaledAnimationFromBeatAsync("Light01", startBeat: beat, timeScale: 0.5f, animLayer: 1);
            BeatAction.New(Instance, new List<BeatAction.Action>
                {
                    new(beat + length, delegate { Instance.IntroSign.DoScaledAnimationFromBeatAsync("Light02", startBeat: beat + length, timeScale: 0.5f, animLayer: 1); }),
                    new(beat + (length * 2), delegate { Instance.IntroSign.DoScaledAnimationFromBeatAsync("Light03", startBeat: beat + (length * 2), timeScale: 0.5f, animLayer: 1); }),
                }
            );
        }
        public static void IntroLightsSound(double beat, double length, bool lightsOn)
        {
            if (!lightsOn)
                return;

            MultiSound.Play(new MultiSound.Sound[] {
                new MultiSound.Sound("freezeFrame/beginningSignal1", beat),
                new MultiSound.Sound("freezeFrame/beginningSignal1", beat + length),
                new MultiSound.Sound("freezeFrame/beginningSignal2", beat + (length * 2)),
            }, forcePlay: true);
        }
        public static void ToggleOverlay(double beat, bool showOverlay, bool showCameraMan, bool followCamera)
        {
            Instance.ShowOverlay = showOverlay;
            Instance.ShowCameraMan = showCameraMan;
            Instance.OverlayFollowCamera = followCamera;
        }
        public static void SetMoveCameraMan(RiqEntity e)
        {
            if ((bool)e["doMove"])
            {
                SetMoveCameraMan_OLD(e.beat, e.length, e["startMoveX"], e["startMoveY"], e["endMoveX"], e["endMoveY"], e["ease"]);
            }
            if ((bool)e["doRotate"])
            {
                SetRotateCameraMan_OLD(e.beat, e.length, e["startRotDegrees"], e["endRotDegrees"], e["ease"]);
            }
            if ((bool)e["doScale"])
            {
                SetScaleCameraMan_OLD(e.beat, e.length, e["startScaleX"], e["startScaleY"], e["endScaleX"], e["endScaleY"], e["ease"]);
            }
        }
        public static void SetMoveCameraMan_OLD(double beat, double length, float startX, float startY, float endX, float endY, int easeIndex)
        {
            Instance.CurrentCameraManMoveArgs = new(
                beat,
                length,
                new Vector3(startX, startY, 0) + CameraManStartPos,
                new Vector3(endX, endY, 0) + CameraManStartPos,
                (Util.EasingFunction.Ease)easeIndex
            );
            Instance.CameraManMoving = true;
        }
        public static void SetRotateCameraMan_OLD(double beat, double length, float startRot, float endRot, int easeIndex)
        {
            Instance.CurrentCameraManRotateArgs = new(
                beat,
                length,
                startRot,
                endRot,
                (Util.EasingFunction.Ease)easeIndex
            );
            Instance.CameraManRotating = true;
        }
        public static void SetScaleCameraMan_OLD(double beat, double length, float startX, float startY, float endX, float endY, int easeIndex)
        {
            Instance.CurrentCameraManScaleArgs = new(
                beat,
                length,
                new Vector3(startX, startY, 1),
                new Vector3(endX, endY, 1),
                (Util.EasingFunction.Ease)easeIndex
            );
            Instance.CameraManScaling = true;
        }

        // PRE-FUNCTIONS
        public void SpawnCar(double beat, bool near, string animName, float length)
        {
            if (near)
            {
                if (NearCarPrefab == null || NearCarSpawn == null)
                {
                    Debug.LogError($"Failed to spawn car at beat {beat - 1}.");
                    return;
                }

                Instantiate(NearCarPrefab, NearCarSpawn).GetComponent<Car>().Setup(beat, animName, length);;
            }
            else
            {
                if (FarCarPrefab == null || FarCarSpawn == null)
                {
                    Debug.LogError($"Failed to spawn car at beat {beat - 1}.");
                    return;
                }

                Instantiate(FarCarPrefab, FarCarSpawn).GetComponent<Car>().Setup(beat, animName, length);;
            }
        }
        /*public void SpawnCar(SpawnCarArgs args)
        {
            if (args.Near)
            {
                if (NearCarSpawn == null)
                {
                    UnityEngine.Debug.LogError($"Failed to spawn a car at beat {args.Beat}.");
                    return;
                }
                Animator car = Instantiate(NearCarPrefab, NearCarSpawn).GetComponent<Animator>();
                car.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);
                
                if (args.Fast)
                    car.DoScaledAnimationFromBeatAsync("FastCarGo", startBeat: args.Beat, timeScale: 2.666666666666667f, animLayer: 1);
                else
                    car.DoScaledAnimationFromBeatAsync("SlowCarGo", startBeat: args.Beat, timeScale: 1.5f, animLayer: 1);

                //BeatAction.New(Instance, new List<BeatAction.Action>() { new BeatAction.Action(args.Beat + 3, delegate { Destroy(car); }) });
            }
            else
            {
                if (FarCarSpawn == null)
                {
                    UnityEngine.Debug.LogError($"Failed to spawn a car at beat {args.Beat}.");
                    return;
                }
                Animator car = Instantiate(FarCarPrefab, FarCarSpawn).GetComponent<Animator>();
                car.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);

                if (args.Fast)
                    car.DoScaledAnimationFromBeatAsync("FastCarGo", startBeat: args.Beat, timeScale: 0.5f, animLayer: 1);
                else
                    car.DoScaledAnimationFromBeatAsync("SlowCarGo", startBeat: args.Beat, timeScale: 0.16666666666666666666666666666667f, animLayer: 1);

                //BeatAction.New(Instance, new List<BeatAction.Action>() { new BeatAction.Action(args.Beat + 8, delegate { Destroy(car); }) });
            }
        }*/
        /*public void SpawnSlowCarNear(double beat)
        {
            if (NearCarSpawn == null) return;
            Animator nearCar = Instantiate(NearCarPrefab, NearCarSpawn).GetComponent<Animator>();
            nearCar.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);

            double startBeat = beat + 2 - 0.16666666666666666666666666666667;
            BeatAction.New(Instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(startBeat, delegate { nearCar.DoScaledAnimationFromBeatAsync("SlowCarGo", startBeat: startBeat, timeScale: 1.5f, animLayer: 1); }),
                new BeatAction.Action(beat + 3, delegate { Destroy(nearCar); } )
            });
        }
        public void SpawnSlowCarFar(double beat)
        {
            //if (beat < 0) return;
            if (FarCarSpawn == null) return;
            Animator farCar = Instantiate(FarCarPrefab, FarCarSpawn).GetComponent<Animator>();
            farCar.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);
            farCar.DoScaledAnimationFromBeatAsync("SlowCarGo", startBeat: beat, timeScale: 0.16666666666666666666666666666667f, animLayer: 1);

            BeatAction.New(Instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 7, delegate { Destroy(farCar); } )
            });
        }
        public void SpawnFastCar(double beat)
        {
            if (FarCarSpawn != null)
            {
                UnityEngine.Debug.Log("farcar");
                Animator farCar = Instantiate(FarCarPrefab, FarCarSpawn).GetComponent<Animator>();
                farCar.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);
                
                BeatAction.New(Instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat - 0.5, delegate { if (beat >= 0.5) farCar.DoScaledAnimationFromBeatAsync("FastCarGo", startBeat: beat - 0.5, timeScale: 0.5f, animLayer: 1); }),
                    new BeatAction.Action(beat + 3, delegate { Destroy(farCar); } )
                });
            }
            if (NearCarSpawn != null)
            {
                UnityEngine.Debug.Log("fartcar");
                Animator nearCar = Instantiate(NearCarPrefab, NearCarSpawn).GetComponent<Animator>();
                nearCar.DoScaledAnimationFromBeatAsync("Idle", startBeat: 0f, timeScale: 0.5f, animLayer: 0);
                
                BeatAction.New(Instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat + 2 - 0.09375, delegate { nearCar.DoScaledAnimationFromBeatAsync("FastCarGo", startBeat: beat - 0.09375, timeScale: 2.666666666666667f, animLayer: 1); }),
                    new BeatAction.Action(beat + 3, delegate { Destroy(nearCar); } )
                });
            }
        }*/

        // INPUT RESULTS
        public void PhotoSuccess(PlayerActionEvent caller, float state)
        {
            PhotoArgs args;
            bool hasArgs = EventArgs.TryGetValue(caller, out args);
            EventArgs.Remove(caller);

            // passing the args for the photos
            if (hasArgs)
            {
                if (state >= 1f)
                {
                    args.State = 1;
                }
                else if (state <= -1f)
                {
                    args.State = -1;
                }
                else
                {
                    args.State = 0;
                }

                PushPhoto(args);
            }
            CameraFlash();
        }
        public void PhotoMiss(PlayerActionEvent caller)
        {
            PhotoArgs args;
            bool hasArgs = EventArgs.TryGetValue(caller, out args);
            EventArgs.Remove(caller);

            if (hasArgs)
            {
                args.State = -2;
                PushPhoto(args);
            }
        }
        public void PhotoEmpty(PlayerActionEvent caller)
        {
            
        }

        // GENERAL METHODS
        public void Bop()
        {
            CameraMan.DoScaledAnimationAsync("Bop", 0.5f);
        }
        public void CrosshairBlink()
        {
            Crosshair.SetActive(!Crosshair.activeSelf);
        }
        public void CameraFlash()
        {
            Shutter.DoScaledAnimationAsync("Shut", 0.5f);
            CameraMan.DoScaledAnimationAsync("Flash", 0.5f);
            SoundByte.PlayOneShotGame("freezeFrame/shutter"/*, pitch: (float)new System.Random().NextDouble() + 0.5f*/);
        }
        public void PushPhoto(PhotoArgs args)
        {
            if (args.ClearPhotos)
                ClearPhotos();

            if (args.PhotoType == PhotoType.Random)
            {
                if (UnityEngine.Random.Range(0, 8) >= 7)
                {
                    switch (UnityEngine.Random.Range(0, 3))
                    {
                        case 0:
                            args.PhotoType = PhotoType.Ninja;
                            break;
                        case 1:
                            args.PhotoType = PhotoType.Ghost;
                            break;
                        case 2:
                            args.PhotoType = PhotoType.Rats;
                            break;
                        default:
                            args.PhotoType = PhotoType.Default;
                            break;
                    }
                }
                else
                    args.PhotoType = PhotoType.Default;
            }

            PhotoList.Add(args);
        }
        public void HidePhotos(double beat)
        {
            Overlay.SetActive(ShowOverlay);
            DimRect.SetActive(false);
            foreach (Photograph photo in Photographs)
                photo.HideAll();
            Results.DoScaledAnimationAsync("None", 0.5f);
            IsShowingPhotos = false;
            if (beat % 1 == 0 && DoAutoBop)
                CameraMan.DoScaledAnimationAsync("Bop", 0.5f);
            else
                CameraMan.DoScaledAnimationAsync("Idle", 0.5f);
        }
        public Sprite GetCrowdSprite(int i)
        {
            if (CrowdSprites.Length <= 0)
            {
                Debug.LogError("Error from Freeze Frame: CrowdSprites was empty.");
                return null;
            }
            else
            {
                // just looping back thru the array jic there's an invalid index
                return CrowdSprites[i % CrowdSprites.Length];
            }
        }
        public void CalculateAutoShowPhotos()
        {
            List<RiqEntity> allCars = EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { "slowCar", "fastCar" });

            List<BeatAction.Action> actions = new();
            List<double> beats = new(); // so you don't double up

            foreach (RiqEntity entity in allCars.Where(car => (bool)car["autoShowPhotos"]))
            {
                double showBeat = 3f;
                if (allCars.Any(car => car.beat == entity.beat - 1f))
                    showBeat = 3.5f;
                if (entity.datamodel == "freezeFrame/fastCar")
                    showBeat = 4f;
                if (allCars.Any(car => car.beat == entity.beat - 2f))
                    showBeat = 4.5f;
                showBeat = entity.beat + showBeat;
                
                if (!allCars.Any(car => car.beat > entity.beat && car.beat <= showBeat))
                {
                    if (!beats.Any(b => showBeat >= b && showBeat < b + 2))
                    {
                        beats.Add(showBeat);
                        actions.Add(new BeatAction.Action(showBeat, delegate { ShowPhotos(showBeat, 2, (int)entity["gradeType"], (bool)entity["audience"], false); }));
                    }
                }
            }

            if (actions.Count > 0)
            {
                BeatAction.New(Instance, actions);
            }
        }
        public void CalculateCarSpawns()
        {
            List<RiqEntity> fastCars = EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { "fastCar" });
            foreach (RiqEntity e in fastCars)
            {
                BeatAction.New(this, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(e.beat - 0.5, delegate { SpawnCar(e.beat - 0.5, false, "FastCarGo", 1); }),
                    new BeatAction.Action(e.beat + 2 - 0.09375, delegate { SpawnCar(e.beat + 2 - 0.09375, true, "FastCarGo", 3f / 16f); }),
                });
            }

            List<RiqEntity> slowCars = EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { "slowCar" });
            foreach (RiqEntity e in slowCars)
            {
                BeatAction.New(this, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(e.beat + 2 - 0.16666666666666666666666666666667, delegate { SpawnCar(e.beat + 2 - 0.16666666666666666666666666666667, true, "SlowCarGo", 1f / 3f); })
                });
            }

            List<List<double>> clusters = new();

            while (slowCars.Count > 0)
            {
                double minBeat = slowCars[0].beat;
                double maxBeat = minBeat + 2;

                clusters.Add(slowCars.Where(car => car.beat >= minBeat && car.beat < maxBeat).Select(car => car.beat).ToList());
                slowCars.RemoveAll(car => car.beat >= minBeat && car.beat < maxBeat);
            }

            foreach (List<double> cluster in clusters)
            {
                double midBeat = cluster.Min() + ((cluster.Max() - cluster.Min()) / 2);

                foreach (double beat in cluster)
                {
                    double diff = midBeat - beat;
                    double modifiedBeat = midBeat + (diff / 4);

                    BeatAction.New(this, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(modifiedBeat - 4, delegate { SpawnCar(modifiedBeat - 4, false, "SlowCarGo", 3f); })
                    });
                }
            }
        }
        public void PreRandomizeWalkers()
        {
            IEnumerable<RiqEntity> walkers = EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { "spawnPerson" }).Where(e => (PersonDirection)e["direction"] == PersonDirection.Random);
            foreach (RiqEntity e in walkers)
            {
                if (!WalkerDirections.ContainsKey(e))
                {
                    float rand = UnityEngine.Random.Range(0.0f, 1.0f);
                    if (rand >= 0.5)
                    {
                        WalkerDirections.Add(e, PersonDirection.Left);
                    }
                    else
                    {
                        WalkerDirections.Add(e, PersonDirection.Right);
                    }
                }
            }
            List<RiqEntity> keysToRemove = new();
            foreach (RiqEntity key in WalkerDirections.Keys)
            {
                if (!walkers.Contains(key))
                    keysToRemove.Add(key);
            }
            foreach (RiqEntity key in keysToRemove)
            {
                WalkerDirections.Remove(key);
            }
        }
        public void CarbageCollection()
        {
            foreach (Transform child in FarCarSpawn)
            {
                Destroy(child.gameObject);
            }
            foreach (Transform child in NearCarSpawn)
            {
                Destroy(child.gameObject);
            }
            foreach (Transform child in WalkerSpawn)
            {
                Destroy(child.gameObject);
            }
        }
        public RiqEntity GetLastEntityOfType(double beat, string datamodel)
        {
            foreach (RiqEntity e in EventCaller.GetAllInGameManagerList("freezeFrame", new string[] { datamodel }).OrderBy(e => -e.beat))
            {
                if (e.beat < beat)
                    return e;
            }
            return null;
        }
        public List<RiqEntity> GetCurrentlyActiveEntities(double beat, string datamodel)
        {
            return GetCurrentlyActiveEntities(beat, new string[] { datamodel });
        }
        public List<RiqEntity> GetCurrentlyActiveEntities(double beat, string[] datamodel)
        {
            List<RiqEntity> result = new();
            foreach (RiqEntity e in EventCaller.GetAllInGameManagerList("freezeFrame", datamodel))
            {
                if (beat >= e.beat && beat <= e.beat + e.length)
                    result.Add(e);
                if (e.beat > beat)
                    break;
            }
            return result;
        }

        // ENUMS
        public enum CarType : int
        {
            SlowCar = 0,
            FastCar = 1
        }
        public enum PhotoType : int
        {
            Random = 0,
            Default = 1,
            Ninja = 2,
            Ghost = 3,
            Rats = 4,
            PeaceSign = 5,
            GirlfriendRight = 6,
            GirlfriendLeft = 7,
            Dude1Right = 8,
            Dude1Left = 9,
            Dude2Right = 10,
            Dude2Left = 11,
        }
        public enum PersonType : int
        {
            Dude1 = 0,
            Dude2 = 1,
            Girlfriend = 2
        }
        public enum PersonDirection : int
        {
            Random = 0,
            Right = 1,
            Left = 2
        }
        public enum GradeType : int
        {
            Symbols = 0,
            Thumbs = 1,
            None = 2
        }
        public enum CustomCrowdType : int
        {
            TealDancers = 0,
            YellowDancers = 1,
            PinkDancers = 2,
            CyanDancers = 3,
        }

        // STRUCTS
        public struct PhotoArgs
        {
            public CarType Car;
            public PhotoType PhotoType;
            public float State;
            public bool ClearPhotos;

            public PhotoArgs(CarType car, PhotoType photoType, float state, bool clear)
            {
                Car = car;
                PhotoType = photoType;
                State = state;
                ClearPhotos = clear;
            }
        }
        public struct WalkerArgs
        {
            public Animator Walker;
            public double StartTime;
            public double Length;
            public string AnimName;

            public WalkerArgs(Animator walker, double startTime, double length, string animName)
            {
                Walker = walker;
                StartTime = startTime;
                Length = length;
                AnimName = animName;
            }
        }
        public struct SignMoveArgs
        {
            public string AnimName;
            public double StartTime;
            public double Length;
            public Util.EasingFunction.Ease Ease;

            public SignMoveArgs(string animName, double startTime, double length, Util.EasingFunction.Ease ease)
            {
                AnimName = animName;
                StartTime = startTime;
                Length = length;
                Ease = ease;
            }
        }
        public struct CameraManMoveArgs
        {
            public double StartBeat;
            public double Length;
            public Vector3 StartPos;
            public Vector3 EndPos;
            public Util.EasingFunction.Ease Ease;

            public CameraManMoveArgs(double startBeat, double length, Vector3 startPos, Vector3 endPos, Util.EasingFunction.Ease ease)
            {
                StartBeat = startBeat;
                Length = length;
                StartPos = startPos;
                EndPos = endPos;
                Ease = ease;
            }
        }
        public struct CameraManRotateArgs
        {
            public double StartBeat;
            public double Length;
            public float StartRot;
            public float EndRot;
            public Util.EasingFunction.Ease Ease;

            public CameraManRotateArgs(double startBeat, double length, float startRot, float endRot, Util.EasingFunction.Ease ease)
            {
                StartBeat = startBeat;
                Length = length;
                StartRot = startRot;
                EndRot = endRot;
                Ease = ease;
            }
        }
        public struct CameraManScaleArgs
        {
            public double StartBeat;
            public double Length;
            public Vector3 StartScale;
            public Vector3 EndScale;
            public Util.EasingFunction.Ease Ease;

            public CameraManScaleArgs(double startBeat, double length, Vector3 startScale, Vector3 endScale, Util.EasingFunction.Ease ease)
            {
                StartBeat = startBeat;
                Length = length;
                StartScale = startScale;
                EndScale = endScale;
                Ease = ease;
            }
        }
    }
}

// This minigame ported by Yin. ☆