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 Continentis.Mods.Basic.Buffs;
using Sirenix.OdinInspector;
using SoulliesFramework.General;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.Serialization;

namespace Continentis.MainGame
{
    public partial class CombatMainManager : Singleton<CombatMainManager>
    {
        [Title("References")] 
        public List<CharacterBase> characters;
        public List<CharacterBase> actionOrderList;
        public List<CombatCharacterViewBase> combatCharacterViews;
    }

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

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

        [Title("Keywords")] 
        public KeywordCollection keywordCollection;
    }

    public partial class CombatMainManager
    {
        protected override void Awake()
        {
            base.Awake();
            actionOrderList = new List<CharacterBase>();
            combatCharacterViews = new List<CombatCharacterViewBase>();
            eventCollection = new CombatEventCollection();
        }

        private void Start()
        {
            characters = MainGameManager.Instance.characters; //TODO: 将修改为获取本场战斗的角色列表
            
            CombatUIManager.Instance.hudPage.Initialize();
            
            foreach (CharacterBase character in characters)
            {
                character.characterView.hudContainer.EnableHUD("MainAttributesBar");
                character.characterView.hudContainer.EnableHUD("CharacterBuffCollection");
                
                if (character is CombatNPC)
                {
                    character.characterView.hudContainer.EnableHUD("Intention");
                }
            }

            StartCombat();
        }
    }

    public partial class CombatMainManager
    {
        public CardData testCardData;
        public EquipmentData testEquipmentData;
        
        public void StartCombat()
        {
            currentRound = 0;
            
            eventCollection.onCombatStart.Invoke();
            
            testCardData.GenerateCardInstance(MainGameManager.Instance.playerTeam, "Hand");
            //testEquipmentData.GenerateEquipment(characters[0]);

            foreach (CharacterBase character in characters)
            {
                character.InitializeCards();
                
                if (character is PlayerHero)
                {
                    List<CardInstance> drawPile = character.deckSubmodule.DrawPile;

                    drawPile.Shuffle();

                    // 处理“固有”卡牌
                    foreach (CardInstance card in drawPile.Where(card => card.cardLogic.HasKeyword("Innate")).ToList())
                    {
                        drawPile.Transfer(card, 0);
                    }

                    // 处理“迟钝”卡牌
                    foreach (CardInstance card in drawPile.Where(card => card.cardLogic.HasKeyword("Tardy")).ToList())
                    {
                        character.deckSubmodule.TransferCard("Draw", "Discard", card);
                    }
                }
            }
            
            foreach (CharacterBase character in characters)
            {
                character.eventSubmodule.onCombatStart.Add("Test", new EventUnit(() =>
                {
                    Basic_Vulnerable vulnerable = new Basic_Vulnerable(2);
                    vulnerable.Apply(character);
                }));
                
                character.eventSubmodule.onCombatStart.Invoke();
            }
            
            foreach (CardInstance card in characters.SelectMany(character => character.deckSubmodule.GetAllCards()))
            {
                card.cardLogic.eventSubmodule.onCombatStart.Invoke();
            }
            
            NextRound();
        }
        
        public void NextRound()
        {
            currentRound++;
            eventCollection.onRoundStart.Invoke();
            foreach (CharacterBase character in characters)
            {
                if (character is CombatNPC npc)
                {
                    //npc.intentionConfirmed = false;
                }
            }

            SetActionOrder();
            currentActionIndex = 0;
            
            foreach (CharacterBase character in characters)
            {
                if (character is CombatNPC npc)
                {
                    npc.intentionSubmodule.getIntendedCards.Invoke();
                    foreach (IntendedCard intendedCard in npc.intentionSubmodule.intendedCards)
                    {
                        intendedCard.cardInstance.GenerateIntentionCardView();
                    }
                    /*List<CardBase> intentionCards = enemy.ApplyIntention(enemy.GetCombatAttribute("ActionPoint"), 2);
                    intentionCards.ForEach(card =>
                    {
                        card.cardObject.EnableCardObject(entity.connectedHudContainer.enablingHUDs["Intention"] as ICardObjectContainer);
                        (card.cardObject as IntentionCardObject).RefreshCardMain();
                    });
                    enemy.intentionConfirmed = true;*/
                }
            }
            
            NextAction();
        }
        
        [Button("Next Action")]
        public void NextAction()
        {
            if (currentActionIndex >= actionOrderList.Count)
            {
                NextRound();
                return;
            }

            currentCharacter = actionOrderList[currentActionIndex++];
            
            currentCharacter.eventSubmodule.onActionStart.Invoke();
            //currentCharacter.StartActionSetUI();

            if (currentCharacter is PlayerHero playerHero)
            {
                DeckPage deckPage = CombatUIManager.Instance.deckPage;
                
                playerHero.deckSubmodule.SetUpCardViews();
                
                deckPage.handPile.isUpdatingLayout = false;
                playerHero.deckSubmodule.DrawCards(5, 0.1f);
                CommandQueueManager.Instance.AddCommand(new Cmd_Function(0f, () => deckPage.handPile.isUpdatingLayout = true));
                
                deckPage.combatResourcesDisplayer.SetCharacter(playerHero);
                
                CombatUIManager.Instance.deckPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "End Action";
                CombatUIManager.Instance.deckPage.endActionButton.interactable = true;
            }
            else if (currentCharacter is CombatNPC)
            {
                if (currentCharacter.fraction == Fraction.Enemy)
                {
                    CombatUIManager.Instance.deckPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Enemy Action";
                }
                else if (currentCharacter.fraction == Fraction.Enemy)
                {
                    CombatUIManager.Instance.deckPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Ally Action";
                }
                else
                {
                    CombatUIManager.Instance.deckPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Others Action";
                }

                CombatUIManager.Instance.deckPage.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));
            }
        }

        [Button("End Action")]
        public void EndAction()
        {
            CombatUIManager.Instance.deckPage.endActionButton.GetComponentInChildren<TMP_Text>().text = "Waiting...";
            CombatUIManager.Instance.deckPage.endActionButton.interactable = false;
            
            currentCharacter.eventSubmodule.onActionEnd.Invoke();

            if (currentCharacter is PlayerHero playerHero)
            {
                List<CardInstance> cardsToDiscard = new List<CardInstance>(playerHero.deckSubmodule.HandPile);
                playerHero.deckSubmodule.DiscardCards(cardsToDiscard);
            }

            CommandQueueManager.Instance.AddCommand(new Cmd_Function(0, CombatUIManager.Instance.deckPage.ClearAllCardViews));
            CommandQueueManager.Instance.AddCommand(new Cmd_Function(0.5f, null));
            CommandQueueManager.Instance.AddCommand(new Cmd_Function(0f, NextAction));
        }
    }

    public partial class CombatMainManager
    {
        public void SetActionOrder()
        {
            Dictionary<int, float> speeds = new Dictionary<int, float>();

            for (var index = 0; index < characters.Count; index++)
            {
                CharacterBase character = characters[index];
                float speed = character.attributeSubmodule.generalAttributeGroup.current.GetValue("Speed");

                if (character.fraction is Fraction.Player)
                {
                    speed += 0.01f; // 玩家角色微增速度，确保同速度时玩家角色优先
                }
                
                speeds.Add(index, speed);
            }

            actionOrderList.Clear();
            foreach (var pair in speeds.OrderByDescending(pair => pair.Value))
            {
                actionOrderList.Add(characters[pair.Key]);
            }
        }
    }
}