TH1/Unity/Assets/Scripts/TH1_Anim/Fragments/FragmentSuikaFallingSplash.cs

using System.Collections.Generic;
using Logic.Audio;
using TH1_Anim.UnitAtomAnim;
using TH1_Logic.Core;
using TH1_Renderer;
using TH1_Renderer.UnitAtomAnim;
using TH1Renderer;
using UnityEngine;

namespace TH1_Anim.Fragments
{
    public class FragmentSuikaFallingSplash : FragmentBase
    {
        private const float JumpDuration = 1.1f;
        private const float JumpHeight = 18f;
        private const float FinalMoveDuration = 0.35f;
        private const float SplashImpactPause = 0.2f;
        private const float GroundLandingImpactDuration = 0.2f;

        public FragmentSuikaFallingSplashData Data;

        public FragmentSuikaFallingSplash(FragmentSuikaFallingSplashData data) : base()
        {
            Data = data;
            if (Data?.SuikaRenderer == null || Data.OriginGrid == null || Data.TargetGrid == null ||
                Data.FinalGrid == null)
            {
                State = FragmentState.Wrong;
                return;
            }

            var animTable = Table.Instance.AnimDataAssets;
            InitSteps();

            AddStep(AnimPhase.AttackStart, JumpDuration, () =>
            {
                var animData = new UnitAtomAnimParabolaMoveData(
                    Data.OriginGrid.Pos.V2(), Data.TargetGrid.Pos.V2(), JumpHeight, JumpDuration);
                Data.SuikaRenderer.AnimManager.EnqueueAnim(UnitAtomAnimType.ParabolaMove, animData);
                Data.OriginGrid.Renderer(Main.MapData)?.InstantUpdateGrid();
                AudioManager.Instance.PlayAudio("SFX/UNIT_attack");
            });

            AddStep(AnimPhase.AttackImpact,
                Data.IsGroundLanding ? GroundLandingImpactDuration : animTable.BounceDownTime + animTable.BounceUpTime,
                () =>
            {
                PlayTargetAttackImpact();
                PlayLandingImpact();
            });

            if (Data.SplashSteps != null)
            {
                foreach (var step in Data.SplashSteps)
                    AddStep(AnimPhase.AttackImpact + 10, step.Duration, step.Execute);
            }

            if (!Data.IsGroundLanding)
                AddStep(AnimPhase.AttackImpact + 15, SplashImpactPause, () => { });

            if (!Data.TargetKilled && Data.FinalGrid.Id != Data.TargetGrid.Id)
            {
                AddStep(AnimPhase.AttackImpact + 20, FinalMoveDuration, () =>
                {
                    var path = new List<Vector2Int> { Data.TargetGrid.Pos.V2(), Data.FinalGrid.Pos.V2() };
                    var animData = new UnitAtomAnimMoveData(Data.TargetGrid.Pos.V2(), Data.FinalGrid.Pos.V2(), path,
                        FinalMoveDuration);
                    Data.SuikaRenderer.AnimManager.EnqueueAnim(UnitAtomAnimType.Move, animData);
                });
            }

            AddStep(AnimPhase.Settle, 0f, RefreshFinalState);
            RecalcDuration();
        }

        private void PlayTargetAttackImpact()
        {
            var targetGridRenderer = Data.TargetGrid.Renderer(Main.MapData);
            if (!Data.HasAttackTarget)
            {
                targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Fog));
                targetGridRenderer?.InstantUpdateGrid();
                return;
            }

            if (Data.TargetKilled)
            {
                Data.TargetUnitRenderer?.Die();
                Data.TargetCity?.SetCityRenderer(Main.MapData);
                MapRenderer.Instance?.UpdateAroundHighlight(Main.MapData, Data.TargetGrid);
                targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Hurt));
                targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Fog));
                if (!Data.TargetCanNotBeKilled)
                    targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Die));
                targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Damage, Data.AttackDmg));
                return;
            }

            Data.TargetUnitRenderer?.InstantUpdateUnit(true);
            Data.TargetUnitRenderer?.AnimManager.EnqueueAnim(UnitAtomAnimType.Bounce,
                UnitAtomAnimDataFactory.Create(UnitAtomAnimType.Bounce));
            targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Hurt));
            targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Damage, Data.AttackDmg));
        }

        private void PlayLandingImpact()
        {
            var targetGridRenderer = Data.TargetGrid.Renderer(Main.MapData);
            targetGridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Fog));
            Data.SuikaRenderer?.AnimManager.EnqueueAnim(UnitAtomAnimType.Bounce,
                UnitAtomAnimDataFactory.Create(UnitAtomAnimType.Bounce));
            targetGridRenderer?.InstantUpdateGrid();
        }

        private void RefreshFinalState()
        {
            Data.SuikaRenderer?.InstantUpdateUnitPos();
            Data.SuikaRenderer?.InstantUpdateUnit(true);
            Data.OriginGrid.Renderer(Main.MapData)?.InstantUpdateGrid();
            Data.TargetGrid.Renderer(Main.MapData)?.InstantUpdateGrid();
            Data.FinalGrid.Renderer(Main.MapData)?.InstantUpdateGrid();
            RefreshLandingSight();
            Data.OriginCity?.SetCityRenderer(Main.MapData);
            Data.TargetCity?.SetCityRenderer(Main.MapData);
            Data.FinalCity?.SetCityRenderer(Main.MapData);
            MapRenderer.Instance?.UpdateAroundHighlight(Main.MapData, Data.OriginGrid);
            MapRenderer.Instance?.UpdateAroundHighlight(Main.MapData, Data.TargetGrid);
            MapRenderer.Instance?.UpdateAroundHighlight(Main.MapData, Data.FinalGrid);
        }

        private void RefreshLandingSight()
        {
            if (Data.SightRefreshGrids == null) return;

            foreach (var grid in Data.SightRefreshGrids)
            {
                if (grid == null) continue;
                var gridRenderer = grid.Renderer(Main.MapData);
                gridRenderer?.PlayVFXInSight(new GridVFXParams(GridVFXType.Fog));
                gridRenderer?.InstantUpdateGrid(true);
                MapRenderer.Instance?.UpdateAroundHighlight(Main.MapData, grid);
            }
        }

        public override bool CheckDone(float progressTime)
        {
            return CheckStepsDone(progressTime);
        }

        public override void OnUpdate(float progressTime)
        {
            UpdateSteps(progressTime);
        }
    }
}