TH1/Unity/Assets/Scripts/TH1_Logic/Action/HakureiNorwayHeroAction.cs

/*
 * @Author: Codex
 * @Description: Hakurei Empire Norway hero unit actions except Reimu
 * @Date: 2026-06-15
 * @Modify:
 */

using System.Collections.Generic;
using Logic.Skill;
using RuntimeData;
using TH1_Logic.Core;
using TH1Renderer;
using UnityEngine;

namespace Logic.Action
{
    public abstract class HakureiNorwayHeroUnitAction : UnitActionAction
    {
        protected HakureiNorwayHeroUnitAction(CommonActionId id) : base(id)
        {
        }

        protected bool CheckOwnedUnit(CommonActionParams actionParams)
        {
            return UnitActionCheckBaseInfo(actionParams) && UnitActionCheckUnitBelongPlayer(actionParams);
        }

        protected GridData TargetOrSelfGrid(CommonActionParams actionParams)
        {
            return actionParams.TargetGridData ?? actionParams.GridData;
        }

        protected bool CheckShowCommon(CommonActionParams actionParams, out ShowType showType)
        {
            showType = ShowType.None;
            return CheckOwnedUnit(actionParams);
        }

        protected void ConsumeCaptureAndRefresh(CommonActionParams actionParams)
        {
            actionParams.UnitData?.ClearActionPoint();
            actionParams.UnitData?.Renderer(actionParams.MapData)?.InstantUpdateUnit(false);
        }
    }

    public class UnitActionKasenToggleOniForm : HakureiNorwayHeroUnitAction
    {
        public UnitActionKasenToggleOniForm(CommonActionId id) : base(id)
        {
        }

        protected override bool Execute(CommonActionParams actionParams)
        {
            var kasen = actionParams.UnitData;
            if (kasen.GetSkill(SkillType.KasenOniForm, out _))
                kasen.RemoveSkill(SkillType.KasenOniForm, actionParams.MapData);
            else
                kasen.AddOrOverrideSkill(SkillType.KasenOniForm, actionParams.MapData, kasen.Id);
            ConsumeCaptureAndRefresh(actionParams);
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParams)
        {
            if (!CheckShow(actionParams, out _)) return false;
            return UnitActionCheckUnitHasCP(actionParams);
        }

        public override bool CheckShow(CommonActionParams actionParams, out ShowType showType)
        {
            if (!CheckShowCommon(actionParams, out showType)) return false;
            if (!HakureiNorwayHeroSkillUtil.IsKasen(actionParams.UnitData)) return false;
            if (HakureiNorwayHeroSkillUtil.HeroLevel(actionParams.UnitData) < 4) return false;
            if (actionParams.UnitData.GetActionPoint(ActionPointType.Capture) <= 0) showType = ShowType.Done;
            return true;
        }
    }

    public class UnitActionSuikaShakeOffMinis : HakureiNorwayHeroUnitAction
    {
        public UnitActionSuikaShakeOffMinis(CommonActionId id) : base(id)
        {
        }

        protected override bool Execute(CommonActionParams actionParams)
        {
            var suika = actionParams.UnitData;
            var count = HakureiNorwayHeroSkillUtil.GetMiniSuikaStack(suika);
            if (count <= 0 || !suika.Grid(actionParams.MapData, out var grid)) return false;
            var spawned = 0;
            var buf = new List<GridData>();
            actionParams.MapData.GridMap.GetAroundGridData(1, 1, grid, buf);
            foreach (var target in buf)
            {
                if (spawned >= count) break;
                if (target.RealUnit(actionParams.MapData, out _)) continue;
                if (HakureiNorwayHeroSkillUtil.TrySpawnMiniSuika(actionParams.MapData, suika, target, out _))
                    spawned++;
            }
            if (spawned <= 0) return false;
            if (suika.GetSkill(SkillType.SuikaMiniStack, out var stack))
                stack.ReduceLevel(actionParams.MapData, suika, spawned);
            HakureiNorwayHeroSkillUtil.RefreshSuikaForm(actionParams.MapData, suika);
            ConsumeCaptureAndRefresh(actionParams);
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParams)
        {
            if (!CheckShow(actionParams, out _)) return false;
            return UnitActionCheckUnitHasCP(actionParams);
        }

        public override bool CheckShow(CommonActionParams actionParams, out ShowType showType)
        {
            if (!CheckShowCommon(actionParams, out showType)) return false;
            if (!HakureiNorwayHeroSkillUtil.IsSuika(actionParams.UnitData)) return false;
            if (HakureiNorwayHeroSkillUtil.GetMiniSuikaStack(actionParams.UnitData) <= 0) return false;
            if (actionParams.UnitData.GetActionPoint(ActionPointType.Capture) <= 0) showType = ShowType.Done;
            return true;
        }
    }

    public class UnitActionSuikaCreateMiniByHp : HakureiNorwayHeroUnitAction
    {
        public UnitActionSuikaCreateMiniByHp(CommonActionId id) : base(id)
        {
        }

        protected override bool Execute(CommonActionParams actionParams)
        {
            var suika = actionParams.UnitData;
            if (!suika.Grid(actionParams.MapData, out var grid)) return false;
            if (!HakureiNorwayHeroSkillUtil.TryFindFirstEmptyAround(actionParams.MapData, grid, 1, 1,
                    out var spawnGrid)) return false;
            suika.Health = Mathf.Max(1, suika.Health - 5);
            if (!HakureiNorwayHeroSkillUtil.TrySpawnMiniSuika(actionParams.MapData, suika, spawnGrid, out _))
                return false;
            suika.Renderer(actionParams.MapData)?.InstantUpdateUnit(false);
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParams)
        {
            return CheckShow(actionParams, out _);
        }

        public override bool CheckShow(CommonActionParams actionParams, out ShowType showType)
        {
            if (!CheckShowCommon(actionParams, out showType)) return false;
            if (!HakureiNorwayHeroSkillUtil.IsSuika(actionParams.UnitData)) return false;
            if (HakureiNorwayHeroSkillUtil.HeroLevel(actionParams.UnitData) < 3) return false;
            return actionParams.UnitData.Health > 5;
        }
    }

    public class UnitActionSuikaThrowUnit : HakureiNorwayHeroUnitAction
    {
        public UnitActionSuikaThrowUnit(CommonActionId id) : base(id)
        {
        }

        protected override bool Execute(CommonActionParams actionParams)
        {
            var suika = actionParams.UnitData;
            if (!TryFindThrowable(actionParams, out var target)) return false;
            if (!TryFindThrowLanding(actionParams, out var landing)) return false;
            if (!HakureiNorwayHeroSkillUtil.TryMoveUnit(actionParams.MapData, target, landing, MoveType.PushMove))
                return false;
            ConsumeCaptureAndRefresh(actionParams);
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParams)
        {
            if (!CheckShow(actionParams, out _)) return false;
            if (!UnitActionCheckUnitHasCP(actionParams)) return false;
            return TryFindThrowable(actionParams, out _) && TryFindThrowLanding(actionParams, out _);
        }

        public override bool CheckShow(CommonActionParams actionParams, out ShowType showType)
        {
            if (!CheckShowCommon(actionParams, out showType)) return false;
            if (!HakureiNorwayHeroSkillUtil.IsSuika(actionParams.UnitData)) return false;
            if (!actionParams.UnitData.GetSkill(SkillType.SuikaBigForm, out _) &&
                !actionParams.UnitData.GetSkill(SkillType.SuikaGiantForm, out _)) return false;
            if (actionParams.UnitData.GetActionPoint(ActionPointType.Capture) <= 0) showType = ShowType.Done;
            return true;
        }

        private bool TryFindThrowable(CommonActionParams actionParams, out UnitData target)
        {
            target = actionParams.TargetUnitData;
            if (target != null) return true;
            var suika = actionParams.UnitData;
            if (suika == null || !suika.Grid(actionParams.MapData, out var suikaGrid)) return false;
            var buf = new List<GridData>();
            actionParams.MapData.GridMap.GetAroundGridData(1, 1, suikaGrid, buf);
            foreach (var grid in buf)
            {
                if (!grid.RealUnit(actionParams.MapData, out var unit)) continue;
                if (unit.Id == suika.Id) continue;
                target = unit;
                return true;
            }
            return false;
        }

        private bool TryFindThrowLanding(CommonActionParams actionParams, out GridData landing)
        {
            landing = actionParams.TargetGridData;
            if (landing != null && !landing.RealUnit(actionParams.MapData, out _)) return true;
            if (!actionParams.UnitData.Grid(actionParams.MapData, out var grid)) return false;
            var buf = new List<GridData>();
            actionParams.MapData.GridMap.GetAroundGridData(3, 3, grid, buf);
            foreach (var candidate in buf)
            {
                if (candidate.RealUnit(actionParams.MapData, out _)) continue;
                landing = candidate;
                return true;
            }
            return false;
        }
    }

}