Continentis/Assets/Scripts/MainGame/Combat/CombatMainManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Continentis.MainGame.Card;
using Continentis.MainGame.Character;
using Continentis.MainGame.Commands;
using Continentis.MainGame.Equipment;
using Continentis.MainGame.UI;
using SLSFramework.General;
using SLSFramework.UModAssistance;
using TMPro;
using UnityEngine;

namespace Continentis.MainGame.Combat
{
    public partial class CombatMainManager : Singleton<CombatMainManager>
    {
        public CombatCharacterController characterController;
    }

    public partial class CombatMainManager
    {
        [Header("Combat State")]
        public int currentRound;
        public int currentActionIndex;
        public CharacterBase currentCharacter;
    }

    public partial class CombatMainManager
    {
        [Header("Events")]
        public CombatEventCollection eventCollection;
    }

    public partial class CombatMainManager
    {
        protected override void Awake()
        {
            base.Awake();
            characterController = new CombatCharacterController();
            eventCollection = new CombatEventCollection();
        }

        private void Start()
        {
            characterController.Initialize(MainGameManager.Instance.playerHeroDataList, MainGameManager.Instance.enemyDataList);
            StartCombat();
        }
    }

    public partial class CombatMainManager
    {
        public CardData testCardData;
        public EquipmentData testEquipmentData;
        
        public void StartCombat()
        {
            foreach (CharacterBase character in characterController.characters)
            {
                character.InitializeCards();
            }
            
            testEquipmentData = ModManager.GetAsset<EquipmentData>("EquipmentData_Basic_SteelBracer");
            EquipmentBase.GenerateEquipment(testEquipmentData, characterController.characters[0]);
            
            currentRound = 0;
            
            eventCollection.onCombatStart.Invoke();
            
            foreach (CharacterBase character in characterController.characters)
            {
                character.eventSubmodule.onCombatStart.Invoke();
                
                foreach (EquipmentBase equipment in character.equipmentSubmodule.currentEquipments)
                {
                    equipment.eventSubmodule.onCombatStart.Invoke();
                }
            }
            
            foreach (CardInstance card in characterController.characters.SelectMany(character => character.deckSubmodule.GetAllCards()))
            {
                card.cardLogic.eventSubmodule.onCombatStart.Invoke();
            }
            
            NextRound();
        }
        
        public void NextRound()
        {
            currentRound++;
            eventCollection.onRoundStart.Invoke();
            foreach (CharacterBase character in characterController.characters)
            {
                character.actionCountThisRound = 0;
            }

            characterController.SetActionOrder();
            CombatUIManager.Instance.combatMainPage.actionOrderDisplayer.InitializeTurnOrder();
            currentActionIndex = 0;
            
            foreach (CharacterBase character in characterController.characters)
            {
                if (character is CombatNPC npc)
                {
                    npc.intentionSubmodule.getIntendedCards.Invoke();
                    foreach (IntendedCard intendedCard in npc.intentionSubmodule.intendedCards)
                    {
                        intendedCard.cardInstance.GenerateIntentionCardView();
                        if (intendedCard.targets.Count > 0)
                        {
                            var cardLogic = intendedCard.cardInstance.cardLogic;
                            cardLogic.eventSubmodule.onTargeting(intendedCard.targets[0]); 
                            CardTextInterpreter.InterpretText(cardLogic);
                            cardLogic.intentionCardView.cardDescriptionText.text = cardLogic.contentSubmodule.interpretedFunctionText;
                            //TODO: 现在仅对第一个目标显示指向，后续可以对多目标进行优化
                        }
                    }
                }
                
                character.eventSubmodule.onRoundStart.Invoke();
                character.equipmentSubmodule.currentEquipments.ForEach(equipment => equipment.eventSubmodule.onRoundStart.Invoke());
                character.combatBuffSubmodule.RoundStart();
            }
            
            NextAction();
        }
        
        
        public void NextAction()
        {
            if (characterController.actionOrderList.Count == 0)
            {
                foreach (CharacterBase character in characterController.characters)
                {
                    character.eventSubmodule.onRoundEnd.Invoke();
                    character.equipmentSubmodule.currentEquipments.ForEach(equipment => equipment.eventSubmodule.onRoundEnd.Invoke());
                    character.combatBuffSubmodule.RoundEnd();
                }

                NextRound();
                return;
            }

            currentCharacter = characterController.actionOrderList[0];
            
            currentCharacter.eventSubmodule.onActionStart.Invoke();
            //currentCharacter.StartActionSetUI();

            if (currentCharacter is PlayerHero playerHero)
            {
                CombatMainPage combatMainPage = CombatUIManager.Instance.combatMainPage;
                
                playerHero.deckSubmodule.SetUpHandCardViews();
                playerHero.combatBuffSubmodule.ActionStart();
                
                combatMainPage.handPile.isUpdatingLayout = false;
                CommandQueueManager.Instance.AddCommand(playerHero.deckSubmodule.DrawCards(playerHero.GetAttribute("DrawCardAmountPerAction")));
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(0f, () =>
                {
                    //Debug.Log((drawCard.groupContext.context["DrawnCards"] as List<CardInstance>).Count);
                    combatMainPage.handPile.isUpdatingLayout = true;
                }));
                
                combatMainPage.combatResourcesDisplayer.SetCharacter(playerHero);
                
                CombatUIManager.Instance.combatMainPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "End Action";
                CombatUIManager.Instance.combatMainPage.endActionButton.interactable = true;
            }
            else if (currentCharacter is CombatNPC)
            {
                if (currentCharacter.fraction == Fraction.Enemy)
                {
                    CombatUIManager.Instance.combatMainPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Enemy Action";
                }
                else if (currentCharacter.fraction == Fraction.Enemy)
                {
                    CombatUIManager.Instance.combatMainPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Ally Action";
                }
                else
                {
                    CombatUIManager.Instance.combatMainPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Others Action";
                }

                CombatUIManager.Instance.combatMainPage.endActionButton.interactable = false;

                CommandQueueManager.Instance.AddCommand(new Cmd_Function(0.25f, null));
                foreach (IntendedCard intendedCard in currentCharacter.intentionSubmodule.intendedCards)
                {
                    CommandQueueManager.Instance.AddCommand(new Cmd_Function(0.25f, () => intendedCard.cardInstance.DestroyIntentionCardView()));
                    intendedCard.cardInstance.cardLogic.Play(intendedCard.targets, currentCharacter, false);
                }
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(0f, EndAction));
            }

            currentCharacter.actionCountThisRound++;
        }
        
        
        public void EndAction()
        {
            CombatUIManager.Instance.combatMainPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Waiting...";
            CombatUIManager.Instance.combatMainPage.endActionButton.interactable = false;
            
            CommandQueueManager.Instance.AddCommand(new Cmd_Function(currentCharacter.eventSubmodule.onActionEnd.Invoke));
            foreach (var card in currentCharacter.deckSubmodule.GetAllCards())
            {
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(card.cardLogic.eventSubmodule.onActionEnd.Invoke));
            }

            CommandQueueManager.Instance.AddCommand(new Cmd_Function(() =>
            {
                if (currentCharacter is PlayerHero playerHero)
                {
                    playerHero.combatBuffSubmodule.ActionEnd();
                    
                    Debug.Log(currentCharacter.data.className + " 结束行动，整理手牌。");

                    List<CardInstance> handPile = new List<CardInstance>(playerHero.deckSubmodule.HandPile);
                    List<CardInstance> cardToRetain = handPile.Where(card => card.cardLogic.HasKeyword("Retain")).ToList(); //含有“保留”关键词的卡牌
                    List<CardInstance> cardToExhaust = handPile.Where(card => card.cardLogic.HasKeyword("Ethereal")).ToList(); //含有“虚无”关键词的卡牌
                    List<CardInstance> cardsToDiscard = handPile.Except(cardToRetain).Except(cardToExhaust).ToList(); //其他卡牌，默认丢弃
                    CommandQueueManager.Instance.AddCommand(playerHero.deckSubmodule.ExhaustCards(cardToExhaust));
                    CommandQueueManager.Instance.AddCommand(playerHero.deckSubmodule.DiscardCards(cardsToDiscard, false));
                }
                
                characterController.actionOrderList.Remove(currentCharacter);
                CombatUIManager.Instance.combatMainPage.actionOrderDisplayer.EndAction();
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(CombatUIManager.Instance.combatMainPage.ClearAllCardViews));
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(0.5f, null));
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(NextAction));
            }));
        }
    }
}