HeavenStudio/Assets/Scripts/Games/FanClub/FanClub.cs

using HeavenStudio.Util;
using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine;
using UnityEngine.Rendering; //don't ask

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    public static class NtrIdolLoader
    {
        public static Minigame AddGame(EventCaller eventCaller) {
            return new Minigame("fanClub", "Fan Club", "ff78ff", false, false, new List<GameAction>()
                {
                    new GameAction("bop", "Bop")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.Bop(e.beat, e.length, e["type"], e["type2"]); }, 
                        resizable = true,
                        parameters = new List<Param>()
                        {
                            new Param("type", FanClub.IdolBopType.Both, "Bop target", "Who to make bop"),
                            new Param("type2", FanClub.IdolBopType.None, "Bop target (Auto)", "Who to make auto bop"),
                        }
                    },
                    new GameAction("yeah, yeah, yeah", "Yeah, Yeah, Yeah!")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallHai(e.beat, e["toggle"]); }, 
                        defaultLength = 8,
                        parameters = new List<Param>()
                        {
                            new Param("toggle", false, "Disable call", "Disable the idol's call")
                        },
                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e["toggle"]);},
                        preFunction = delegate { var e = eventCaller.currentEntity; FanClub.HaiSound(e.beat, e["toggle"]); }
                    },
                    new GameAction("I suppose", "I Suppose!")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallKamone(e.beat, e["toggle"], 0, e["type"], e["alt"]); }, 
                        defaultLength = 6, 
                        parameters = new List<Param>()
                        {
                            new Param("type", FanClub.KamoneResponseType.Through, "Response type", "Type of response to use"),
                            new Param("toggle", false, "Disable call", "Disable the idol's call"),
                            new Param("alt", false, "Alternate cue", "Use an alternate cue")
                        },
                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e["toggle"], 0, e["type"], e["alt"]);},
                        preFunction = delegate { var e = eventCaller.currentEntity; FanClub.KamoneSound(e.beat, e["toggle"], 0, e["type"], e["alt"]); }
                    },
                    new GameAction("double clap", "Double Clap")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallBigReady(e.beat, e["toggle"]); }, 
                        defaultLength = 4,
                        parameters = new List<Param>()
                        {
                            new Param("toggle", false, "Disable call", "Disable the call")
                        },
                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e["toggle"]); },
                        preFunction = delegate { var e = eventCaller.currentEntity; FanClub.BigReadySound(e.beat, e["toggle"]); }
                    },
                    new GameAction("play idol animation", "Idol Coreography")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnim(e.beat, e.length, e["type"], e["who"]); },
                        resizable = true, 
                        parameters = new List<Param>()
                        {
                            new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Animation to play"),
                            new Param("who", FanClub.IdolType.All, "Target Idol", "Target to play the animation on")
                        }
                    },
                    new GameAction("play stage animation", "Stage Coreography")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnimStage(e.beat, e["type"]); }, 
                        resizable = true, 
                        parameters = new List<Param>()
                        {
                            new Param("type", FanClub.StageAnimations.Flash, "Animation", "Animation to play")
                        }
                    },
                    new GameAction("friend walk", "Backup Dancers Entrance")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.DancerTravel(e.beat, e.length, e["exit"], e["instant"]); },
                        defaultLength = 16f,
                        resizable = true, 
                        parameters = new List<Param>()
                        {
                            new Param("exit", false, "Exit", "Backup dancers exit instead"),
                            new Param("instant", false, "Instant Travel", "Backup dancers instantly finish their travel"),
                        }
                    },
                    new GameAction("set performance type", "Coreography Type")
                    {

                        function = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e["type"]);},
                        defaultLength = 0.5f,
                        parameters = new List<Param>()
                        {
                            new Param("type", FanClub.IdolPerformanceType.Normal, "Performance Type", "Set of animations for the idol to use")
                        },
                        inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e["type"]); }
                    },
                    new GameAction("finish", "Applause")
                    {
                        function = delegate { var e = eventCaller.currentEntity; FanClub.instance.FinalCheer(e.beat); }, 
                    },
                },
                new List<string>() {"ntr", "normal"},
                "ntridol", "jp",
                new List<string>() {"jp"}
            );
        }
    }
}

namespace HeavenStudio.Games
{
    using Scripts_FanClub;
    
    public class FanClub : Minigame
    {
        public enum IdolBopType {
            Both,
            Idol,
            Spectators,
            None
        }
        public enum IdolAnimations {
            Bop,
            PeaceVocal,
            Peace,
            Clap,
            Call,
            Response,
            Jump,
            BigCall,
            Squat,
            Wink,
            Dab,
            None
        }
        public enum KamoneResponseType {
            Through,
            Jump,
            ThroughFast,
            JumpFast,
        }
        public enum StageAnimations {
            Reset,
            Flash,
            Spot
        }
        public enum IdolPerformanceType {
            Normal,
            Arrange,
            // Tour(this one is fan made so ?)
        }
        public enum IdolType {
            All,
            Idol,
            LeftDancer,
            RightDancer
        }

        // userdata here
        [Header("Animators")]
        //stage
        [SerializeField] Animator StageAnimator;

        [Header("Objects")]
        // our girl
        [SerializeField] GameObject Arisa;
        [SerializeField] GameObject ArisaRootMotion;
        [SerializeField] GameObject ArisaShadow;

        // spectators
        [SerializeField] GameObject spectator;
        [SerializeField] GameObject spectatorAnchor;

        // backup dancers
        [SerializeField] NtrIdolAmie Blue;
        [SerializeField] NtrIdolAmie Orange;

        [Header("References")]
        [SerializeField] Material spectatorMat;

        // end userdata

        public bool JudgementPaused { get => noJudgement; }
        public bool JudgementInputPaused { get => noJudgementInput; set => noJudgementInput = value;}

        //arisa's animation controller
        private Animator idolAnimator;

        // blue's animation controller
        private Animator backupRAnimator;

        // orange's animation controller
        private Animator backupLAnimator;
        
        //spectators
        private NtrIdolFan Player;
        private List<GameObject> Spectators;

        //bop-type animations
        private GameEvent bop = new GameEvent();
        private GameEvent specBop = new GameEvent();
        private GameEvent noBop = new GameEvent();
        private GameEvent noResponse = new GameEvent();
        private GameEvent noCall = new GameEvent();
        private GameEvent noSpecBop = new GameEvent();

        private float idolJumpStartTime = Single.MinValue;
        private static int performanceType = (int) IdolPerformanceType.Normal;
        private bool responseToggle = false;
        private static float wantHais = Single.MinValue;
        private static float wantKamone = Single.MinValue;
        private static int wantKamoneType = (int) KamoneResponseType.Through;
        private static bool wantKamoneAlt = false;
        private static float wantBigReady = Single.MinValue;
        private bool hasJumped = false;
        private bool goBopIdol = true;
        private bool goBopSpec = true;
        private bool noJudgement = false;
        private bool noJudgementInput = false;

        //game scene
        public static FanClub instance;

        const int FAN_COUNT = 12;
        const float RADIUS = 1.5f;
        private void Awake()
        {
            instance = this;
            Spectators = new List<GameObject>();
            idolAnimator = Arisa.GetComponent<Animator>();
            backupRAnimator = Blue.GetComponent<Animator>();
            backupLAnimator = Orange.GetComponent<Animator>();

            // procedurally spawning the spectators
            // from middle of viewport:

            //  |========A========|
            //  f==f==f==0==p==f==f
            // f==f==f==0==0==f==f==f

            //spawn 12, the 4th is our player (idx 3)
            Vector3 origin = spectatorAnchor.transform.localPosition;
            int sortOrigin = spectatorAnchor.GetComponent<SortingGroup>().sortingOrder;
            Vector3 spawnPos = new Vector3(origin.x, origin.y, origin.z);
            spawnPos.x -= RADIUS * 2 * 3;
            for (int i = 0; i < FAN_COUNT; i++)
            {
                GameObject mobj = Instantiate(spectator, spectatorAnchor.transform.parent);
                NtrIdolFan fan = mobj.GetComponent<NtrIdolFan>();
                mobj.transform.localPosition = new Vector3(spawnPos.x, spawnPos.y, spawnPos.z);
                mobj.GetComponent<SortingGroup>().sortingOrder = i + sortOrigin;
                if (i == 3)
                {
                    Player = fan;
                    Player.player = true;
                }
                Spectators.Add(mobj);

                //prepare spawn point of next spectator
                spawnPos.x += RADIUS * 2;
                if (i == 2)
                    spawnPos.x += RADIUS * 2;
                if (i == 8)
                    spawnPos.x += RADIUS * 4;
                if (i == 5)
                {
                    spawnPos = new Vector3(origin.x, origin.y, origin.z);
                    spawnPos.x -= RADIUS * 2 * 4 - RADIUS;
                    spawnPos.y -= RADIUS;
                    // spawnPos.z -= RADIUS/4;
                }
            }

            if (performanceType != (int) IdolPerformanceType.Normal)
            {
                idolAnimator.Play("NoPose" + GetPerformanceSuffix(), -1, 0);
            }

            ToSpot();
            noJudgement = false;
            noJudgementInput = false;
        }

        private void Start()
        {
            Blue.Init();
            Orange.Init();

            var amieWalkEvts = EventCaller.GetAllInGameManagerList("fanClub", new string[] { "friend walk" });
            foreach (var e in amieWalkEvts)
            {
                if (e.beat <= Conductor.instance.songPositionInBeatsAsDouble)
                {
                    DancerTravel(e.beat, e.length, e["exit"], e["instant"]);
                }
            }

            FanClub.SetPerformanceType((int) IdolPerformanceType.Normal);
            var choreoTypeEvts = EventCaller.GetAllInGameManagerList("fanClub", new string[] { "set performance type" });
            foreach (var e in choreoTypeEvts)
            {
                if (e.beat <= Conductor.instance.songPositionInBeatsAsDouble)
                {
                    FanClub.SetPerformanceType(e["type"]);
                }
            }
        }

        public static string GetPerformanceSuffix()
        {
            switch (performanceType)
            {
                case (int) IdolPerformanceType.Arrange:
                    return "Arrange";
                default:
                    return "";
            }
        }
        
        public static void SetPerformanceType(int type = (int) IdolPerformanceType.Normal)
        {
            performanceType = type;
            if (GameManager.instance.currentGame == "fanClub")
            {
                FanClub.instance.idolAnimator.Play("NoPose" + GetPerformanceSuffix(), -1, 0);
            }
        }

        public override void OnGameSwitch(float beat)
        {
            if (wantHais != Single.MinValue)
            {
                ContinueHais(wantHais);
                wantHais = Single.MinValue;
            }
            if (wantKamone != Single.MinValue)
            {
                ContinueKamone(wantKamone, 0, wantKamoneType, wantKamoneAlt);
                wantKamone = Single.MinValue;
            }
            if (wantBigReady != Single.MinValue)
            {
                ContinueBigReady(wantBigReady);
                wantBigReady = Single.MinValue;
            }
        }

        private void Update()
        {
            var cond = Conductor.instance;
            if (cond.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1))
            {
                if (goBopIdol)
                {
                    if (!(cond.songPositionInBeats >= noBop.startBeat && cond.songPositionInBeats < noBop.startBeat + noBop.length))
                    {
                        idolAnimator.Play("IdolBeat" + GetPerformanceSuffix(), 0, 0);
                        Blue.PlayAnimState("Beat");
                        Orange.PlayAnimState("Beat");
                    }
                }
            }

            if (cond.ReportBeat(ref specBop.lastReportedBeat, specBop.startBeat % 1))
            {
                if (goBopSpec)
                {
                    if (!(cond.songPositionInBeats >= noSpecBop.startBeat && cond.songPositionInBeats < noSpecBop.startBeat + noSpecBop.length))
                        BopAll();
                }
            }
            
            //idol jumping physics
            float jumpPos = cond.GetPositionFromBeat(idolJumpStartTime, 1f);
            float IDOL_SHADOW_SCALE = 1.18f;
            if (cond.songPositionInBeats >= idolJumpStartTime && cond.songPositionInBeats < idolJumpStartTime + 1f)
            {
                hasJumped = true;
                float yMul = jumpPos * 2f - 1f;
                float yWeight = -(yMul*yMul) + 1f;
                ArisaRootMotion.transform.localPosition = new Vector3(0, 2f * yWeight + 0.25f);
                ArisaShadow.transform.localScale = new Vector3((1f-yWeight*0.8f) * IDOL_SHADOW_SCALE, (1f-yWeight*0.8f) * IDOL_SHADOW_SCALE, 1f);
            }
            else
            {
                idolJumpStartTime = Single.MinValue;
                ArisaRootMotion.transform.localPosition = new Vector3(0, 0);
                ArisaShadow.transform.localScale = new Vector3(IDOL_SHADOW_SCALE, IDOL_SHADOW_SCALE, 1f);
            }
        }

        public void Bop(float beat, float length, int target = (int) IdolBopType.Both, int targetAuto = (int)IdolBopType.Both)
        {
            goBopIdol = targetAuto == (int)IdolBopType.Both || targetAuto == (int)IdolBopType.Idol;
            goBopSpec = targetAuto == (int)IdolBopType.Both || targetAuto == (int)IdolBopType.Spectators;
            for (int i = 0; i < length; i++)
            {
                BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat + i, delegate { BopSingle(target); })
                });
            }
        }

        void BopSingle(int target)
        {
            switch (target)
            {
                case (int)IdolBopType.Idol:
                    idolAnimator.Play("IdolBeat" + GetPerformanceSuffix(), 0, 0);
                    Blue.PlayAnimState("Beat");
                    Orange.PlayAnimState("Beat");
                    break;
                case (int)IdolBopType.Spectators:
                    BopAll();
                    break;
                case (int)IdolBopType.Both:
                    idolAnimator.Play("IdolBeat" + GetPerformanceSuffix(), 0, 0);
                    Blue.PlayAnimState("Beat");
                    Orange.PlayAnimState("Beat");
                    BopAll();
                    break;
                default:
                    break;
            }
        }

        private void DisableBop(float beat, float length)
        {
            noBop.length = length;
            noBop.startBeat = beat;
        }

        private void DisableResponse(float beat, float length)
        {
            noResponse.length = length;
            noResponse.startBeat = beat;
        }

        private void DisableCall(float beat, float length)
        {
            noCall.length = length;
            noCall.startBeat = beat;
        }

        private void DisableSpecBop(float beat, float length)
        {
            float bt = Conductor.instance.songPositionInBeats;
            if (bt >= noSpecBop.startBeat && bt < noSpecBop.startBeat + noSpecBop.length)
            {
                float thisStToNextSt = beat - noSpecBop.startBeat;
                float newLen = thisStToNextSt + length;
                if (newLen > noSpecBop.length)
                    noSpecBop.length = thisStToNextSt + length;
            }
            else
            {
                noSpecBop.length = length;
                noSpecBop.startBeat = beat;
            }
        }

        public void PlayAnim(float beat, float length, int type, int who)
        {
            idolJumpStartTime = Single.MinValue;
            DisableResponse(beat, length + 0.5f);
            DisableBop(beat, length + 0.5f);
            DisableCall(beat, length + 0.5f);

            if (who is (int)IdolType.All or (int)IdolType.LeftDancer)
                Orange.PlayAnim(beat, length, type);
            if (who is (int)IdolType.All or (int)IdolType.RightDancer)
                Blue.PlayAnim(beat, length, type);

            if (who is (int)IdolType.All or (int)IdolType.Idol)
            {
                switch (type)
                {
                    case (int)IdolAnimations.Bop:
                        idolAnimator.Play("IdolBeat" + GetPerformanceSuffix(), -1, 0);
                        break;
                    case (int)IdolAnimations.PeaceVocal:
                        idolAnimator.Play("IdolPeace" + GetPerformanceSuffix(), -1, 0);
                        break;
                    case (int)IdolAnimations.Peace:
                        idolAnimator.Play("IdolPeaceNoSync" + GetPerformanceSuffix(), -1, 0);
                        break;
                    case (int)IdolAnimations.Clap:
                        idolAnimator.Play("IdolCrap" + GetPerformanceSuffix(), -1, 0);
                        break;
                    case (int)IdolAnimations.Call:
                        BeatAction.New(Arisa, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat,             delegate { Arisa.GetComponent<Animator>().Play("IdolCall0" + GetPerformanceSuffix(), -1, 0); }),
                        new BeatAction.Action(beat + 0.75f,     delegate { Arisa.GetComponent<Animator>().Play("IdolCall1" + GetPerformanceSuffix(), -1, 0); }),
                    });
                        break;
                    case (int)IdolAnimations.Response:
                        idolAnimator.Play("IdolResponse" + GetPerformanceSuffix(), -1, 0);
                        break;
                    case (int)IdolAnimations.Jump:
                        DoIdolJump(beat, length);
                        break;
                    case (int)IdolAnimations.BigCall:
                        BeatAction.New(Arisa, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat,             delegate { Arisa.GetComponent<Animator>().Play("IdolBigCall0" + GetPerformanceSuffix(), -1, 0); }),
                        new BeatAction.Action(beat + length,    delegate { Arisa.GetComponent<Animator>().Play("IdolBigCall1" + GetPerformanceSuffix(), -1, 0); }),
                    });
                        break;
                    case (int)IdolAnimations.Squat:
                        BeatAction.New(Arisa, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat,             delegate { Arisa.GetComponent<Animator>().Play("IdolSquat0" + GetPerformanceSuffix(), -1, 0); }),
                        new BeatAction.Action(beat + length,    delegate { Arisa.GetComponent<Animator>().Play("IdolSquat1" + GetPerformanceSuffix(), -1, 0); }),
                    });
                        break;
                    case (int)IdolAnimations.Wink:
                        BeatAction.New(Arisa, new List<BeatAction.Action>()
                    {
                        new BeatAction.Action(beat,             delegate { Arisa.GetComponent<Animator>().Play("IdolWink0" + GetPerformanceSuffix(), -1, 0); }),
                        new BeatAction.Action(beat + length,    delegate { Arisa.GetComponent<Animator>().Play("IdolWink1" + GetPerformanceSuffix(), -1, 0); }),
                    });
                        break;
                    case (int)IdolAnimations.Dab:
                        idolAnimator.Play("IdolDab" + GetPerformanceSuffix(), -1, 0);
                        Jukebox.PlayOneShotGame("fanClub/arisa_dab");
                        break;
                    default: break;
                }
            }
        }

        public void PlayAnimStage(float beat, int type)
        {
            switch (type)
            {
                case (int) StageAnimations.Reset:
                    StageAnimator.Play("Bg", -1, 0);
                    ToSpot();
                    break;
                case (int) StageAnimations.Flash:
                    StageAnimator.Play("Bg_Light", -1, 0);
                    ToSpot();
                    break;
                case (int) StageAnimations.Spot:
                    StageAnimator.Play("Bg_Spot", -1, 0);
                    ToSpot(false);
                    break;
            }
        }

        public void ToSpot(bool unspot = true)
        {
            Arisa.GetComponent<NtrIdolAri>().ToSpot(unspot);
            Blue.ToSpot(unspot);
            Orange.ToSpot(unspot);
            if (unspot)
                spectatorMat.SetColor("_Color", new Color(1, 1, 1, 1));
            else
                spectatorMat.SetColor("_Color", new Color(117/255f, 177/255f, 209/255f, 1));
        }

        private void DoIdolJump(float beat, float length = 3f)
        {
            DisableBop(beat, length);
            DisableResponse(beat, length);
            idolJumpStartTime = beat;

            //play anim
            BeatAction.New(Arisa, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat,                     delegate { Arisa.GetComponent<Animator>().Play("IdolJump" + GetPerformanceSuffix(), -1, 0); }),
                new BeatAction.Action(beat + 1f,                delegate { Arisa.GetComponent<Animator>().Play("IdolLand" + GetPerformanceSuffix(), -1, 0); }),
            });
        }

        private void DoIdolClaps()
        {
            if (!responseToggle)
            {
                if (!(Conductor.instance.songPositionInBeats >= noResponse.startBeat && Conductor.instance.songPositionInBeats < noResponse.startBeat + noResponse.length))
                {
                    idolAnimator.Play("IdolCrap" + GetPerformanceSuffix(), -1, 0);
                    Blue.PlayAnimState("Crap");
                    Orange.PlayAnimState("Crap");
                }
            }
        }

        private void DoIdolPeace(bool sync = true)
        {
            if (!(Conductor.instance.songPositionInBeats >= noCall.startBeat && Conductor.instance.songPositionInBeats < noCall.startBeat + noCall.length))
            {
                if (sync)
                    idolAnimator.Play("IdolPeace" + GetPerformanceSuffix(), -1, 0);
                else
                    idolAnimator.Play("IdolPeaceNoSync" + GetPerformanceSuffix(), -1, 0);
                Blue.PlayAnimState("Peace");
                Orange.PlayAnimState("Peace");
            }
        }

        private void DoIdolResponse()
        {
            if (responseToggle)
            {
                if (!(Conductor.instance.songPositionInBeats >= noResponse.startBeat && Conductor.instance.songPositionInBeats < noResponse.startBeat + noResponse.length))
                    idolAnimator.Play("IdolResponse" + GetPerformanceSuffix(), -1, 0);
            }
        }

        private void DoIdolCall(int part = 0, bool big = false)
        {
            if (!(Conductor.instance.songPositionInBeats >= noCall.startBeat && Conductor.instance.songPositionInBeats < noCall.startBeat + noCall.length))
            {
                if (big)
                {
                    idolAnimator.Play("IdolBigCall" + part + GetPerformanceSuffix(), -1, 0);
                }
                else
                {
                    idolAnimator.Play("IdolCall" + part + GetPerformanceSuffix(), -1, 0);
                }
            }
        }

        const float HAIS_LENGTH = 4.5f;
        public void CallHai(float beat, bool noSound = false, int type = 0)
        {
            responseToggle = false;
            DisableBop(beat, 8f);

            Prepare(beat + 3f); 
            Prepare(beat + 4f); 
            Prepare(beat + 5f); 
            Prepare(beat + 6f); 

            BeatAction.New(Arisa, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat,         delegate { DoIdolPeace();}),
                new BeatAction.Action(beat + 1f,    delegate { DoIdolPeace();}),
                new BeatAction.Action(beat + 2f,    delegate { DoIdolPeace();}),
                new BeatAction.Action(beat + 2.5f,  delegate { DisableSpecBop(beat + 2.5f, 5f);}),
                new BeatAction.Action(beat + 3f,    delegate { DoIdolPeace(false); PlayPrepare(); }),

                new BeatAction.Action(beat + 4f,    delegate { PlayOneClap(beat + 4f); DoIdolClaps();}),
                new BeatAction.Action(beat + 5f,    delegate { PlayOneClap(beat + 5f); DoIdolClaps();}),
                new BeatAction.Action(beat + 6f,    delegate { PlayOneClap(beat + 6f); DoIdolClaps();}),
                new BeatAction.Action(beat + 7f,    delegate { PlayOneClap(beat + 7f); DoIdolClaps();}),
            });

            PlaySoundSequence("fanClub", "crowd_hai", beat + 4f);
        }

        public static void WarnHai(float beat, bool noSound = false, int type = 0)
        {
            wantHais = beat;
        }

        public static void HaiSound(float beat, bool noSound = false, int type = 0)
        {
            if (noSound) return;
            PlaySoundSequence("fanClub", "arisa_hai", beat);
        }


        public void ContinueHais(float beat, int type = 0)
        {
            CallHai(beat, true, type);
        }

        const float CALL_LENGTH = 2.5f;
        public void CallKamone(float beat, bool noSound = false, int type = 0, int responseType = (int) KamoneResponseType.Through, bool alt = false)
        {
            bool doJump = (responseType == (int) KamoneResponseType.Jump || responseType == (int) KamoneResponseType.JumpFast);
            bool isBig = (responseType == (int) KamoneResponseType.ThroughFast || responseType == (int) KamoneResponseType.JumpFast);
            DisableResponse(beat, 2f);

            responseToggle = true;
            DisableBop(beat, (doJump) ? 6.25f : 5.25f);
            DisableSpecBop(beat + 0.5f, 6f);

            Prepare(beat + 1f, 3);
            Prepare(beat + 2.5f);
            Prepare(beat + 3f, 2);
            Prepare(beat + 4f, 1);

            BeatAction.New(Arisa, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat,                         delegate { DoIdolCall(0, isBig); Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat"); }),
                new BeatAction.Action(beat + (isBig ? 1f : 0.75f),  delegate { DoIdolCall(1, isBig); }),
                new BeatAction.Action(beat + 1f,    delegate { PlayPrepare(); Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat");  }),

                new BeatAction.Action(beat + 2f,    delegate { PlayLongClap(beat + 2f); DoIdolResponse(); Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat");  }),
                new BeatAction.Action(beat + 3f,    delegate { DoIdolResponse(); Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat");  }),
                new BeatAction.Action(beat + 3.5f,  delegate { PlayOneClap(beat + 3.5f); }),
                new BeatAction.Action(beat + 4f,    delegate { PlayChargeClap(beat + 4f); DoIdolResponse(); Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat");  }),
                new BeatAction.Action(beat + 5f,    delegate { PlayJump(beat + 5f);
                    if (doJump) 
                    {
                        DoIdolJump(beat + 5f);
                        Blue.DoIdolJump(beat + 5f);
                        Orange.DoIdolJump(beat + 5f);
                    }
                    else
                    {
                        DoIdolResponse();
                        Blue.PlayAnimState("Beat"); Orange.PlayAnimState("Beat"); 
                    }
                }),
            });

            PlaySoundSequence("fanClub", alt ? "crowd_iina" : "crowd_kamone", beat + 2f);
        }

        public static void WarnKamone(float beat, bool noSound = false, int type = 0, int responseType = (int) KamoneResponseType.Through, bool alt = false)
        {
            wantKamone = beat;
            wantKamoneType = responseType;
            wantKamoneAlt = alt;
        }

        public static void KamoneSound(float beat, bool noSound = false, int type = 0, int responseType = (int) KamoneResponseType.Through, bool alt = false)
        {
            if (noSound) return;
            if (responseType == (int) KamoneResponseType.ThroughFast || responseType == (int) KamoneResponseType.JumpFast)
            {
                PlaySoundSequence("fanClub", alt ? "arisa_iina_fast" : "arisa_kamone_fast", beat);
            }
            else
            {
                PlaySoundSequence("fanClub", alt ? "arisa_iina" : "arisa_kamone", beat);
            }
        }

        public void ContinueKamone(float beat, int type = 0, int responseType = (int) KamoneResponseType.Through, bool alt = false)
        {
            CallKamone(beat, true, type, responseType, alt);
        }

        const float BIGCALL_LENGTH = 2.75f;
        public void CallBigReady(float beat, bool noSound = false)
        {
            Prepare(beat + 1.5f);
            Prepare(beat + 2f);
            
            DisableSpecBop(beat, 3.75f);

            PlayAnimationAll("FanBigReady", onlyOverrideBop: true);
            BeatAction.New(this.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat + 1.5f,   delegate { PlayAnimationAll("FanBigReady", onlyOverrideBop: true); }),
                new BeatAction.Action(beat + 2f,    delegate { PlayAnimationAll("FanBigReady", onlyOverrideBop: true); }),
                new BeatAction.Action(beat + 2.5f,  delegate { PlayOneClap(beat + 2.5f);}),
                new BeatAction.Action(beat + 3f,    delegate { PlayOneClap(beat + 3f);}),
            });
        }

        public static void WarnBigReady(float beat, bool noSound = false)
        {
            wantBigReady = beat;
        }

        public static void BigReadySound(float beat, bool noSound = false)
        {
            if (noSound) return;
            PlaySoundSequence("fanClub", "crowd_big_ready", beat);
        }

        public void ContinueBigReady(float beat)
        {
            CallBigReady(beat, true);
        }

        public void Prepare(float beat, int type = 0)
        {
            Player.AddHit(beat, type);
        }

        private void PlayAnimationAll(string anim, bool noPlayer = false, bool doForced = false, bool onlyOverrideBop = false)
        {
            for (int i = 0; i < Spectators.Count; i++)
            {
                if (i == 3 && noPlayer)
                    continue;
                
                if (!Spectators[i].GetComponent<Animator>().IsAnimationNotPlaying() && !doForced)
                {
                    if (onlyOverrideBop)
                    {
                        string clipName = Spectators[i].GetComponent<Animator>().GetCurrentAnimatorClipInfo(0)[0].clip.name;
                        if (clipName == "FanBeat" || clipName == "NoPose")
                            Spectators[i].GetComponent<Animator>().Play(anim, -1, 0);
                    }
                    continue;
                }
                Spectators[i].GetComponent<Animator>().Play(anim, -1, 0);
            }
        }

        private void BopAll(bool noPlayer = false, bool doForced = false)
        {
            for (int i = 0; i < Spectators.Count; i++)
            {
                if (i == 3 && noPlayer)
                    continue;
                
                string clipName = Spectators[i].GetComponent<Animator>().GetCurrentAnimatorClipInfo(0)[0].clip.name;
                if (!Spectators[i].GetComponent<Animator>().IsAnimationNotPlaying() && !doForced)
                {
                    if (clipName == "FanBeat" || clipName == "NoPose")
                        Spectators[i].GetComponent<NtrIdolFan>().Bop();
                    continue;
                }
                Spectators[i].GetComponent<NtrIdolFan>().Bop();
            }
        }

        private void PlayPrepare()
        {
            for (int i = 0; i < Spectators.Count; i++)
            {
                if (Spectators[i].GetComponent<NtrIdolFan>().IsJumping())
                    continue;
                Spectators[i].GetComponent<Animator>().Play("FanPrepare", -1, 0);
            }
        }

        private void PlayOneClap(float beat, int who = -1)
        {
            if (who != -1) 
            {
                if (who == 3)
                {
                    if (GameManager.instance.autoplay)
                    {
                        Player.ClapStart(true, false, 0.1f);
                    }
                    return;
                }
                // Jukebox.PlayOneShotGame("fanClub/play_clap", volume: 0.08f);
                Jukebox.PlayOneShotGame("fanClub/crap_impact", pitch: UnityEngine.Random.Range(0.95f, 1.05f), volume: 0.1f);
                BeatAction.New(Spectators[who], new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat, delegate { Spectators[who].GetComponent<Animator>().Play("FanClap", -1, 0); }),
                    new BeatAction.Action(beat + 0.1f, delegate { Spectators[who].GetComponent<Animator>().Play("FanFree", -1, 0); }),

                });
            }
            else
            {
                BeatAction.New(this.gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(beat, delegate { PlayAnimationAll("FanClap", true, true);}),
                    new BeatAction.Action(beat + 0.1f, delegate { PlayAnimationAll("FanFree", true, true);}),
                });
            }
        }

        private void PlayLongClap(float beat)
        {
            BeatAction.New(this.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { PlayAnimationAll("FanClap", true, true);}),
                new BeatAction.Action(beat + 1f, delegate { PlayAnimationAll("FanFree", true, true);}),
            });
        }

        private void PlayChargeClap(float beat)
        {
            BeatAction.New(this.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { PlayAnimationAll("FanClap", true, true);}),
                new BeatAction.Action(beat + 0.1f, delegate { PlayAnimationAll("FanClapCharge", true, true);}),
            });
        }

        private void StartJump(int idx, float beat)
        {
            Spectators[idx].GetComponent<NtrIdolFan>().jumpStartTime = beat;
            BeatAction.New(Spectators[idx], new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { Spectators[idx].GetComponent<Animator>().Play("FanJump", -1, 0);}),
                new BeatAction.Action(beat + 1f, delegate { Spectators[idx].GetComponent<Animator>().Play("FanPrepare", -1, 0);}),
            });
        }

        private void PlayJump(float beat)
        {
            for (int i = 0; i < Spectators.Count; i++)
            {
                if (i == 3)
                    continue;
                
                StartJump(i, beat);
            }
        }

        public void AngerOnMiss()
        {
            for (int i = 0; i <= 5; i++)
            {
                if (i == 3)
                    continue;
                Spectators[i].GetComponent<NtrIdolFan>().MakeAngry(i > 3);
            }
        }

        public void DancerTravel(float beat, float length, bool exit, bool instant)
        {
            if (instant)
            {
                Blue.FinishEntrance(exit);
                Orange.FinishEntrance(exit);
            }
            else
            {
                Blue.StartEntrance(beat, length, exit);
                Orange.StartEntrance(beat, length, exit);
            }
        }

        public void FinalCheer(float beat)
        {
            if (noJudgement) return;
            noJudgement = true;
            noJudgementInput = false;
            goBopSpec = false;

            // recreation of sub61
            BeatAction.New(this.gameObject, new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { StartClapLoop(beat, 1);}),
                
                new BeatAction.Action(beat + (2f/3f), delegate { StartClapLoop(beat + (2f/3f), 0);}),
                new BeatAction.Action(beat + (2f/3f), delegate { StartClapLoop(beat + (2f/3f), 3);}),

                new BeatAction.Action(beat + (2f/3f) + 0.25f, delegate { StartClapLoop(beat + (2f/3f) + 0.25f, 6);}),
                new BeatAction.Action(beat + (2f/3f) + 0.25f, delegate { StartClapLoop(beat + (2f/3f) + 0.25f, 8);}),

                new BeatAction.Action(beat + (2f/3f) + 0.5f, delegate { StartClapLoop(beat + (2f/3f) + 0.5f, 7);}),
                new BeatAction.Action(beat + (2f/3f) + 0.5f, delegate { StartClapLoop(beat + (2f/3f) + 0.5f, 4);}),

                new BeatAction.Action(beat + 1.5f, delegate { StartClapLoop(beat + 1.5f, 2);}),
                new BeatAction.Action(beat + 1.5f, delegate { StartClapLoop(beat + 1.5f, 11);}),

                new BeatAction.Action(beat + 1.5f + (1f/3f), delegate { StartClapLoop(beat + 1.5f + (1f/3f), 5);}),
                new BeatAction.Action(beat + 1.5f + (1f/3f), delegate { StartClapLoop(beat + 1.5f + (1f/3f), 10);}),

                new BeatAction.Action(beat + 2f + (1f/3f), delegate { StartClapLoop(beat + 2f + (1f/3f), 9);}),

                // 0x113
                new BeatAction.Action(beat + 6f , delegate { CheckApplause();}),
            });

            MultiSound.Play(new MultiSound.Sound[] {
                new MultiSound.Sound("fanClub/play_jump", beat,                     pitch: 1f, volume: 0.6f),
                new MultiSound.Sound("fanClub/play_jump", beat + (2f/3f),           pitch: 0.98f, volume: 0.5f),
                new MultiSound.Sound("fanClub/play_jump", beat + (2f/3f) + 0.25f,   pitch: UnityEngine.Random.Range(0.9f, 1.05f), volume: 0.6f),
                new MultiSound.Sound("fanClub/play_jump", beat + (2f/3f) + 0.5f,    pitch: UnityEngine.Random.Range(0.9f, 1.05f), volume: 0.6f),
                new MultiSound.Sound("fanClub/play_jump", beat + 1.5f,              pitch: UnityEngine.Random.Range(0.9f, 1.05f), volume: 0.6f),
                new MultiSound.Sound("fanClub/play_jump", beat + 1.5f + (1f/3f),    pitch: UnityEngine.Random.Range(0.9f, 1.05f), volume: 0.6f),
                new MultiSound.Sound("fanClub/play_jump", beat + 2f + (1f/3f),      pitch: UnityEngine.Random.Range(0.9f, 1.05f), volume: 0.6f),
            });
        }

        void StartClapLoop(float beat, int who)
        {
            BeatAction.New(Spectators[who], new List<BeatAction.Action>()
            {
                new BeatAction.Action(beat, delegate { PlayOneClap(beat, who); }),
                new BeatAction.Action(beat + 0.5f, delegate { StartClapLoop(beat + 0.5f, who); }),
            });
        }

        void CheckApplause()
        {
            if (!noJudgementInput)
            {
                AngerOnMiss();
                // fuck you
                FanClub.instance.ScoreMiss(69);
            }
        }
    }
}