using HeavenStudio.Util;
using System;
using System.Collections.Generic;
using UnityEngine;
using NaughtyBezierCurves;

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    public static class RvlWorkingDoughLoader
    {
        public static Minigame AddGame(EventCaller eventCaller)
        {
            return new Minigame("workingDough", "Drop Balls", "000000", false, false, new List<GameAction>()
            {
                new GameAction("beat intervals", "Start Interval")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.SetIntervalStart(e.beat, e.length);  },
                    preFunction = delegate { var e = eventCaller.currentEntity; WorkingDough.PreSetIntervalStart(e.beat, e.length);  },
                    defaultLength = 8f,
                    resizable = true,
                    priority = 2
                },
                new GameAction("small ball", "Small Ball")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.OnSpawnBall(e.beat, false);  },
                    preFunction = delegate { var e = eventCaller.currentEntity; WorkingDough.PreSpawnBall(e.beat, false);  },
                    defaultLength = 0.5f,
                    priority = 1
                },
                new GameAction("big ball", "Big Ball")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.OnSpawnBall(e.beat, true);  },
                    preFunction = delegate { var e = eventCaller.currentEntity; WorkingDough.PreSpawnBall(e.beat, true);  },
                    defaultLength = 0.5f,
                    priority = 1
                },
                new GameAction("launch spaceship", "Launch Spaceship")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.LaunchShip(e.beat, e.length);  },
                    defaultLength = 4f,
                    resizable = true,
                    priority = 0
                },
                new GameAction("rise spaceship", "Rise Up Spaceship")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.RiseUpShip(e.beat, e.length);  },
                    defaultLength = 4f,
                    resizable = true,
                    priority = 0
                },
                new GameAction("lift dough dudes", "Lift Dough Dudes")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.Elevate(e.beat, e.length, e["toggle"]);  },
                    defaultLength = 4f,
                    parameters = new List<Param>()
                    {
                    new Param("toggle", false, "Go Up?", "Toggle to go Up or Down.")
                    },
                    resizable = true,
                    priority = 0
                },
                new GameAction("instant lift", "Instant Lift")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.InstantElevation(e["toggle"]);  },
                    parameters = new List<Param>()
                    {
                    new Param("toggle", true, "Go Up?", "Toggle to go Up or Down.")
                    },
                    defaultLength = 0.5f,
                    priority = 0
                },
                new GameAction("mr game and watch enter or exit", "Mr. G&W Enter or Exit")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.GANDWEnterOrExit(e.beat, e.length, e["toggle"]);  },
                    defaultLength = 4f,
                    parameters = new List<Param>()
                    {
                    new Param("toggle", false, "Should exit?", "Toggle to make him leave or enter.")
                    },
                    resizable = true,
                    priority = 0
                },
                new GameAction("instant game and watch", "Instant Mr. G&W Enter or Exit")
                {
                    function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.InstantGANDWEnterOrExit(e["toggle"]);  },
                    parameters = new List<Param>()
                    {
                    new Param("toggle", false, "Exit?", "Toggle to make him leave or enter.")
                    },
                    defaultLength = 0.5f,
                    priority = 0
                },
            });
        }
    }
}

namespace HeavenStudio.Games
{
    using Scripts_WorkingDough;
    public class WorkingDough : Minigame
    {
        [Header("Components")]
        [SerializeField] GameObject doughDudesNPC; //Jump animations
        public GameObject doughDudesPlayer; //Jump animations
        [SerializeField] GameObject ballTransporterRightNPC; //Close and open animations
        [SerializeField] GameObject ballTransporterLeftNPC; //Close and open animations
        [SerializeField] GameObject ballTransporterRightPlayer; //Close and open animations
        [SerializeField] GameObject ballTransporterLeftPlayer; //Close and open animations
        [SerializeField] GameObject npcImpact;
        [SerializeField] GameObject playerImpact;
        [SerializeField] GameObject smallBallNPC;
        [SerializeField] GameObject bigBallNPC;
        [SerializeField] Transform ballHolder;
        [SerializeField] SpriteRenderer arrowSRLeftNPC;
        [SerializeField] SpriteRenderer arrowSRRightNPC;
        [SerializeField] SpriteRenderer arrowSRLeftPlayer;
        [SerializeField] SpriteRenderer arrowSRRightPlayer;
        [SerializeField] GameObject NPCBallTransporters;
        [SerializeField] GameObject PlayerBallTransporters;
        [SerializeField] GameObject playerEnterSmallBall;
        [SerializeField] GameObject playerEnterBigBall;
        [SerializeField] GameObject missImpact;
        [SerializeField] Transform breakParticleHolder;
        [SerializeField] GameObject breakParticleEffect;
        [SerializeField] Animator backgroundAnimator;
        [SerializeField] Animator conveyerAnimator;
        [SerializeField] GameObject smallBGBall;
        [SerializeField] GameObject bigBGBall;
        [SerializeField] Animator spaceshipAnimator;
        [SerializeField] GameObject spaceshipLights;
        [SerializeField] Animator doughDudesHolderAnim;
        [SerializeField] Animator gandwAnim;

        [Header("Variables")]
        public bool intervalStarted;
        float intervalStartBeat;
        float risingLength = 4f;
        float risingStartBeat;
        float liftingLength = 4f;
        float liftingStartBeat;
        public static float beatInterval = 8f;
        float gandMovingLength = 4f;
        float gandMovingStartBeat;
        public bool bigMode;
        public bool bigModePlayer;
        static List<QueuedBall> queuedBalls = new List<QueuedBall>();
        struct QueuedBall
        {
            public float beat;
            public bool isBig;
        }
        static List<QueuedInterval> queuedIntervals = new List<QueuedInterval>();
        struct QueuedInterval
        {
            public float beat;
            public float interval;
        }
        private List<GameObject> currentBalls = new List<GameObject>();
        public bool shouldMiss = true;
        public bool spaceshipRisen = false;
        public bool spaceshipRising = false;
        bool liftingDoughDudes;
        string liftingAnimName;
        bool ballTriggerSetInterval = true;
        bool gandwHasEntered = true;
        bool gandwMoving;
        string gandwMovingAnimName;

        [Header("Curves")]
        public BezierCurve3D npcEnterUpCurve;
        public BezierCurve3D npcEnterDownCurve;
        public BezierCurve3D npcExitUpCurve;
        public BezierCurve3D npcExitDownCurve;
        public BezierCurve3D playerEnterUpCurve;
        public BezierCurve3D playerEnterDownCurve;
        public BezierCurve3D playerExitUpCurve;
        public BezierCurve3D playerExitDownCurve;
        public BezierCurve3D playerMissCurveFirst;
        public BezierCurve3D playerMissCurveSecond;
        public BezierCurve3D playerBarelyCurveFirst;
        public BezierCurve3D playerBarelyCurveSecond;
        public BezierCurve3D playerWrongInputTooWeakFirstCurve;
        public BezierCurve3D playerWrongInputTooWeakSecondCurve;
        public BezierCurve3D firstBGCurveBig;
        public BezierCurve3D secondBGCurveBig;
        public BezierCurve3D thirdBGCurveBig;
        public BezierCurve3D firstBGCurveSmall;
        public BezierCurve3D secondBGCurveSmall;
        public BezierCurve3D thirdBGCurveSmall;

        [Header("Resources")]
        public Sprite whiteArrowSprite;
        public Sprite redArrowSprite;

        public static WorkingDough instance;

        void Awake()
        {
            instance = this;
        }

        void Start()
        {
            shouldMiss = true;
            ballTriggerSetInterval = true;
            conveyerAnimator.Play("ConveyerBelt", 0, 0);
            doughDudesHolderAnim.Play("OnGround", 0, 0);
        }

        public void SetIntervalStart(float beat, float interval)
        {
            Debug.Log("Start Interval");
            if (!intervalStarted)
            {
                instance.ballTriggerSetInterval = false;
                intervalStarted = true;
                bigMode = false;
                BeatAction.New(ballTransporterLeftNPC, new List<BeatAction.Action>()
                {
                    //Open player transporters
                    new BeatAction.Action(beat + interval - 1f, delegate {
                         ballTransporterLeftPlayer.GetComponent<Animator>().Play("BallTransporterLeftOpen", 0, 0);
                    }),
                    new BeatAction.Action(beat + interval - 1f, delegate {
                        ballTransporterRightPlayer.GetComponent<Animator>().Play("BallTransporterRightOpen", 0, 0);
                    }),

                    //End interval
                    new BeatAction.Action(beat + interval, delegate { intervalStarted = false; }),
                    new BeatAction.Action(beat + interval, delegate {ballTriggerSetInterval = true; }),

                    //Close npc transporters
                    new BeatAction.Action(beat + interval, delegate {
                        if (bigMode)
                        {
                            NPCBallTransporters.GetComponent<Animator>().Play("NPCExitBigMode", 0, 0);
                            bigMode = false;
                        }
                    }),
                    new BeatAction.Action(beat + interval + 1, delegate { if (!intervalStarted) ballTransporterLeftNPC.GetComponent<Animator>().Play("BallTransporterLeftClose", 0, 0); }),
                    new BeatAction.Action(beat + interval + 1, delegate { if (!intervalStarted) ballTransporterRightNPC.GetComponent<Animator>().Play("BallTransporterRightClose", 0, 0); }),
                    new BeatAction.Action(beat + interval + 1, delegate { if (gandwHasEntered) gandwAnim.Play("MrGameAndWatchLeverDown", 0, 0); }),
                    //Close player transporters
                    new BeatAction.Action(beat + interval * 2 + 1, delegate { ballTransporterLeftPlayer.GetComponent<Animator>().Play("BallTransporterLeftClose", 0, 0); }),
                    new BeatAction.Action(beat + interval * 2 + 1, delegate { ballTransporterRightPlayer.GetComponent<Animator>().Play("BallTransporterRightClose", 0, 0); }),
                    new BeatAction.Action(beat + interval * 2 + 1, delegate {
                        if (bigModePlayer)
                        {
                            PlayerBallTransporters.GetComponent<Animator>().Play("PlayerExitBigMode", 0, 0);
                            bigModePlayer = false;
                        }
                    }),
                });
            }
            beatInterval = interval;
            intervalStartBeat = beat;
        }

        public void SpawnBall(float beat, bool isBig)
        {
            if (!intervalStarted && ballTriggerSetInterval)
            {
                SetIntervalStart(beat, beatInterval);
            }
            var objectToSpawn = isBig ? bigBallNPC : smallBallNPC;
            var spawnedBall = GameObject.Instantiate(objectToSpawn, ballHolder);

            var ballComponent = spawnedBall.GetComponent<NPCDoughBall>();
            ballComponent.startBeat = beat;
            ballComponent.exitUpCurve = npcExitUpCurve;
            ballComponent.enterUpCurve = npcEnterUpCurve;
            ballComponent.exitDownCurve = npcExitDownCurve;
            ballComponent.enterDownCurve = npcEnterDownCurve;

            spawnedBall.SetActive(true);

            if (isBig && !bigMode)
            {
                NPCBallTransporters.GetComponent<Animator>().Play("NPCGoBigMode", 0, 0);
                bigMode = true;
            }

            MultiSound.Play(new MultiSound.Sound[] {
                new MultiSound.Sound(isBig ? "workingDough/NPCBigBall" : "workingDough/NPCSmallBall", beat + 1f),
            });

            arrowSRLeftNPC.sprite = redArrowSprite;
            BeatAction.New(doughDudesNPC, new List<BeatAction.Action>()
            {
                //Jump and play sound
                new BeatAction.Action(beat + 0.1f, delegate { arrowSRLeftNPC.sprite = whiteArrowSprite; }),
                new BeatAction.Action(beat + 1f, delegate { doughDudesNPC.GetComponent<Animator>().Play(isBig ? "BigDoughJump" :"SmallDoughJump", 0, 0); }),
                new BeatAction.Action(beat + 1f, delegate { npcImpact.SetActive(true); }),
                new BeatAction.Action(beat + 1.1f, delegate { npcImpact.SetActive(false); }),
                new BeatAction.Action(beat + 1.9f, delegate { arrowSRRightNPC.sprite = redArrowSprite; }),
                new BeatAction.Action(beat + 2f, delegate { arrowSRRightNPC.sprite = whiteArrowSprite; }),
            });
        }

        public void InstantExitBall(float beat, bool isBig, float offSet)
        {
            var objectToSpawn = isBig ? bigBallNPC : smallBallNPC;
            var spawnedBall = GameObject.Instantiate(objectToSpawn, ballHolder);

            var ballComponent = spawnedBall.GetComponent<NPCDoughBall>();
            ballComponent.startBeat = beat - 1f;
            ballComponent.exitUpCurve = npcExitUpCurve;
            ballComponent.enterUpCurve = npcEnterUpCurve;
            ballComponent.exitDownCurve = npcExitDownCurve;
            ballComponent.enterDownCurve = npcEnterDownCurve;
            ballComponent.currentFlyingStage = (FlyingStage)(2 - Mathf.Abs(offSet));

            if (isBig && !bigMode)
            {
                bigMode = true;
            }

            if (beat >= Conductor.instance.songPositionInBeatsAsDouble)
            {
                MultiSound.Play(new MultiSound.Sound[] {
                    new MultiSound.Sound(isBig ? "workingDough/NPCBigBall" : "workingDough/NPCSmallBall", beat),
                });
            }
            
            BeatAction.New(doughDudesNPC, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat - offSet, delegate { spawnedBall.SetActive(true); }),
                new BeatAction.Action(beat, delegate { doughDudesNPC.GetComponent<Animator>().Play(isBig ? "BigDoughJump" : "SmallDoughJump", 0, 0); } ),
                new BeatAction.Action(beat, delegate { npcImpact.SetActive(true); } ),
                new BeatAction.Action(beat + 0.1f, delegate { npcImpact.SetActive(false); }),
                new BeatAction.Action(beat + 0.9f, delegate { arrowSRRightNPC.sprite = redArrowSprite; }),
                new BeatAction.Action(beat + 1f, delegate { arrowSRRightNPC.sprite = whiteArrowSprite; }),
            });
        }

        public static void PreSpawnBall(float beat, bool isBig)
        {
            float spawnBeat = beat - 1f;
            beat -= 1f;
            if (GameManager.instance.currentGame == "workingDough")
            {
                BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(spawnBeat, delegate
                    {
                        if (!instance.ballTransporterLeftNPC.GetComponent<Animator>().IsPlayingAnimationName("BallTransporterLeftOpened") && !instance.intervalStarted && instance.ballTriggerSetInterval)
                        {
                            instance.ballTransporterLeftNPC.GetComponent<Animator>().Play("BallTransporterLeftOpen", 0, 0);
                            instance.ballTransporterRightNPC.GetComponent<Animator>().Play("BallTransporterRightOpen", 0, 0);
                            if (instance.gandwHasEntered) instance.gandwAnim.Play("GANDWLeverUp", 0, 0);
                        }
                    }),
                    new BeatAction.Action(spawnBeat, delegate { if (instance != null) instance.SpawnBall(beat, isBig); }),
                    // new BeatAction.Action(spawnBeat + instance.beatInterval, delegate { instance.SpawnPlayerBall(beat + instance.beatInterval, isBig); }),
                });
            }
            else
            {
                queuedBalls.Add(new QueuedBall()
                {
                    beat = beat + 1f,
                    isBig = isBig,
                });
            }
        }

        public void OnSpawnBall(float beat, bool isBig)
        {
            beat -= 1f;
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + beatInterval, delegate { instance.SpawnPlayerBall(beat + beatInterval, isBig); }),
            });
        }

        public void OnSpawnBallInactive(float beat, bool isBig)
        {
            queuedBalls.Add(new QueuedBall()
            {
                beat = beat + 1f,
                isBig = isBig,
            });
        }

        public void SpawnPlayerBall(float beat, bool isBig)
        {
            var objectToSpawn = isBig ? playerEnterBigBall : playerEnterSmallBall;
            var spawnedBall = GameObject.Instantiate(objectToSpawn, ballHolder);

            var ballComponent = spawnedBall.GetComponent<PlayerEnterDoughBall>();
            ballComponent.startBeat = beat;
            ballComponent.firstCurve = playerEnterUpCurve;
            ballComponent.secondCurve = playerEnterDownCurve;
            ballComponent.deletingAutomatically = false;
            currentBalls.Add(spawnedBall);

            if (isBig && !bigModePlayer)
            {
                PlayerBallTransporters.GetComponent<Animator>().Play("PlayerGoBigMode", 0, 0);
                bigModePlayer = true;
            }

            //shouldMiss = true;
            if (isBig)
            {
                ScheduleInput(beat, 1, InputType.STANDARD_ALT_DOWN, JustBig, MissBig, Nothing);
                ScheduleUserInput(beat, 1, InputType.STANDARD_DOWN, WrongInputBig, Nothing, Nothing);
            }
            else
            {
                ScheduleInput(beat, 1, InputType.STANDARD_DOWN, JustSmall, MissSmall, Nothing);
                ScheduleUserInput(beat, 1, InputType.STANDARD_ALT_DOWN, WrongInputSmall, Nothing, Nothing);
            }


            BeatAction.New(doughDudesPlayer, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { spawnedBall.SetActive(true); }),
                new BeatAction.Action(beat, delegate { arrowSRLeftPlayer.sprite = redArrowSprite; }),
                new BeatAction.Action(beat + 0.1f, delegate { arrowSRLeftPlayer.sprite = whiteArrowSprite; }),
            });
        }

        public void SpawnPlayerBallResult(float beat, bool isBig, BezierCurve3D firstCurve, BezierCurve3D secondCurve, float firstBeatsToTravel, float secondBeatsToTravel)
        {
            var objectToSpawn = isBig ? playerEnterBigBall : playerEnterSmallBall;
            var spawnedBall = GameObject.Instantiate(objectToSpawn, ballHolder);

            var ballComponent = spawnedBall.GetComponent<PlayerEnterDoughBall>();
            ballComponent.startBeat = beat;
            ballComponent.firstCurve = firstCurve;
            ballComponent.secondCurve = secondCurve;
            ballComponent.firstBeatsToTravel = firstBeatsToTravel;
            ballComponent.secondBeatsToTravel = secondBeatsToTravel;

            spawnedBall.SetActive(true);
        }

        public static void PreSetIntervalStart(float beat, float interval)
        {
            beat -= 1f;
            if (GameManager.instance.currentGame == "workingDough")
            {
                // instance.ballTriggerSetInterval = false;
                // beatInterval = interval;
                BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat, delegate
                    {
                        if (!instance.ballTransporterLeftNPC.GetComponent<Animator>().IsPlayingAnimationName("BallTransporterLeftOpened"))
                        {
                            instance.ballTransporterLeftNPC.GetComponent<Animator>().Play("BallTransporterLeftOpen", 0, 0);
                            instance.ballTransporterRightNPC.GetComponent<Animator>().Play("BallTransporterRightOpen", 0, 0);
                            if (instance.gandwHasEntered) instance.gandwAnim.Play("GANDWLeverUp", 0, 0);
                        }
                    }),
                    // new BeatAction.Action(beat + 1, delegate { if (instance != null) instance.SetIntervalStart(beat + 1, interval); }),
                });
            }
            else
            {
                queuedIntervals.Add(new QueuedInterval()
                {
                    beat = beat + 1f,
                    interval = interval,
                });
            }
        }

        void OnDestroy()
        {
            if (queuedIntervals.Count > 0) queuedIntervals.Clear();
            if (queuedBalls.Count > 0) queuedBalls.Clear();
        }

        void Update()
        {
            Conductor cond = Conductor.instance;
            if (!cond.isPlaying || cond.isPaused)
            {
                if (queuedIntervals.Count > 0) queuedIntervals.Clear();
                if (queuedBalls.Count > 0) queuedBalls.Clear();
            }

            if (spaceshipRising) spaceshipAnimator.DoScaledAnimation("RiseSpaceship", risingStartBeat, risingLength);
            if (liftingDoughDudes) doughDudesHolderAnim.DoScaledAnimation(liftingAnimName, liftingStartBeat, liftingLength);
            if (gandwMoving) gandwAnim.DoScaledAnimation(gandwMovingAnimName, gandMovingStartBeat, gandMovingLength);
            if (queuedIntervals.Count > 0)
            {
                foreach (var interval in queuedIntervals)
                {
                    ballTriggerSetInterval = false;
                    beatInterval = interval.interval;
                    ballTransporterLeftNPC.GetComponent<Animator>().Play("BallTransporterLeftOpened", 0, 0);
                    ballTransporterRightNPC.GetComponent<Animator>().Play("BallTransporterRightOpened", 0, 0);
                    if (gandwHasEntered) gandwAnim.Play("GANDWLeverUp", 0, 0);
                    BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(interval.beat, delegate { SetIntervalStart(interval.beat, interval.interval); }),
                    });

                }
                queuedIntervals.Clear();
            }
            if (queuedBalls.Count > 0)
            {
                foreach (var ball in queuedBalls)
                {
                    float offSet = ball.beat - cond.songPositionInBeats;
                    float spawnOffset = offSet > 1f ? offSet - 1 : 0;
                    if (ball.isBig) NPCBallTransporters.GetComponent<Animator>().Play("BigMode", 0, 0);
                    BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(ball.beat - offSet + spawnOffset, delegate { 
                            if (!intervalStarted && ballTriggerSetInterval) 
                            {
                                ballTransporterLeftNPC.GetComponent<Animator>().Play("BallTransporterLeftOpened", 0, 0);
                                ballTransporterRightNPC.GetComponent<Animator>().Play("BallTransporterRightOpened", 0, 0);
                                if (gandwHasEntered) gandwAnim.Play("GANDWLeverUp", 0, 0);
                                SetIntervalStart(ball.beat, beatInterval); 
                            }
                        }),
                        new BeatAction.Action(ball.beat - offSet + spawnOffset, delegate { InstantExitBall(ball.beat, ball.isBig, offSet); }),
                        new BeatAction.Action(ball.beat + beatInterval - 1, delegate { SpawnPlayerBall(ball.beat + beatInterval - 1, ball.isBig); }),
                    });

                }
                queuedBalls.Clear();
            }
            if (PlayerInput.Pressed() && !IsExpectingInputNow(InputType.STANDARD_DOWN))
            {
                doughDudesPlayer.GetComponent<Animator>().Play("SmallDoughJump", 0, 0);
                Jukebox.PlayOneShotGame("workingDough/PlayerSmallJump");
            }
            else if (PlayerInput.AltPressed() && !IsExpectingInputNow(InputType.STANDARD_ALT_DOWN))
            {
                doughDudesPlayer.GetComponent<Animator>().Play("BigDoughJump", 0, 0);
                Jukebox.PlayOneShotGame("workingDough/PlayerBigJump");
            }
        }

        void WrongInputBig(PlayerActionEvent caller, float state)
        {
            float beat = caller.startBeat + caller.timer;
            shouldMiss = false;
            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }
            doughDudesPlayer.GetComponent<Animator>().Play("SmallDoughJump", 0, 0);
            Jukebox.PlayOneShotGame("workingDough/BigBallTooWeak");
            SpawnPlayerBallResult(beat, true, playerWrongInputTooWeakFirstCurve, playerWrongInputTooWeakSecondCurve, 0.5f, 1f);
            playerImpact.SetActive(true);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.1f, delegate { playerImpact.SetActive(false); }),
            });
        }

        void WrongInputSmall(PlayerActionEvent caller, float state)
        {
            float beat = caller.startBeat + caller.timer;
            shouldMiss = false;
            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }
            GameObject.Instantiate(breakParticleEffect, breakParticleHolder);
            doughDudesPlayer.GetComponent<Animator>().Play("BigDoughJump", 0, 0);
            Jukebox.PlayOneShotGame("workingDough/BreakBall");
            playerImpact.SetActive(true);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.1f, delegate { playerImpact.SetActive(false); }),
            });
        }

        void MissBig(PlayerActionEvent caller)
        {
            if (!shouldMiss)
            {
                shouldMiss = true;
                return;
            }
            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }

            float beat = caller.startBeat + caller.timer;
            SpawnPlayerBallResult(beat, true, playerMissCurveFirst, playerMissCurveSecond, 0.25f, 0.75f);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.25f, delegate { missImpact.SetActive(true); }),
                new BeatAction.Action(beat + 0.25f, delegate { Jukebox.PlayOneShotGame("workingDough/BallMiss"); }),
                new BeatAction.Action(beat + 0.35f, delegate { missImpact.SetActive(false); }),
            });
        }
        void MissSmall(PlayerActionEvent caller)
        {
            if (!shouldMiss)
            {
                shouldMiss = true;
                return;
            }

            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }
            float beat = caller.startBeat + caller.timer;
            SpawnPlayerBallResult(beat, false, playerMissCurveFirst, playerMissCurveSecond, 0.25f, 0.75f);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.25f, delegate { missImpact.SetActive(true); }),
                new BeatAction.Action(beat + 0.25f, delegate { Jukebox.PlayOneShotGame("workingDough/BallMiss"); }),
                new BeatAction.Action(beat + 0.35f, delegate { missImpact.SetActive(false); }),
            });
        }

        void JustSmall(PlayerActionEvent caller, float state)
        {
            if (GameManager.instance.currentGame != "workingDough") return;
            float beat = caller.startBeat + caller.timer;
            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }
            if (state >= 1f || state <= -1f)
            {
                Jukebox.PlayOneShotGame("workingDough/SmallBarely");
                doughDudesPlayer.GetComponent<Animator>().Play("SmallDoughJump", 0, 0);

                playerImpact.SetActive(true);
                SpawnPlayerBallResult(beat, false, playerBarelyCurveFirst, playerBarelyCurveSecond, 0.75f, 1f);
                BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat + 0.1f, delegate { playerImpact.SetActive(false); }),
                });
                return;
            }
            Success(false, beat);
        }

        void JustBig(PlayerActionEvent caller, float state)
        {
            if (GameManager.instance.currentGame != "workingDough") return;
            float beat = caller.startBeat + caller.timer;
            if (currentBalls.Count > 0)
            {
                GameObject currentBall = currentBalls[0];
                currentBalls.Remove(currentBall);
                GameObject.Destroy(currentBall);
            }
            if (state >= 1f || state <= -1f)
            {
                Jukebox.PlayOneShotGame("workingDough/BigBarely");
                doughDudesPlayer.GetComponent<Animator>().Play("BigDoughJump", 0, 0);

                playerImpact.SetActive(true);
                SpawnPlayerBallResult(beat, true, playerBarelyCurveFirst, playerBarelyCurveSecond, 0.75f, 1f);
                BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat + 0.1f, delegate { playerImpact.SetActive(false); }),
                });
                return;
            }
            Success(true, beat);
        }

        void Success(bool isBig, float beat)
        {
            if (isBig)
            {
                Jukebox.PlayOneShotGame("workingDough/rightBig");
                doughDudesPlayer.GetComponent<Animator>().Play("BigDoughJump", 0, 0);
                backgroundAnimator.Play("BackgroundFlash", 0, 0);
            }
            else
            {
                Jukebox.PlayOneShotGame("workingDough/rightSmall");
                doughDudesPlayer.GetComponent<Animator>().Play("SmallDoughJump", 0, 0);
            }
            playerImpact.SetActive(true);
            SpawnPlayerBallResult(beat, isBig, playerExitUpCurve, playerExitDownCurve, 0.5f, 0.5f);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 0.1f, delegate { playerImpact.SetActive(false); }),
                new BeatAction.Action(beat + 0.9f, delegate { arrowSRRightPlayer.sprite = redArrowSprite; }),
                new BeatAction.Action(beat + 1f, delegate { arrowSRRightPlayer.sprite = whiteArrowSprite; }),
                new BeatAction.Action(beat + 2f, delegate { SpawnBGBall(beat + 2f, isBig); }),
            });
        }

        void SpawnBGBall(float beat, bool isBig)
        {
            var objectToSpawn = isBig ? bigBGBall : smallBGBall;
            var spawnedBall = GameObject.Instantiate(objectToSpawn, ballHolder);

            var ballComponent = spawnedBall.GetComponent<BGBall>();
            ballComponent.startBeat = beat;
            ballComponent.firstCurve = isBig ? firstBGCurveBig : firstBGCurveSmall;
            ballComponent.secondCurve = isBig ? secondBGCurveBig : secondBGCurveSmall;
            ballComponent.thirdCurve = isBig ? thirdBGCurveBig : thirdBGCurveSmall;

            spawnedBall.SetActive(true);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 9f, delegate { if (!spaceshipRisen) spaceshipAnimator.Play("AbsorbBall", 0, 0); }),
            });
        }

        public void InstantElevation(bool isUp)
        {
            doughDudesHolderAnim.Play(isUp ? "InAir" : "OnGround", 0, 0);
        }

        public void Elevate(float beat, float length, bool isUp)
        {
            liftingAnimName = isUp ? "LiftUp" : "LiftDown";
            liftingStartBeat = beat;
            liftingLength = length;
            liftingDoughDudes = true;
            doughDudesHolderAnim.DoScaledAnimation(liftingAnimName, liftingStartBeat, liftingLength);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + length - 0.1f, delegate { liftingDoughDudes = false; }),
            });
        } 

        public void LaunchShip(float beat, float length)
        {
            spaceshipRisen = true;
            if (!spaceshipLights.activeSelf)
            {
                spaceshipLights.SetActive(true);
                spaceshipLights.GetComponent<Animator>().Play("SpaceshipLights", 0, 0);
            }
            spaceshipAnimator.Play("SpaceshipShake", 0, 0);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + length, delegate { spaceshipAnimator.Play("SpaceshipLaunch", 0, 0); }),
                new BeatAction.Action(beat + length, delegate { Jukebox.PlayOneShotGame("workingDough/LaunchRobot"); }),
                new BeatAction.Action(beat + length, delegate { Jukebox.PlayOneShotGame("workingDough/Rocket"); }),
            });
        }

        public void RiseUpShip(float beat, float length)
        { 
            spaceshipRisen = true;
            spaceshipRising = true;
            risingLength = length;
            risingStartBeat = beat;
            if (!spaceshipLights.activeSelf)
            {
                spaceshipLights.SetActive(true);
                spaceshipLights.GetComponent<Animator>().Play("SpaceshipLights", 0, 0);
            }
            spaceshipAnimator.DoScaledAnimation("RiseSpaceship", risingStartBeat, risingLength);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + length - 0.1f, delegate { spaceshipRising = false; }),
            });
        }

        public void GANDWEnterOrExit(float beat, float length, bool shouldExit)
        {
            gandwMoving = true;
            gandwHasEntered = false;
            gandMovingLength = length;
            gandMovingStartBeat = beat;
            gandwMovingAnimName = shouldExit ? "GANDWLeave" : "GANDWEnter";
            gandwAnim.DoScaledAnimation(gandwMovingAnimName, gandMovingStartBeat, gandMovingLength);
            BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + length - 0.1f, delegate { gandwMoving = false; }),
                new BeatAction.Action(beat + length, delegate { gandwHasEntered = shouldExit ? false : true; }),
            });
        }

        public void InstantGANDWEnterOrExit(bool shouldExit)
        {
            gandwAnim.Play(shouldExit ? "GANDWLeft" : "MrGameAndWatchLeverDown", 0, 0);
            gandwHasEntered = shouldExit ? false : true;
        }

        void Nothing (PlayerActionEvent caller) {}
    }
}