HeavenStudioPlus/Assets/Scripts/Games/Airboarder/Airboarder.cs

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

using HeavenStudio.Util;
using HeavenStudio.InputSystem;

using Jukebox;

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    /// Minigame loaders handle the setup of your minigame.
    /// Here, you designate the game prefab, define entities, and mark what AssetBundle to load

    /// Names of minigame loaders follow a specific naming convention of `PlatformcodeNameLoader`, where:
    /// `Platformcode` is a three-leter platform code with the minigame's origin
    /// `Name` is a short internal name
    /// `Loader` is the string "Loader"

    /// Platform codes are as follows:
    /// Agb: Gameboy Advance    ("Advance Gameboy")
    /// Ntr: Nintendo DS        ("Nitro")
    /// Rvl: Nintendo Wii       ("Revolution")
    /// Ctr: Nintendo 3DS       ("Centrair")
    /// Mob: Mobile
    /// Pco: PC / Other

    /// Fill in the loader class label, "*prefab name*", and "*Display Name*" with the relevant information
    /// For help, feel free to reach out to us on our discord, in the #development channel.
    public static class NtrAirboarderLoader
    {
        public static Minigame AddGame(EventCaller eventCaller)
        {
            return new Minigame("airboarder", "Airboarder", "fbd4f2", false, false, new List<GameAction>()
            {

                new GameAction("bop", "Bop")
                {
                    function = delegate {Airboarder.instance.BopToggle(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["auto"], eventCaller.currentEntity["toggle"]);},
                    defaultLength = 1f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("toggle", true, "Bop", "Toggle if the airboarders should bop for the duration of this event."),
                        new Param("auto", false, "Autobop", "Toggle if the airboarders should bop automatically until another Bop event is reached."),
                    }
                },

                new GameAction("duck", "Duck")
                {
                    function = delegate {Airboarder.instance.PrepareJump(eventCaller.currentEntity.beat, eventCaller.currentEntity["ready"]);},
                    defaultLength = 4f,
                    resizable = false,
                    parameters = new List<Param>()
                    {
                        new Param("ready", true, "Play Ready Sound", "Toggle if the ready sound plays."),
                    }
                },

                new GameAction("crouch", "Charged Duck")
                {
                    function = delegate {Airboarder.instance.PrepareJump(eventCaller.currentEntity.beat, eventCaller.currentEntity["ready"]);},
                    defaultLength = 4f,
                    resizable = false,
                    parameters = new List<Param>()
                    {
                        new Param("ready", true, "Play Ready Sound", "Toggle if the ready sound plays."),
                    }
                },

                new GameAction("jump", "Jump")
                {
                    function = delegate {Airboarder.instance.PrepareJump(eventCaller.currentEntity.beat, eventCaller.currentEntity["ready"]);},
                    defaultLength = 4f,
                    resizable = false,
                    parameters = new List<Param>()
                    {
                        new Param("ready", false, "Play Ready Sound", "Toggle if the ready sound plays."),
                    }
                },

                new GameAction("forceCharge", "Force Charge")
                {
                    function = delegate {Airboarder.instance.ForceCharge(); },
                    defaultLength = 0.5f,
                    resizable = false,
                },


                new GameAction("letsGo", "YEAAAAAH LET'S GO")
                {
                    function = delegate {Airboarder.instance.YeahLetsGo(eventCaller.currentEntity.beat, eventCaller.currentEntity["sound"]);},
                    defaultLength = 8f,
                    resizable = false,
                    parameters = new List<Param>()
                    {
                        new Param("sound", true, "Play Sound", "Toggle if the 'YEAAAAAH LET'S GO' voice clip plays."),
                    }
                },

                new GameAction("fade background", "Background Color")
                {
                    function = delegate {Airboarder.instance.BackgroundColor(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["colorStart"], eventCaller.currentEntity["colorEnd"], eventCaller.currentEntity["cloudStart"], eventCaller.currentEntity["cloudEnd"], eventCaller.currentEntity["ease"]); },
                    defaultLength = 4f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("colorStart", Airboarder.defaultBGColor, "Sky Start Color", "Set the sky color at the start of the event."),
                        new Param("colorEnd", Airboarder.defaultBGColor, "Sky End Color", "Set the sky color at the end of the event."),
                        new Param("cloudStart", Color.white, "Cloud Start Color", "Set the cloud color at the start of the event."),
                        new Param("cloudEnd", Color.white, "Cloud End Color", "Set the cloud color at the end of the event."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
                    }
                },

                new GameAction("fade floor", "Floor Color")
                {
                    function = delegate {Airboarder.instance.FloorColor(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["colorStart"], eventCaller.currentEntity["colorEnd"], eventCaller.currentEntity["stripeStart"], eventCaller.currentEntity["stripeEnd"], eventCaller.currentEntity["ease"]);},
                    defaultLength = 4f,
                    resizable = true,
                    parameters = new List<Param>()
                    {
                        new Param("colorStart", Color.white, "Wide Stripe Start Color", "Set the color of the wide stripes at the start of the event."),
                        new Param("colorEnd", Color.white, "Wide Stripe End Color", "Set the color of the wide stripes at the end of the event."),
                        new Param("stripeStart", Airboarder.defaultStripeColor, "Thin Stripe Start Color", "Set the color of the thin stripes at the start of the event."),
                        new Param("stripeEnd", Airboarder.defaultStripeColor, "Thin Stripe End Color", "Set the color of the thin stripes at the end of the event."),
                        new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
                    }
                },


                new GameAction("camera", "Camera Controls")
                {
                    function = delegate {
                        var e = eventCaller.currentEntity;
                        // var rotation = new Vector3(0, e["valA"], 0);
                        Airboarder.instance.ChangeCamera(eventCaller.currentEntity.beat, eventCaller.currentEntity["valA"], eventCaller.currentEntity["valB"], eventCaller.currentEntity.length, (Util.EasingFunction.Ease)eventCaller.currentEntity["type"], eventCaller.currentEntity["additive"]);
                    },
                    defaultLength = 4,
                    resizable = true,
                    hidden = true,
                    parameters = new List<Param>() {
                        new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Rotation", "Set the rotation of the camera around the pivot point."),
                        new Param("valB", new EntityTypes.Float(0.1f, 4f, 0.5f), "Zoom", "Set the camera's level of zoom."),
                        new Param("type", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
                        new Param("additive", true, "Additive Rotation", "Toggle if the above rotation should be added to the current angle instead of setting the target angle to travel to.")
                    }
                },
            },
            // ,
            new List<string>() {"ntr", "normal"},
            // "ntrAirboarder", "en",
            // new List<string>() { }
            chronologicalSortKey: 99
            );
        }
    }
}



namespace HeavenStudio.Games
{
    /// This class handles the minigame logic.
    /// Minigame inherits directly from MonoBehaviour, and adds Heaven Studio specific methods to override.

    using Scripts_Airboarder;

    public class Airboarder : Minigame
    {
        

        public static Airboarder instance;

        public static Color defaultBGColor = new Color(0.9921569f, 0.7686275f, 0.9921569f);
        public static Color defaultFloorColor = Color.white;
        public static Color defaultStripeColor = new Color(0.8274511f, 0.1254902f, 0.8078432f);
        public static Color defaultCloudColor = Color.white;

        private ColorEase bgColorEase = new(defaultBGColor);
        private ColorEase cloudColorEase = new(defaultCloudColor);
        private ColorEase[] colorEases = new ColorEase[2];

        public bool wantsCrouch;
        [Header("Materials")]
        [SerializeField] private Material bgMaterial;
        [SerializeField] private Material fadeMaterial;
        [SerializeField] private Material floorMaterial;
        [SerializeField] private Material cloudMaterial;
        
        [Header("Camera")]
        [SerializeField] Transform cameraPivot;
        [SerializeField] Transform cameraPos;
        [SerializeField] float cameraFOV;

        [Header("Objects")]
        [SerializeField] Arch archBasic;
        [SerializeField] Wall wallBasic;
        [SerializeField] GameObject floor;

        [Header("Animators")]
        [SerializeField] public Animator CPU1;
        [SerializeField] public Animator CPU2;
        [SerializeField] public Animator Player;
        [SerializeField] public Animator Dog;
        [SerializeField] public Animator Tail;
        [SerializeField] public Animator Floor;

        bool goBop;
        public bool cpu1CantBop = false;
        public bool cpu2CantBop = false;
        public bool playerCantBop = false;
        
        public double startBeat;
        public double switchBeat;


        double cameraRotateBeat = double.MaxValue;
        double cameraRotateLength;
        Util.EasingFunction.Ease cameraRotateEase;
        float cameraRotateLast = 0, cameraScaleLast = 1;
        float cameraRotateNext = 0, cameraScaleNext = 1;


        public float startFloor;

        private void Awake()
        {
            colorEases = new ColorEase[] {
            new(Color.white),
            new(new Color (0.8274511F, 0.1254902F, 0.8078432F)),
            };
            instance = this;
            SetupBopRegion("airboarder", "bop", "auto");   
            wantsCrouch = false;
            GameCamera.AdditionalPosition = cameraPos.position + (Quaternion.Euler(cameraPos.rotation.eulerAngles) * Vector3.forward * 10f);
            GameCamera.AdditionalRotEuler = cameraPos.rotation.eulerAngles;
            GameCamera.AdditionalFoV = cameraFOV;
            
        }

        public override void OnGameSwitch(double beat)
        {
            
            List<BeatAction.Action> actions = new()
            {};
            wantsCrouch = false;

            double switchBeat = beat;
            //double startBeat = double.MaxValue;    Unused value - Marc
            double endBeat = double.MaxValue;
            
            var entities = GameManager.instance.Beatmap.Entities;
            //find when the next game switch/remix end happens
            var nextGameSwitches = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" }).FindAll(x => x.beat > beat && x.datamodel != "gameManager/switchGame/airboarder");
            //double nextGameSwitchBeat = double.MaxValue;    Unused value - Marc

            //lists arch and wall events
            List<RiqEntity> blockEvents = gameManager.Beatmap.Entities.FindAll(e => e.datamodel is "airboarder/duck" or "airboarder/crouch" or "airboarder/jump" && e.beat >= beat && e.beat < endBeat);
        
            foreach (var e in blockEvents)
            {
                double unswungBeat = Conductor.instance.GetUnSwungBeat(e.beat);
                switch (e.datamodel) {
                    case "airboarder/duck":
                    RequestArch(e.beat - 25, false);
                    break;
                    case "airboarder/crouch":
                    RequestArch(e.beat - 25, true);
                    break;
                    case "airboarder/jump":
                    RequestWall(e.beat - 25);
                    break;
                }
            }
            PersistColor (beat);
        }

        private void Start()
        {
            EntityPreCheck(Conductor.instance.songPositionInBeatsAsDouble);
            bgMaterial.color = defaultBGColor;
            fadeMaterial.color = defaultBGColor;
            cloudMaterial.color = defaultCloudColor;

        }

        void EntityPreCheck(double beat)
        {
            cameraRotateBeat = double.MaxValue;
            cameraRotateLength = 0;
            cameraRotateEase = Util.EasingFunction.Ease.Linear;
            cameraRotateLast = 0; cameraScaleLast = 1;
            cameraRotateNext = 0; cameraScaleNext = 1;
            
            List<RiqEntity> prevEntities = GameManager.instance.Beatmap.Entities.FindAll(c => c.beat < beat && c.datamodel.Split(0) == "airboarder");
            RiqEntity lastGameSwitch = GameManager.instance.Beatmap.Entities.FindLast(c => c.beat <= beat && c.datamodel == "gameManager/switchGame/airboarder");

            if (lastGameSwitch == null) return;
            List<RiqEntity> cameraEntities = prevEntities.FindAll(c => c.beat >= lastGameSwitch.beat && c.datamodel == "airboarder/camera");

            foreach (var entity in cameraEntities)
            {
                ChangeCamera(entity.beat, entity["valA"], entity["valB"], entity.length, (Util.EasingFunction.Ease)entity["type"], entity["additive"]);
            }

            UpdateCamera(beat);
        }

        public override void OnPlay(double beat)
        {
            EntityPreCheck(beat);
            OnGameSwitch(beat);
        }

        void UpdateCamera(double beat)
        {
            if (beat >= cameraRotateBeat)
            {
                Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(cameraRotateEase);
                float rotProg = Conductor.instance.GetPositionFromBeat(cameraRotateBeat, cameraRotateLength, true);
                rotProg = Mathf.Clamp01(rotProg);
                float rot = func(cameraRotateLast, cameraRotateNext, rotProg);
                cameraPivot.rotation = Quaternion.Euler(0, rot, 0);
                cameraPivot.localScale = Vector3.one * func(cameraScaleLast, cameraScaleNext, rotProg);
            }

            GameCamera.AdditionalPosition = cameraPos.position + (Quaternion.Euler(cameraPos.rotation.eulerAngles) * Vector3.forward * 10f);
            GameCamera.AdditionalRotEuler = cameraPos.rotation.eulerAngles;
            GameCamera.AdditionalFoV = cameraFOV;
        }

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

            ColorUpdate();
            
            float normalizedBeat = Conductor.instance.GetPositionFromBeat(startBeat, 5f);

            Floor.Play("moving", 0, normalizedBeat);
            Floor.speed = 0;
            Dog.Play("run", 0, normalizedBeat*7.5f);
            Dog.Play("wag",1,normalizedBeat*2.5f);

          
            if (cond.isPlaying && !cond.isPaused){
                if (PlayerInput.GetIsAction(InputAction_BasicPress) && !IsExpectingInputNow(InputAction_BasicPress)){
                    if (wantsCrouch)
                    {
                        Player.DoScaledAnimationAsync("charge",1f, 0, 1);
                        playerCantBop = true;
                    }
                    else 
                    {
                        Player.DoScaledAnimationAsync("duck",1f, 0, 1);
                        SoundByte.PlayOneShotGame("airboarder/crouch");
                        BeatAction.New(this, new() {
                            new(currentBeat, ()=>playerCantBop = true),
                            new(currentBeat+1.5f, ()=>playerCantBop = false)});
                    }
                }
                if (PlayerInput.GetIsAction(InputAction_BasicRelease) && !IsExpectingInputNow(InputAction_BasicRelease)){
                    if (wantsCrouch)
                    {
                        Player.DoScaledAnimationAsync("hold",1f, 0, 1);
                        playerCantBop = false;
                    }
                }
                
                if (PlayerInput.GetIsAction(InputAction_FlickRelease) && !IsExpectingInputNow(InputAction_FlickRelease))
                {
                    if ( PlayerInput.CurrentControlStyle == InputController.ControlStyles.Touch)
                    {
                        Player.DoScaledAnimationAsync("jump",1f, 0, 1);
                        SoundByte.PlayOneShotGame("airboarder/jump");
                        BeatAction.New(this, new() {
                            new(currentBeat, ()=>playerCantBop = true),
                            new(currentBeat+1.5f, ()=>playerCantBop = false)});
                    }
                }
            }

            UpdateCamera(currentBeat);

        }



        //call this in update
        private void ColorUpdate()
        {
            bgMaterial.color = bgColorEase.GetColor();
            fadeMaterial.color = bgColorEase.GetColor();
            cloudMaterial.color = cloudColorEase.GetColor();
            floorMaterial.SetColor("_BlueColor", colorEases[0].GetColor());
            floorMaterial.SetColor("_RedColor", colorEases[1].GetColor());

        }

        public void BackgroundColor(double beat, float length, Color startColor, Color endColor, Color startCloud, Color endCloud, int ease)
        {
            bgColorEase = new(beat, length, startColor, endColor, ease);
            cloudColorEase = new(beat, length, startCloud, endCloud, ease);
        }
        
        public void FloorColor(double beat, float length, Color startColor, Color endColor, Color startStripe, Color endStripe, int ease)
        {
            colorEases = new ColorEase[] {
                new(beat, length, startColor, endColor, ease),
                new(beat, length, startStripe, endStripe, ease),
            };
        }

        private void PersistColor(double beat)
        {
            var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("airboarder", new string[] { "fade background" }).FindAll(x => x.beat < beat);
            if (allEventsBeforeBeat.Count > 0)
            {
                allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
                var lastEvent = allEventsBeforeBeat[^1];
                BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorStart"], lastEvent["colorEnd"], lastEvent["cloudStart"], lastEvent["cloudEnd"], lastEvent["ease"]);
            }

            var allEventsBeforeBeatF = EventCaller.GetAllInGameManagerList("airboarder", new string[] { "fade floor" }).FindAll(x => x.beat < beat);
            if (allEventsBeforeBeatF.Count > 0)
            {
                allEventsBeforeBeatF.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
                var lastEventF = allEventsBeforeBeatF[^1];
                FloorColor(lastEventF.beat, lastEventF.length, lastEventF["colorStart"], lastEventF["colorEnd"], lastEventF["stripeStart"], lastEventF["stripeEnd"], lastEventF["ease"]);
            }
        }

        public void ForceCharge()
        {
            CPU1.DoScaledAnimationAsync("charge", 1f, 0, 1);
            CPU2.DoScaledAnimationAsync("charge", 1f, 0, 1);
            Player.DoScaledAnimationAsync("charge", 1f, 0, 1);
            cpu1CantBop = true;
            cpu2CantBop = true;
            playerCantBop = true;
            wantsCrouch = true;
        }

        public override void OnBeatPulse(double beat)
        {
            if (BeatIsInBopRegion(beat))
            {
                Bop();
            }

        }

        public void PrepareJump(double beat, bool readySound)
        {
            if (readySound)
            {
                SoundByte.PlayOneShotGame("airboarder/ready");
            }

        }

        public void ChangeCamera(double beat, float rotation, float camZoom, double length, Util.EasingFunction.Ease ease, bool additive = true)
        {
            cameraRotateBeat = beat;
            cameraRotateLength = length;
            cameraRotateEase = ease;
            cameraRotateLast = cameraRotateNext % 360f;
            cameraScaleLast = cameraScaleNext;
            cameraScaleNext = camZoom;
            if (additive)
            {
                cameraRotateNext = cameraRotateLast + rotation;
            }
            else
            {
                cameraRotateNext = rotation;
            }
        }

        public void BopToggle(double beat, float length, bool boarders, bool autoBop)
        {
            
            if (boarders)
            {
                List<BeatAction.Action> bops = new List<BeatAction.Action>();
                for (int i = 0; i < length; i++)
                {
                    bops.Add(new BeatAction.Action(beat + i, delegate { Bop(); }));
                }
                BeatAction.New(instance, bops);
            }
        }

        public void Bop()
        {
            if (!playerCantBop){
            Player.DoScaledAnimationAsync("bop",0.5f, 0, 1);
            }
            if (!cpu1CantBop){
            CPU1.DoScaledAnimationAsync("bop",0.5f, 0, 1);
            }
            if (!cpu2CantBop){
            CPU2.DoScaledAnimationAsync("bop",0.5f, 0, 1);
            }
        }

        public void YeahLetsGo(double beat, bool voiceOn)
        {
            if(voiceOn)
            {
                BeatAction.New(instance, new List<BeatAction.Action>(){
                    
                    new BeatAction.Action(beat, delegate {SoundByte.PlayOneShotGame("airboarder/start1");}),
                    new BeatAction.Action(beat + 6.5, delegate {SoundByte.PlayOneShotGame("airboarder/start2");}),
                    new BeatAction.Action(beat + 7, delegate {SoundByte.PlayOneShotGame("airboarder/start3");}),
                });
            }
            BeatAction.New(instance, new List<BeatAction.Action>(){
                
                new BeatAction.Action(beat, delegate {
                    cpu1CantBop = true;
                    cpu2CantBop = true;
                    playerCantBop = true;
                    CPU1.DoScaledAnimationAsync("letsgo", 1f, 0, 1);
                    CPU2.DoScaledAnimationAsync("letsgo", 1f, 0, 1);
                    Player.DoScaledAnimationAsync("letsgo", 1f, 0, 1);
                    }),

                new BeatAction.Action(beat+7, delegate {
                    cpu1CantBop = false;
                    cpu2CantBop = false;
                    playerCantBop = false;
                    })
            }

            );
        }

        public void MissSound(double beat)
        {
            MultiSound.Play(new MultiSound.Sound[]
            {
                new MultiSound.Sound("airboarder/miss1", beat),
                new MultiSound.Sound("airboarder/missvox", beat),
                new MultiSound.Sound("airboarder/miss2", beat + 0.25f),
                new MultiSound.Sound("airboarder/miss3", beat + 0.75f),
                new MultiSound.Sound("airboarder/miss4", beat + 0.875f),
                new MultiSound.Sound("airboarder/miss5", beat + 1f),
                new MultiSound.Sound("airboarder/miss6", beat + 1.125f),
                new MultiSound.Sound("airboarder/miss7", beat + 1.25f),
                new MultiSound.Sound("airboarder/miss8", beat + 1.5f),
                new MultiSound.Sound("airboarder/miss9", beat + 1.75f),
                new MultiSound.Sound("airboarder/miss10", beat + 2f),
                new MultiSound.Sound("airboarder/miss11", beat + 2.25f),
                new MultiSound.Sound("airboarder/miss12", beat + 2.5f),
                new MultiSound.Sound("airboarder/miss13", beat + 2.75f),
                new MultiSound.Sound("airboarder/miss14", beat + 3f),
                new MultiSound.Sound("airboarder/miss15", beat + 3.25f)
            });
        }

        public void RequestArch(double beat, bool crouch)
        {
            Arch newArch = Instantiate(archBasic, transform);
            newArch.appearBeat = beat;
            newArch.gameObject.SetActive(true);
            if (crouch) {
                archBasic.CueCrouch(beat+25);
            } else {
                newArch.CueDuck(beat+25);
            }
        }

        public void RequestWall(double beat)
        {
            Wall newWall = Instantiate(wallBasic, transform);
            newWall.appearBeat = beat;
            newWall.gameObject.SetActive(true);
            newWall.CueJump(beat+25);
        }




        

        


    }
}