HeavenStudio/Assets/Scripts/Games/CropStomp/CropStomp.cs

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

namespace HeavenStudio.Games.Loaders
{
    using static Minigames;
    public static class NtrCropLoader
    {
        public static Minigame AddGame(EventCaller eventCaller) {
            return new Minigame("cropStomp", "Crop Stomp", "c0f0b8", false, false, new List<GameAction>()
            {
                new GameAction("start marching", "Start Marching")
                {
                    function = delegate { CropStomp.instance.StartMarching(eventCaller.currentEntity.beat); }, 
                    defaultLength = 2f,
                    inactiveFunction = delegate { CropStomp.MarchInactive(eventCaller.currentEntity.beat); }
                },
                new GameAction("veggies", "Veggies")
                {
                    defaultLength = 4f, 
                    resizable = true
                },
                new GameAction("mole", "Mole")
                {
                    preFunction = delegate
                    {
                        if (eventCaller.currentEntity["mute"]) return;
                        CropStomp.MoleSound(eventCaller.currentEntity.beat);
                    },
                    defaultLength = 2f,
                    parameters = new List<Param>()
                    {
                        new Param("mute", false, "Mute", "Should the mole laugh sound be muted?")
                    },
                    preFunctionLength = 6
                },
                new GameAction("end", "End")
                {
                    parameters = new List<Param>()
                    {
                        new Param("mute", true, "Mute Humming?")
                    }
                },
                new GameAction("plantCollect", "Veggie Collection Values")
                {
                    function = delegate { var e = eventCaller.currentEntity; 
                        CropStomp.instance.SetCollectThresholds(e["threshold"], e["limit"], e["force"], e["forceAmount"]); },
                    defaultLength = 0.5f,
                    parameters = new List<Param>()
                    {
                        new Param("threshold", new EntityTypes.Integer(1, 80, 8), "Threshold", "For each time the threshold is met a new plant will appear in the veggie bag."),
                        new Param("limit", new EntityTypes.Integer(1, 1000, 80), "Limit", "What is the limit for plants collected?"),
                        new Param("force", false, "Force Amount of Collected Plants"),
                        new Param("forceAmount", new EntityTypes.Integer(0, 1000, 0), "Force Amount")
                    }
                }
            },
            new List<string>() {"ntr", "keep"},
            "ntrstomp", "en",
            new List<string>() {}
            );
        }
    }
}

namespace HeavenStudio.Games
{
    using Scripts_CropStomp;

    public class CropStomp : Minigame
    {
        const float stepDistance = 2.115f;
        //public static float[] moleSoundOffsets = new float[]{ 0.134f, 0.05f, 0.061f };

        float scrollRate => stepDistance / (Conductor.instance.pitchedSecPerBeat * 2f);
        float grassWidth;
        float dotsWidth = 19.2f;

        private double newBeat = -1f; // So that marching can happen on beat 0.
        private double marchStartBeat = -1f;
        private double marchEndBeat = double.MaxValue;
        private bool willNotHum = true;
        private double marchOffset;
        private int currentMarchBeat;
        private int stepCount;
        private bool isStepping;
        
        private static double inactiveStart = -1f;

        public bool isMarching => marchStartBeat != -1f;

        [NonSerialized] public bool isFlicking;

        public GameObject baseVeggie;
        public GameObject baseMole;
        public Animator legsAnim;
        public Animator bodyAnim;
        public Transform farmerTrans;
        public SpriteRenderer grass;
        public Transform grassTrans;
        public Transform dotsTrans;
        public Transform scrollingHolder;
        public Transform veggieHolder;
        public Farmer farmer;
        public BezierCurve3D pickCurve;
        public BezierCurve3D moleCurve;

        private Tween shakeTween;

        public ParticleSystem hitParticle;

        public static CropStomp instance;

        private void Awake()
        {
            instance = this;// Finding grass sprite width for grass scrolling.
            farmer.Init();
            var grassSprite = grass.sprite;
            var borderLeft = grassSprite.rect.xMin + grassSprite.border.x;
            var borderRight = grassSprite.rect.xMax - grassSprite.border.z;
            var borderWidthPixels = borderRight - borderLeft;
            grassWidth = borderWidthPixels / grassSprite.pixelsPerUnit;

            legsAnim.Play("LiftFront", 0, 1); // Start with leg up.

            // Initialize vegetables.
            var cond = Conductor.instance;
            var entities = GameManager.instance.Beatmap.Entities;

            double startBeat = cond.songPositionInBeatsAsDouble;
            double endBeat = double.MaxValue;

            if (inactiveStart == -1f)
            {
                // Find the beat of the closest "start marching" event.
                var marchStarts = entities.FindAll(m => m.datamodel == "cropStomp/start marching");
                for (int i = 0; i < marchStarts.Count; i++)
                {
                    var sampleBeat = marchStarts[i].beat;
                    if (cond.songPositionInBeatsAsDouble <= sampleBeat + 0.25f) // 0.25-beat buffer in case the start marching event is directly next to the game switch event.
                    {
                        startBeat = sampleBeat;
                        break;
                    }
                }
            }
            else
            {
                // Find the beat of the next step, assuming marching started at inactiveStart.
                int stepsPassed = 0;

                while (inactiveStart + (stepsPassed * 2f) < cond.songPositionInBeatsAsDouble)
                {
                    stepsPassed++;

                    if (stepsPassed > 1000)
                    {
                        Debug.Log("Loop broke!");
                        return;
                    }
                }

                startBeat = inactiveStart + (stepsPassed * 2f);

                // Cue the marching proper to begin when applicable.
                BeatAction.New(gameObject, new List<BeatAction.Action>()
                {
                    new BeatAction.Action(startBeat - 0.25f, delegate { StartMarching(startBeat); })
                });

                inactiveStart = -1f;
            }

            // find out when the next game switch (or remix end) happens
            var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame", "end" });
            if (allEnds.Count == 0)
            {
                endBeat = double.MaxValue;
            }
            else
            {
                allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));

                //get the beat of the closest end event
                foreach (var end in allEnds)
                {
                    if (end.datamodel != "gameManager/end" && end.datamodel.Split(2) == "cropStomp") continue;
                    if (end.beat > startBeat)
                    {
                        endBeat = end.beat;
                        break;
                    }
                }
            }

            // Veggie and mole events.
            var vegEvents = entities.FindAll(v => v.datamodel == "cropStomp/veggies");
            var moleEvents = entities.FindAll(m => m.datamodel == "cropStomp/mole");

            // Spawn veggies.
            for (int i = 0; i < vegEvents.Count; i++)
            {
                var vegBeat = vegEvents[i].beat;
                var vegLength = vegEvents[i].length;

                // Only consider veggie events that aren't past the start point.
                if (startBeat <= vegBeat + vegLength)
                {
                    int veggiesInEvent = Mathf.CeilToInt(vegLength + 1) / 2;

                    for (int b = 0; b < veggiesInEvent; b++)
                    {
                        var targetVeggieBeat = vegBeat + 2f * b;
                        if (startBeat <= targetVeggieBeat && targetVeggieBeat < endBeat)
                        {
                            SpawnVeggie(targetVeggieBeat, startBeat, false);
                        }
                    }
                }
            }

            // Spawn moles.
            for (int i = 0; i < moleEvents.Count; i++)
            {
                var moleBeat = moleEvents[i].beat;

                if (startBeat <= moleBeat && moleBeat < endBeat)
                {
                    SpawnVeggie(moleBeat, startBeat, true);
                }
            }
        }

        List<RiqEntity> cuedMoleSounds = new List<RiqEntity>();

        public override void OnGameSwitch(double beat)
        {
            SetInitTresholds(beat);
            SetMarchEndBeat(beat);
        }

        public override void OnPlay(double beat)
        {
            SetInitTresholds(beat);
            SetMarchEndBeat(beat);
        }

        private void SetMarchEndBeat(double beat)
        {
            double nextEndBeat = double.MaxValue;
            var nextEnd = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame", "end" }).Find(e => e.beat > beat);
            if (nextEnd != null) nextEndBeat = nextEnd.beat;

            var allEnds = EventCaller.GetAllInGameManagerList("cropStomp", new string[] { "end" });
            var tempEnds = allEnds.FindAll(x => x.beat >= beat && x.beat < nextEndBeat);
            if (tempEnds.Count == 0) return;

            marchEndBeat = tempEnds[0].beat;
            willNotHum = tempEnds[0]["mute"];
        }

        public static void MoleSound(double beat)
        {
            MultiSound.Play(new MultiSound.Sound[] 
            { 
                new MultiSound.Sound("cropStomp/moleNyeh", beat - 2, 1, 1, false, 0.134),
                new MultiSound.Sound("cropStomp/moleHeh1", beat - 1.5, 1, 1, false, 0.05),
                new MultiSound.Sound("cropStomp/moleHeh2", beat - 1, 1, 1, false, 0.061) 
            }, forcePlay: true);
        }

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

            if (!cond.isPlaying)
                return;

            if (!isMarching)
                return;
            // Debug.Log(newBeat);

            bool cameraLocked = cond.songPositionInBeats >= marchEndBeat;
            bool isHumming = !(cameraLocked && willNotHum);

            if (cond.ReportBeat(ref newBeat, marchOffset, true))
            {
                currentMarchBeat += 1;

                PlayAnims();
                if (currentMarchBeat % 2 != 0 && isHumming) //step sound
                {
                    MultiSound.Play(new MultiSound.Sound[] {new MultiSound.Sound("cropStomp/hmm", newBeat + marchOffset)});
                }
            }

            if (cameraLocked) return;

            // Object scroll.
            var scrollPos = scrollingHolder.localPosition;
            var newScrollX = scrollPos.x + (scrollRate * Time.deltaTime);
            scrollingHolder.localPosition = new Vector3(newScrollX, scrollPos.y, scrollPos.z);

            // Grass scroll.
            var grassPos = grassTrans.localPosition;

            var newGrassX = grassPos.x + (scrollRate * Time.deltaTime);
            newGrassX = (newGrassX % (grassWidth * 4.5f));

            grassTrans.localPosition = new Vector3(newGrassX, grassPos.y, grassPos.z);

            // Dots scroll
            var dotsPos = dotsTrans.localPosition;

            var newDotsX = dotsPos.x + (scrollRate * Time.deltaTime);
            newDotsX = (newDotsX % dotsWidth);

            dotsTrans.localPosition = new Vector3(newDotsX, dotsPos.y, dotsPos.z);
        }

        private void LateUpdate()
        {
            if (!isMarching)
                return;

            if (PlayerInput.PressedUp())
            {
                // Don't play raise animation if successfully flicked.
                if (!isFlicking)
                    bodyAnim.Play("Raise");
            }

            isFlicking = false;
        }

        public void SetCollectThresholds(int thresholdEvolve, int limit, bool force, int forceAmount)
        {
            farmer.plantThreshold = thresholdEvolve;
            farmer.plantLimit = limit;
            if (force) Farmer.collectedPlants = forceAmount;
            farmer.UpdatePlants();
        }

        private void SetInitTresholds(double beat)
        {
            var allCollects = EventCaller.GetAllInGameManagerList("cropStomp", new string[] { "plantCollect" });
            if (allCollects.Count == 0) return;

            var tempCollect = allCollects.FindLast(x => x.beat < beat);
            if (tempCollect == null) return;
            SetCollectThresholds(tempCollect["threshold"], tempCollect["limit"], tempCollect["force"], tempCollect["forceAmount"]);
        }

        public void CollectPlant(int veggieType)
        {
            farmer.CollectPlant(veggieType);
        }

        private void PlayAnims()
        {
            // Step.
            if (currentMarchBeat % 2 != 0)
            {
                // Don't step if already stomped.
                if (!isStepping)
                {
                    stepCount += 1;
                    var stepAnim = (stepCount % 2 != 0 ? "StepFront" : "StepBack");

                    legsAnim.Play(stepAnim, 0, 0);

                    isStepping = true;
                }

            }
            // Lift.
            else
            {
                var liftAnim = (stepCount % 2 != 0 ? "LiftBack" : "LiftFront");
                legsAnim.Play(liftAnim, 0, 0);

                var farmerPos = farmerTrans.localPosition;
                farmerTrans.localPosition = new Vector3(farmerPos.x - stepDistance, farmerPos.y, farmerPos.z);

                isStepping = false;
            }
        }

        public void StartMarching(double beat)
        {
            marchStartBeat = beat;
            marchOffset = marchStartBeat % 1;
            currentMarchBeat = 0;
            stepCount = 0;

            farmer.nextStompBeat = beat;
        }

        public void Stomp()
        {
            // Don't increment step counter if autostep stepped already.
            if (!isStepping)
                stepCount += 1;

            var stompAnim = (stepCount % 2 != 0 ? "StompFront" : "StompBack");
            
            legsAnim.Play(stompAnim, 0, 0);

            SoundByte.PlayOneShotGame("cropStomp/stomp");

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

            DOTween.Punch(() => GameCamera.additionalPosition, x => GameCamera.additionalPosition = x, new Vector3(0, 0.75f, 0), 
                Conductor.instance.pitchedSecPerBeat*0.5f, 18, 1f);

            isStepping = true;
        }

        private void SpawnVeggie(double beat, double startBeat, bool isMole)
        {
            var newVeggie = GameObject.Instantiate(isMole ? baseMole : baseVeggie, veggieHolder).GetComponent<Veggie>();

            newVeggie.targetBeat = beat;

            var veggieX = (beat - startBeat) * -stepDistance / 2f;
            newVeggie.transform.localPosition = new Vector3((float)veggieX, 0f, 0f);
            newVeggie.Init();
            newVeggie.gameObject.SetActive(true);
        }
        
        public static void MarchInactive(double beat)
        {
            if (GameManager.instance.currentGame == "cropStomp") //this function is only meant for making march sounds while the game is inactive
            {
                return;
            }
            inactiveStart = beat;
            RiqEntity gameSwitch = GameManager.instance.Beatmap.Entities.Find(c => c.beat >= beat && c.datamodel == "gameManager/switchGame/cropStomp");
            if (gameSwitch == null)
                return;
            int length = (int)Math.Ceiling((gameSwitch.beat - beat)/2);
            MultiSound.Sound[] sounds = new MultiSound.Sound[length];
            for(int i = 0; i < length; i++)
            {
                sounds[i] = new MultiSound.Sound("cropStomp/hmm", beat + i*2);
            }
            MultiSound.Play(sounds, forcePlay:true);
        }
    }
}