HeavenStudioPlus/Assets/Scripts/Games/Ringside/Ringside.cs

using HeavenStudio.Util;
using HeavenStudio.InputSystem;
using System;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using Jukebox;

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    public static class RvlRingsideLoader
    {
        public static Minigame AddGame(EventCaller eventCaller)
        {
            return new Minigame("ringside", "Ringside", "6bdfe7", false, false, new List<GameAction>()
            {
                new GameAction("question", "Question")
                {
                    function = delegate {var e = eventCaller.currentEntity; Ringside.instance.Question(e.beat, e["alt"], e["variant"]); },
                    parameters = new List<Param>()
                    {
                        new Param("alt", false, "Alt", "Whether the alt voice line should be used or not."),
                        new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
                    },
                    defaultLength = 4f
                },
                new GameAction("woahYouGoBigGuy", "Woah You Go Big Guy!")
                {
                    function = delegate {var e = eventCaller.currentEntity; Ringside.instance.BigGuy(e.beat, e["variant"]); },
                    parameters = new List<Param>()
                    {
                        new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
                    },
                    defaultLength = 4f
                },
                new GameAction("poseForTheFans", "Pose For The Fans!")
                {
                    preFunction = delegate {var e = eventCaller.currentEntity; Ringside.PoseForTheFans(e.beat, e["and"], e["variant"], e["keepZoomedOut"], e["newspaperBeats"]); },
                    parameters = new List<Param>()
                    {
                        new Param("and", false, "And", "Whether the And voice line should be said or not."),
                        new Param("variant", Ringside.PoseForTheFansVariant.Random, "Variant", "Which variant of the cue do you wish to play."),
                        new Param("keepZoomedOut", false, "Keep Zoomed Out", "Whether the camera should keep being zoomed out after the event has completed."),
                        new Param("newspaperBeats", new EntityTypes.Float(0, 80, 0), "Newspaper Beats", "How many beats should the newspaper stay for?"),
                        new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Camera Ease", "What ease should the camera use?"),
                    },
                    defaultLength = 4f
                },
                new GameAction("toggleBop", "Bop")
                {
                    function = delegate {var e = eventCaller.currentEntity; Ringside.instance.ToggleBop(e.beat, e.length, e["bop2"], e["bop"]); },
                    parameters = new List<Param>()
                    {
                        new Param("bop2", true, "Bop?", "Whether the wrestler should bop or not."),
                        new Param("bop", false, "Bop? (Auto)", "Whether the wrestler should bop automatically or not."),
                    },
                    resizable = true,
                },
                new GameAction("toggleSweat", "Toggle Sweat")
                {
                    function = delegate {var e = eventCaller.currentEntity; Ringside.instance.ToggleSweat(e["sweat"]); },
                    parameters = new List<Param>()
                    {
                        new Param("sweat", false, "Sweat?", "Whether the wrestler should sweat or not."),
                    },
                    defaultLength = 0.5f
                },
                new GameAction("questionScaled", "Question (Stretchable)")
                {
                    function = delegate {var e = eventCaller.currentEntity; Ringside.instance.Question(e.beat, e["alt"], e["variant"], e.length); },
                    preFunction = delegate {if (Ringside.instance == null) return; var e = eventCaller.currentEntity; Ringside.instance.PreQuestion(e.beat, e["variant"], e.length); },
                    parameters = new List<Param>()
                    {
                        new Param("alt", false, "Alt", "Whether the alt voice line should be used or not."),
                        new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
                    },
                    defaultLength = 4f,
                    resizable = true
                },
            },
            new List<string>() {"rvl", "normal"},
            "rvlinterview", "en",
            new List<string>() {"en"}
            );
        }
    }
}

namespace HeavenStudio.Games
{
    public class Ringside : Minigame
    {
        private static Color _defaultBGColorLight;
        public static Color defaultBGColorLight
        {
            get
            {
                ColorUtility.TryParseHtmlString("#5a5a5a", out _defaultBGColorLight);
                return _defaultBGColorLight;
            }
        }

        [Header("Components")]
        [SerializeField] Animator wrestlerAnim;
        [SerializeField] Animator reporterAnim;
        [SerializeField] Animator audienceAnim;
        [SerializeField] Animator wrestlerNewspaperAnim;
        [SerializeField] Animator reporterNewspaperAnim;
        [SerializeField] SpriteRenderer flashWhite;
        [SerializeField] SpriteRenderer blackVoid;
        [SerializeField] GameObject flashObject;
        [SerializeField] GameObject poseFlash;
        [SerializeField] GameObject newspaper;
        [SerializeField] Transform wrestlerTransform;
        [SerializeField] SpriteRenderer bg;
        [SerializeField] ParticleSystem flashParticles;
        [SerializeField] ParticleSystem sweatParticles;

        [Header("Variables")]
        public static List<QueuedPose> queuedPoses = new List<QueuedPose>();
        public struct QueuedPose
        {
            public double beat;
            public bool keepZoomedOut;
            public float newspaperBeats;
        }
        Tween flashTween;
        Tween bgTween;
        public enum QuestionVariant
        {
            First = 1,
            Second = 2,
            Third = 3,
            Random = 4,
        }
        public enum PoseForTheFansVariant
        {
            First = 1,
            Second = 2,
            Random = 3
        }
        private float currentZoomCamBeat;
        private Vector3 lastCamPos = new Vector3(0, 0, -10);
        private Vector3 currentCamPos = new Vector3(0, 0, -10);
        private bool shouldBop = true;
        private bool missedBigGuy;
        private bool reporterShouldHeart;
        private bool hitPose;
        private bool shouldNotInput;
        private bool keepZoomOut;
        private bool canBop = true;
        private Sound kidsLaugh;
        private int currentPose;
        private Util.EasingFunction.Ease lastEase;
        private GameObject currentNewspaper;

        private int currentZoomIndex;

        private List<RiqEntity> allCameraEvents = new List<RiqEntity>();

        public GameEvent bop = new GameEvent();

        public static Ringside instance;

        const int IAAltDownCat = IAMAXCAT;

        protected static bool IA_PadAltPress(out double dt)
        {
            return PlayerInput.GetPadDown(InputController.ActionsPad.South, out dt);
        }
        protected static bool IA_BatonAltPress(out double dt)
        {
            return PlayerInput.GetSqueezeDown(out dt);
        }
        protected static bool IA_TouchAltPress(out double dt)
        {
            return PlayerInput.GetTouchDown(InputController.ActionsTouch.Tap, out dt)
                && instance.IsExpectingInputNow(InputAction_Alt);
        }

        public static PlayerInput.InputAction InputAction_Alt =
            new("RvlInterviewAlt", new int[] { IAAltDownCat, IAAltDownCat, IAAltDownCat },
            IA_PadAltPress, IA_TouchAltPress, IA_BatonAltPress);

        void OnDestroy()
        {
            if (queuedPoses.Count > 0) queuedPoses.Clear();
            SoundByte.KillLoop(kidsLaugh, 2f);
            foreach (var evt in scheduledInputs)
            {
                evt.Disable();
            }
        }

        public override void OnTimeChange()
        {
            UpdateCameraZoom();
        }

        void Awake()
        {
            instance = this;
            var camEvents = EventCaller.GetAllInGameManagerList("ringside", new string[] { "poseForTheFans" });
            List<RiqEntity> tempEvents = new List<RiqEntity>();
            for (int i = 0; i < camEvents.Count; i++)
            {
                if (camEvents[i].beat + camEvents[i].beat >= Conductor.instance.songPositionInBeatsAsDouble)
                {
                    tempEvents.Add(camEvents[i]);
                }
            }

            allCameraEvents = tempEvents;

            UpdateCameraZoom();
            wrestlerAnim.Play("Idle", 0, 1);
            ReporterBlink();
        }

        public override void OnBeatPulse(double beat)
        {
            if (shouldBop && canBop)
            {
                if (UnityEngine.Random.Range(1, 18) == 1)
                {
                    wrestlerAnim.DoScaledAnimationAsync("BopPec");
                }
                else
                {
                    wrestlerAnim.DoScaledAnimationAsync("Bop");
                }
            }
        }

        void Update()
        {
            var cond = Conductor.instance;

            if (cond.isPlaying && !cond.isPaused)
            {
                if (PlayerInput.GetIsAction(InputAction_BasicPress) && !IsExpectingInputNow(InputAction_BasicPress) && !shouldNotInput)
                {
                    if ((PlayerInput.CurrentControlStyle != InputController.ControlStyles.Touch)
                        || (PlayerInput.CurrentControlStyle == InputController.ControlStyles.Touch && !IsExpectingInputNow(InputAction_Alt)))
                    {
                        Ringside.instance.ScoreMiss(0.5);

                        wrestlerAnim.DoScaledAnimationAsync("YeMiss", 0.25f);
                        SoundByte.PlayOneShotGame($"ringside/confusedanswer");
                        if (reporterAnim.IsPlayingAnimationName("IdleReporter")) reporterAnim.Play("IdleLate", 0, 0);
                    }
                }
                if ( PlayerInput.CurrentControlStyle == InputController.ControlStyles.Touch
                    && PlayerInput.GetIsAction(InputAction_FlickPress) && !IsExpectingInputNow(InputAction_FlickPress) && !shouldNotInput)
                {
                    Ringside.instance.ScoreMiss(0.5);
                    
                    SoundByte.PlayOneShotGame($"ringside/muscles2");
                    wrestlerAnim.DoScaledAnimationAsync("BigGuyTwo", 0.5f);
                    reporterAnim.Play("FlinchReporter", 0, 0);
                    SoundByte.PlayOneShotGame("ringside/barely");
                }
                if (PlayerInput.GetIsAction(InputAction_Alt) && !IsExpectingInputNow(InputAction_Alt) && !shouldNotInput)
                {
                    Ringside.instance.ScoreMiss(0.5);
                    
                    int randomPose = UnityEngine.Random.Range(1, 7);
                    wrestlerAnim.Play($"Pose{randomPose}", 0, 0);
                    reporterAnim.Play("FlinchReporter", 0, 0);
                    SoundByte.PlayOneShotGame($"ringside/yell{UnityEngine.Random.Range(1, 7)}Raw");
                    wrestlerTransform.localScale = new Vector3(1.1f, 1.1f, 1f);
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(cond.songPositionInBeatsAsDouble + 0.1f, delegate { wrestlerTransform.localScale = new Vector3(1f, 1f, 1f); }),
                    });
                }
            }
            if (allCameraEvents.Count > 0)
            {
                if (currentZoomIndex < allCameraEvents.Count && currentZoomIndex >= 0)
                {
                    if (Conductor.instance.songPositionInBeatsAsDouble >= allCameraEvents[currentZoomIndex].beat)
                    {
                        UpdateCameraZoom();
                        currentZoomIndex++;
                    }
                }

                float normalizedBeat = Conductor.instance.GetPositionFromBeat(currentZoomCamBeat, 2.5f);
                float normalizedShouldStopBeat = Conductor.instance.GetPositionFromBeat(currentZoomCamBeat, 3.99f);

                if (normalizedBeat >= 0)
                {
                    if (normalizedShouldStopBeat > 1 && !keepZoomOut)
                    {
                        GameCamera.AdditionalPosition = new Vector3(0, 0, 0);
                    }
                    else if (normalizedBeat > 1)
                    {
                        GameCamera.AdditionalPosition = new Vector3(currentCamPos.x, currentCamPos.y, currentCamPos.z + 10);
                    }
                    else
                    {
                        Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(lastEase);
                        float newPosX = func(lastCamPos.x, currentCamPos.x, normalizedBeat);
                        float newPosY = func(lastCamPos.y, currentCamPos.y, normalizedBeat);
                        float newPosZ = func(lastCamPos.z + 10, currentCamPos.z + 10, normalizedBeat);
                        GameCamera.AdditionalPosition = new Vector3(newPosX, newPosY, newPosZ);
                    }
                }
            }
        }
        
        void LateUpdate()
        {
            var cond = Conductor.instance;
            if (cond.isPlaying && !cond.isPaused)
            {
                if (queuedPoses.Count > 0)
                {
                    foreach (var p in queuedPoses)
                    {
                        QueuePose(p.beat, p.keepZoomedOut, p.newspaperBeats);
                    }
                    queuedPoses.Clear();
                }
            }

        }

        public void ToggleBop(double beat, float length, bool startBopping, bool autoBop)
        {
            shouldBop = autoBop;
            if (startBopping)
            {
                for (int i = 0; i < length; i++)
                {
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat + i, delegate
                        {
                            if (wrestlerAnim.IsAnimationNotPlaying())
                            {
                                if (UnityEngine.Random.Range(1, 18) == 1)
                                {
                                    wrestlerAnim.DoScaledAnimationAsync("BopPec");
                                }
                                else
                                {
                                    wrestlerAnim.DoScaledAnimationAsync("Bop");
                                }
                            }
                        })
                    });
                }
            }
        }

        public void ToggleSweat(bool shouldSweat)
        {
            if (shouldSweat)
            {
                sweatParticles.Play();
            }
            else
            {
                sweatParticles.Stop();
            }
        }

        public void Question(double beat, bool alt, int questionVariant, float length = 4f)
        {
            if (length <= 2f) return;
            int currentQuestion = questionVariant;
            if (currentQuestion == (int)QuestionVariant.Random) currentQuestion = UnityEngine.Random.Range(1, 4);
            reporterAnim.DoScaledAnimationAsync("WubbaLubbaDubbaThatTrue", 0.4f);
            List<MultiSound.Sound> qSounds = new List<MultiSound.Sound>();
            if (alt)
            {
                qSounds.Add(new MultiSound.Sound($"ringside/wub{currentQuestion}", beat));
            }
            else
            {
                qSounds.Add(new MultiSound.Sound($"ringside/wubba{currentQuestion}-1", beat));
                qSounds.Add(new MultiSound.Sound($"ringside/wubba{currentQuestion}-2", beat + 0.25f));
            }
            float extend = length - 3f;
            int totalExtend = 0;
            if (extend > 0f)
            {
                for (int i = 0; i < extend; i++)
                {
                    qSounds.Add(new MultiSound.Sound($"ringside/dubba{currentQuestion}-1", beat + i + 0.5f ));
                    qSounds.Add(new MultiSound.Sound($"ringside/dubba{currentQuestion}-2", beat + i + 0.75f ));
                    qSounds.Add(new MultiSound.Sound($"ringside/dubba{currentQuestion}-3", beat + i + 1f ));
                    qSounds.Add(new MultiSound.Sound($"ringside/dubba{currentQuestion}-4", beat + i + 1.25f ));
                    totalExtend++;
                }
            }

            MultiSound.Play(qSounds.ToArray(), forcePlay: true);
            ThatTrue(beat + totalExtend, currentQuestion);
        }

        public void PreQuestion(double beat, int questionVariant, float length = 4f)
        {
            if (GameManager.instance.currentGame != "ringside") return;
            if (instance == null) return;
            if (length <= 2f)
            {
                int currentQuestion = questionVariant;
                if (currentQuestion == (int)QuestionVariant.Random) currentQuestion = UnityEngine.Random.Range(1, 4);
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat - 0.5f, delegate { reporterAnim.DoScaledAnimationAsync("WubbaLubbaDubbaThatTrue", 0.4f); }),
                });
                ThatTrue(beat - 1, currentQuestion);
            }
        }

        public void ThatTrue(double beat, int currentQuestion)
        {
            MultiSound.Play(new MultiSound.Sound[]
            {
                new MultiSound.Sound($"ringside/that{currentQuestion}", beat + 0.5f),
                new MultiSound.Sound($"ringside/true{currentQuestion}", beat + 1f),
            }, forcePlay: true);
            ScheduleInput(beat, 2f, InputAction_BasicPress, JustQuestion, Miss, Nothing);
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.5f, delegate { reporterAnim.DoScaledAnimationAsync("ThatTrue", 0.5f); }),
                new BeatAction.Action(beat + 1.5f, delegate { canBop = false; }),
                new BeatAction.Action(beat + 2.5f, delegate { canBop = true; })
            });
        }

        public void BigGuy(double beat, int questionVariant)
        {
            int currentQuestion = questionVariant;
            if (currentQuestion == (int)QuestionVariant.Random) currentQuestion = UnityEngine.Random.Range(1, 4);
            reporterAnim.DoScaledAnimationAsync("Woah", 0.5f);
            float youBeat = 0.65f;
            if (currentQuestion == (int)QuestionVariant.Third) youBeat = 0.7f;
            MultiSound.Play(new MultiSound.Sound[]
            {
                new MultiSound.Sound($"ringside/woah{currentQuestion}", beat),
                new MultiSound.Sound($"ringside/you{currentQuestion}", beat + youBeat),
                new MultiSound.Sound($"ringside/go{currentQuestion}", beat + 1f),
                new MultiSound.Sound($"ringside/big{currentQuestion}", beat + 1.5f),
                new MultiSound.Sound($"ringside/guy{currentQuestion}", beat + 2f),
            }, forcePlay: true);

            ScheduleInput(beat, 2.5f, InputAction_BasicPress, JustBigGuyFirst, MissBigGuyOne, Nothing);
            ScheduleInput(beat, 3f, InputAction_FlickPress, JustBigGuySecond, MissBigGuyTwo, Nothing);
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 2f, delegate { reporterAnim.Play("True", 0, 0); }),
                new BeatAction.Action(beat + 2.25f, delegate { canBop = false; }),
                new BeatAction.Action(beat + 3.5f, delegate { canBop = true; })
            });
        }

        public static void PoseForTheFans(double beat, bool and, int variant, bool keepZoomedOut, float newspaperBeats)
        {
            if (and)
            {
                MultiSound.Play(new MultiSound.Sound[]
                {
                    new MultiSound.Sound("ringside/poseAnd", beat - 0.5f),
                }, forcePlay: true);
            }
            int poseLine = variant;
            if (poseLine == 3) poseLine = UnityEngine.Random.Range(1, 3);
            MultiSound.Play(new MultiSound.Sound[]
            {
                new MultiSound.Sound($"ringside/pose{poseLine}", beat),
                new MultiSound.Sound($"ringside/for{poseLine}", beat + 0.5f),
                new MultiSound.Sound($"ringside/the{poseLine}", beat + 0.75f),
                new MultiSound.Sound($"ringside/fans{poseLine}", beat + 1f),
            }, forcePlay: true);
            if (GameManager.instance.currentGame == "ringside")
            {
                Ringside.instance.QueuePose(beat, keepZoomedOut, newspaperBeats);
            }
            else
            {
                queuedPoses.Add(new QueuedPose { beat = beat, keepZoomedOut = keepZoomedOut, newspaperBeats = newspaperBeats});
            }
        }

        public void QueuePose(double beat, bool keepZoomedOut, float newspaperBeats)
        {
            if (newspaperBeats > 0)
            {
                reporterShouldHeart = true;
            }
            else
            {
                reporterShouldHeart = false;
            }
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate 
                {
                    audienceAnim.DoScaledAnimationAsync("PoseAudience", 0.25f);
                    wrestlerAnim.DoScaledAnimationAsync("PreparePose", 0.25f);
                    canBop = false;
                }),
                new BeatAction.Action(beat + 1, delegate  { PoseCheck(beat); }),
                new BeatAction.Action(beat + 4f, delegate
                {
                    if (shouldBop)
                    {
                        if (UnityEngine.Random.Range(1, 18) == 1)
                        {
                            wrestlerAnim.DoScaledAnimationAsync("BopPec");
                        }
                        else
                        {
                            wrestlerAnim.DoScaledAnimationAsync("Bop");
                        }
                    }
                    else wrestlerAnim.Play("Idle", 0, 1);
                    reporterAnim.DoUnscaledAnimation("IdleReporter");
                    shouldNotInput = false;
                    canBop = true;
                }),
            });
            if (!keepZoomedOut)
            {
                if (newspaperBeats > 0)
                {
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat + 3f, delegate
                        {
                            keepZoomOut = true;
                            blackVoid.color = Color.black;
                            GameObject spawnedNewsPaper = Instantiate(newspaper, transform);
                            spawnedNewsPaper.SetActive(true);
                            currentNewspaper = spawnedNewsPaper;
                            wrestlerNewspaperAnim = spawnedNewsPaper.transform.GetChild(1).GetComponent<Animator>();
                            reporterNewspaperAnim = spawnedNewsPaper.transform.GetChild(2).GetComponent<Animator>();
                            if (UnityEngine.Random.Range(1, 3) == 1)
                            {
                                spawnedNewsPaper.GetComponent<Animator>().Play("NewspaperEnter", 0, 0);
                            }
                            else
                            {
                                spawnedNewsPaper.GetComponent<Animator>().Play("NewspaperEnterRight", 0, 0);
                            }
                            if (!hitPose)
                            {
                                wrestlerNewspaperAnim.Play($"Miss{UnityEngine.Random.Range(1, 7)}Newspaper", 0, 0);
                                reporterNewspaperAnim.Play("IdleReporterNewspaper", 0, 0);
                                kidsLaugh = SoundByte.PlayOneShotGame("ringside/kidslaugh", -1, 1, 1, true);
                            }
                            else
                            {
                                wrestlerNewspaperAnim.Play($"Pose{currentPose}Newspaper", 0, 0);
                                reporterNewspaperAnim.Play("HeartReporterNewspaper", 0, 0);
                                hitPose = true;
                            }
                        }),
                        new BeatAction.Action(beat + 3f + newspaperBeats, delegate
                        {
                            blackVoid.color = new Color(1f, 1f, 1f, 0);
                            Destroy(currentNewspaper); currentNewspaper = null;
                            lastCamPos = new Vector3(0, 0, -10);
                            SoundByte.KillLoop(kidsLaugh, 0.25f);
                            keepZoomOut = false;
                        })
                    });
                }
                else
                {
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat + 3.99f, delegate
                        {
                            lastCamPos = new Vector3(0, 0, -10);
                            keepZoomOut = false;
                        }),
                    });

                }
            }
            else
            {
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat + 2.5f, delegate
                    {
                        lastCamPos = currentCamPos;
                        keepZoomOut = true;
                    })
                });
                if (newspaperBeats > 0)
                {
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat + 3f, delegate
                        {
                            blackVoid.color = Color.black;
                            GameObject spawnedNewsPaper = Instantiate(newspaper, transform);
                            spawnedNewsPaper.SetActive(true);
                            currentNewspaper = spawnedNewsPaper;
                            wrestlerNewspaperAnim = spawnedNewsPaper.transform.GetChild(1).GetComponent<Animator>();
                            reporterNewspaperAnim = spawnedNewsPaper.transform.GetChild(2).GetComponent<Animator>();
                            if (UnityEngine.Random.Range(1, 3) == 1)
                            {
                                spawnedNewsPaper.GetComponent<Animator>().Play("NewspaperEnter", 0, 0);
                            }
                            else
                            {
                                spawnedNewsPaper.GetComponent<Animator>().Play("NewspaperEnterRight", 0, 0);
                            }
                            if (!hitPose)
                            {
                                wrestlerNewspaperAnim.Play($"Miss{UnityEngine.Random.Range(1, 7)}Newspaper", 0, 0);
                                reporterNewspaperAnim.Play("IdleReporterNewspaper", 0, 0);
                                kidsLaugh = SoundByte.PlayOneShotGame("ringside/kidslaugh", -1, 1, 1, true);
                            }
                            else
                            {
                                wrestlerNewspaperAnim.Play($"Pose{currentPose}Newspaper", 0, 0);
                                reporterNewspaperAnim.Play("HeartReporterNewspaper", 0, 0);
                                hitPose = true;
                            }
                        }),
                        new BeatAction.Action(beat + 3f + newspaperBeats, delegate
                        {
                            blackVoid.color = new Color(1f, 1f, 1f, 0);
                            Destroy(currentNewspaper); currentNewspaper = null;
                            SoundByte.KillLoop(kidsLaugh, 0.25f);
                        })
                    });
                }
            }
        }

        private void UpdateCameraZoom()
        {
            if (currentZoomIndex < allCameraEvents.Count && currentZoomIndex >= 0)
            {
                currentZoomCamBeat = (float)allCameraEvents[currentZoomIndex].beat;
                currentCamPos = new Vector3(poseFlash.transform.position.x, poseFlash.transform.position.y, -21.5f);
                lastEase = (Util.EasingFunction.Ease)allCameraEvents[currentZoomIndex]["ease"];
            }
        }

        public void PoseCheck(double beat)
        {
            ScheduleInput(beat, 2f, InputAction_Alt, JustPoseForTheFans, MissPose, Nothing);
        }

        public void ChangeFlashColor(Color color, float beats)
        {
            var seconds = Conductor.instance.secPerBeat * beats;

            if (flashTween != null)
                flashTween.Kill(true);

            if (seconds == 0)
            {
                flashWhite.color = color;
            }
            else
            {
                flashTween = flashWhite.DOColor(color, seconds);
            }
        }

        public void FadeFlashColor(Color start, Color end, float beats)
        {
            ChangeFlashColor(start, 0f);
            ChangeFlashColor(end, beats);
        }

        public void ChangeBGColor(Color color, float beats)
        {
            var seconds = Conductor.instance.secPerBeat * beats;

            if (bgTween != null)
                bgTween.Kill(true);

            if (seconds == 0)
            {
                bg.color = color;
            }
            else
            {
                flashTween = bg.DOColor(color, seconds);
            }
        }

        public void FadeBGColor(Color start, Color end, float beats)
        {
            ChangeBGColor(start, 0f);
            ChangeBGColor(end, beats);
        }

        public void ReporterBlink()
        {
            if (reporterAnim.GetCurrentAnimatorStateInfo(0).IsName("IdleReporter"))
            {
                reporterAnim.DoUnscaledAnimation("BlinkReporter");
            }
            float randomTime = UnityEngine.Random.Range(0.3f, 1.8f);
            Invoke("ReporterBlink", randomTime);
        }

        public void JustQuestion(PlayerActionEvent caller, float state)
        {
            if (state >= 1f || state <= -1f)
            {
                wrestlerAnim.DoScaledAnimationAsync("Cough", 0.5f);
                SoundByte.PlayOneShotGame($"ringside/cough");
                reporterAnim.Play("ExtendMiss", 0, 0);
                SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleMiss", 0, 0); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                });
                return;
            }
            SuccessQuestion(caller);
        }

        public void SuccessQuestion(PlayerActionEvent caller)
        {
            wrestlerAnim.DoScaledAnimationAsync("Ye", 0.5f);
            reporterAnim.Play("ExtendSmile", 0, 0);
            SoundByte.PlayOneShotGame($"ringside/ye{UnityEngine.Random.Range(1, 4)}");
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { SoundByte.PlayOneShotGame("ringside/yeCamera"); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { FadeFlashColor(Color.white, new Color(1, 1, 1, 0), 0.5f); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { flashObject.SetActive(true); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("SmileReporter", 0, 0); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.6f, delegate { flashObject.SetActive(false); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
            });
        }

        public void JustBigGuyFirst(PlayerActionEvent caller, float state)
        {
            if (state >= 1f || state <= -1f)
            {
                missedBigGuy = true;
                SoundByte.PlayOneShotGame($"ringside/muscles1");
                wrestlerAnim.DoScaledAnimationAsync("BigGuyOne", 0.5f);
                return;
            }
            SuccessBigGuyFirst();
        }

        public void SuccessBigGuyFirst()
        {
            missedBigGuy = false;
            SoundByte.PlayOneShotGame($"ringside/muscles1");
            wrestlerAnim.DoScaledAnimationAsync("BigGuyOne", 0.5f);
        }

        public void JustBigGuySecond(PlayerActionEvent caller, float state)
        {
            if (state >= 1f || state <= -1f)
            {
                SoundByte.PlayOneShotGame($"ringside/muscles2");
                wrestlerAnim.DoScaledAnimationAsync("BigGuyTwo", 0.5f);
                if (!missedBigGuy)
                {
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                    });
                }
                else
                {
                    reporterAnim.Play("ExtendMiss", 0, 0);
                    SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
                    BeatAction.New(instance, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleMiss", 0, 0); }),
                        new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                    });
                }
                return;
            }
            SuccessBigGuySecond(caller);
        }

        public void SuccessBigGuySecond(PlayerActionEvent caller)
        {
            SoundByte.PlayOneShotGame($"ringside/muscles2");
            wrestlerAnim.DoScaledAnimationAsync("BigGuyTwo", 0.5f);
            if (!missedBigGuy)
            {
                reporterAnim.Play("ExtendSmile", 0, 0);
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { SoundByte.PlayOneShotGame("ringside/musclesCamera"); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("SmileReporter", 0, 0); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { FadeFlashColor(Color.white, new Color(1, 1, 1, 0), 0.5f); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { flashObject.SetActive(true); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.6f, delegate { flashObject.SetActive(false); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                });
            }
            else
            {
                reporterAnim.Play("ExtendMiss", 0, 0);
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleMiss", 0, 0); }),
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                });
            }
        }

        public void JustPoseForTheFans(PlayerActionEvent caller, float state)
        {
            shouldNotInput = true;
            if (state >= 1f || state <= -1f)
            {
                wrestlerTransform.localScale = new Vector3(1.2f, 1.2f, 1f);
                int randomPose = UnityEngine.Random.Range(1, 7);
                wrestlerAnim.Play($"Pose{randomPose}", 0, 0);
                SoundByte.PlayOneShotGame($"ringside/yell{UnityEngine.Random.Range(1, 7)}Raw");
                reporterAnim.Play("IdleMiss", 0, 0);
                SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
                BeatAction.New(instance, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(caller.startBeat + caller.timer + 0.1f, delegate { wrestlerTransform.localScale = new Vector3(1f, 1f, 1f); }),
                });
                return;
            }
            SuccessPoseForTheFans(caller);
        }

        public void SuccessPoseForTheFans(PlayerActionEvent caller)
        {
            wrestlerTransform.localScale = new Vector3(1.2f, 1.2f, 1f);
            int randomPose = UnityEngine.Random.Range(1, 7);
            currentPose = randomPose;
            wrestlerAnim.Play($"Pose{randomPose}", 0, 0);
            if (reporterShouldHeart)
            {
                reporterAnim.Play("HeartReporter", 0, 0);
            }
            else
            {
                reporterAnim.Play("ExcitedReporter", 0, 0);
            }
            hitPose = true;
            SoundByte.PlayOneShotGame($"ringside/yell{UnityEngine.Random.Range(1, 7)}");
            FadeFlashColor(Color.white, new Color(1, 1, 1, 0), 1f);
            FadeBGColor(Color.black, defaultBGColorLight, 1f);
            flashParticles.Play();
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(caller.startBeat + caller.timer + 0.1f, delegate { wrestlerTransform.localScale = new Vector3(1f, 1f, 1f); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 1f, delegate { SoundByte.PlayOneShotGame("ringside/poseCamera"); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 1f, delegate { flashParticles.Stop(); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 1f, delegate { poseFlash.SetActive(true); poseFlash.GetComponent<Animator>().Play("PoseFlashing", 0, 0); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 1.99f, delegate { poseFlash.SetActive(false); }),
            });
        }

        public void Miss(PlayerActionEvent caller)
        {
            reporterAnim.Play("ExtendMiss", 0, 0);
            SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleMiss", 0, 0); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
            });
        }

        public void MissBigGuyOne(PlayerActionEvent caller)
        {
            missedBigGuy = true;
        }

        public void MissBigGuyTwo(PlayerActionEvent caller)
        {
            reporterAnim.Play("ExtendMiss", 0, 0);
            SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
            BeatAction.New(instance, new List<BeatAction.Action>()
            {
                new BeatAction.Action(caller.startBeat + caller.timer + 0.5f, delegate { reporterAnim.Play("IdleMiss", 0, 0); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { reporterAnim.Play("IdleReporter", 0, 0); }),
                new BeatAction.Action(caller.startBeat + caller.timer + 0.9f, delegate { wrestlerAnim.Play("Idle", 0, 0); }),
            });
        }
        
        public void MissPose(PlayerActionEvent caller)
        {
            shouldNotInput = true;
            reporterAnim.Play("IdleMiss", 0, 0);
            SoundByte.PlayOneShotGame($"ringside/huhaudience{UnityEngine.Random.Range(0, 2)}");
        }

        public void Nothing(PlayerActionEvent caller){}
    }
}