diff --git a/SVSim.BattleEngine/COPIED.manifest.tsv b/SVSim.BattleEngine/COPIED.manifest.tsv new file mode 100644 index 0000000..a9bf525 --- /dev/null +++ b/SVSim.BattleEngine/COPIED.manifest.tsv @@ -0,0 +1,6 @@ +# engine-relpath source-relpath sha256 patched(0|1) +BattleCardBase.cs BattleCardBase.cs b105aec032149ab0a1730c6e06e25530699851707150ad4b72e24fe6d17fd50f 0 +BattleManagerBase.cs BattleManagerBase.cs b4181eac7af0ed578835ea75b7003e1b3466331006a35cd84b40139825680eb7 0 +BattlePlayerBase.cs BattlePlayerBase.cs 9d3a665158706460a52900008dcfcdf575dbe08cb6d3cc05e63e718b2885b51b 0 +SkillCreator.cs SkillCreator.cs 6b90cd32dea619058e1cf942bdd288981495f7711a76bff8ccc9e2787e3f6439 0 +Wizard.Battle/ActionProcessor.cs Wizard.Battle/ActionProcessor.cs 7c8b40454a4948dd48a58c0efc240703eab9a77aea0add64e542f6b06c7323af 0 diff --git a/SVSim.BattleEngine/Engine/.gitattributes b/SVSim.BattleEngine/Engine/.gitattributes new file mode 100644 index 0000000..9f9dc72 --- /dev/null +++ b/SVSim.BattleEngine/Engine/.gitattributes @@ -0,0 +1,2 @@ +# Verbatim engine copies: never normalize line endings (keeps sha256 manifest valid). +*.cs -text diff --git a/SVSim.BattleEngine/Engine/BattleCardBase.cs b/SVSim.BattleEngine/Engine/BattleCardBase.cs new file mode 100644 index 0000000..0d24e10 --- /dev/null +++ b/SVSim.BattleEngine/Engine/BattleCardBase.cs @@ -0,0 +1,3876 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using Cute; +using UnityEngine; +using Wizard; +using Wizard.Battle; +using Wizard.Battle.Card.InnerOptions; +using Wizard.Battle.Resource; +using Wizard.Battle.View; +using Wizard.Battle.View.Vfx; + +public abstract class BattleCardBase : IReadOnlyBattleCardInfo, IBattleCardUniqueID +{ + public class BuildInfo + { + public GameObject GameObject; + + public int CardId; + + public BattlePlayerBase SelfBattlePlayer; + + public BattlePlayerBase OpponentBattlePlayer; + + public IBattlePlayerReadOnlyInfo SelfBattlePlayerReadOnlyInfo; + + public List NormalSkillBuildInfos; + + public List EvolveSkillBuildInfos; + + public bool IsPlayer; + + public int BattleCardIndex; + + public CardInnerOptionsBase InnerOptions; + + public BattleManagerBase BattleMgr; + + public IBattleResourceMgr ResourceMgr; + + public BuildInfo(GameObject _gameObject, int _cardId, BattlePlayerBase _selfBattlePlayer, BattlePlayerBase _opponentBattlePlayer, IBattlePlayerReadOnlyInfo _selfBattlePlayerReadOnlyInfo, List _normalSkillBuildInfos, List _evolveSkillBuildInfos, bool _isPlayer, int _battleCardIndex, CardInnerOptionsBase _innerOptions, BattleManagerBase _battleMgr, IBattleResourceMgr _resourceMgr) + { + GameObject = _gameObject; + CardId = _cardId; + SelfBattlePlayer = _selfBattlePlayer; + OpponentBattlePlayer = _opponentBattlePlayer; + SelfBattlePlayerReadOnlyInfo = _selfBattlePlayerReadOnlyInfo; + NormalSkillBuildInfos = _normalSkillBuildInfos; + EvolveSkillBuildInfos = _evolveSkillBuildInfos; + IsPlayer = _isPlayer; + BattleCardIndex = _battleCardIndex; + InnerOptions = _innerOptions; + BattleMgr = _battleMgr; + ResourceMgr = _resourceMgr; + } + + public BuildInfo VirtualClone(BattlePlayerBase virtualSelfBattlePlayer, BattlePlayerBase virtualOpponentBattlePlayer) + { + return new BuildInfo(null, CardId, virtualSelfBattlePlayer, virtualOpponentBattlePlayer, virtualSelfBattlePlayer, new List(NormalSkillBuildInfos), new List(EvolveSkillBuildInfos), IsPlayer, BattleCardIndex, InnerOptions.VirtualClone(), BattleMgr, ResourceMgr); + } + } + + public class DeathTypeInformation + { + public bool WhenDestroy; + + public bool DestroyedByKiller; + + public bool ChantDestroy; + + public bool MysteriesDestroy; + + public bool BanishDestroy; + + public bool BurialRite; + + public bool UseFusionIngredient; + + public bool UseFusionMetamorphoseIngredient; + + public bool LeaveByGetOn; + + public DeathTypeInformation() + { + WhenDestroy = false; + DestroyedByKiller = false; + ChantDestroy = false; + MysteriesDestroy = false; + BanishDestroy = false; + BurialRite = false; + UseFusionIngredient = false; + UseFusionMetamorphoseIngredient = false; + LeaveByGetOn = false; + } + + public DeathTypeInformation Clone() + { + return (DeathTypeInformation)MemberwiseClone(); + } + + public void Reset() + { + WhenDestroy = false; + DestroyedByKiller = false; + ChantDestroy = false; + MysteriesDestroy = false; + BanishDestroy = false; + BurialRite = false; + UseFusionIngredient = false; + UseFusionMetamorphoseIngredient = false; + LeaveByGetOn = false; + } + } + + public class ParameterChangeInformation + { + public int CurrentAtk; + + public int BaseAtk; + + public int CurrentHealth; + + public int MaxHealth; + + public int BaseHealth; + + public ParameterChangeInformation(int currentAtk, int baseAtk, int currentHealth, int maxHealth, int baseHealth) + { + CurrentAtk = currentAtk; + BaseAtk = baseAtk; + CurrentHealth = currentHealth; + MaxHealth = maxHealth; + BaseHealth = baseHealth; + } + } + + public class ItWasDamagedCounter + { + public int SelfTurnDamage { get; private set; } + + public int OpponentTurnDamage { get; private set; } + + public ItWasDamagedCounter() + { + Clear(); + } + + public ItWasDamagedCounter(int selfTurnDamage, int opponentTurnDamage) + { + SelfTurnDamage = selfTurnDamage; + OpponentTurnDamage = opponentTurnDamage; + } + + public void Clear() + { + SelfTurnDamage = 0; + OpponentTurnDamage = 0; + } + + public void AddDamageCount(bool selfTurn) + { + if (selfTurn) + { + SelfTurnDamage++; + } + else + { + OpponentTurnDamage++; + } + } + + public int GetDamageCount(bool selfTurn) + { + if (selfTurn) + { + return SelfTurnDamage; + } + return OpponentTurnDamage; + } + } + + private struct DamageClipping + { + public int ClippingMax; + + public int GiveCount; + + public DamageClipping(int clippingMax, int count) + { + ClippingMax = clippingMax; + GiveCount = count; + } + } + + public struct TransformInformation + { + public BattleCardBase OriginalCard { get; private set; } + + public TransformType Type { get; private set; } + + public TransformInformation(TransformType type, BattleCardBase card) + { + Type = type; + OriginalCard = card; + } + } + + public struct SkillActivationInfo + { + public long SkillId { get; private set; } + + public SkillBase Skill { get; private set; } + + public SkillActivationInfo(long skillId, SkillBase skill) + { + SkillId = skillId; + Skill = skill; + } + } + + public enum CHECK_CONDITION_MUTATIONSKILL_TYPE + { + NONE, + NOT_HAVE_MUTATION_SKILL, + SELECT_ACCELERATE_SKILL_NOT_ACTIVE, + CRYSTALLIZE_SKILL_ACTIVE, + SELECT_CRYSTALLIZE_SKILL_NOT_ACTIVE, + NOT_PLAY, + PLAY + } + + public enum TransformType + { + None, + Accelerate, + Crystallize, + Choice, + Metamorphose + } + + public class DestroyedBySkillInfo + { + public enum DestroyedBySkillAbility + { + None, + WhenPlay, + Accelerate, + Crystallize, + WhenDestroy + } + + public DestroyedBySkillAbility Ability { get; private set; } + + public int BaseCardId { get; private set; } + + public string Player { get; private set; } + + public DestroyedBySkillInfo(DestroyedBySkillAbility ability, int baseCardId, bool isDestroyedBySelf) + { + Ability = ability; + BaseCardId = baseCardId; + Player = (isDestroyedBySelf ? "me" : "op"); + } + } + + public class BanishInfo + { + public enum BanishPlace + { + None, + Hand, + Field, + Deck + } + + public int Turn { get; private set; } + + public bool IsSelfTurn { get; private set; } + + public BanishPlace Place { get; private set; } + + public BanishInfo(int turn, bool isSelfTurn, BanishPlace place) + { + Turn = turn; + IsSelfTurn = isSelfTurn; + Place = place; + } + } + + public class AttackCountInfo + { + public Skill_attack_count Skill { get; private set; } + + public int Count { get; private set; } + + public AttackCountInfo(Skill_attack_count skill, int count) + { + Skill = skill; + Count = count; + } + + public virtual int CalcAttackCount(int baseAttackCount) + { + return baseAttackCount; + } + } + + public class SetAttackCountInfo : AttackCountInfo + { + public SetAttackCountInfo(Skill_attack_count skill, int count) + : base(skill, count) + { + } + + public override int CalcAttackCount(int baseAttackCount) + { + return base.Count; + } + } + + public class AddAttackCountInfo : AttackCountInfo + { + public AddAttackCountInfo(Skill_attack_count skill, int count) + : base(skill, count) + { + } + + public override int CalcAttackCount(int baseAttackCount) + { + return baseAttackCount + base.Count; + } + } + + public class AttackOpponentResult + { + public VfxBase attackVfx { get; private set; } + + public VfxBase damageVfx { get; private set; } + + public DamageResult damageResult { get; private set; } + + public AttackOpponentResult(VfxBase _attackVfx, VfxBase _damageVfx, DamageResult _damageResult) + { + attackVfx = _attackVfx; + damageVfx = _damageVfx; + damageResult = _damageResult; + } + } + + public struct DamageParam + { + public int Damage; + + public BattleCardBase OwnerCard { get; private set; } + + public DamageParam(int damage, BattleCardBase card, string damageType = "_OPT_NULL_", CardBasePrm.ClanType damageClan = CardBasePrm.ClanType.NONE) + { + List list = card.SkillApplyInformation.AddDamageList.Where((DamageModifier m) => m.IsEffective(damageType, damageClan, isUseClass: false)).ToList(); + list.AddRange(card.SelfBattlePlayer.Class.SkillApplyInformation.AddDamageList.Where((DamageModifier m) => m.IsEffective(damageType, damageClan, isUseClass: true))); + list.Sort((DamageModifier a, DamageModifier b) => a.OrderCount - b.OrderCount); + for (int num = 0; num < list.Count; num++) + { + damage = list[num].Calc(damage); + } + Damage = damage; + OwnerCard = card; + } + } + + public class DamageResult + { + public VfxBase Vfx { get; private set; } + + public VfxBase PreDamageVfx { get; private set; } + + public VfxBase PostDamageVfx { get; private set; } + + public int DamageApplied { get; private set; } + + public int GainLife { get; private set; } + + public bool IsReflectedDamage { get; private set; } + + public DamageResult(VfxBase _vfx, int _damageApplied, int _gainLife, VfxBase _preDamageVfx = null, VfxBase _postDamageVfx = null, bool isReflectedDamage = false) + { + Vfx = _vfx; + DamageApplied = _damageApplied; + GainLife = _gainLife; + IsReflectedDamage = isReflectedDamage; + PreDamageVfx = ((_preDamageVfx == null) ? NullVfx.GetInstance() : _preDamageVfx); + PostDamageVfx = ((_postDamageVfx == null) ? NullVfx.GetInstance() : _postDamageVfx); + } + } + + public struct HealParam + { + public int HealAmount; + + public HealParam(int healAmount, BattleCardBase owner, BattleCardBase target, bool applyModifier = true) + { + if (applyModifier) + { + List list = owner.SelfBattlePlayer.Class.SkillApplyInformation.HealModifierList.ToList(); + list.AddRange(owner.OpponentBattlePlayer.Class.SkillApplyInformation.HealModifierList); + list.Sort((HealModifier a, HealModifier b) => a.OrderCount - b.OrderCount); + for (int num = 0; num < list.Count; num++) + { + healAmount = list[num].Calc(healAmount, owner, target); + } + } + HealAmount = healAmount; + } + } + + public class HealResult + { + public int HealAmount { get; private set; } + + public VfxBase HealVfx { get; private set; } + + public VfxBase PrehealVfxVfx { get; private set; } + + public VfxBase PosthealVfxVfx { get; private set; } + + public HealResult(int healAmount, VfxBase _healVfx, VfxBase _prehealVfxVfx = null, VfxBase _posthealVfxVfx = null) + { + HealAmount = healAmount; + HealVfx = _healVfx; + PrehealVfxVfx = ((_prehealVfxVfx == null) ? NullVfx.GetInstance() : _prehealVfxVfx); + PosthealVfxVfx = ((_posthealVfxVfx == null) ? NullVfx.GetInstance() : _posthealVfxVfx); + } + } + + public class CopySkillInfo + { + public VfxBase Vfx { get; private set; } + + public bool IsEvolutionSkill { get; private set; } + + public SkillBaseCopy NewCopySkill { get; private set; } + + public List CopiedSkillList { get; private set; } + + public List AttachBuffs { get; private set; } + + public CopySkillInfo(VfxBase vfx, bool isEvolutionSkill, SkillBaseCopy copySkill, List copiedSkillList, List buffs) + { + Vfx = vfx; + IsEvolutionSkill = isEvolutionSkill; + NewCopySkill = copySkill; + CopiedSkillList = copiedSkillList; + AttachBuffs = buffs; + } + } + + private const string CONDITION_CHARGE_COUNT = "charge_count"; + + private const string TARGET_CONDITION_CHARGE_COUNT = "self.charge_count"; + + private const string ME_INPLAY_CLASS_COUNT = "{me.inplay.class.count}"; + + private BattleCardBase _finalMetamorphoseCard; + + protected BuildInfo _buildInfo; + + public List ReplayNoConsumeEpBuffInfoNameList = new List(); + + protected SkillCollectionBase _normalSkillCollection; + + protected SkillCollectionBase _evolveSkillCollection; + + private CardParameter _baseParameter; + + private CardParameter _evolveToOtherCardBaseParameter; + + public readonly IBattlePlayerReadOnlyInfo SelfBattlePlayerReadOnlyInfo; + + private bool _isOndraw; + + public const int NONE_COST = -1; + + public const int DEFAULT_SKILL_ACTIVATED_COUNT = 1; + + public const int DEFAULT_THIS_TURN_SKILL_ACTIVATED_COUNT = 0; + + private int _skillActivatedCountWrapValue = -1; + + private int _skillActivatedCount; + + private int _normalIndividualId = -1; + + private int _evolutionIndividualId = -1; + + private List _tribeCache; + + private List _lastTribeInfo = new List(); + + private int _playedCost = -1; + + private int _lastCost = -1; + + public readonly List CostModifierList; + + public List attackCountinfo; + + private static StringBuilder _extractedText = new StringBuilder(512); + + public BattleCardBase Card + { + get + { + if (MetamorphoseCard != null) + { + return MetamorphoseCard.Card; + } + return this; + } + } + + public virtual bool IsClass => false; + + public virtual bool IsUnit => false; + + public virtual bool IsSpell => false; + + public virtual bool IsField => false; + + public virtual bool IsChantField => false; + + public virtual bool IsSpecialSkill => false; + + public BattleCardBase LastDrawOpenCard { get; set; } + + public BattleCardBase MetamorphoseCard { get; set; } + + public BattleCardBase FinalMetamorphoseCard + { + get + { + if (_finalMetamorphoseCard == null && MetamorphoseCard != null) + { + _finalMetamorphoseCard = MetamorphoseCard; + } + while (_finalMetamorphoseCard != null && _finalMetamorphoseCard.MetamorphoseCard != null) + { + _finalMetamorphoseCard = _finalMetamorphoseCard.MetamorphoseCard; + } + return _finalMetamorphoseCard; + } + } + + public int MetamorphoseCount + { + get + { + int num = 0; + BattleCardBase metamorphoseCard = MetamorphoseCard; + while (metamorphoseCard != null) + { + metamorphoseCard = metamorphoseCard.MetamorphoseCard; + num++; + } + return num; + } + } + + public BattleCardBase ReplayBuffInfoCard { get; set; } + + public int PlayedTurn { get; protected set; } + + public DeathTypeInformation DeathTypeInfo { get; protected set; } + + public BuildInfo GetBuildInfo => _buildInfo; + + public int UpdateBuildInfoBeforeCardId { get; private set; } = -1; + + public string UpdateBuildInfoBeforeCardName { get; private set; } = string.Empty; + + public bool IsChoiceEvolutionCardBeforeUpdateBuildInfo => UpdateBuildInfoBeforeCardId / 1000000 == 910; + + public List NormalSkillBuildInfos => _buildInfo.NormalSkillBuildInfos; + + public List EvolveSkillBuildInfos => _buildInfo.EvolveSkillBuildInfos; + + public IEnumerable GetCopiedCardList + { + get + { + List list = new List(); + list.AddRange(NormalSkillBuildInfos); + list.AddRange(EvolveSkillBuildInfos); + return (from b in list + where b._previousSkillOwner != null + select b._previousSkillOwner).Distinct(); + } + } + + public List BuffInfoList { get; private set; } + + public List ReplayBuffInfoList { get; set; } = new List(); + + public List ReplayAllCopyBuffInfoList { get; set; } = new List(); + + public List ReplayBuffInfoLabelList { get; set; } = new List(); + + protected CardInnerOptionsBase InnerOptions => _buildInfo.InnerOptions; + + public IBattleResourceMgr ResourceMgr => _buildInfo.ResourceMgr; + + public IBattleCardView BattleCardView { get; protected set; } + + public virtual int Index => _buildInfo.BattleCardIndex; + + public BattlePlayerBase SelfBattlePlayer { get; protected set; } + + public BattlePlayerBase OpponentBattlePlayer { get; protected set; } + + public CardParameter BaseParameter + { + get + { + if (_evolveToOtherCardBaseParameter != null) + { + return _evolveToOtherCardBaseParameter; + } + return _baseParameter; + } + private set + { + _baseParameter = value; + } + } + + public SkillCollectionBase Skills { get; protected set; } + + public SkillCollectionBase NormalSkills => _normalSkillCollection; + + public SkillCollectionBase EvolutionSkills => _evolveSkillCollection; + + public TransformInformation TransformInfo { get; set; } + + public ISkillApplyInformation SkillApplyInformation { get; protected set; } + + public bool HasAnySkill { get; private set; } + + public bool IsTokenLoad { get; set; } + + public bool IsPlayer { get; private set; } + + public bool IsFirstTurn { get; protected set; } + + public bool IsOnMove { get; private set; } + + public bool IsSelfTurn => SelfBattlePlayer.IsSelfTurn; + + public virtual bool IsOnDraw + { + get + { + return _isOndraw; + } + private set + { + _isOndraw = value; + if (value) + { + OnStartDraw.Call(); + } + } + } + + public Action OnStartDraw { get; set; } + + public virtual bool IsActionCard => false; + + public virtual bool IsEvolution => false; + + public virtual bool IsEvolvedOnWhenLeave => false; + + public bool IsEvolDrunkenness + { + get + { + if (IsFirstTurn && IsSummonDrunkenness) + { + return !SkillApplyInformation.IsQuick; + } + return false; + } + } + + public virtual bool IsCantAttackClass + { + get + { + if (!GameMgr.GetIns().IsNewReplayBattle) + { + if (!SelfBattlePlayer.Class.IsCantAttackClass && !SkillApplyInformation.IsSkillCantAtkClass && !IsEvolDrunkenness) + { + if (IsFirstTurn && SkillApplyInformation.IsRush) + { + return !SkillApplyInformation.IsQuick; + } + return false; + } + return true; + } + return IsCantAttackClassOnReplay; + } + } + + public bool IsCantAttackClassOnReplay { get; set; } + + public bool IsCantAttackClassOnlyEvolDrunkenness + { + get + { + if (!SelfBattlePlayer.Class.IsCantAttackClass && !SkillApplyInformation.IsSkillCantAtkClass && IsEvolDrunkenness) + { + if (IsFirstTurn && SkillApplyInformation.IsRush) + { + return SkillApplyInformation.IsQuick; + } + return true; + } + return false; + } + } + + public bool IsSummonDrunkenness { get; set; } + + public bool IsPreviousTurnAttacked { get; set; } + + public bool IsSelectedDuringSelectingBurialRiteTarget { get; set; } + + public bool IsCantAttack + { + get + { + if (IsCantAttackClass) + { + return SkillApplyInformation.IsSkillCantAtkUnit; + } + return false; + } + } + + public List ReplaySkillDescriptionValueList { get; set; } = new List(); + + public List ReplayEvoSkillDescriptionValueList { get; set; } = new List(); + + public List ReplayBuffDetailSkillDescriptionValueList { get; set; } = new List(); + + public List ReplayBuffDetailEvoSkillDescriptionValueList { get; set; } = new List(); + + public virtual bool IsCantActivateFanfare => false; + + public int SpellChargeCount { get; protected set; } + + public int ChantCount => SkillApplyInformation.GetChantCount(BaseParameter.ChantCount); + + public int ExecutedFixedUseCostIndex { get; set; } + + public bool IsExecutedEarthRite { get; set; } + + public bool IsSkillLost { get; set; } + + public bool IsReanimate { get; set; } + + public ItWasDamagedCounter DamagedCounter { get; private set; } + + public bool HasSkillActivatedCountWrapValue => _skillActivatedCountWrapValue != -1; + + public int SkillActivatedCount + { + get + { + if (_skillActivatedCountWrapValue == -1) + { + return _skillActivatedCount; + } + int num; + for (num = _skillActivatedCount; num > _skillActivatedCountWrapValue; num -= _skillActivatedCountWrapValue) + { + } + return num; + } + protected set + { + _skillActivatedCount = value; + } + } + + public int ThisTurnSkillActivatedCount { get; protected set; } + + public int NormalIndividualId + { + get + { + if (_normalIndividualId == -1) + { + return _normalSkillCollection.GetIndividualId(); + } + return _normalIndividualId; + } + set + { + _normalIndividualId = value; + } + } + + public int EvolutionIndividualId + { + get + { + if (_evolutionIndividualId == -1) + { + return _evolveSkillCollection.GetIndividualId(); + } + return _evolutionIndividualId; + } + set + { + _evolutionIndividualId = value; + } + } + + public List SkillActivationList { get; set; } + + public bool AlreadyInactiveSkillActivateCountBySimultaneousDestroyedCardList { get; private set; } + + public bool ActiveSkillActivateCountBySimultaneousDestroyedCardList { get; set; } + + public bool AlreadyInactiveSkillActivateCountBySimultaneousBuffingCards { get; private set; } + + public bool ActiveSkillActivateCountBySimultaneousBuffingCards { get; set; } + + public bool AlreadyInactiveSkillActivateCountBySimultaneousSummonedCard { get; private set; } + + public bool ActiveSkillActivateCountBySimultaneousSummonedCard { get; set; } + + public bool HasSpellCharge + { + get + { + if (IsClass) + { + return false; + } + if (Skills.Any((SkillBase s) => s.OnWhenSpellChargeStart != 0)) + { + return true; + } + if (Skills.Any((SkillBase s) => Regex.IsMatch(s.CallCountText, "CHARGE_COUNT"))) + { + return true; + } + if (Skills.Any((SkillBase s) => s.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter t) => t.Lhs.Contains("charge_count")))) + { + return true; + } + if (BaseParameter.SkillTarget.Contains("self.charge_count")) + { + return true; + } + string oddChargeCountText = SkillFilterCreator.ContentKeyword.odd_charge_count.ToStringCustom(); + string evenChargeCountText = SkillFilterCreator.ContentKeyword.even_charge_count.ToStringCustom(); + return Skills.Any((SkillBase s) => s.IsRefVariable("CHARGE_COUNT") || s.IsRefVariable(oddChargeCountText) || s.IsRefVariable(evenChargeCountText)); + } + } + + public bool IsFusionable + { + get + { + SkillBase skillBase = Skills.FirstOrDefault((SkillBase s) => s is Skill_fusion); + if (skillBase == null) + { + return false; + } + if (IsAlreadyFusionInThisTurn) + { + return false; + } + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + if (skillBase.GetSelectableCards(playerInfoPair, option).Count() == 0) + { + return false; + } + if (!skillBase.CheckCondition(playerInfoPair, option, isPrePlay: true)) + { + return false; + } + return true; + } + } + + public bool IsAlreadyFusionInThisTurn => SkillApplyInformation.FusionIngredients.Any((FusionIngredientInfo c) => c.FusionTurn == SelfBattlePlayer.Turn); + + public List FusionIngredients => SkillApplyInformation.FusionIngredients.Select((FusionIngredientInfo f) => f.Card).ToList(); + + public int FusionedTurn { get; protected set; } + + public List GetOnCards => SkillApplyInformation.GetOnCards.ToList(); + + public bool IsChoiceEvolutionCard => CardId / 1000000 == 910; + + public List GetOffCards { get; set; } + + public bool CanPlayAsChoiceBraveCard + { + get + { + if (CardMaster.IsChoiceBraveCardCheck(CardId) && Cost <= SelfBattlePlayer.Bp) + { + if (Skills.Any((SkillBase s) => s.IsUserSelectType)) + { + return Skills.CheckWhenPlaySelectTargetSkillCondition; + } + return true; + } + return false; + } + } + + public virtual CHECK_CONDITION_MUTATIONSKILL_TYPE IsCheckActiveMutationSkill + { + get + { + using (IEnumerator enumerator = Skills.GetEnumerator()) + { + if (enumerator.MoveNext()) + { + if (!(enumerator.Current is Skill_pp_fixeduse skill_pp_fixeduse)) + { + return CHECK_CONDITION_MUTATIONSKILL_TYPE.NOT_HAVE_MUTATION_SKILL; + } + if (skill_pp_fixeduse.IsMutationFixedUseCost) + { + Skill_transform accelerateOrCrystallizeTransformSkill = GetAccelerateOrCrystallizeTransformSkill(); + if (accelerateOrCrystallizeTransformSkill != null) + { + BattleCardBase battleCardBase = SelfBattlePlayer.BattleMgr.CreateTransformCardRegisterVfx(this, accelerateOrCrystallizeTransformSkill.TransformId, accelerateOrCrystallizeTransformSkill.SkillPrm.ownerCard.IsPlayer); + if (battleCardBase.Skills.Any((SkillBase t) => t.IsUserSelectType)) + { + IEnumerable selectTypeSkill = battleCardBase.GetSelectTypeSkill(); + if (selectTypeSkill != null && selectTypeSkill.Count() > 0 && (battleCardBase.BaseParameter.CharType != CardBasePrm.CharaType.SPELL || (battleCardBase as SpellBattleCard).IsSelectableSkillTarget())) + { + return (battleCardBase.BaseParameter.CharType == CardBasePrm.CharaType.SPELL) ? CHECK_CONDITION_MUTATIONSKILL_TYPE.PLAY : CHECK_CONDITION_MUTATIONSKILL_TYPE.CRYSTALLIZE_SKILL_ACTIVE; + } + return (battleCardBase.BaseParameter.CharType == CardBasePrm.CharaType.SPELL) ? CHECK_CONDITION_MUTATIONSKILL_TYPE.SELECT_ACCELERATE_SKILL_NOT_ACTIVE : CHECK_CONDITION_MUTATIONSKILL_TYPE.SELECT_CRYSTALLIZE_SKILL_NOT_ACTIVE; + } + return (battleCardBase.BaseParameter.CharType == CardBasePrm.CharaType.SPELL) ? CHECK_CONDITION_MUTATIONSKILL_TYPE.PLAY : CHECK_CONDITION_MUTATIONSKILL_TYPE.CRYSTALLIZE_SKILL_ACTIVE; + } + } + return CHECK_CONDITION_MUTATIONSKILL_TYPE.NOT_PLAY; + } + } + return CHECK_CONDITION_MUTATIONSKILL_TYPE.NONE; + } + } + + public virtual bool BaseMovable => Movable(); + + public virtual bool IsInHand => SelfBattlePlayer.HandCardList.Contains(this); + + public virtual bool IsInDeck => SelfBattlePlayer.DeckCardList.Contains(this); + + public virtual bool IsInplay => SelfBattlePlayer.ClassAndInPlayCardList.Contains(this); + + public virtual bool IsInCemetery => SelfBattlePlayer.CemeteryList.Contains(this); + + public virtual bool IsInNecromanceZone => SelfBattlePlayer.NecromanceZoneList.Contains(this); + + public virtual bool IsFusionIngredient => SelfBattlePlayer.FusionIngredientList.Contains(this); + + public bool IsDestroyedByKiller { get; protected set; } + + public bool IsDestroyedBySkill { get; protected set; } + + public virtual bool IsDead + { + get + { + if (!IsLifeZeroDead && !IsDestroyedByKiller) + { + return IsDestroyedBySkill; + } + return true; + } + } + + public virtual bool IsLifeZeroDead => Life <= 0; + + public int DestroyedTurn { get; private set; } + + public bool IsDestroySelfTurn { get; private set; } + + public List DestroyedBySkillList { get; private set; } + + public BanishInfo BanishedInfo { get; private set; } + + public SkillBase DiscardedSkill { get; private set; } + + public SkillBase ReturnedSkill { get; private set; } + + public bool HasDeckSelfSkill => Skills.Any((SkillBase s) => s.IsDeckSelfSkill); + + public int AttackableCount { get; set; } + + public virtual bool Attackable + { + get + { + if (!GameMgr.GetIns().IsNewReplayBattle) + { + if (AttackableCount <= 0 || (IsSummonDrunkenness && (!IsSummonDrunkenness || !IsEvolution)) || IsCantAttack) + { + if (SkillApplyInformation.IsInfiniteAttack && !IsSummonDrunkenness) + { + return !IsCantAttack; + } + return false; + } + return true; + } + return AttackableOnReplay; + } + } + + public bool AttackableOnReplay { get; set; } + + public virtual List Tribe + { + get + { + if (SkillApplyInformation == null || SkillApplyInformation.TribeSkinInfo.Count == 0) + { + return BaseParameter.Tribe; + } + if (_tribeCache != null && _lastTribeInfo != null && _lastTribeInfo.SequenceEqual(SkillApplyInformation.TribeSkinInfo)) + { + return _tribeCache; + } + List list = new List(BaseParameter.Tribe); + for (int i = 0; i < SkillApplyInformation.TribeSkinInfo.Count(); i++) + { + if (SkillApplyInformation.TribeSkinInfo[i].TribeTypeList != null) + { + switch (SkillApplyInformation.TribeSkinInfo[i].ChangeType) + { + case CardBasePrm.TribeChangeType.CHANGE: + list = SkillApplyInformation.TribeSkinInfo[i].TribeTypeList; + break; + case CardBasePrm.TribeChangeType.ADD: + list.AddRange(SkillApplyInformation.TribeSkinInfo[i].TribeTypeList); + break; + default: + list = SkillApplyInformation.TribeSkinInfo[i].TribeTypeList; + break; + } + } + } + _tribeCache = list.Distinct().ToList(); + if (_tribeCache.Count >= 2 && _tribeCache.Contains(CardBasePrm.TribeType.ALL)) + { + _tribeCache.Remove(CardBasePrm.TribeType.ALL); + } + _lastTribeInfo.Clear(); + _lastTribeInfo.AddRange(SkillApplyInformation.TribeSkinInfo); + return _tribeCache; + } + } + + public virtual CardBasePrm.ClanType Clan + { + get + { + if (SkillApplyInformation.ClanSkinInfo.Count <= 0) + { + return BaseParameter.Clan; + } + return SkillApplyInformation.ClanSkinInfo.Last(); + } + } + + public int CardId => _buildInfo.CardId; + + public int EquitedCardId + { + get + { + if (IsChoiceEvolutionCard) + { + return BaseParameter.BaseCardId; + } + DataMgr.SpecialBattleSetting specialBattleSettingInfo = GameMgr.GetIns().GetDataMgr().SpecialBattleSettingInfo; + if (specialBattleSettingInfo == null) + { + return CardId; + } + Dictionary idOverridePairDict = specialBattleSettingInfo.IdOverridePairDict; + if (idOverridePairDict == null) + { + return CardId; + } + if (idOverridePairDict.ContainsKey(CardId)) + { + return idOverridePairDict[CardId]; + } + return CardId; + } + } + + public int Cost + { + get + { + int num = BaseParameter.Cost; + if (IsChoiceBraveSkillCard) + { + return num; + } + for (int i = 0; i < CostModifierList.Count; i++) + { + ICardCostModifier cardCostModifier = CostModifierList[i]; + if (!(cardCostModifier is CostHalfModifier)) + { + num = cardCostModifier.CalcCost(num); + } + } + for (int j = 0; j < CostModifierList.Count; j++) + { + ICardCostModifier cardCostModifier2 = CostModifierList[j]; + if (cardCostModifier2 is CostHalfModifier) + { + num = cardCostModifier2.CalcCost(num); + } + } + return Math.Max(0, num); + } + } + + public int BaseCost => BaseParameter.Cost; + + public int Atk => SkillApplyInformation.GetAtk(); + + public int BaseAtk + { + get + { + if (!IsEvolution) + { + return BaseParameter.Atk; + } + return BaseParameter.EvoAtk; + } + } + + public int Life => SkillApplyInformation.GetLife(); + + public int MaxLife => SkillApplyInformation.GetMaxLife(); + + public int[] GenericValueArray => SkillApplyInformation.SkillGenericValueArray; + + public virtual int BaseMaxLife + { + get + { + if (!IsEvolution) + { + return BaseParameter.Life; + } + return BaseParameter.EvoLife; + } + } + + public int PlayedCost => _playedCost; + + public int LastCost => _lastCost; + + public int MaxAttackableCount + { + get + { + int num = 1; + for (int i = 0; i < attackCountinfo.Count; i++) + { + num = attackCountinfo[i].CalcAttackCount(num); + } + return num; + } + } + + public DamageParam DamageCalculationAtkTypeAttack => new DamageParam(SkillApplyInformation.IsAttackByLifeTypeAttack ? Life : Atk, this, SkillFilterCreator.ContentKeyword.unit.ToString(), Clan); + + public DamageParam DamageCalculationAtkTypeBeAttacked => new DamageParam(SkillApplyInformation.IsAttackByLifeTypeBeAttacked ? Life : Atk, this, SkillFilterCreator.ContentKeyword.unit.ToString(), Clan); + + public ICardVfxCreator VfxCreator { get; protected set; } + + public bool AreCanPlayConditionsFulfilled => this.OnCheckCanPlay.GetAllFuncCallResults().All((bool condition) => condition); + + public bool AreCanAttackConditionsFulfilled => this.OnCheckCanAttack.GetAllFuncCallResults().All((bool condition) => condition); + + public bool AreCanBeAttackedConditionsFulfilled => this.OnCheckCanBeAttacked.GetAllFuncCallResults().All((bool condition) => condition); + + public bool AreCanBeSelectedConditionsFulfilled => this.OnCheckCanBeSelected.GetAllFuncCallResults().All((bool condition) => condition); + + public bool AreCanShowDetailConditionsFulfilled => this.OnCheckCanShowDetail.GetAllFuncCallResults().All((bool condition) => condition); + + public bool AreCanEvolveConditionsFulfilled => this.OnCheckCanEvolve.GetAllFuncCallResults().All((bool condition) => condition); + + public int FixedUseCost => CalcFixedUseCost(SelfBattlePlayer.Pp); + + public List UseCostList + { + get + { + List list = new List(); + List list2 = new List(); + int pp = SelfBattlePlayer.Pp; + for (int i = 0; i < Skills.Count(); i++) + { + if (Skills.ElementAt(i) is Skill_pp_fixeduse skill_pp_fixeduse) + { + if (skill_pp_fixeduse.IsAccelerateOrCrystallize) + { + list2.Add(skill_pp_fixeduse._fixedUsePP); + } + else + { + list.Add(skill_pp_fixeduse._fixedUsePP); + } + } + } + List list3 = new List(); + if (!list.Any() && !list2.Any()) + { + return list3; + } + if (IsSelectedDuringSelectingBurialRiteTarget) + { + return list3; + } + if (!IsCantActivateFanfare) + { + list3.AddRange(list.Where((int c) => c <= pp).Reverse()); + } + if ((!list.Any((int c) => c <= Cost) || IsCantActivateFanfare) && Cost <= pp) + { + list3.Add(Cost); + } + list3.AddRange(list2.Where((int c) => pp >= c && c < Cost).Reverse()); + list3.AddRange(list2.Where((int c) => pp < c && c < Cost)); + if (!list.Any((int c) => c <= Cost) && pp < Cost) + { + list3.Add(Cost); + } + if (!IsCantActivateFanfare) + { + list3.AddRange(list.Where((int c) => pp < c)); + } + list3.AddRange(list2.Where((int c) => Cost <= c)); + if (list.Any((int c) => c <= Cost)) + { + list3.Add(Cost); + } + if (IsCantActivateFanfare) + { + list3.AddRange(list); + } + return list3; + } + } + + public bool HasSkillFixedUseCost => FixedUseCost != -1; + + public bool HasSkillAccelerate => Skills.Any((SkillBase s) => s.OnWhenAccelerate != 0); + + public bool HasSkillCrystallize => Skills.Any((SkillBase s) => s.OnWhenCrystallize != 0); + + public bool HasSkillEnhance => Skills.Any((SkillBase s) => s.IsEnhance()); + + public bool HasSkillDestroyWhiteRitual => HasSkillDestroyTribe(CardBasePrm.TribeType.WHITE_RITUAL); + + public bool HasSkillStackWhiteRitual => Skills.Any((SkillBase s) => s is Skill_stack_white_ritual); + + public bool HasSkillBurialRite + { + get + { + if (!NormalSkills.Any((SkillBase s) => s.IsBurialRite)) + { + return EvolutionSkills.Any((SkillBase s) => s.IsBurialRite); + } + return true; + } + } + + public bool HasSkillNecromance { get; private set; } + + public bool HasSkillWhenDestroy + { + get + { + if (IsInDeck) + { + if (!NormalSkills.Any((SkillBase s) => s.IsWhenDestroySkill)) + { + return EvolutionSkills.Any((SkillBase s) => s.IsWhenDestroySkill); + } + return true; + } + return Skills.Any((SkillBase s) => s.IsWhenDestroySkill); + } + } + + public bool HasSkillReanimate + { + get + { + if (!NormalSkills.Any((SkillBase s) => s is Skill_summon_token && (s as Skill_summon_token).IsReanimate)) + { + return EvolutionSkills.Any((SkillBase s) => s is Skill_summon_token && (s as Skill_summon_token).IsReanimate); + } + return true; + } + } + + public bool HasSkillFusion => NormalSkills.Any((SkillBase s) => s is Skill_fusion); + + public bool HasWhenAttack => Skills.Any((SkillBase s) => s.IsBeforAttackSkill); + + public bool HasWhenFight => Skills.Any((SkillBase s) => s.IsWhenFightSkill); + + public bool HasFusionSkill => Skills.Any((SkillBase s) => s is Skill_fusion); + + public bool HasNoSelectFusionSkill => Skills.Any((SkillBase s) => s.IsNoSelectFusionSkill); + + public bool IsChoiceBraveSkillCard { get; set; } + + public bool HasSkillWhenEvolve => EvolutionSkills.Any((SkillBase s) => s.IsWhenEvolveSkill); + + public bool HasUnionBurst + { + get + { + string unionBurstString = SkillFilterCreator.ContentKeyword.union_burst_count.ToString(); + if (Skills.Any((SkillBase s) => s.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter t) => t.Lhs.Contains(unionBurstString)))) + { + return true; + } + return false; + } + } + + public bool HasSkyboundArt + { + get + { + string skyboundArtString = SkillFilterCreator.ContentKeyword.skybound_art_count.ToString(); + return Skills.Any((SkillBase s) => s.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter t) => t.Lhs.Contains(skyboundArtString))); + } + } + + public bool HasSuperSkyboundArt + { + get + { + string superSkyboundArtString = SkillFilterCreator.ContentKeyword.super_skybound_art_count.ToString(); + return Skills.Any((SkillBase s) => s.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter t) => t.Lhs.Contains(superSkyboundArtString))); + } + } + + public bool IsLegend => BaseParameter.Rarity >= 4; + + public int DrawTurn { get; set; } + + public bool IsHaveBurialRiteJudgeBothFlag + { + get + { + bool flag = false; + bool flag2 = false; + foreach (SkillBase skill in Skills) + { + List list = skill.ConditionFilterCollection.ConditionCheckerFilterList.FindAll((ISkillConditionChecker x) => x is SkillConditionBurialRite).ConvertAll((ISkillConditionChecker x) => x as SkillConditionBurialRite); + if (list == null) + { + continue; + } + if (!flag) + { + flag = list.Find((SkillConditionBurialRite x) => x.judgeFlg) != null; + } + if (!flag2) + { + flag2 = list.Find((SkillConditionBurialRite x) => !x.judgeFlg) != null; + } + } + return flag && flag2; + } + } + + public bool IsBuffDetail + { + get + { + if (IsShowBuffDetail || IsRecordingBuffDetail) + { + return !IsRecordingExceptBuffDetail; + } + return false; + } + } + + public bool IsShowBuffDetail { get; set; } + + public bool IsRecordingBuffDetail { get; set; } + + public bool IsRecordingExceptBuffDetail { get; set; } + + public bool IsRecordingFusionInfo { get; set; } + + public event Func OnRemoveFromInPlayAfterOneTime; + + public event Func OnBeforeEvolve; + + public event Action OnEvolveEvent; + + public event Func OnPlay; + + public event Func OnFinishWhenPlaySkill; + + public event Func OnDestroy; + + public event Func OnBanish; + + public event Func OnReturnCard; + + public event Func OnMetamorphose; + + public event Func OnGetOn; + + public event Action OnAddCostState; + + public event Action OnRemoveCostState; + + public event Func OnAfterAddDamage; + + public event Action OnAttachSkill; + + public event Action OnCopySkillComplete; + + public event Func OnLoseSkillOneTime; + + public event Func OnDamageAfter; + + public event Func OnGiveDamage; + + public event Func OnReflectionAfter; + + public event Action OnResetCardParameter; + + public event Action> OnFusionEvent; + + public event Action OnTurnStart; + + public event Func OnCheckCanPlay; + + public event Func OnCheckCanAttack; + + public event Func OnCheckCanBeAttacked; + + public event Func OnCheckCanBeSelected; + + public event Func OnCheckCanShowDetail; + + public event Func OnCheckCanEvolve; + + public void SetPlayedTurnNow() + { + PlayedTurn = SelfBattlePlayer.Turn; + } + + private void ResetUpdateBuildInfo() + { + UpdateBuildInfoBeforeCardId = -1; + UpdateBuildInfoBeforeCardName = string.Empty; + } + + public void UpdateBuildInfoAndSkillCollection(int cardId, bool isFoil, bool isNotUpdateAtkLife = false) + { + UpdateBuildInfoBeforeCardId = BaseParameter.NormalCardId; + UpdateBuildInfoBeforeCardName = BaseParameter.CardName; + SkillCreator.CardSkillsBuildInfo cardSkillsBuildInfo = SkillCreator.CreateBuildInfo(CardMaster.GetInstanceForBattle().GetCardParameterFromId(cardId)); + _buildInfo = new BuildInfo(_buildInfo.GameObject, isFoil ? (cardId + 1) : cardId, _buildInfo.SelfBattlePlayer, _buildInfo.OpponentBattlePlayer, _buildInfo.SelfBattlePlayer, cardSkillsBuildInfo.normalSkillBuildInfos, cardSkillsBuildInfo.evolveSkillBuildInfos, _buildInfo.IsPlayer, _buildInfo.BattleCardIndex, _buildInfo.InnerOptions, _buildInfo.BattleMgr, _buildInfo.ResourceMgr); + int evoAtk = BaseParameter.EvoAtk; + int evoLife = BaseParameter.EvoLife; + _evolveToOtherCardBaseParameter = CardMaster.GetInstanceForBattle().GetCardParameterFromId(_buildInfo.CardId).Clone(); + InitSkillCollection(); + if (isNotUpdateAtkLife) + { + _evolveToOtherCardBaseParameter.UpdateEvoAtkLife(evoAtk, evoLife); + } + } + + public void ResetChoiceEvolutionCardBuildInfo() + { + UpdateBuildInfoAndSkillCollection(BaseParameter.BaseCardId, BaseParameter.IsFoil); + if (!SelfBattlePlayer.BattleMgr.IsRecovery || IsPlayer) + { + BattleCardView.CardTemplate.NormalNameLabelTemp.text = BaseParameter.CardName; + Global.SetRepositionNameLabel(BattleCardView.CardTemplate.NormalNameLabelTemp, BaseParameter.CardName, is2D: false); + BattleCardView.InitializeVoiceInfo(CardId); + for (int i = 0; i < NormalSkills.Count(); i++) + { + NormalSkills.ElementAt(i).SetInductionVoiceIndex(); + } + for (int j = 0; j < EvolutionSkills.Count(); j++) + { + EvolutionSkills.ElementAt(j).SetInductionVoiceIndex(); + } + } + } + + public void UpdateChoiceEvolutionBeforeCard(int cardId, string cardName) + { + UpdateBuildInfoBeforeCardId = cardId; + UpdateBuildInfoBeforeCardName = cardName; + } + + public void ResetReplayBuffInfo() + { + ReplayBuffInfoList.Clear(); + ReplayNoConsumeEpBuffInfoNameList.Clear(); + ReplayBuffInfoLabelList.Clear(); + } + + public virtual string SkillDescription(BattlePlayerBase.SideLogInfo sideLogInfo = null, bool isSkipOption = false, BuffInfo buff = null, string divergenceId = "", List skillDescriptionValueList = null, List sideLogDescriptionValueList = null) + { + return ConvertSkillDescription(BaseParameter.SkillDescription, sideLogInfo, isSkipOption, buff, divergenceId, skillDescriptionValueList, (IsBuffDetail && sideLogInfo == null && ReplayBuffDetailSkillDescriptionValueList.Count > 0) ? ReplayBuffDetailSkillDescriptionValueList : ((sideLogDescriptionValueList != null) ? sideLogDescriptionValueList : ReplaySkillDescriptionValueList)); + } + + public virtual string EvoSkillDescription(BattlePlayerBase.SideLogInfo sideLogInfo = null, bool isSkipOption = false, BuffInfo buff = null, string divergenceId = "", List skillDescriptionValueList = null, List sideLogDescriptionValueList = null) + { + return ConvertSkillDescription(BaseParameter.EvoSkillDescription, sideLogInfo, isSkipOption, buff, divergenceId, skillDescriptionValueList, (IsBuffDetail && sideLogInfo == null && ReplayBuffDetailEvoSkillDescriptionValueList.Count > 0) ? ReplayBuffDetailEvoSkillDescriptionValueList : ((sideLogDescriptionValueList != null) ? sideLogDescriptionValueList : ReplayEvoSkillDescriptionValueList)); + } + + public string CopiedSkillDescription(string skillDescription, List skillDescriptionValueList) + { + return ConvertSkillDescription(skillDescription, null, isSkipOption: false, null, "", skillDescriptionValueList, null); + } + + public string CopiedEvoSkillDescription(string skillDescription, List skillDescriptionValueList) + { + return ConvertSkillDescription(skillDescription, null, isSkipOption: false, null, "", skillDescriptionValueList, null); + } + + public string CopiedSkillDescriptionInReplay(BuffInfo buff, List copiedSkillDescriptionValueList) + { + return ConvertSkillDescription(BaseParameter.SkillDescription, null, isSkipOption: false, buff, "", null, copiedSkillDescriptionValueList); + } + + public string CopiedEvoSkillDescriptionInReplay(BuffInfo buff, List copiedEvoSkillDescriptionValueList) + { + return ConvertSkillDescription(BaseParameter.EvoSkillDescription, null, isSkipOption: false, buff, "", null, copiedEvoSkillDescriptionValueList); + } + + public virtual bool CantBeFocusedAttack(BattleCardBase attackCard) + { + if (SkillApplyInformation.IsSneak) + { + return true; + } + if (SkillApplyInformation.NotBeAttackedInfoList.Any((NotBeAttackedInfo s) => !s.CheckAttacked(attackCard))) + { + return true; + } + return false; + } + + public bool CanEvolution(bool isSkill, bool isSelfBattlePlayer) + { + BattlePlayerBase battlePlayerBase = (isSelfBattlePlayer ? SelfBattlePlayer : OpponentBattlePlayer); + if (isSkill) + { + if (!IsEvolution) + { + return true; + } + } + else if (battlePlayerBase.EvolveWaitTurnCount <= 0 && battlePlayerBase.NowTurnEvol && (battlePlayerBase.CurrentEpCount - SkillApplyInformation.GetEp() >= 0 || battlePlayerBase.CheckNotConsumeEpCard(this)) && !IsEvolution && !SkillApplyInformation.CantEvolutionList.Any((int f) => (f & Skill_cant_evolution.BIT_FLAG_EPUSE) != 0)) + { + return true; + } + return false; + } + + public void IncrementSkillActivatedCount() + { + SkillActivatedCount++; + ThisTurnSkillActivatedCount++; + } + + public void SetSkillActivatedCount(int value) + { + SkillActivatedCount = value; + } + + public void SetSkillActivatedCountWrapValue(int value) + { + _skillActivatedCountWrapValue = value; + } + + public void ResetSkillActivateCountBySimultaneousDestroyedCardList() + { + ActiveSkillActivateCountBySimultaneousDestroyedCardList = false; + AlreadyInactiveSkillActivateCountBySimultaneousDestroyedCardList = false; + } + + public void InactiveSkillActivateCountBySimultaneousDestroyedCardList() + { + ActiveSkillActivateCountBySimultaneousDestroyedCardList = false; + AlreadyInactiveSkillActivateCountBySimultaneousDestroyedCardList = true; + } + + public void ResetSkillActivateCountBySimultaneousBuffingCards() + { + ActiveSkillActivateCountBySimultaneousBuffingCards = false; + AlreadyInactiveSkillActivateCountBySimultaneousBuffingCards = false; + } + + public void InactiveSkillActivateCountBySimultaneousBuffingCards() + { + ActiveSkillActivateCountBySimultaneousBuffingCards = false; + AlreadyInactiveSkillActivateCountBySimultaneousBuffingCards = true; + } + + public void ResetSkillActivateCountBySimultaneousSummonedCard() + { + ActiveSkillActivateCountBySimultaneousSummonedCard = false; + AlreadyInactiveSkillActivateCountBySimultaneousSummonedCard = false; + } + + public void InactiveSkillActivateCountBySimultaneousSummonedCard() + { + ActiveSkillActivateCountBySimultaneousSummonedCard = false; + AlreadyInactiveSkillActivateCountBySimultaneousSummonedCard = true; + } + + protected virtual bool GetIsMovableOnView() + { + if (IsOnDraw) + { + return false; + } + return Movable(isCheckOnDraw: false); + } + + public virtual bool Movable(bool isCheckOnDraw = true, bool isSkipSelecting = false, CHECK_CONDITION_MUTATIONSKILL_TYPE type = CHECK_CONDITION_MUTATIONSKILL_TYPE.NONE, bool isRecording = false) + { + if (SelfBattlePlayer.Class.SkillApplyInformation.IsCantPlay(this, type)) + { + return false; + } + if (!SelfBattlePlayer.HandCardList.Contains(this)) + { + return false; + } + if (SelfBattlePlayer.Pp < Cost && FixedUseCost == -1) + { + return false; + } + if (!IsSelfTurn) + { + return false; + } + if (SelfBattlePlayer.Class.IsDead || OpponentBattlePlayer.Class.IsDead) + { + return false; + } + if (!InnerOptions.CheckMovable(SelfBattlePlayer.BattleView, BattleCardView, isCheckOnDraw && IsOnDraw, isSkipSelecting, isRecording)) + { + return false; + } + if (!SelfBattlePlayer.IsPlayer && GameMgr.GetIns().IsAdminWatch) + { + if (isCheckOnDraw && IsOnDraw) + { + return false; + } + if (BattleCardView._hasCardEnteredPlayQueue) + { + return false; + } + if (SelfBattlePlayer.BattleView.IsSelecting && !isSkipSelecting) + { + return false; + } + } + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + SkillConditionCheckerOption checkerOption = new SkillConditionCheckerOption(); + if (Skills.Any((SkillBase s) => s is Skill_can_play_self && !s.CheckCondition(playerInfoPair, checkerOption, isPrePlay: true))) + { + return false; + } + return true; + } + + public Skill_transform GetAccelerateOrCrystallizeTransformSkill() + { + BattlePlayerReadOnlyInfoPair pair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + for (int i = 0; i < Skills.Count(); i++) + { + if (Skills.ElementAt(i) is Skill_pp_fixeduse { IsAccelerateOrCrystallize: false } skill_pp_fixeduse && !IsCantActivateFanfare && skill_pp_fixeduse.CheckCondition(pair, option, isPrePlay: true)) + { + return null; + } + } + return (Skill_transform)Skills.LastOrDefault((SkillBase s) => (s.OnWhenAccelerate != 0 || s.OnWhenCrystallize != 0) && s is Skill_transform && s.CheckCondition(pair, option, isPrePlay: true)); + } + + public bool IsMutationMovable(CHECK_CONDITION_MUTATIONSKILL_TYPE type) + { + if (type == CHECK_CONDITION_MUTATIONSKILL_TYPE.SELECT_ACCELERATE_SKILL_NOT_ACTIVE) + { + return false; + } + if (SelfBattlePlayer.InPlayCards.Count() >= 5) + { + switch (type) + { + case CHECK_CONDITION_MUTATIONSKILL_TYPE.CRYSTALLIZE_SKILL_ACTIVE: + case CHECK_CONDITION_MUTATIONSKILL_TYPE.SELECT_CRYSTALLIZE_SKILL_NOT_ACTIVE: + return false; + default: + return false; + case CHECK_CONDITION_MUTATIONSKILL_TYPE.NONE: + case CHECK_CONDITION_MUTATIONSKILL_TYPE.PLAY: + break; + } + } + return true; + } + + public void SetDestroyedBySkillList(SkillBase skill) + { + DestroyedBySkillList = new List(); + if (skill == null) + { + return; + } + bool isDestroyedBySelf = skill.SkillPrm.ownerCard.SelfBattlePlayer.IsPlayer == SelfBattlePlayer.IsPlayer; + if (skill.IsWhenPlaySkill) + { + DestroyedBySkillList.Add(new DestroyedBySkillInfo(DestroyedBySkillInfo.DestroyedBySkillAbility.WhenPlay, skill.SkillPrm.ownerCard.BaseParameter.BaseCardId, isDestroyedBySelf)); + TransformInformation transformInfo = skill.SkillPrm.ownerCard.TransformInfo; + switch (transformInfo.Type) + { + case TransformType.Accelerate: + DestroyedBySkillList.Add(new DestroyedBySkillInfo(DestroyedBySkillInfo.DestroyedBySkillAbility.Accelerate, transformInfo.OriginalCard.BaseParameter.BaseCardId, isDestroyedBySelf)); + break; + case TransformType.Crystallize: + DestroyedBySkillList.Add(new DestroyedBySkillInfo(DestroyedBySkillInfo.DestroyedBySkillAbility.Crystallize, transformInfo.OriginalCard.BaseParameter.BaseCardId, isDestroyedBySelf)); + break; + } + } + else if (skill.IsWhenDestroySkill) + { + DestroyedBySkillList.Add(new DestroyedBySkillInfo(DestroyedBySkillInfo.DestroyedBySkillAbility.WhenDestroy, skill.SkillPrm.ownerCard.BaseParameter.BaseCardId, isDestroyedBySelf)); + } + else + { + DestroyedBySkillList.Add(new DestroyedBySkillInfo(DestroyedBySkillInfo.DestroyedBySkillAbility.None, skill.SkillPrm.ownerCard.BaseParameter.BaseCardId, isDestroyedBySelf)); + } + } + + public void SetBanishedInfo(BanishInfo.BanishPlace place) + { + BattlePlayerBase battlePlayerBase = (SelfBattlePlayer.IsSelfTurn ? SelfBattlePlayer : OpponentBattlePlayer); + BanishedInfo = new BanishInfo(battlePlayerBase.Turn, battlePlayerBase.IsPlayer, place); + } + + public void SetDiscardedSkill(SkillBase discardedSkill) + { + DiscardedSkill = discardedSkill; + } + + public void SetReturnedSkill(SkillBase returnedSkill) + { + ReturnedSkill = returnedSkill; + } + + public bool IsTribe(CardBasePrm.TribeType tribe) + { + if (Tribe != null) + { + return Tribe.Contains(tribe); + } + return false; + } + + public bool HasMoreDamageThan(BattleCardBase other) + { + return SkillApplyInformation.HasMoreDamageThan(other.SkillApplyInformation); + } + + protected void ResetPlayedCost() + { + _playedCost = -1; + } + + protected void ResetLastCost() + { + _lastCost = -1; + } + + public void GiveAttackCount(Skill_attack_count skill, int count) + { + if (skill.IsAddAttackCount()) + { + attackCountinfo.Add(new AddAttackCountInfo(skill, count)); + } + else if (skill.IsSetAttackCount()) + { + attackCountinfo.Add(new SetAttackCountInfo(skill, count)); + } + } + + public void DepriveAttackCount(Skill_attack_count skill) + { + attackCountinfo.RemoveAll((AttackCountInfo s) => s.Skill == skill); + } + + public void ClearAttackCount() + { + attackCountinfo.Clear(); + } + + public void CallOnAttachSkill(BattleCardBase card, SkillBase skill) + { + if (card.IsClass) + { + skill.SetAndAddPublishedActiveSkillCount(); + } + this.OnAttachSkill.Call(card, skill); + } + + public Action ForceAttackOff() + { + if (BattleManagerBase.GetIns().IsRecovery) + { + return delegate + { + }; + } + Func forceAttackOffFunc = () => false; + OnCheckCanAttack += forceAttackOffFunc; + return delegate + { + OnCheckCanAttack -= forceAttackOffFunc; + }; + } + + public bool HasSkillWhenPlay(bool isOnlyNoSelect) + { + if (isOnlyNoSelect) + { + bool hasChoiceTransform = NormalSkills.Any((SkillBase s) => s.OnWhenChoicePlayStart != 0 && s is Skill_transform); + if (NormalSkills.Any((SkillBase s) => s.IsWhenPlaySkill)) + { + return !NormalSkills.Any((SkillBase s) => (s.IsWhenPlaySkill && (s.IsUserSelectType || s.IsBurialRite)) || (!hasChoiceTransform && s.OnWhenChoicePlayStart != 0)); + } + return false; + } + return NormalSkills.Any((SkillBase s) => s.IsWhenPlaySkill); + } + + public int GetCurrentAtkBuff() + { + if (IsEvolution) + { + return SkillApplyInformation.GetAtk(ignoreLowerLimit: true) - BaseParameter.EvoAtk; + } + return SkillApplyInformation.GetAtk(ignoreLowerLimit: true) - BaseParameter.Atk; + } + + public int GetCurrentLifeBuff() + { + if (IsEvolution) + { + return SkillApplyInformation.GetMaxLife() - BaseParameter.EvoLife; + } + return SkillApplyInformation.GetMaxLife() - BaseParameter.Life; + } + + public bool IsMutationPlayPp(int pp) + { + int num = CalcFixedUseCost(pp, skipCondition: true); + if (-1 != num && num <= pp) + { + return pp < Cost; + } + return false; + } + + public Skill_pp_fixeduse GetAccelerateOrCrystallizeSkill(int currentPp) + { + Skill_pp_fixeduse result = null; + for (int i = 0; i < Skills.Count(); i++) + { + if (Skills.ElementAt(i) is Skill_pp_fixeduse skill_pp_fixeduse && skill_pp_fixeduse._fixedUsePP <= currentPp && skill_pp_fixeduse._fixedUsePP < Cost && currentPp < Cost) + { + result = skill_pp_fixeduse; + } + } + return result; + } + + public int CalcFixedUseCost(int currentPp, bool skipCondition = false) + { + int num = -1; + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + for (int i = 0; i < Skills.Count(); i++) + { + if (Skills.ElementAt(i) is Skill_pp_fixeduse skill_pp_fixeduse && currentPp >= skill_pp_fixeduse._fixedUsePP) + { + bool flag = skill_pp_fixeduse.CheckCondition(playerInfoPair, new SkillConditionCheckerOption(), isPrePlay: true); + bool num2 = flag && num < skill_pp_fixeduse._fixedUsePP; + bool flag2 = (skipCondition || flag) && skill_pp_fixeduse._fixedUsePP < Cost && currentPp < Cost; + if (num2 || flag2) + { + num = skill_pp_fixeduse._fixedUsePP; + } + } + } + return num; + } + + public int GetPaidFixedCost() + { + if (ExecutedFixedUseCostIndex != -1 && Skills.ElementAt(ExecutedFixedUseCostIndex) is Skill_pp_fixeduse skill_pp_fixeduse) + { + return skill_pp_fixeduse._fixedUsePP; + } + return -1; + } + + public bool CheckConditionFixedUseCost(bool isPrePlay) + { + for (int i = 0; i < Skills.Count(); i++) + { + if (Skills.ElementAt(i) is Skill_pp_fixeduse skill_pp_fixeduse && skill_pp_fixeduse.CheckCondition(new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer), new SkillConditionCheckerOption(), isPrePlay)) + { + return true; + } + } + return false; + } + + protected bool IsFixedUseEnable(int labelCost) + { + if (Skills.Any((SkillBase s) => s is Skill_pp_fixeduse && (s as Skill_pp_fixeduse)._fixedUsePP == labelCost && ((s as Skill_pp_fixeduse)._fixedUsePP < Cost || !(s as Skill_pp_fixeduse).IsAccelerateOrCrystallize))) + { + return true; + } + return false; + } + + public bool HasSkillDestroyTribe(CardBasePrm.TribeType tribe) + { + if (_normalSkillCollection != null && HasSkillDestroyTribeInner(tribe, _normalSkillCollection)) + { + return true; + } + if (_evolveSkillCollection != null && HasSkillDestroyTribeInner(tribe, _evolveSkillCollection)) + { + return true; + } + return false; + } + + private bool HasSkillDestroyTribeInner(CardBasePrm.TribeType tribe, SkillCollectionBase skills) + { + if (skills == null) + { + return false; + } + for (int i = 0; i < skills.Count(); i++) + { + for (int j = 0; j < skills.ElementAt(i).PreprocessList.Count; j++) + { + if (skills.ElementAt(i).PreprocessList[j] is SkillPreprocessDestroyTribe skillPreprocessDestroyTribe && tribe == skillPreprocessDestroyTribe.GetDestroyTribe()) + { + return true; + } + } + } + return false; + } + + private CardParameter CreateClassParameter(bool isPlayer) + { + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + return new CardParameter((CardBasePrm.ClanType)(isPlayer ? dataMgr.GetPlayerClassId() : dataMgr.GetEnemyClassId())); + } + + public void ChangeClassClanParameter() + { + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + BaseParameter.ChangeClanParameter((CardBasePrm.ClanType)(IsPlayer ? dataMgr.GetPlayerClassId() : dataMgr.GetEnemyClassId())); + } + + public void CreateParameter() + { + if (CardMaster.IsClass(_buildInfo.CardId)) + { + BaseParameter = CreateClassParameter(IsPlayer); + } + else + { + BaseParameter = CardMaster.GetInstanceForBattle().GetCardParameterFromId(_buildInfo.CardId); + } + } + + public BattleCardBase(BuildInfo buildInfo) + { + _buildInfo = buildInfo; + IsTokenLoad = false; + SelfBattlePlayer = buildInfo.SelfBattlePlayer; + OpponentBattlePlayer = buildInfo.OpponentBattlePlayer; + SelfBattlePlayerReadOnlyInfo = buildInfo.SelfBattlePlayerReadOnlyInfo; + IsPlayer = buildInfo.IsPlayer; + CreateParameter(); + CostModifierList = new List(); + attackCountinfo = new List(); + SpellChargeCount = 0; + ExecutedFixedUseCostIndex = -1; + DamagedCounter = new ItWasDamagedCounter(); + GetOffCards = new List(); + IsSummonDrunkenness = true; + IsOnMove = false; + IsOnDraw = true; + ResetPlayedCost(); + ResetLastCost(); + PlayedTurn = -1; + DeathTypeInfo = new DeathTypeInformation(); + BuffInfoList = new List(); + SkillActivationList = new List(); + _skillActivatedCount = 1; + ThisTurnSkillActivatedCount = 0; + InitSkillCollection(); + Skills = _normalSkillCollection; + IsSkillLost = false; + IsReanimate = false; + HasAnySkill = (NormalSkills != null && NormalSkills.Any((SkillBase skill) => !(skill is Skill_none) && !skill.IsAttachedSkill)) || (EvolutionSkills != null && EvolutionSkills.Any((SkillBase skill) => !(skill is Skill_none) && !skill.IsAttachedSkill)); + HasSkillNecromance = (NormalSkills != null && NormalSkills.Any((SkillBase skill) => skill.PreprocessList.Any((SkillPreprocessBase p) => p is SkillPreprocessNecromance) && !skill.IsAttachedSkill)) || (EvolutionSkills != null && EvolutionSkills.Any((SkillBase skill) => skill.PreprocessList.Any((SkillPreprocessBase p) => p is SkillPreprocessNecromance) && !skill.IsAttachedSkill)); + OnPlay += delegate + { + BattleCardView.HideCanPlayEffect(); + return NullVfx.GetInstance(); + }; + } + + public virtual void Setup(bool createNullView = false, bool isRecreate = false) + { + BattleCardView = CreateView(CreateViewBuildInfo(_buildInfo), createNullView); + VfxCreator = CreateVfxCreator(IsPlayer, BattleCardView, createNullView); + if (!createNullView) + { + foreach (SkillBase normalSkill in NormalSkills) + { + normalSkill.SetInductionVoiceIndex(); + } + foreach (SkillBase evolutionSkill in EvolutionSkills) + { + evolutionSkill.SetInductionVoiceIndex(); + } + } + if (SkillApplyInformation == null) + { + SkillApplyInformation = CreateSkillApplyInformation(this, VfxCreator); + SkillApplyInformation.InitializeInformation(); + } + if (!isRecreate) + { + DrawTurn = -1; + } + DestroyedTurn = -1; + DestroyedBySkillList = new List(); + BanishedInfo = new BanishInfo(-1, isSelfTurn: false, BanishInfo.BanishPlace.None); + } + + public void RecreateView(GameObject cardGameObject) + { + _buildInfo.GameObject = cardGameObject; + Setup(createNullView: false, isRecreate: true); + SkillApplyInformation.ReSetupVfxCreator(VfxCreator); + } + + protected virtual void InitSkillCollection() + { + _normalSkillCollection = CreateSkillCondition(_buildInfo.NormalSkillBuildInfos, _buildInfo.SelfBattlePlayer, _buildInfo.OpponentBattlePlayer, _buildInfo.ResourceMgr); + _evolveSkillCollection = CreateSkillCondition(_buildInfo.EvolveSkillBuildInfos, _buildInfo.SelfBattlePlayer, _buildInfo.OpponentBattlePlayer, _buildInfo.ResourceMgr); + } + + public void SetIndex(int setIndex) + { + _buildInfo.BattleCardIndex = setIndex; + } + + public virtual void UpdateSkillCollection() + { + } + + protected virtual BattleCardView.BuildInfo CreateViewBuildInfo(BuildInfo baseBuildInfo) + { + Func getIsTouchable = null; + if (baseBuildInfo.SelfBattlePlayer != null) + { + getIsTouchable = baseBuildInfo.SelfBattlePlayer.BattleView.IsTouchable; + } + return new BattleCardView.BuildInfo(this, new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer), baseBuildInfo.GameObject, SelfBattlePlayer.BattleCamera, SelfBattlePlayer.BackGround, baseBuildInfo.ResourceMgr, getIsTouchable, () => GetIsMovableOnView(), () => IsOnMove, (int cost) => IsFixedUseEnable(cost), () => !IsActionCard, () => Attackable && IsInplay && IsSelfTurn, () => IsCantAttackClass, GetHandCardFrameEffectType); + } + + protected virtual IBattleCardView CreateView(BattleCardView.BuildInfo buildInfo, bool IsNullView) + { + if (IsNullView) + { + return new NullBattleCardView(buildInfo); + } + return new BattleCardView(buildInfo); + } + + protected SkillCollectionBase CreateSkillCondition(IEnumerable buildInfos, BattlePlayerBase selfBattlPlayer, BattlePlayerBase opponentBattlePlayer, IBattleResourceMgr resourceMgr) + { + if (buildInfos == null) + { + return null; + } + SkillCollectionBase skillCollectionBase = CreateSkillCollection(); + List list = null; + SkillCreator skillCreator = CreateSkillCreator(selfBattlPlayer, opponentBattlePlayer, resourceMgr); + foreach (SkillCreator.SkillBuildInfo buildInfo in buildInfos) + { + SkillBase skillBase = skillCreator.Create(buildInfo, list); + skillCollectionBase.Add(skillBase); + if (skillBase.PreprocessList.Any()) + { + if (skillBase.PreprocessList.Any((SkillPreprocessBase p) => p is SkillPreprocessReferencePrevious)) + { + list.AddRange(skillBase.PreprocessList); + } + else + { + list = skillBase.PreprocessList.ToList(); + } + } + } + skillCollectionBase.Complete(); + return skillCollectionBase; + } + + public virtual SkillCreator CreateSkillCreator(BattlePlayerBase selfBattlPlayer, BattlePlayerBase opponentBattlePlayer, IBattleResourceMgr resourceMgr) + { + return new SkillCreator(this, selfBattlPlayer, opponentBattlePlayer, resourceMgr); + } + + protected virtual SkillCollectionBase CreateSkillCollection() + { + return new SkillCollectionBase(this); + } + + public virtual VfxBase TurnStart(SkillProcessor skillProcessor) + { + if (IsInplay) + { + this.OnTurnStart.Call(); + AttackableCount = MaxAttackableCount; + IsFirstTurn = false; + IsSummonDrunkenness = false; + } + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + skillProcessor.Register(Skills.CreateTurnStartInfo(skillProcessor, playerInfoPair)); + return Skills.RegisterAndProcessWhenTurnStartImmediateInfo(new BattlePlayerPair(SelfBattlePlayer, OpponentBattlePlayer)); + } + + public virtual VfxBase OpponentTurnStart(SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + skillProcessor.Register(Skills.CreateTurnStartInfo(skillProcessor, playerInfoPair)); + return Skills.RegisterAndProcessWhenTurnStartImmediateInfo(new BattlePlayerPair(SelfBattlePlayer, OpponentBattlePlayer)); + } + + public virtual void Necromance(BattleCardBase necromanceCard, SkillProcessor skillProcessor, int necromanceCount) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + skillProcessor.Register(Skills.CreateNecromanceInfo(necromanceCard, skillProcessor, playerInfoPair, necromanceCount)); + } + + public virtual VfxBase TurnEndPostProcess() + { + return NullVfx.GetInstance(); + } + + public virtual void TurnEndSkillProcess(SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + skillProcessor.Register(Skills.CreateTurnEndInfo(skillProcessor, playerInfoPair)); + ThisTurnSkillActivatedCount = 0; + } + + public void CheckPreviousTurnAttacked() + { + if (SelfBattlePlayer.IsSelfTurn && IsInplay) + { + IsPreviousTurnAttacked = AttackableCount < MaxAttackableCount; + } + } + + public virtual VfxBase Draw(Vector3 Pos) + { + return VfxCreator.CreateDraw(Pos, IsLegend); + } + + public virtual VfxBase Moving(Vector3 Pos) + { + return VfxCreator.CreateMoving(Pos); + } + + protected virtual VfxBase StartPlayCard() + { + foreach (BattleCardBase handCard in SelfBattlePlayer.HandCardList) + { + if (handCard != this) + { + handCard.BattleCardView.areArrowsForcedOff = false; + handCard.BattleCardView.UpdateMovability(); + } + } + if (!GameMgr.GetIns().IsNewReplayBattle) + { + SelfBattlePlayer.CantPlayChoiceBrave = false; + SelfBattlePlayer.BattleView.UpdateChoiceBraveButtonPulsateEffectAndSprite(); + } + BattleCardView.HideHandCardInfo(); + return NullVfx.GetInstance(); + } + + public VfxWith PlayCard(SkillProcessor skillProcessor, SkillConditionCheckerOption option, bool isInplayGeneration = false, BattleCardBase originalCard = null) + { + SequentialVfxPlayer sequentialVfx = SequentialVfxPlayer.Create(); + IsSummonDrunkenness = true; + AttackableCount = MaxAttackableCount; + VfxBase instance = NullVfx.GetInstance(); + if (!IsChoiceBraveSkillCard) + { + int useCost = Cost; + if (CheckConditionFixedUseCost(isPrePlay: true)) + { + useCost = CalcFixedUseCost(SelfBattlePlayer.Pp); + List list = Skills.Where((SkillBase s) => s is Skill_pp_fixeduse && !(s as Skill_pp_fixeduse).IsAccelerateOrCrystallize).ToList(); + SkillBase item = list.SingleOrDefault((SkillBase s) => (s as Skill_pp_fixeduse)._fixedUsePP == useCost); + ExecutedFixedUseCostIndex = list.IndexOf(item); + } + instance = SelfBattlePlayer.UsePp(useCost); + _playedCost = useCost; + _lastCost = useCost; + SelfBattlePlayer.SummonedCards.Add(this); + } + else + { + instance = SelfBattlePlayer.UseBp(Cost, BaseParameter.IsVariableCost, IsPlayer); + _playedCost = Cost; + } + VfxBase vfxBase = StartPlayCard(); + sequentialVfx.Register(ParallelVfxPlayer.Create(instance, vfxBase)); + sequentialVfx.Register(SetUpInplay()); + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + VfxWith vfxWith = (isInplayGeneration ? new VfxWith(NullVfx.GetInstance(), null) : Skills.CreateWhenPlayInfo(this, skillProcessor, playerInfoPair, option)); + VfxBase allFuncVfxResults = this.OnPlay.GetAllFuncVfxResults(); + sequentialVfx.Register(allFuncVfxResults); + sequentialVfx.Register(vfxWith.Vfx); + SelfBattlePlayer.CallOnPlayCard((originalCard != null) ? originalCard : this, this, IsChoiceBraveSkillCard); + SelfBattlePlayer.AddRallyCount(SelfBattlePlayer.SummonedCards.Where((BattleCardBase c) => c.IsInplay && c.IsUnit).Count()); + sequentialVfx.Register(InstantVfx.Create(delegate + { + if (SelfBattlePlayer.HandCardList.Count <= 0) + { + sequentialVfx.Register(SelfBattlePlayer.BattleView.HandUnfocus()); + } + })); + sequentialVfx.Register(InstantVfx.Create(delegate + { + MotionUtils.SetLayerAll(BattleCardView.CardTemplate.CardNormalTemp.gameObject, 10); + })); + return new VfxWith(sequentialVfx, vfxWith.Value); + } + + public virtual VfxWith PlayChoiceCard(SkillProcessor skillProcessor, SkillConditionCheckerOption option) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + return Skills.CreateWhenChoicePlayInfo(skillProcessor, playerInfoPair, option); + } + + public VfxBase FinishWhenPlaySkill() + { + VfxBase[] allFuncCallResults = this.OnFinishWhenPlaySkill.GetAllFuncCallResults(); + if (allFuncCallResults.IsNotNullOrEmpty()) + { + return SequentialVfxPlayer.Create(allFuncCallResults); + } + return null; + } + + public virtual VfxBase DestroyInPlay(SkillProcessor skillProcessor, bool useDestroy = true, SkillBase destroyedSkill = null) + { + if (IsDead) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (IsChoiceEvolutionCard) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + UpdateBuildInfoAndSkillCollection(BaseParameter.BaseCardId, BaseParameter.IsFoil, isNotUpdateAtkLife: true); + })); + } + sequentialVfxPlayer.Register(RemoveFromInPlay()); + VfxBase allFuncVfxResults = this.OnDestroy.GetAllFuncVfxResults(this, skillProcessor); + if (!SelfBattlePlayer.ClassAndInPlayCardList.Contains(this)) + { + DeathTypeInfo.WhenDestroy = Skills._skillTimingInfo.IsWhenDestroy; + VfxBase vfx = VfxCreator.CreateDestroy(DeathTypeInfo, SelfBattlePlayer); + sequentialVfxPlayer.Register(vfx); + } + sequentialVfxPlayer.Register(allFuncVfxResults); + BattlePlayerBase battlePlayerBase = (SelfBattlePlayer.IsSelfTurn ? SelfBattlePlayer : OpponentBattlePlayer); + DestroyedTurn = battlePlayerBase.Turn; + IsDestroySelfTurn = battlePlayerBase.IsPlayer; + return sequentialVfxPlayer; + } + return NullVfx.GetInstance(); + } + + public virtual VfxBase DestroyInHand(SkillProcessor skillProcessor) + { + BattlePlayerBase battlePlayerBase = (SelfBattlePlayer.IsSelfTurn ? SelfBattlePlayer : OpponentBattlePlayer); + DestroyedTurn = battlePlayerBase.Turn; + IsDestroySelfTurn = battlePlayerBase.IsPlayer; + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(StopSpellCharge()); + VfxBase allFuncVfxResults = this.OnDestroy.GetAllFuncVfxResults(this, skillProcessor); + if (!SelfBattlePlayer.HandCardList.Contains(this)) + { + VfxBase vfx = VfxCreator.CreateDestroyHand(DeathTypeInfo, SelfBattlePlayer); + BattleCardView.HideCanPlayEffect(); + sequentialVfxPlayer.Register(vfx); + } + sequentialVfxPlayer.Register(allFuncVfxResults); + return sequentialVfxPlayer; + } + + public virtual VfxBase Banish(SkillProcessor skillProcessor, bool isReturn = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (IsChoiceEvolutionCard) + { + if (isReturn) + { + UpdateBuildInfoAndSkillCollection(BaseParameter.BaseCardId, BaseParameter.IsFoil); + if (!SelfBattlePlayer.BattleMgr.IsRecovery || IsPlayer) + { + BattleCardView.CardTemplate.NormalNameLabelTemp.text = BaseParameter.CardName; + Global.SetRepositionNameLabel(BattleCardView.CardTemplate.NormalNameLabelTemp, BaseParameter.CardName, is2D: false); + } + } + else + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + UpdateBuildInfoAndSkillCollection(BaseParameter.BaseCardId, BaseParameter.IsFoil, isNotUpdateAtkLife: true); + })); + } + } + sequentialVfxPlayer.Register(this.OnBanish.GetAllFuncVfxResults(this, skillProcessor)); + if (!isReturn) + { + sequentialVfxPlayer.Register(VfxCreator.CreateBanish(DeathTypeInfo, SelfBattlePlayer)); + } + return sequentialVfxPlayer; + } + + public virtual VfxWithLoading BanishInHand(SkillProcessor skillProcessor) + { + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(this.OnBanish.GetAllFuncVfxResults(this, skillProcessor)); + if (!SelfBattlePlayer.HandCardList.Contains(this)) + { + vfxWithLoadingSequential.RegisterVfxWithLoading(VfxCreator.CreateBanishHand(DeathTypeInfo, SelfBattlePlayer)); + } + return vfxWithLoadingSequential; + } + + public virtual VfxBase BanishInDeck(SkillProcessor skillProcessor) + { + return this.OnBanish.GetAllFuncVfxResults(this, skillProcessor); + } + + public virtual VfxBase GetOn(Transform vehicleCardTrans, IBattleCardView vehicleCardView, SkillProcessor skillProcessor, bool isReturn = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(this.OnGetOn.GetAllFuncVfxResults(this, skillProcessor)); + sequentialVfxPlayer.Register(VfxCreator.CreateGeton(vehicleCardTrans, vehicleCardView, DeathTypeInfo, SelfBattlePlayer)); + return sequentialVfxPlayer; + } + + public virtual VfxBase UniteInPlay(SkillProcessor skillProcessor, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(LoseSkill()); + sequentialVfxPlayer.Register(SkillApplyInformation.AllSkillEffectStop()); + sequentialVfxPlayer.Register(RemoveFromInPlay()); + sequentialVfxPlayer.Register(SelfBattlePlayer.UniteCard(this, skillProcessor, skill)); + sequentialVfxPlayer.Register(VfxCreator.CreateBanish(DeathTypeInfo, SelfBattlePlayer)); + return sequentialVfxPlayer; + } + + public virtual VfxWithLoading FusionMaterialized(SkillProcessor skillProcessor, BattleCardBase fusionCard, bool isFusionMetamorphose) + { + fusionCard.SkillApplyInformation.AddFusionIngredientCard(this); + FusionedTurn = SelfBattlePlayer.Turn; + DeathTypeInfo.UseFusionIngredient = true; + DeathTypeInfo.UseFusionMetamorphoseIngredient = isFusionMetamorphose; + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(this.OnBanish.GetAllFuncVfxResults(this, skillProcessor)); + vfxWithLoadingSequential.RegisterVfxWithLoading(VfxCreator.CreateFusionHand(SelfBattlePlayer, fusionCard.BattleCardView, isFusionMetamorphose)); + return vfxWithLoadingSequential; + } + + public virtual VfxBase Metamorphose(SkillProcessor SkillProcessor) + { + return this.OnMetamorphose.GetAllFuncVfxResults(this, SkillProcessor); + } + + public VfxWithLoadingSequential SkillPlayCard(bool isPlayer, SkillBaseSummon.SUMMON_TYPE summonType, SkillProcessor skillProcessor, SkillBase skill, bool isGetoff = false, bool isReanimate = false) + { + _lastCost = Cost; + VfxBase vfxBase = SelfBattlePlayer.PickCard(this, skill, summonType, isGetoff, isReanimate); + VfxBase vfxBase2 = SetUpInplay(); + IsReanimate = isReanimate; + if (summonType == SkillBaseSummon.SUMMON_TYPE.HAND) + { + skillProcessor.Register(Skills.CreateWhenHandToNotPlayInfo(skillProcessor, new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer), new SkillConditionCheckerOption())); + } + return VfxWithLoadingSequential.Create(vfxBase, vfxBase2); + } + + public VfxBase StartHandEffect() + { + if (SelfBattlePlayer.IsPlayer || GameMgr.GetIns().IsAdminWatch) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (SpellChargeCount > 0 && HasSpellCharge && IsInHand) + { + sequentialVfxPlayer.Register(new HandEffectLoopStartVfx(BattleCardView, () => IsActionCard, HandEffectLoopStartVfx.HandEffectType.SpellCharge)); + } + return sequentialVfxPlayer; + } + return NullVfx.GetInstance(); + } + + public virtual VfxBase RecoveryAttackCount() + { + AttackableCount = MaxAttackableCount; + return InstantVfx.Create(delegate + { + BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect(); + }); + } + + public virtual VfxBase StopSpellCharge() + { + return new HandEffectLoopEndVfx(BattleCardView); + } + + public virtual VfxBase CreateMoveToHandVfx() + { + if (IsPlayer) + { + return new PlayerDrawCardToHandVfx(this); + } + return NullVfx.GetInstance(); + } + + public VfxBase CreateShowLogVfx(float time, SkillBase skill, bool isEvolve, string SkillDescription) + { + if (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SHOW_SIDE_LOG)) + { + BattlePlayerBase.SideLogInfo sideLogInfo = new BattlePlayerBase.SideLogInfo(skill); + return new ShowSideLogVfx(this, skill, SelfBattlePlayer.BattleView.GetSideLogControl(isSkillTargetSelect: false), (SkillDescription == string.Empty) ? GetCardSkillDescription(sideLogInfo, isEvolve) : SkillDescription, time, isEvol: false, sideLogInfo); + } + return NullVfx.GetInstance(); + } + + public virtual AttackOpponentResult AttackOpponent(BattleCardBase target, DamageParam damageParam, SkillProcessor skillProcessor, bool IsChallenge) + { + return new AttackOpponentResult(NullVfx.GetInstance(), NullVfx.GetInstance(), null); + } + + public void SetOnMove(bool move) + { + IsOnMove = move; + } + + public void SetOnDraw(bool draw) + { + IsOnDraw = draw; + } + + public IEnumerable GetSelectTypeSkill(bool isEvolve = false, bool isFusion = false, bool isRegister = false, bool isEvolutionSimpleProcessor = false, bool isChoiceCheck = false) + { + SkillCollectionBase skillCollectionBase = (isEvolve ? EvolutionSkills : Skills); + NetworkBattleManagerBase networkBattleManagerBase = SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase; + GameMgr ins = GameMgr.GetIns(); + if (!ins.IsAdminWatch && !ins.IsAINetwork && networkBattleManagerBase != null) + { + NetworkBattleReceiver.ReceiveData receiveData = networkBattleManagerBase.networkBattleData.GetReceiveData(); + if (Index == receiveData.playCardIndex && !isEvolutionSimpleProcessor && !isChoiceCheck) + { + List list = new List(); + for (int i = 0; i < receiveData.OpponentTargetDataList.Count; i++) + { + list.AddRange(receiveData.OpponentTargetDataList[i].SelectSkillIndexList); + } + list = list.Distinct().ToList(); + if (list.Count > 0) + { + List list2 = new List(); + for (int j = 0; j < list.Count; j++) + { + if (list[j] < skillCollectionBase.Count()) + { + list2.Add(skillCollectionBase.ElementAt(list[j])); + continue; + } + LocalLog.AccumulateTraceLog("SelectSkillIndex " + list[j] + " out of range. CardId:" + CardId + " &&" + StackTraceUtility.ExtractStackTrace()); + } + return list2; + } + } + } + BattlePlayerReadOnlyInfoPair readOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + BattleCardBase battleCardBase = SelfBattlePlayer.Class; + bool isActivateFanfare = (!IsUnit || !battleCardBase.SkillApplyInformation.IsCantActivateFanfareUnit) && (!IsField || !battleCardBase.SkillApplyInformation.IsCantActivateFanfareField); + IEnumerable selectTypeSkill = skillCollectionBase.GetSelectTypeSkill(isEvolve, isFusion, isActivateFanfare, readOnlyInfoPair); + if (isRegister && SelfBattlePlayer.BattleMgr is NetworkBattleManagerBase networkBattleManagerBase2) + { + for (int k = 0; k < selectTypeSkill.Count(); k++) + { + networkBattleManagerBase2.AddRegisterSelectTypeSkillIndexList(skillCollectionBase.IndexOf(selectTypeSkill.ElementAt(k))); + } + } + return selectTypeSkill; + } + + public virtual VfxBase StartAttack(BattleCardBase underAttackCard, BattlePlayerPair battlePlayerPair) + { + return NullVfx.GetInstance(); + } + + public virtual DamageResult ApplyDamage(SkillBase skill, DamageParam damage, bool doesAttackerPossessKiller, bool isReflectedDamage, SkillProcessor skillProcessor, BattleCardBase reflectCard) + { + DamagedCounter.AddDamageCount(SelfBattlePlayer.IsSelfTurn); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (this.OnDamageAfter != null) + { + sequentialVfxPlayer.Register(this.OnDamageAfter.GetAllFuncVfxResults(skillProcessor)); + } + if (reflectCard != null && reflectCard.OnReflectionAfter != null) + { + sequentialVfxPlayer.Register(reflectCard.OnReflectionAfter.GetAllFuncVfxResults(skillProcessor)); + } + BattleCardBase battleCardBase = damage.OwnerCard.SelfBattlePlayer.Class; + if (battleCardBase != damage.OwnerCard && battleCardBase.SkillApplyInformation.AddDamageList.Count() > 0 && battleCardBase.OnGiveDamage != null) + { + sequentialVfxPlayer.Register(battleCardBase.OnGiveDamage.GetAllFuncVfxResults(skillProcessor)); + } + if (damage.OwnerCard.OnGiveDamage != null) + { + sequentialVfxPlayer.Register(damage.OwnerCard.OnGiveDamage.GetAllFuncVfxResults(skillProcessor)); + } + return new DamageResult(sequentialVfxPlayer, 0, 0); + } + + public virtual HealResult ApplyHealing(HealParam healParam, SkillProcessor skillProcessor) + { + return new HealResult(-1, NullVfx.GetInstance()); + } + + protected VfxBase CreateVfxWithCardPlayabilityRefresh(VfxBase originalVfx) + { + return SequentialVfxPlayer.Create(originalVfx, InstantVfx.Create(delegate + { + SelfBattlePlayer.UpdateHandCardsPlayability(); + })); + } + + public virtual VfxBase Evolution(bool isSkill, SkillProcessor skillProcessor, SkillConditionCheckerOption option, Func getEvolveVfxFunc = null) + { + return NullVfx.GetInstance(); + } + + public void CallOnFusionEvent(List ingredientCards) + { + this.OnFusionEvent.Call(ingredientCards); + } + + public VfxBase Fusion(SkillProcessor skillProcessor, List ingredientCards, bool isFusionMetamorphose) + { + if (!isFusionMetamorphose) + { + SetActiveSkillCount(); + } + skillProcessor.Register(Skills.CreateWhenFusionInfo(ingredientCards, skillProcessor, new BattlePlayerPair(SelfBattlePlayer, OpponentBattlePlayer))); + for (int i = 0; i < ingredientCards.Count; i++) + { + skillProcessor.Register(ingredientCards[i].Skills.CreateWhenFusionedInfo(skillProcessor, new BattlePlayerPair(SelfBattlePlayer, OpponentBattlePlayer))); + } + BattlePlayerBase battlePlayerBase = (IsSelfTurn ? SelfBattlePlayer : OpponentBattlePlayer); + BattlePlayerBase obj = (IsSelfTurn ? OpponentBattlePlayer : SelfBattlePlayer); + battlePlayerBase.StartSkillWhenFusionOther(ingredientCards, skillProcessor); + obj.StartSkillWhenFusionOther(ingredientCards, skillProcessor); + return NullVfx.GetInstance(); + } + + public virtual void InitializeParameterOnWhenReturn() + { + InitSkillApplyInformationOnWhenReturn(); + } + + protected virtual void InitSkillApplyInformationOnWhenReturn() + { + SkillApplyInformation.InitializeInformation(isReturnCard: true); + SkillApplyInformation.ClearParameterModifier(); + ClearCostModifier(); + TransformInfo = default(TransformInformation); + int normalIndividualId = NormalIndividualId; + int evolutionIndividualId = EvolutionIndividualId; + SkillApplyInformation.AttachedSkillsInfo.Clear(); + _normalSkillCollection.Clear(); + _evolveSkillCollection.Clear(); + SkillCreator.CardSkillsBuildInfo cardSkillsBuildInfo = SkillCreator.CreateBuildInfo(CardMaster.GetInstanceForBattle().GetCardParameterFromId(CardId)); + _buildInfo.NormalSkillBuildInfos = cardSkillsBuildInfo.normalSkillBuildInfos; + _buildInfo.EvolveSkillBuildInfos = cardSkillsBuildInfo.evolveSkillBuildInfos; + foreach (SkillBase item in CreateSkillCondition(cardSkillsBuildInfo.normalSkillBuildInfos, SelfBattlePlayer, OpponentBattlePlayer, _buildInfo.ResourceMgr)) + { + _normalSkillCollection.Add(item); + item.SetInductionVoiceIndex(); + item.SetIndividualId(normalIndividualId); + } + foreach (SkillBase item2 in CreateSkillCondition(cardSkillsBuildInfo.evolveSkillBuildInfos, SelfBattlePlayer, OpponentBattlePlayer, _buildInfo.ResourceMgr)) + { + _evolveSkillCollection.Add(item2); + item2.SetInductionVoiceIndex(); + item2.SetIndividualId(evolutionIndividualId); + } + Skills = _normalSkillCollection; + Skills.Complete(); + } + + public virtual VfxBase ReturnCard(SkillProcessor skillProcessor) + { + if (IsChoiceEvolutionCard) + { + ResetChoiceEvolutionCardBuildInfo(); + } + InitSkill(); + SpellChargeCount = 0; + SkillApplyInformation.ForceDepriveChantCount(); + SkillApplyInformation.ForceDepriveBuffLife(); + _skillActivatedCount = 1; + ThisTurnSkillActivatedCount = 0; + VfxBase[] allFuncCallResults = this.OnReturnCard.GetAllFuncCallResults(this, skillProcessor); + ClearCostModifier(); + BattleCardView.InitHandParameter(); + UpdateCostViewStrategy(isForceUpdate: true); + BattleCardView.UpdateCost(BattleCardView.GetUseCostList(BaseParameter.Cost), isGenerateInHand: false); + ClearBuffInfo(); + ResetPlayedCost(); + ResetLastCost(); + ExecutedFixedUseCostIndex = -1; + IsExecutedEarthRite = false; + IsSkillLost = false; + IsReanimate = false; + DamagedCounter.Clear(); + GetOffCards.Clear(); + ResetUpdateBuildInfo(); + return ParallelVfxPlayer.Create(allFuncCallResults); + } + + public void FlagCardAsDestroyedByKiller() + { + IsDestroyedByKiller = true; + DeathTypeInfo.DestroyedByKiller = true; + } + + public virtual void ResetFlagCardAsDestroyed() + { + IsDestroyedBySkill = false; + IsDestroyedByKiller = false; + } + + public virtual void FlagCardAsDestroyedBySkill() + { + IsDestroyedBySkill = true; + } + + public VfxBase CreateMaskCardInPlayVfx() + { + return VfxCreator.CreateMaskCardInPlay(); + } + + public void AddCostModifier(ICardCostModifier modifier, SkillBase skill, bool eventCall = true) + { + if (eventCall && skill != null) + { + this.OnAddCostState.Call(skill, modifier); + } + if (modifier.IsClearBeforeModifier) + { + CostModifierList.RemoveAll((ICardCostModifier c) => !c.IsResidentModifier); + } + CostModifierList.Add(modifier); + } + + public void RemoveCostModifier(SkillBase skill, ICardCostModifier modifier) + { + this.OnRemoveCostState.Call(skill, modifier); + CostModifierList.Remove(modifier); + } + + public void ClearCostModifier() + { + CostModifierList.Clear(); + } + + public int CalculateFinalDamageAmount(int damageAmount, bool isSkillDamage = false, bool isSpellDamage = false, ParallelVfxPlayer lifeLowerLimitEffectVfx = null) + { + bool flag = !isSkillDamage && !isSpellDamage; + if (SkillApplyInformation.IsShieldAll || (isSkillDamage && SkillApplyInformation.IsShieldSkill) || (isSpellDamage && SkillApplyInformation.IsShieldSpell) || (flag && SkillApplyInformation.IsShieldAttack)) + { + return 0; + } + damageAmount -= SkillApplyInformation.GetDamageCutAmount(isSkillDamage ? DamageCutInfo.DamageType.SKILL : DamageCutInfo.DamageType.ALL); + damageAmount = SkillApplyInformation.GetClippingDamage(damageAmount, lifeLowerLimitEffectVfx); + return Mathf.Max(damageAmount, 0); + } + + public int HealLife(int healAmount, int turn, bool isSelfTurn) + { + int life = Life; + SkillApplyInformation.HealLife(healAmount, turn, isSelfTurn); + return Life - life; + } + + public virtual string GetCardSkillDescription(BattlePlayerBase.SideLogInfo sideLogInfo, bool? isForceGetEvolveText = null) + { + return SkillDescription(sideLogInfo); + } + + public VfxBase LoseSkill(SkillBase loseSkill = null, SkillProcessor skillProcessor = null) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + IsSkillLost = true; + AttackableCount = ((AttackableCount >= MaxAttackableCount) ? 1 : 0); + NormalSkills.Clear(); + NormalSkills.InitTimingInfo(); + EvolutionSkills.Clear(); + EvolutionSkills.InitTimingInfo(); + SkillApplyInformation.AttachedSkillsInfo.Clear(); + SkillApplyInformation.AttachedSkillsInfo.AttachedSkills.InitTimingInfo(); + _buildInfo.NormalSkillBuildInfos.Clear(); + _buildInfo.EvolveSkillBuildInfos.Clear(); + parallelVfxPlayer.Register(SkillApplyInformation.AllSkillEffectStop()); + SkillApplyInformation.InitializeInformationWithoutLifeOffenseModifier(); + parallelVfxPlayer.Register(ParallelVfxPlayer.Create(this.OnLoseSkillOneTime.GetAllFuncCallResults(loseSkill, skillProcessor, this))); + this.OnLoseSkillOneTime = null; + RemoveBuffInfo((BuffInfo buff) => !(buff.SkillFrom is Skill_powerup) && !(buff.SkillFrom is Skill_power_down)); + parallelVfxPlayer.Register(BattleCardView.InitializeBattleCardIcon(this, Skills)); + if (IsFirstTurn) + { + IsSummonDrunkenness = true; + } + else + { + IsSummonDrunkenness = false; + } + bool isSelfTurn = SelfBattlePlayer.IsSelfTurn; + return SequentialVfxPlayer.Create(parallelVfxPlayer, SkillApplyInformation.AllSkillEffectRestart(), InstantVfx.Create(delegate + { + BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect(null, isSelfTurn); + })); + } + + public CopySkillInfo CopySkill(BattleCardBase targetCard, string copySkillType, bool isRemain) + { + SkillFilterCreator.ContentKeyword skillType = (SkillFilterCreator.ContentKeyword)Enum.Parse(typeof(SkillFilterCreator.ContentKeyword), copySkillType, ignoreCase: true); + List copySkills = GetCopySkill(targetCard.Skills, skillType); + bool isEvolutionSkill = targetCard.EvolutionSkills.Any((SkillBase skill) => skill == copySkills.FirstOrDefault()); + int num = 0; + List list = new List(); + foreach (SkillBase item in copySkills) + { + if (!isRemain) + { + targetCard.Skills.Remove(item); + if (!targetCard.IsEvolution) + { + List list2 = new List(); + foreach (SkillBase evolutionSkill in targetCard.EvolutionSkills) + { + if (item.IsSameSkill(evolutionSkill)) + { + list2.Add(evolutionSkill); + } + } + foreach (SkillBase item2 in list2) + { + targetCard.EvolutionSkills.Remove(item2); + } + } + } + if (item.GetAttachSkill == null) + { + num++; + } + } + List copiedSkillBuildInfoList = new List(); + if (num > 0) + { + string timing = skillType.ToStringCustom(); + copiedSkillBuildInfoList.AddRange(SettingRobSkillInfo(targetCard, timing, targetCard.IsEvolution, isRemain)); + } + foreach (SkillBase item3 in _normalSkillCollection) + { + if (item3.GetAttachSkill != null) + { + list.Add(item3); + } + } + _normalSkillCollection.Clear(); + _evolveSkillCollection.Clear(); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(SkillApplyInformation.AllSkillEffectStop()); + CombineVirtualCardSkill(this); + AttachedSkillInformation attachedSkillsInfo = targetCard.SkillApplyInformation.AttachedSkillsInfo; + List copySkill = GetCopySkill(attachedSkillsInfo.AttachedSkills, skillType); + List list3 = new List(); + foreach (SkillBase item4 in copySkill) + { + int index = attachedSkillsInfo.AttachedSkills.IndexOf(item4); + Skill_attach_skill creatorSkill = attachedSkillsInfo.CreatorSkillList[index] as Skill_attach_skill; + string text = attachedSkillsInfo.OwnerCardNameList[index]; + int num2 = attachedSkillsInfo.OwnerCardIdList[index]; + long duplicateBanNum = attachedSkillsInfo.DuplicateBanNum[index]; + if (isRemain) + { + SkillBase attachSkill = targetCard.SkillApplyInformation.CloneAttachSkill(SkillApplyInformation as SkillApplyInformation, creatorSkill); + SkillBase.BuffInfoContainer buffInfo = creatorSkill.GetBuffInfo(targetCard); + if (buffInfo != null) + { + buffInfo = buffInfo.Clone(); + buffInfo._targetCard = this; + buffInfo._attachSkill = attachSkill; + buffInfo._buffInfo = buffInfo._buffInfo.Clone(); + buffInfo._buffInfo.IsCopied = true; + buffInfo._buffInfo.IsCopiedEvolutionSkill = creatorSkill.SkillPrm.ownerCard.EvolutionSkills.Any((SkillBase s) => s == creatorSkill); + buffInfo._buffInfo.SetPreviousOwner(creatorSkill.SkillPrm.ownerCard); + AddBuffInfo(buffInfo._buffInfo); + creatorSkill.AddBuffInfo(buffInfo); + list3.Add(buffInfo._buffInfo); + } + else + { + BuffInfo buffInfo2 = creatorSkill.AddBuffInfoIfNeeded(this); + buffInfo2.SetPreviousOwner(creatorSkill.SkillPrm.ownerCard); + buffInfo2.IsCopied = true; + buffInfo2.IsCopiedEvolutionSkill = creatorSkill.SkillPrm.ownerCard.EvolutionSkills.Any((SkillBase s) => s == creatorSkill); + buffInfo = new SkillBase.BuffInfoContainer(this, buffInfo2, -1, "", null, 0L); + buffInfo._attachSkill = attachSkill; + creatorSkill.AddBuffInfo(buffInfo); + list3.Add(buffInfo._buffInfo); + } + } + else + { + int index2 = attachedSkillsInfo.CreatorSkillIndexList[index]; + item4.SkillPrm.ownerCard = this; + item4.SkillPrm.selfBattlePlayer = SelfBattlePlayer; + item4.SkillPrm.opponentBattlePlayer = OpponentBattlePlayer; + SkillApplyInformation.AttachSkill(item4.SkillPrm.buildInfo, item4.SkillPrm.resourceMgr, text, num2, duplicateBanNum, creatorSkill); + targetCard.SkillApplyInformation.AttachedSkillsInfo.Remove(item4, text, num2, duplicateBanNum, creatorSkill, index2); + SkillBase.BuffInfoContainer buffInfoContainer = creatorSkill.PopBuffInfo(targetCard); + if (buffInfoContainer == null) + { + CardParameter baseParameter = creatorSkill.SkillPrm.ownerCard.BaseParameter; + BuffInfo buffInfo3 = new BuffInfo(baseParameter.BaseCardId, baseParameter.NormalCardId, creatorSkill); + buffInfoContainer = new SkillBase.BuffInfoContainer(targetCard, buffInfo3, -1, "", null, 0L); + } + buffInfoContainer._buffInfo.IsCopied = true; + buffInfoContainer._buffInfo.IsCopiedEvolutionSkill = creatorSkill.SkillPrm.ownerCard.EvolutionSkills.Any((SkillBase s) => s == creatorSkill); + buffInfoContainer._buffInfo.SetPreviousOwner(creatorSkill.SkillPrm.ownerCard); + targetCard.RemoveBuffInfo(buffInfoContainer._buffInfo); + buffInfoContainer._targetCard = this; + AddBuffInfo(buffInfoContainer._buffInfo); + creatorSkill.AddBuffInfo(buffInfoContainer); + list3.Add(buffInfoContainer._buffInfo); + } + } + Skills.Complete(); + SetActiveSkillCount(); + targetCard.SkillApplyInformation.AttachedSkillsInfo.AttachedSkills.InitTimingInfo(); + SkillApplyInformation.AttachedSkillsInfo.AttachedSkills.InitTimingInfo(); + targetCard.NormalSkills.InitTimingInfo(); + NormalSkills.InitTimingInfo(); + targetCard.EvolutionSkills.InitTimingInfo(); + EvolutionSkills.InitTimingInfo(); + sequentialVfxPlayer.Register(targetCard.BattleCardView.InitializeBattleCardIcon(targetCard, targetCard.Skills)); + sequentialVfxPlayer.Register(BattleCardView.InitializeBattleCardIcon(this, Skills)); + sequentialVfxPlayer.Register(SkillApplyInformation.AllSkillEffectRestart()); + this.OnCopySkillComplete.Call(this); + SkillBaseCopy copySkill2 = Skills.Where((SkillBase s) => s is SkillBaseCopy && s.OptionValue.GetString(SkillFilterCreator.ContentKeyword.ability, "NONE") == skillType.ToString()).FirstOrDefault() as SkillBaseCopy; + List copiedSkillList = Skills.Where((SkillBase s) => copiedSkillBuildInfoList.Contains(s.SkillPrm.buildInfo)).ToList(); + return new CopySkillInfo(sequentialVfxPlayer, isEvolutionSkill, copySkill2, copiedSkillList, list3); + } + + private List SettingRobSkillInfo(BattleCardBase targetCard, string timing, bool isEvolution, bool isRemain) + { + List list = new List(); + bool flag = false; + List list2 = (isEvolution ? targetCard._buildInfo.EvolveSkillBuildInfos : targetCard._buildInfo.NormalSkillBuildInfos); + foreach (SkillCreator.SkillBuildInfo skillInfo in list2) + { + if (!(skillInfo._timing == timing)) + { + continue; + } + flag = true; + _buildInfo.NormalSkillBuildInfos.Add(skillInfo); + if (_buildInfo.EvolveSkillBuildInfos.IsNotNullOrEmpty()) + { + _buildInfo.EvolveSkillBuildInfos.Add(skillInfo); + } + if (skillInfo._previousSkillOwner == null) + { + skillInfo._previousSkillOwner = targetCard; + } + OnRemoveFromInPlayAfterOneTime += delegate + { + if (!IsDead) + { + _buildInfo.NormalSkillBuildInfos.Remove(skillInfo); + if (_buildInfo.EvolveSkillBuildInfos.Contains(skillInfo)) + { + _buildInfo.EvolveSkillBuildInfos.Remove(skillInfo); + } + } + return NullVfx.GetInstance(); + }; + list.Add(skillInfo); + } + if (flag || !isEvolution) + { + if (!isRemain) + { + list2.RemoveAll((SkillCreator.SkillBuildInfo b) => b._timing == timing); + } + } + else + { + list.AddRange(SettingRobSkillInfo(targetCard, timing, isEvolution: false, isRemain)); + } + return list; + } + + private List GetCopySkill(SkillCollectionBase skills, SkillFilterCreator.ContentKeyword skillType) + { + List list = new List(); + foreach (SkillBase skill in skills) + { + switch (skillType) + { + case SkillFilterCreator.ContentKeyword.when_destroy: + if (skill.IsWhenDestroySkill) + { + list.Add(skill); + } + break; + case SkillFilterCreator.ContentKeyword.when_attack: + if (skill.IsBeforAttackSkill) + { + list.Add(skill); + } + break; + case SkillFilterCreator.ContentKeyword.when_fight: + if (skill.IsWhenFightSkill) + { + list.Add(skill); + } + break; + } + } + return list; + } + + public virtual VfxBase RemoveFromInPlay() + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + if (!IsClass) + { + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + BattleCardView.BattleCardIconAnimations.ClearAllSkillIcons(); + })); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + BattleCardView.HideAttackFinished(); + })); + } + return parallelVfxPlayer; + } + + public virtual VfxBase RemoveFromInPlayAfter(SkillProcessor skillProcessor, bool isReturn = false) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(this.OnRemoveFromInPlayAfterOneTime.GetAllFuncCallResults(isReturn, skillProcessor)); + this.OnRemoveFromInPlayAfterOneTime = null; + ParallelVfxPlayer parallelVfxPlayer2 = ParallelVfxPlayer.Create(this.OnLoseSkillOneTime.GetAllFuncCallResults(null, skillProcessor, this)); + this.OnLoseSkillOneTime = null; + return ParallelVfxPlayer.Create(parallelVfxPlayer, parallelVfxPlayer2); + } + + protected virtual ICardVfxCreator CreateVfxCreator(bool isPlayer, IBattleCardView battleCardView, bool isNullView) + { + if (isNullView) + { + return NullCardVfxCreator.GetInstance(); + } + return new CardVfxCreatorBase(isPlayer, this, battleCardView, _buildInfo.ResourceMgr); + } + + protected virtual ISkillApplyInformation CreateSkillApplyInformation(BattleCardBase card, ICardVfxCreator vfxCreator) + { + return new SkillApplyInformation(card, vfxCreator); + } + + public ParameterChangeInformation CreateParameterChangeInfo() + { + return new ParameterChangeInformation(Atk, BaseAtk, Life, MaxLife, BaseMaxLife); + } + + public void AddBuffInfo(BuffInfo buffInfo) + { + BuffInfoList.Add(buffInfo); + } + + public void InsertBuffInfo(BuffInfo buffInfo, int index) + { + if (index >= BuffInfoList.Count) + { + index = BuffInfoList.Count; + } + BuffInfoList.Insert(index, buffInfo); + } + + public void RemoveBuffInfo(BuffInfo buffInfo) + { + BuffInfoList.Remove(buffInfo); + } + + public void RemoveBuffInfo(Predicate condition) + { + BuffInfoList.RemoveAll(condition); + } + + public bool IsContainBuffInfo(BuffInfo buffInfo) + { + return BuffInfoList.Contains(buffInfo); + } + + public void ClearBuffInfo() + { + BuffInfoList.Clear(); + } + + public void ShallowCopyBuffInfoList(BattleCardBase originalCard) + { + BuffInfoList = originalCard.BuffInfoList; + this.OnResetCardParameter = originalCard.OnResetCardParameter; + } + + public VfxBase AfterAddDamage() + { + VfxBase allFuncVfxResults = this.OnAfterAddDamage.GetAllFuncVfxResults(); + this.OnAfterAddDamage = null; + return allFuncVfxResults; + } + + public virtual VfxBase SetUpInplay() + { + ResetCardParameter(); + IsFirstTurn = true; + SetOnMove(move: false); + AttackableCount = MaxAttackableCount; + IsSummonDrunkenness = true; + IsOnDraw = true; + SetActiveSkillCount(); + return NullVfx.GetInstance(); + } + + public void SetActiveSkillCount() + { + _normalSkillCollection.SetAndAddPublishedActiveSkillsCount(); + _evolveSkillCollection.SetAndAddPublishedActiveSkillsCount(); + } + + public virtual void ResetCardParameter() + { + IsDestroyedByKiller = false; + IsDestroyedBySkill = false; + DeathTypeInfo.DestroyedByKiller = false; + DeathTypeInfo.MysteriesDestroy = false; + DeathTypeInfo.WhenDestroy = false; + ClearCostModifier(); + this.OnResetCardParameter.Call(); + } + + public void ResetCardParameterInHand() + { + IsDestroyedByKiller = false; + IsDestroyedBySkill = false; + DeathTypeInfo.DestroyedByKiller = false; + DeathTypeInfo.MysteriesDestroy = false; + DeathTypeInfo.WhenDestroy = false; + } + + public HandCardFrameEffectType GetHandCardFrameEffectType() + { + return GetHandCardFrameEffectType(isNewReplayRecord: false); + } + + public HandCardFrameEffectType GetHandCardFrameEffectType(bool isNewReplayRecord) + { + HandCardFrameEffectType handCardFrameEffectType = HandCardFrameEffectType.NONE; + BattlePlayerReadOnlyInfoPair pair = new BattlePlayerReadOnlyInfoPair(SelfBattlePlayer, OpponentBattlePlayer); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + List list = new List(); + list.AddRange(NormalSkills); + list.AddRange(EvolutionSkills); + for (int i = 0; i < list.Count(); i++) + { + SkillBase skill = list[i]; + if (skill == null) + { + continue; + } + HandCardFrameEffectType handCardFrameEffectType2 = skill.SkillPrm.buildInfo._handCardFrameEffectType; + if ((handCardFrameEffectType < handCardFrameEffectType2 || (handCardFrameEffectType == HandCardFrameEffectType.LIGHT_BLUE && skill is Skill_pp_fixeduse)) && skill.VisualCheckCondition(pair, option, isPrePlay: true) && skill.PreprocessList.All((SkillPreprocessBase p) => p.IsRight(pair, option))) + { + handCardFrameEffectType = handCardFrameEffectType2; + if ((GameMgr.GetIns().IsWatchBattle || isNewReplayRecord) && handCardFrameEffectType == HandCardFrameEffectType.YELLOW && (skill.ConditionTargetFilter is SkillTargetDeckFilter || skill.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter c) => c.Text.Contains("deck") && RegisterSkillConditionCheck.IsSkillConditionCheck(skill)))) + { + handCardFrameEffectType = HandCardFrameEffectType.NONE; + } + } + } + return handCardFrameEffectType; + } + + protected string ConvertSkillDescription(string text, BattlePlayerBase.SideLogInfo sideLogInfo, bool isSkipOption, BuffInfo buff, string divergenceId, List skillDescriptionValueList, List replaySkillDescriptionValueList) + { + SelfBattlePlayer.SideLogSkill = sideLogInfo; + OpponentBattlePlayer.SideLogSkill = sideLogInfo; + bool num = sideLogInfo != null; + bool isRobBuff = buff != null && buff.IsCopied; + string text2 = (text.Contains("<<${") ? GetSkillDescriptionVariables(text) : text); + bool flag = IsInHand || (text2.Contains("{me.inplay.class.count}") && (text2.Contains(SkillFilterCreator.ContentKeyword.hand.ToString()) || text2.Contains(SkillFilterCreator.ContentKeyword.deck.ToString()))); + if (num && !isSkipOption && !IsPlayer && !GameMgr.GetIns().IsAdminWatch && flag) + { + isSkipOption = true; + } + Action setupOptionValue = (isSkipOption ? null : ((Action)delegate(SkillOptionValue optionValue) + { + BattleCardBase battleCardBase = ((!isRobBuff) ? this : ((buff.SkillFrom != null) ? buff.SkillFrom.SkillPrm.ownerCard : buff.OwnerCard)); + bool flag2 = isRobBuff && SelfBattlePlayer != battleCardBase.SelfBattlePlayer; + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(flag2 ? OpponentBattlePlayer : SelfBattlePlayer, flag2 ? SelfBattlePlayer : OpponentBattlePlayer); + SkillBase skill = null; + if (text.Contains(SkillFilterCreator.ContentKeyword.is_individual.ToString())) + { + skill = SelfBattlePlayer.Class.Skills.FirstOrDefault((SkillBase s) => s.HasIndividualId && s.IsAttachedSkill && s.GetAttachSkill.SkillPrm.ownerCard.Index == Index); + } + SkillCollectionBase.SetupOptionValue(optionValue, playerInfoPair, battleCardBase, skill); + })); + string result = ConvertSkillDescriptionText(text, setupOptionValue, IsPlayer, divergenceId, skillDescriptionValueList, replaySkillDescriptionValueList); + SelfBattlePlayer.SideLogSkill = null; + OpponentBattlePlayer.SideLogSkill = null; + return result; + } + + private string GetSkillDescriptionVariables(string originalText) + { + if (originalText == null || originalText == string.Empty) + { + return string.Empty; + } + string text = string.Empty; + string text2 = originalText; + int num = 0; + while (true) + { + num++; + if (num >= 21) + { + Debug.LogError("Maybe infinity loop. OriginalText=" + originalText); + break; + } + string variableNumberText = GetVariableNumberText(text2); + if (variableNumberText == string.Empty) + { + break; + } + if (variableNumberText.Contains('?')) + { + List list = variableNumberText.Split('?').ToList(); + text2 = text2.Replace("<<" + list[0] + "?" + list[1] + "?" + list[2] + ">>", string.Empty); + text = text + list[1] + list[2]; + } + } + return text; + } + + private static string GetDefaultValue(string expression) + { + if (expression.Contains(SkillFilterCreator.ContentKeyword.union_burst_count.ToStringCustom())) + { + return 10.ToString(); + } + if (expression.Contains(SkillFilterCreator.ContentKeyword.super_skybound_art_count.ToStringCustom())) + { + return 15.ToString(); + } + if (expression.Contains(SkillFilterCreator.ContentKeyword.skybound_art_count.ToStringCustom())) + { + return 10.ToString(); + } + if (expression.Contains(SkillFilterCreator.ContentKeyword.fixed_generic_value.ToStringCustom())) + { + return (-1).ToString(); + } + if (expression.Contains(SkillFilterCreator.ContentKeyword.white_ritual_stack.ToStringCustom())) + { + return 1.ToString(); + } + return "0"; + } + + private static string CreateDefaultOptionValue(string expression) + { + if (expression.Contains('{')) + { + bool flag = false; + bool flag2 = false; + int num = 0; + int count = 0; + for (int i = 0; i < expression.Length; i++) + { + if (expression[i] == '{') + { + flag = true; + num = i; + } + if (expression[i] == '}') + { + flag2 = true; + count = ((i != expression.Length) ? (i - num + 1) : (i - num)); + } + if (flag && flag2) + { + string defaultValue = GetDefaultValue(expression); + expression = expression.Remove(num, count); + expression = expression.Insert(num, defaultValue); + i = 0; + flag = false; + flag2 = false; + } + } + } + return expression; + } + + public static string ConvertSkillDescriptionText(string originalText, Action setupOptionValue = null, bool isPlayer = false, string divergenceId = "", List valueList = null, List replaySkillDescriptionValueList = null) + { + if (originalText == null || originalText == "") + { + return null; + } + string text = originalText; + int num = 0; + List list = new List(); + Dictionary dictionary = new Dictionary(); + while (true) + { + num++; + if (num >= 21) + { + Debug.LogError("Maybe infinity loop. OriginalText=" + originalText); + break; + } + Match match = Regex.Match(text, "<<([^>]+(>[^>])*)+>>"); + string variableNumberText = GetVariableNumberText(text); + if (variableNumberText == string.Empty) + { + break; + } + string text2 = variableNumberText; + bool flag = text2.Contains('?'); + List list2 = null; + if (flag) + { + list2 = text2.Split('?').ToList(); + text2 = list2[0]; + } + bool flag2 = text2.StartsWith("$", StringComparison.Ordinal); + if (flag && flag2) + { + text2 = text2.Remove(0, 1); + } + Action action = setupOptionValue; + bool flag3 = action == null; + if (flag3) + { + if (!flag2) + { + text2 = CreateDefaultOptionValue(text2); + } + action = SetupDefaultOptionValue; + } + bool isSkillDescriptionExpressionValueDefault = !flag2; + if (flag) + { + isSkillDescriptionExpressionValueDefault = ((flag3 || !GameMgr.GetIns().IsNewReplayBattle || text2.Contains("(divergence_id=")) ? EvalExpressionAndCondition(isSkillDescriptionExpressionValueDefault, text2, flag2, flag3, divergenceId, action, dictionary) : (replaySkillDescriptionValueList[num - 1] == 1)); + string empty = string.Empty; + empty = ((!isSkillDescriptionExpressionValueDefault) ? list2[2] : list2[1]); + valueList?.Add(isSkillDescriptionExpressionValueDefault ? 1 : 0); + text = text.Replace("<<" + list2[0] + "?" + list2[1] + "?" + list2[2] + ">>", empty); + continue; + } + SkillOptionValue skillOptionValue = new SkillOptionValue("v=" + text2); + action(skillOptionValue); + isSkillDescriptionExpressionValueDefault = IsSkillDescriptionExpressionValueDefault(text2, action, dictionary); + string text3 = ""; + string text4 = ""; + if (isSkillDescriptionExpressionValueDefault) + { + Match match2 = Regex.Match(text, "\\[[\\w\\d]+\\]([^[]*<<([^>])+>>[^[]*)\\[-\\]"); + MatchCollection matchCollection = Regex.Matches(text, "\\[[\\w\\d]+\\]([^[]*<<([^>])+>>[^[]*)\\[-\\]|<<([^>]+(>[^>])*)+>>"); + if (match2.Success && matchCollection[0].Value == match2.Value) + { + match = match2; + string value = match.Groups[1].Value; + Match match3 = Regex.Match(value, "<<([^>]+(>[^>])*)+>>"); + text3 = value.Substring(0, match3.Index); + text4 = value.Substring(match3.Index + match3.Length); + } + } + string text5 = text.Substring(0, match.Index) + text3; + string text6 = text4 + text.Substring(match.Index + match.Length); + if (Regex.Match(text, "{<<([^>])+>>@").Success) + { + text = text5 + list.Count + text6; + int item = ((flag3 || !GameMgr.GetIns().IsNewReplayBattle) ? skillOptionValue.GetInt(SkillFilterCreator.ContentKeyword.v) : replaySkillDescriptionValueList[num - 1]); + list.Add(item.ToString()); + valueList?.Add(item); + } + else + { + int item2 = ((flag3 || !GameMgr.GetIns().IsNewReplayBattle) ? skillOptionValue.GetInt(SkillFilterCreator.ContentKeyword.v) : replaySkillDescriptionValueList[num - 1]); + text = text5 + item2 + text6; + valueList?.Add(item2); + } + } + text = Data.SystemText.Convert(text, list.ToArray()); + return text.Replace("\\n", "\n"); + } + + private static bool EvalExpressionAndCondition(bool isSkillDescriptionExpressionValueDefault, string expression, bool isNewExpression, bool isNotBattleScene, string divergenceId, Action setupOptVal, Dictionary evalConditionCache) + { + string[] array = expression.Split('|'); + for (int i = 0; i < array.Length; i++) + { + string text = array[i]; + if (isNewExpression) + { + if (isNotBattleScene) + { + isSkillDescriptionExpressionValueDefault = false; + } + else if (text.StartsWith("(divergence_id=")) + { + text = text.Substring(1, text.Length - 2); + string text2 = text.Split('=')[1]; + isSkillDescriptionExpressionValueDefault |= text2 == divergenceId; + } + else + { + isSkillDescriptionExpressionValueDefault |= EvalNewExpressionAndCondition(text, setupOptVal, evalConditionCache); + } + } + else + { + isSkillDescriptionExpressionValueDefault &= EvalOldExpressionAndCondition(text, setupOptVal, evalConditionCache); + } + } + return isSkillDescriptionExpressionValueDefault; + } + + private static bool EvalNewExpressionAndCondition(string expression, Action setupOptionValue, Dictionary cache) + { + bool flag = true; + string[] array = expression.Split('&'); + for (int i = 0; i < array.Length; i++) + { + SkillTextVariableComareFilter skillTextVariableComareFilter = new SkillTextVariableComareFilter(array[i]); + SkillOptionValue skillOptionValue = new SkillOptionValue("v=" + skillTextVariableComareFilter.Lhs); + setupOptionValue(skillOptionValue); + if (cache.ContainsKey(skillTextVariableComareFilter.Lhs)) + { + skillTextVariableComareFilter.LhsFilteringResult = cache[skillTextVariableComareFilter.Lhs]; + } + else + { + cache[skillTextVariableComareFilter.Lhs] = skillTextVariableComareFilter.FilteringLhs(skillOptionValue); + } + if (cache.ContainsKey(skillTextVariableComareFilter.Rhs)) + { + skillTextVariableComareFilter.RhsFilteringResult = cache[skillTextVariableComareFilter.Rhs]; + } + else + { + cache[skillTextVariableComareFilter.Rhs] = skillTextVariableComareFilter.FilteringRhs(skillOptionValue); + } + flag &= skillTextVariableComareFilter.Filtering(skillOptionValue); + } + return flag; + } + + private static bool EvalOldExpressionAndCondition(string expression, Action setupOptionValue, Dictionary cache) + { + bool flag = false; + string[] array = expression.Split('&'); + for (int i = 0; i < array.Length; i++) + { + string text = array[i]; + bool flag2 = false; + if (!text.Contains("+1")) + { + text += "+1"; + flag2 = true; + } + SkillOptionValue obj = new SkillOptionValue("v=" + text); + setupOptionValue(obj); + bool flag3 = (flag2 ? (!IsSkillDescriptionExpressionValueDefault(text, setupOptionValue, cache)) : IsSkillDescriptionExpressionValueDefault(text, setupOptionValue, cache)); + flag = flag || flag3; + } + return flag; + } + + private static string GetVariableNumberText(string text) + { + _extractedText.Length = 0; + int num = 0; + for (int i = 0; i < text.Length - 1; i++) + { + if (text[i] == '<' && text[i + 1] == '<') + { + if (num > 0) + { + _extractedText.Append(text[i]); + _extractedText.Append(text[i + 1]); + } + i++; + num++; + } + else if (text[i] == '>' && text[i + 1] == '>') + { + num--; + if (num <= 0) + { + break; + } + _extractedText.Append(text[i]); + _extractedText.Append(text[i + 1]); + i++; + } + else if (num > 0) + { + _extractedText.Append(text[i]); + } + } + return _extractedText.ToString(); + } + + private static void SetupDefaultOptionValue(SkillOptionValue optionValue) + { + optionValue.SetVariable("PLAY_COUNT", "0"); + optionValue.SetVariable("HAND_COUNT", "0"); + optionValue.SetVariable("HAND_SPACE_COUNT", "0"); + optionValue.SetVariable("CHANT_COUNT", "0"); + optionValue.SetVariable("CHARGE_COUNT", "0"); + optionValue.SetVariable("DROP_COUNT", "0"); + optionValue.SetVariable("RETURN_COUNT", "0"); + optionValue.SetVariable("INPLAY_ME_COUNT", "0"); + optionValue.SetVariable("INPLAY_OP_COUNT", "0"); + optionValue.SetVariable("INPLAY_UNIT_ME_COUNT", "0"); + optionValue.SetVariable("INPLAY_UNIT_OP_COUNT", "0"); + optionValue.SetVariable("CLASS_ME_LIFE", "0"); + optionValue.SetVariable("CLASS_OP_LIFE", "0"); + optionValue.SetVariable("ADD_CHARGE_COUNT", "0"); + optionValue.SetVariable("ADD_ODD_CHARGE_COUNT", "0"); + optionValue.SetVariable("ADD_EVEN_CHARGE_COUNT", "0"); + } + + private static bool IsSkillDescriptionExpressionValueDefault(string expression, Action setupOptionValue, Dictionary cache) + { + string expression2 = string.Copy(expression); + expression2 = CreateDefaultOptionValue(expression2); + SkillOptionValue skillOptionValue = new SkillOptionValue("v=" + expression2); + SetupDefaultOptionValue(skillOptionValue); + int num; + if (cache.ContainsKey(expression)) + { + num = cache[expression]; + } + else + { + SkillOptionValue skillOptionValue2 = new SkillOptionValue("v=" + expression); + setupOptionValue(skillOptionValue2); + num = (cache[expression] = skillOptionValue2.GetInt(SkillFilterCreator.ContentKeyword.v)); + } + return skillOptionValue.GetInt(SkillFilterCreator.ContentKeyword.v) == num; + } + + public virtual VfxBase LoadResource(bool isLogging = false) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + parallelVfxPlayer.Register(BattleCardView.LoadChoiceTransformCardsResources(this)); + parallelVfxPlayer.Register(BattleCardView.LoadResource()); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(parallelVfxPlayer); + if (isLogging) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + LocalLog.AccumulateLastTraceLog("Loaded" + CardId); + })); + } + return sequentialVfxPlayer; + } + + public virtual VfxBase UnloadResource() + { + return BattleCardView.UnloadResource(); + } + + protected void OnEvolve(bool isSkill) + { + this.OnEvolveEvent(isSkill); + } + + protected VfxBase OnBeforeEvolveEvent(SkillProcessor skillProcessor) + { + return this.OnBeforeEvolve.GetAllFuncVfxResults(skillProcessor); + } + + protected void InitSkill() + { + Skills = _normalSkillCollection; + } + + public virtual VfxBase RecoveryInPlay(int inPlayIndex, bool newReplayMoveTurn = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(new SummonCardPreperationVfx(this)); + sequentialVfxPlayer.Register(new ChangeInPlayViewVfx(BattleCardView)); + sequentialVfxPlayer.Register(CreateMaskCardInPlayVfx()); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + BattleCardView.GameObject.transform.localPosition = InPlayCardControl.CalcPosition(SelfBattlePlayer.InPlayCards.Count(), inPlayIndex, IsPlayer); + BattleCardView.GameObject.SetLayer(10, isSetChildren: true); + BattleCardView.GameObject.SetActive(value: true); + BattleCardView.isHiddenFromInPlayView = false; + SetOnDraw(draw: false); + })); + if (!newReplayMoveTurn) + { + sequentialVfxPlayer.Register(BattleCardView.BattleCardIconAnimations.Initialize(this, Skills)); + } + sequentialVfxPlayer.Register(SkillApplyInformation.AllSkillEffectStop()); + sequentialVfxPlayer.Register(SkillApplyInformation.AllSkillEffectRestart()); + return sequentialVfxPlayer; + } + + public abstract BattleCardBase VirtualClone(BattlePlayerBase selfBattlePlayer, BattlePlayerBase opponentBattlePlayer); + + protected void CopyToVirtualCardBase(BattleCardBase target) + { + target.PlayedTurn = PlayedTurn; + target.DeathTypeInfo = DeathTypeInfo.Clone(); + target.BaseParameter = BaseParameter; + target.IsTokenLoad = IsTokenLoad; + target.IsFirstTurn = IsFirstTurn; + target.IsOnMove = IsOnMove; + target.SpellChargeCount = SpellChargeCount; + target.SkillActivatedCount = SkillActivatedCount; + target.ThisTurnSkillActivatedCount = ThisTurnSkillActivatedCount; + target.IsSummonDrunkenness = IsSummonDrunkenness; + target.IsPreviousTurnAttacked = IsPreviousTurnAttacked; + target.IsDestroyedByKiller = IsDestroyedByKiller; + target.IsDestroyedBySkill = IsDestroyedBySkill; + target.AttackableCount = AttackableCount; + target._playedCost = _playedCost; + target._lastCost = _lastCost; + target.IsSkillLost = IsSkillLost; + target.IsReanimate = IsReanimate; + target.DamagedCounter = new ItWasDamagedCounter(DamagedCounter.GetDamageCount(selfTurn: true), DamagedCounter.GetDamageCount(selfTurn: false)); + target.GetOffCards = GetOffCards; + target.TransformInfo = TransformInfo; + for (int i = 0; i < CostModifierList.Count; i++) + { + target.CostModifierList.Add(CostModifierList[i].Clone()); + } + for (int j = 0; j < attackCountinfo.Count; j++) + { + if (attackCountinfo[j].Skill.IsAddAttackCount()) + { + target.attackCountinfo.Add(new AddAttackCountInfo(attackCountinfo[j].Skill, attackCountinfo[j].Count)); + } + else if (attackCountinfo[j].Skill.IsSetAttackCount()) + { + target.attackCountinfo.Add(new SetAttackCountInfo(attackCountinfo[j].Skill, attackCountinfo[j].Count)); + } + } + if (IsEvolution && EvolutionSkills.Count() > 0) + { + target.Skills = target.EvolutionSkills; + } + target.SkillApplyInformation = SkillApplyInformation.Clone(target); + target._buildInfo = _buildInfo.VirtualClone(SelfBattlePlayer, OpponentBattlePlayer); + target.HasSkillNecromance = HasSkillNecromance; + target.Setup(); + } + + public virtual VfxBase CombineVirtualCardSkill(BattleCardBase target) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + IsSkillLost = false; + foreach (SkillBase item in CreateSkillCondition(target._buildInfo.NormalSkillBuildInfos, SelfBattlePlayer, OpponentBattlePlayer, _buildInfo.ResourceMgr)) + { + _normalSkillCollection.Add(item); + } + foreach (SkillBase item2 in CreateSkillCondition(target._buildInfo.EvolveSkillBuildInfos, SelfBattlePlayer, OpponentBattlePlayer, _buildInfo.ResourceMgr)) + { + item2.ConditionCheckerList = item2.ConditionCheckerList.Where((ISkillConditionChecker c) => !(c is SkillPreprocessEvolutionEndStop)).ToList(); + item2.PreprocessList = item2.PreprocessList.Where((SkillPreprocessBase c) => !(c is SkillPreprocessEvolutionEndStop)).ToList(); + _evolveSkillCollection.Add(item2); + } + Skills = ((IsEvolution && EvolutionSkills.Count() > 0) ? _evolveSkillCollection : _normalSkillCollection); + SkillApplyInformation.Combine(target.SkillApplyInformation); + int count = target.BuffInfoList.Count; + for (int num = 0; num < count; num++) + { + BuffInfo buffInfo = target.BuffInfoList[num]; + if (!(buffInfo.SkillFrom is Skill_powerup) && !(buffInfo.SkillFrom is Skill_power_down) && !BuffInfoList.Contains(buffInfo)) + { + AddBuffInfo(buffInfo); + } + } + Skills.Complete(); + CostModifierList.AddRange(target.CostModifierList); + attackCountinfo.AddRange(target.attackCountinfo); + if (!SelfBattlePlayer.BattleMgr.IsVirtualBattle && !SelfBattlePlayer.BattleMgr.IsRecovery) + { + parallelVfxPlayer.Register(SequentialVfxPlayer.Create(SkillApplyInformation.AllSkillEffectRestart(), InstantVfx.Create(delegate + { + BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect(); + }), BattleCardView.BattleCardIconAnimations.Initialize(this, Skills))); + } + return parallelVfxPlayer; + } + + public void SetSpellChargeCount(int num) + { + if (num != -1) + { + SpellChargeCount = num; + } + } + + public void AddSpellChargeCount(int num) + { + SpellChargeCount += num; + } + + public VfxBase GetSpellChargeLoopEffect(int num) + { + Func getIsActionCard = () => IsActionCard || IsInplay || BattleCardView._hasCardEnteredPlayQueue; + if (SpellChargeCount == 0 && num > 0) + { + return new HandEffectLoopStartVfx(BattleCardView, getIsActionCard, HandEffectLoopStartVfx.HandEffectType.SpellCharge); + } + return NullVfx.GetInstance(); + } + + public BattleCardBase GetDamageReflectionTarget(bool isSkillDamage) + { + if (SkillApplyInformation.IsReflectionClass && (isSkillDamage || SkillApplyInformation.ReflectionInfoList.Any((ReflectionInfo b) => b.Type == ReflectionInfo.DamageType.ALL))) + { + return OpponentBattlePlayer.Class; + } + return this; + } + + public VfxBase CalcHandCost(bool playEffect = true, bool isOnlyFixedUseCost = false) + { + if (SelfBattlePlayer.BattleMgr.IsRecovery) + { + return NullVfx.GetInstance(); + } + if (IsInHand) + { + List costList = BattleCardView.GetUseCostList(Cost); + return InstantVfx.Create(delegate + { + BattleCardView.UpdateCost(costList, isGenerateInHand: true, playEffect, isForceUpdate: false, isOnlyFixedUseCost); + }); + } + return NullVfx.GetInstance(); + } + + public void UpdateCostViewStrategy(bool isForceUpdate = false) + { + BattleCardView.UpdateCostViewStrategy(isForceUpdate); + } + + public void InitHandParameterIconPos(HandParameter.IconLayout layout) + { + BattleCardView.InitHandParameterIconPos(layout); + } + + public IEnumerable AsIEnumerable() + { + yield return this; + } + + public bool IsHoverActionCard() + { + if (IsClass) + { + return false; + } + if (IsOnMove) + { + return false; + } + if (IsOnDraw) + { + return false; + } + if (!GameMgr.GetIns().IsAdmin && !IsPlayer && IsInHand) + { + return false; + } + return true; + } + + public List GetSelectSkillsNoDuplication(List skills) + { + List list = new List(); + BattlePlayerPair playerInfoPair = new BattlePlayerPair(SelfBattlePlayer, OpponentBattlePlayer); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + for (int i = 0; i < skills.Count; i++) + { + SkillBase skillBase = skills[i]; + int val = ((skillBase.IsBurialRite && !skillBase.IsUserSelectType) ? 1 : skillBase.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: true).Count()); + int num = Math.Min(skillBase.GetSkillSelectCount(), val); + for (int j = 0; j < num; j++) + { + list.Add(skillBase); + } + } + if (list.Count == 0) + { + list.AddRange(skills); + } + return list; + } + + public int GetBurialRiteCount(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, bool isPrePlay) + { + if (BattleManagerBase.GetIns().BattlePlayer.PlayerBattleView._isEvolutionSkillSelect) + { + return EvolutionSkills.Count((SkillBase s) => s.CheckConditionWithoutBurialRite(playerInfoPair, option, isPrePlay)); + } + return Skills.Count((SkillBase s) => s.CheckConditionWithoutBurialRite(playerInfoPair, option, isPrePlay)); + } + + public void ReplaceParameterAndSkillOnDeck(int id) + { + _buildInfo.CardId = id; + CreateParameter(); + InitSkillApplyInformationOnWhenReturn(); + } + + public bool HasInductionSkill() + { + for (int i = 0; i < Skills.Count(); i++) + { + SkillBase skillBase = Skills.ElementAt(i); + if (skillBase.IsInductionSkill && skillBase.SkillPrm.buildInfo._icon == "induction") + { + return true; + } + } + return false; + } + + public bool HasInductionNumberSkill() + { + for (int i = 0; i < Skills.Count(); i++) + { + SkillBase skillBase = Skills.ElementAt(i); + if (skillBase.IsInductionSkill && skillBase.SkillPrm.buildInfo._icon != "induction" && skillBase.SkillPrm.buildInfo._icon.Contains("induction")) + { + return true; + } + } + return false; + } + + public int GetInductionLabelNumber() + { + SkillBase skillBase = Skills.FirstOrDefault((SkillBase s) => s.IsInductionSkill && s.SkillPrm.buildInfo._icon != "induction" && s.SkillPrm.buildInfo._icon.Contains("induction")); + if (skillBase == null) + { + return -1; + } + SkillOptionValue skillOptionValue = new SkillOptionValue(skillBase.SkillPrm.buildInfo._icon); + skillOptionValue.SetupFilterVariable(BattleManagerBase.GetIns().GetBattlePlayerInfoPair(IsPlayer), this, isPrePlay: false, null); + return skillOptionValue.GetInt(SkillFilterCreator.ContentKeyword.induction); + } + + public bool HasStackWhiteRitualAndOtherIconSkill() + { + if (HasSkillStackWhiteRitual) + { + if (!HasInductionSkill() && !HasInductionNumberSkill()) + { + return HasSkillWhenDestroy; + } + return true; + } + return false; + } +} diff --git a/SVSim.BattleEngine/Engine/BattleManagerBase.cs b/SVSim.BattleEngine/Engine/BattleManagerBase.cs new file mode 100644 index 0000000..d6fa1d1 --- /dev/null +++ b/SVSim.BattleEngine/Engine/BattleManagerBase.cs @@ -0,0 +1,2443 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using Cute; +using UnityEngine; +using Wizard; +using Wizard.Battle; +using Wizard.Battle.Mulligan; +using Wizard.Battle.Phase; +using Wizard.Battle.Resource; +using Wizard.Battle.UI; +using Wizard.Battle.View; +using Wizard.Battle.View.Vfx; +using Wizard.BattleMgr; + +public class BattleManagerBase +{ + public class CardParameterListInfo + { + public IList HolderCards { get; set; } + + public CardParameterListInfo() + { + HolderCards = new List(); + } + + public void Clear() + { + HolderCards.Clear(); + } + } + + public class XorShift + { + private int w = 111111111; + + private int x = 123456789; + + private int y = 987654321; + + private int z = 555555555; + + public bool IsActive { get; private set; } + + public XorShift(int seed = -1) + { + IsActive = seed != -1; + w = seed; + } + + public int GetChangeInt(double val) + { + double num = Math.Floor((double)Next() / 2147483647.0 * 10000000000.0) / 10000000000.0; + return (int)Math.Floor(val * num); + } + + private int Next() + { + int num = x ^ (x << 11); + x = y; + y = z; + z = w; + return w = w ^ (w >> 19) ^ (num ^ (num >> 8)); + } + } + + public class IndexInfo + { + public int AddIndex { get; private set; } + + public int TargetIndex { get; private set; } + + public bool IsSkillCopy { get; private set; } + + public int CopySkillSelectIndex { get; private set; } + + public IndexInfo(int addIndex = -1, int targetIndex = -1, bool skillCopy = false, int copySelectIndex = -1) + { + AddIndex = addIndex; + TargetIndex = targetIndex; + IsSkillCopy = skillCopy; + CopySkillSelectIndex = copySelectIndex; + } + } + + public class MissionNecessaryInformation + { + private Dictionary NecessaryTargetDictionary; + + private Dictionary _originalTargetDictionary; + + private const string MISSION_INFO_EQUAL = "mission_info="; + + public MissionNecessaryInformation(Dictionary targetDictionary) + { + _originalTargetDictionary = targetDictionary; + NecessaryTargetDictionary = new Dictionary(); + foreach (KeyValuePair item in targetDictionary) + { + SkillOptionValue value = new SkillOptionValue(SkillCreator.ParseContentInfos("mission_info=" + item.Value)); + NecessaryTargetDictionary.Add(item.Key, value); + } + } + + public Dictionary GetMissionNecessaryInfo(BattlePlayerPair pair, BattleCardBase selfClass) + { + Dictionary dictionary = new Dictionary(); + foreach (KeyValuePair item in NecessaryTargetDictionary) + { + SkillCollectionBase.SetupOptionValue(item.Value, pair, selfClass, null); + dictionary.Add(item.Key, item.Value.GetInt(SkillFilterCreator.ContentKeyword.mission_info, 0)); + } + return dictionary; + } + + public Dictionary GetOriginalTargetDictionary() + { + return _originalTargetDictionary; + } + } + + public class CalledCreateFilterPair + { + private readonly IReadOnlyBattleCardInfo _ownerCard; + + private readonly string _checkText; + + public CalledCreateFilterPair(IReadOnlyBattleCardInfo ownerCard, string checkText) + { + _ownerCard = ownerCard; + _checkText = checkText; + } + + public bool Equal(CalledCreateFilterPair piar) + { + if (piar._ownerCard == _ownerCard) + { + return piar._checkText == _checkText; + } + return false; + } + + public bool HasOwnerCard() + { + if (_ownerCard != null) + { + return _ownerCard.SkillApplyInformation != null; + } + return false; + } + + public bool IsOwnerCardDead() + { + if (!BattleLogManager.GetInstance().EnemyFusionCard.Contains(_ownerCard)) + { + if (!_ownerCard.IsDead) + { + if (!_ownerCard.IsInHand) + { + return !_ownerCard.IsInplay; + } + return false; + } + return true; + } + return false; + } + } + + public class CardCreateInfo + { + public readonly bool IsPlayer; + + public readonly NetworkBattleDefine.NetworkCardPlaceState PlaceStatus; + + public readonly IndexInfo IndexInfo; + + public readonly bool IsChoice; + + public readonly bool IsReferenceOpponenCard; + + public int Id { get; private set; } + + public SkillBase Skill { get; private set; } + + public int Cost { get; private set; } = -1; + + public CardCreateInfo(int id, bool isPlayer, bool isChoice, NetworkBattleDefine.NetworkCardPlaceState placeStatus, bool isReferenceOpponentCard = false, SkillBase skill = null) + { + Id = id; + IsPlayer = isPlayer; + PlaceStatus = placeStatus; + IsChoice = isChoice; + IsReferenceOpponenCard = isReferenceOpponentCard; + Skill = skill; + } + + public void SetId(int id) + { + Id = id; + } + + public void SetCost(int cost) + { + Cost = cost; + } + } + + public enum BATTLE_RESULT_TYPE + { + NONE, + WIN, + LOSE, + CONSISTENCY + } + + public enum FINISH_TYPE + { + NORMAL, + RETIRE, + SPECIAL_WIN + } + + protected class AttachInfo + { + public BattleCardBase _classCard; + + public SkillBase _attachSkill; + + public SkillCreator.SkillBuildInfo _targetSkillBuildInfo; + + public string _myRotationBonusId; + + public AttachInfo(BattleCardBase classCard, SkillBase attachSkill, SkillCreator.SkillBuildInfo targetSkillBuildInfo, string myRotationBonusId = "") + { + _classCard = classCard; + _attachSkill = attachSkill; + _targetSkillBuildInfo = targetSkillBuildInfo; + _myRotationBonusId = myRotationBonusId; + } + } + + public class ResourceInfo + { + public string ObjectPath { get; private set; } + + public string SePath { get; private set; } + + public string ObjectFullPath { get; private set; } + + public bool IsEffectBattleInfoDictionary { get; set; } + + public ResourceInfo(string objectPath, string sePath) + { + ObjectPath = objectPath; + SePath = sePath; + ObjectFullPath = Toolbox.ResourcesManager.GetAssetTypePath(objectPath, ResourcesManager.AssetLoadPathType.Effect2D, isfetch: true); + } + + public ResourceInfo(string objectFullPath) + { + ObjectPath = string.Empty; + SePath = string.Empty; + ObjectFullPath = objectFullPath; + } + } + + private Dictionary _calledCreateFilterDictionary = new Dictionary(); + + private Dictionary _calledCreateLimitFilterDictionary = new Dictionary(); + + private Dictionary _calledCreateOrFilterDictionary = new Dictionary(); + + public const int SIMPLE_STAGE_ID = 9; + + public const int NEW_INDEX = -1; + + public static readonly int FIRST_PLAYER_EP_NUM = 2; + + public static readonly int SECOND_PLAYER_EP_NUM = 3; + + protected const int FIRST_PLAYER_EVOLVE_WAIT_TURN = 5; + + protected const int SECOND_PLAYER_EVOLVE_WAIT_TURN = 4; + + public SBattleLoad SBattleLoad; + + protected IBattleMgrContentsCreator _contentsCreator; + + public EmoteUI EmoteUI; + + public BattleEnemy BattleEnemy; + + public BattlePlayer BattlePlayer; + + public GameObject BtlContainer; + + public GameObject BtlUIContainer; + + public GameObject CutInContainer; + + public GameObject Battle3DContainer; + + public GameObject SubParticleContainer; + + protected BattleCamera _battleCamera; + + protected BackGroundBase _backGround; + + public DetailMgr DetailMgr; + + public PanelMgr PanelMgr; + + public IMulliganMgr MulliganMgr; + + protected Camera _subParticleCamera; + + public IEnemyAI EnemyAI; + + public GameObject CardHolder; + + public GameObject ECardHolder; + + public GameObject PCardPlace; + + public GameObject ChoiceCardHolder; + + public GameObject EvolveCardHolder; + + public GameObject Arrow; + + public ArrowControl ArrowControl; + + public GameObject AttackArrowHead; + + public GameObject EvolutionArrowHead; + + public GameObject AlertDialogue; + + public UILabel AlertDialogueLabel; + + public GameObject PSideLog; + + public SideLogControl PSideLogControl; + + public GameObject ESideLog; + + public SideLogControl ESideLogControl; + + public GameObject ESelectSkillSideLog; + + public SideLogControl ESelectSkillSideLogControl; + + private const string UnityEventAgentStr = "Prefab/Game/UnityEventAgent"; + + public ITurnPanelControl TurnPanelControl; + + public GameObject BattleResult; + + public BattleResultUIController BattleResultControl; + + public GameObject BattleStart; + + public BattleStartControl BattleStartControl; + + public CardParameterListInfo PlayerCardParameterListInfo = new CardParameterListInfo(); + + public CardParameterListInfo EnemyCardParameterListInfo = new CardParameterListInfo(); + + public List TransformCardList = new List(); + + public bool IsFirst; + + public Transform SubUI; + + public TweenAlpha SubUIOverLayBG; + + public GameObject MenuButtonObject; + + public int isStorySuccessful; + + protected int _allPublishedActiveSkillCount; + + protected int _temporaryPublishedAddCount; + + public const int NOT_LETHAL_PUBLISHED_COUNT = -1; + + protected int _lethalPublishedActiveSkillCount = -1; + + protected int _lethalMovementCount; + + protected int _allPublishedDamageModifierCount; + + protected int _allPublishedHealModifierCount; + + public int FirstTurn; + + public int SecondTurn; + + public int GroundID; + + public int DamageCount; + + private GameObject _unityEventAgentObject; + + private UnityEventAgent _unityEventAgent; + + protected IPhase _phase; + + private NetworkTouchControl _networkTouchControl; + + private static BattleManagerBase main; + + public static bool IsRandomDraw = false; + + public static bool IsForecast = false; + + public BattleLifeTimeSharedObject BattleLifeTimeSharedObject; + + private BattleUIContainer _battleUIContainer; + + protected System.Random _stableRandom; + + protected System.Random _stableRandomOnlySelf; + + private int stableRandomCount; + + protected XorShift _selfXorShiftRandom; + + protected XorShift _oppXorShiftRandom; + + public bool IsKeyboardEnable = true; + + public static bool IsTutorial + { + get + { + if (Data.Load.data._userTutorial.tutorial_step == 100) + { + return false; + } + return true; + } + } + + protected virtual bool IsStoryTutorial => false; + + protected virtual bool DisableCustomMouse => false; + + public static bool UseCustomMouse + { + get + { + bool flag = GetIns()?.DisableCustomMouse ?? false; + if (InputMgr.MouseControl) + { + return !flag; + } + return false; + } + } + + public static bool UseKeyboard + { + get + { + bool flag = GetIns()?.IsStoryTutorial ?? false; + GameMgr ins = GameMgr.GetIns(); + bool isWatchBattle = ins.IsWatchBattle; + bool isReplayBattle = ins.IsReplayBattle; + if (InputMgr.KeyboardControl && !flag && !isWatchBattle) + { + return !isReplayBattle; + } + return false; + } + } + + public static bool UseKeyboardTurnEndSpaceShortcut + { + get + { + if (UseKeyboard) + { + return InputMgr.KeyboardControlSpace; + } + return false; + } + } + + public int BackgroundId { get; private set; } + + public string BgmId { get; private set; } + + public bool IsBackGroundLoad => _backGround.IsLoadDone; + + public BattleCamera Camera => _battleCamera; + + public BackGroundBase BackGround => _backGround; + + public Camera SubParticleCamera => _subParticleCamera; + + public int AllPublishedActiveSkillCount + { + get + { + return _allPublishedActiveSkillCount; + } + set + { + _allPublishedActiveSkillCount = value; + } + } + + public int TemporaryPublishedAddCount + { + get + { + return _temporaryPublishedAddCount; + } + protected set + { + _temporaryPublishedAddCount = value; + } + } + + public List PublishedSkillList { get; protected set; } + + public int LethalPublishedActiveSkillCount + { + get + { + return _lethalPublishedActiveSkillCount; + } + set + { + _lethalPublishedActiveSkillCount = value; + } + } + + public int LethalMovementCount + { + get + { + return _lethalMovementCount; + } + set + { + _lethalMovementCount = value; + } + } + + public int AllPublishedDamageModifierCount + { + get + { + return _allPublishedDamageModifierCount; + } + set + { + _allPublishedDamageModifierCount = value; + } + } + + public int AllPublishedHealModifierCount + { + get + { + return _allPublishedHealModifierCount; + } + set + { + _allPublishedHealModifierCount = value; + } + } + + public int NextIndividualId { get; private set; } = 1; + + public int CurrentTurn + { + get + { + if (!BattlePlayer.IsSelfTurn) + { + return BattleEnemy.Turn; + } + return BattlePlayer.Turn; + } + } + + public virtual TouchControl TouchControl { get; protected set; } + + public virtual OperateMgr OperateMgr { get; protected set; } + + public IPhaseCreator PhaseCreator { get; private set; } + + public bool IsPreRecovery { get; set; } + + public bool IsRecovery { get; set; } + + public bool IsPuzzleMgr => this is PuzzleBattleManager; + + public virtual bool IsBattleEnd + { + get + { + if (BattlePlayer != null && BattleEnemy != null && !BattlePlayer.Class.IsDead) + { + return BattleEnemy.Class.IsDead; + } + return true; + } + } + + public IBattleResourceMgr BattleResourceMgr { get; private set; } + + public VfxMgr VfxMgr { get; protected set; } + + public virtual bool IsStopOperate => false; + + public BattleUIContainer BattleUIContainer + { + get + { + return _battleUIContainer; + } + set + { + _battleUIContainer = value; + if (Prediction == null || !(_battleUIContainer != null)) + { + return; + } + _battleUIContainer.ShowPrediction = delegate(bool isPress) + { + if (isPress) + { + Prediction.TurnEnd(); + } + else + { + Prediction.Clear(); + } + }; + } + } + + public bool HasFocus => _unityEventAgent.HasFocus; + + public double randomResult { get; protected set; } + + public bool IsMulliganEnd { get; set; } + + public bool IsTurnEnd { get; protected set; } + + public virtual bool IsVirtualBattle => IsForecast; + + public virtual bool IsVirtualBattleEnemyTurn + { + get + { + if (EnemyAI is EnemyAI) + { + return BattleEnemy.IsSelfTurn; + } + return false; + } + } + + public bool IsPlayerRetire { get; protected set; } + + public Prediction Prediction { get; private set; } + + public event Action OnStartOpening; + + public event Action OnWin; + + public event Action OnBattleSettingInfoClear; + + public event Action OnBattleFinish; + + public event Func OnSubmitMulligan; + + public void AddPublishedSkillList(SkillBase skill) + { + PublishedSkillList.Add(skill); + } + + public void IncrementIndividualId() + { + NextIndividualId++; + } + + public virtual int GetMaxDeckCount(bool isSelf) + { + return 40; + } + + public XorShift XorShiftRandom(bool isSelf) + { + if (!isSelf) + { + return _oppXorShiftRandom; + } + return _selfXorShiftRandom; + } + + public static BattleManagerBase GetIns() + { + return main; + } + + protected BattleManagerBase(IBattleMgrContentsCreator contentsCreator) + { + main = this; + BattleLifeTimeSharedObject = new BattleLifeTimeSharedObject(); + PublishedSkillList = new List(); + _contentsCreator = contentsCreator; + BattleResourceMgr = _contentsCreator.CreateResourceMgr(); + _stableRandom = new System.Random(_contentsCreator.RandomSeed); + _stableRandomOnlySelf = new System.Random(_contentsCreator.RandomSeed); + BackgroundId = CreateBackgroundId(); + BgmId = CreateBgmId(); + CreateManager(); + BattlePlayer = CreateBattlePlayer(); + BattleEnemy = CreateBattleEnemy(); + BattlePlayer.ClassAndInPlayCardList[0].Setup(); + BattleEnemy.ClassAndInPlayCardList[0].Setup(); + PhaseCreator = _contentsCreator.CreatePhaseCreator(this); + PhaseCreator.CreateFirstPhase().Setup(); + EmoteUI = null; + PanelMgr = null; + SBattleLoad = null; + IsFirst = false; + BattlePlayer.EvolveWaitTurnCount = 0; + BattleEnemy.EvolveWaitTurnCount = 0; + FirstTurn = (SecondTurn = 0); + EnemyAI = null; + BtlContainer = null; + BtlUIContainer = null; + CutInContainer = null; + Battle3DContainer = null; + SubParticleContainer = null; + CardHolder = null; + PCardPlace = null; + ECardHolder = null; + Arrow = null; + ArrowControl = null; + AttackArrowHead = null; + EvolutionArrowHead = null; + AlertDialogue = null; + TurnPanelControl = null; + BattleResult = null; + BattleResultControl = null; + BattleStart = null; + BattleStartControl = null; + SubUI = null; + SubUIOverLayBG = null; + MenuButtonObject = null; + GameMgr.GetIns().GetPrefabMgr().Load("Prefab/Game/UnityEventAgent"); + _unityEventAgentObject = UnityEngine.Object.Instantiate(GameMgr.GetIns().GetPrefabMgr().Get("Prefab/Game/UnityEventAgent")); + _unityEventAgent = _unityEventAgentObject.GetComponent(); + _unityEventAgent.SetBattleMgr(this); + Prediction = new Prediction(BattleResourceMgr, GetBattlePlayerPair(isPlayer: true)); + TouchControl = new TouchControl(this, _battleCamera, _backGround); + OperateMgr = CreateOperateMgr(); + VfxMgr = _contentsCreator.CreateVfxMgr(); + VfxBase vfx = ChangePhase(PhaseCreator.CreateFirstPhase()); + VfxMgr.RegisterSequentialVfx(vfx); + SetupEvent(); + FirstRecoverySetting(); + FirstReplaySetting(); + OnBattleSettingInfoClear += delegate + { + GameMgr.GetIns().GetDataMgr().SetStoryBgmID("NONE"); + }; + LocalLog.AccumulateSettingLog(); + } + + protected virtual void FirstRecoverySetting() + { + StartRecoveryRecording(); + } + + public void StartRecoveryRecording() + { + _contentsCreator.RecoveryRecordManager.SetupRecording(this, GameMgr.GetIns().GetDataMgr().m_BattleType, _contentsCreator.RandomSeed, BackgroundId, BgmId); + } + + protected virtual void FirstReplaySetting() + { + StartReplayRecording(); + } + + public void StartReplayRecording() + { + _contentsCreator.ReplayRecordManager.SetupRecording(this); + } + + public void SetupReplayBattleInfoFilter() + { + _contentsCreator.ReplayRecordManager.SetupBattleInfoFilter(); + } + + public void CreateXorShift(int selfIdxSeed, int oppIdxSeed = -1) + { + if (selfIdxSeed != -1) + { + _selfXorShiftRandom = new XorShift(selfIdxSeed); + } + if (oppIdxSeed != -1) + { + _oppXorShiftRandom = new XorShift(oppIdxSeed); + } + } + + public void SetBattleMenuBtn() + { + MenuButtonObject = BtlUIContainer.transform.Find("BattleMenuBtn").gameObject; + SetBattleMenuBtnVisibility(); + } + + public virtual void SetBattleMenuBtnVisibility() + { + MenuButtonObject.SetActive(value: false); + } + + protected virtual int CreateBackgroundId() + { + int backGroundId = _contentsCreator.RecoveryManager.BackGroundId; + if (backGroundId >= 0) + { + return backGroundId; + } + int result = 1; + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + if (dataMgr.m_BattleType == DataMgr.BattleType.BossRushQuest && PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SIMPLE_STAGE)) + { + result = 9; + } + else if (dataMgr.m_BattleType == DataMgr.BattleType.Story || dataMgr.IsQuestBattleType() || GameMgr.GetIns().IsPuzzleQuest) + { + result = dataMgr.GetSoroPlay3DFieldID(); + } + else if (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SIMPLE_STAGE)) + { + result = 9; + } + else if (dataMgr.m_BattleType == DataMgr.BattleType.Practice && dataMgr.GetSoroPlay3DFieldID() != 0) + { + result = CalculationRandomStage(); + } + else if (!IsTutorial) + { + result = UnityEngine.Random.Range(1, 8); + } + return result; + } + + protected int CalculationRandomStage() + { + if (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SIMPLE_STAGE)) + { + return 9; + } + List list = new List(); + if (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.USE_OFF_STAGE)) + { + list = PlayerPrefsWrapper.CreateServerSendStageOffList(); + } + List list2 = new List(); + for (int i = 0; i < Data.Load.data.OpenBattleFieldIdList.Count; i++) + { + int item = int.Parse(Data.Load.data.OpenBattleFieldIdList[i]); + if (!list.Contains(item)) + { + list2.Add(item); + } + } + if (list2.Count == 0) + { + return 9; + } + return list2[UnityEngine.Random.Range(0, list2.Count)]; + } + + protected virtual string CreateBgmId() + { + string bgmId = _contentsCreator.RecoveryManager.BgmId; + if (bgmId != "NONE") + { + return bgmId; + } + string result = "NONE"; + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + if (dataMgr.m_BattleType == DataMgr.BattleType.Story || dataMgr.IsQuestBattleType()) + { + result = dataMgr.GetStoryBgmID(); + } + return result; + } + + public BackGroundBase CreateBattleField() + { + _backGround.CreateField(_battleCamera, Battle3DContainer, CutInContainer); + GameMgr.GetIns().GetInputMgr().SetBackGround(_backGround); + return _backGround; + } + + protected void CreateManager() + { + _battleCamera = new BattleCamera(); + GameMgr.GetIns().GetInputMgr().SetBattleCamera(_battleCamera); + DetailMgr = new DetailMgr(); + switch (BackgroundId) + { + case 1: + _backGround = new ForestField(BgmId); + break; + case 2: + _backGround = new CastleField(BgmId); + break; + case 3: + _backGround = new VolcanoField(BgmId); + break; + case 4: + _backGround = new RoyalPalaceField(BgmId); + break; + case 5: + _backGround = new TempleField(BgmId); + break; + case 6: + _backGround = new ChateauField(BgmId); + break; + case 7: + _backGround = new LaboratoryField(BgmId); + break; + case 8: + _backGround = new GateField(BgmId); + break; + case 9: + _backGround = new ArenaField(BgmId); + break; + case 10: + _backGround = new PlazField(BgmId); + break; + case 11: + _backGround = new ForestNightField(BgmId); + break; + case 14: + _backGround = new RoyalPalaceNightField(BgmId); + break; + case 15: + _backGround = new TempleNightField(BgmId); + break; + case 17: + _backGround = new LaboratoryNightField(BgmId); + break; + case 18: + _backGround = new YuwanField(BgmId); + break; + case 20: + _backGround = new PlazRiotingField(BgmId); + break; + case 21: + _backGround = new HillField(BgmId); + break; + case 22: + _backGround = new AlleyField(BgmId); + break; + case 23: + _backGround = new HillRiotingField(BgmId); + break; + case 30: + _backGround = new IronField(BgmId); + break; + case 31: + _backGround = new NateField(BgmId); + break; + case 32: + _backGround = new Nat2Field(BgmId); + break; + case 33: + _backGround = new Nat3Field(BgmId); + break; + case 34: + _backGround = new Nat4Field(BgmId); + break; + case 41: + _backGround = new RivayleField(BgmId); + break; + case 42: + _backGround = new RivayleBackalleyField(BgmId); + break; + case 43: + _backGround = new VellsarDesertField(BgmId); + break; + case 51: + _backGround = new Field51(BgmId); + break; + case 52: + _backGround = new Field52(BgmId); + break; + case 61: + _backGround = new Field61(BgmId); + break; + case 62: + _backGround = new Field62(BgmId); + break; + case 71: + _backGround = new Field71(BgmId); + break; + case 72: + _backGround = new Field72(BgmId); + break; + case 73: + _backGround = new Field73(BgmId); + break; + case 74: + _backGround = new Field74(BgmId); + break; + case 75: + _backGround = new Field75(BgmId); + break; + case 76: + _backGround = new Field76(BgmId); + break; + case 1001: + _backGround = new SpecialArenaField(BgmId); + break; + case 1002: + _backGround = new llField(); + break; + case 1003: + _backGround = new PriConnField(BgmId); + break; + case 1004: + _backGround = new StageField(BgmId); + break; + case 1005: + _backGround = new Field1005(BgmId); + break; + case 1006: + _backGround = new Field1006(BgmId); + break; + case 1007: + _backGround = new Field1007(BgmId); + break; + case 1008: + _backGround = new Field1008(BgmId); + break; + case 1009: + _backGround = new Field1009(BgmId); + break; + case 1010: + _backGround = new Field1010(BgmId); + break; + case 1011: + _backGround = new Field1011(BgmId); + break; + case 1012: + _backGround = new Field1012(BgmId); + break; + } + } + + protected virtual OperateMgr CreateOperateMgr() + { + return new OperateMgr(this, TouchControl); + } + + protected virtual BattlePlayer CreateBattlePlayer() + { + return new BattlePlayer(this, _battleCamera, _backGround, CreatePlayerInnerOptionsBuilder()); + } + + protected virtual BattleEnemy CreateBattleEnemy() + { + return new BattleEnemy(this, _battleCamera, _backGround, CreateEnemyInnerOptionsBuilder()); + } + + public virtual IInnerOptionsBuilder CreatePlayerInnerOptionsBuilder() + { + return new PlayerInnerOptionsBuilder(BattleResourceMgr); + } + + public virtual IInnerOptionsBuilder CreateEnemyInnerOptionsBuilder() + { + return NullInnerOptionsBuilder.GetInstance(); + } + + public virtual void StartOpening(int FirstAttack) + { + LocalLog.AccumulateLastTraceLog("StartOpening"); + FirstAttack = GetFirstAttack(FirstAttack); + bool doesPlayerGoFirst = FirstAttack == 0; + SetupInitialGameState(doesPlayerGoFirst, areCardsRandomlyDrawn: true, 20, 20); + VfxBase vfx = ChangePhase(PhaseCreator.CreateOpeningPhase()); + SkillProcessor skillProcessor = new SkillProcessor(); + VfxBase vfx2 = BattlePlayer.StartSkillWhenBattleStart(skillProcessor); + VfxMgr.RegisterSequentialVfx(vfx); + VfxMgr.RegisterSequentialVfx(vfx2); + this.OnStartOpening.Call(IsFirst); + } + + public virtual void SetupInitialGameState(bool doesPlayerGoFirst, bool areCardsRandomlyDrawn, int playerMaxLife, int enemyMaxLife) + { + IsFirst = doesPlayerGoFirst; + IsRandomDraw = areCardsRandomlyDrawn; + InitializeClassLife(playerMaxLife, enemyMaxLife); + SetUpMyRotationBattle(playerMaxLife, enemyMaxLife); + SetupAvatarBattle(doesPlayerGoFirst); + TurnPanelControl.Initialize(); + SetupEvolCount(doesPlayerGoFirst); + } + + protected virtual void SetupInitialGameState(bool doesPlayerGoFirst, bool areCardsRandomlyDrawn, int playerCurrentLife, int enemyCurrentLife, int playerMaxLife, int enemyMaxLife, int playerEvolCount, int enemyEvolCount, int playerEvolWaitTurnCount, int enemyEvolWaitTurnCount, int playerInitialPp, int enemyInitialPp, int playerInitialCemeteryAmount, int enemyInitialCemeteryAmount, int currentTurnNumber, bool showTurnsLeftUntilEvolve) + { + IsFirst = doesPlayerGoFirst; + IsRandomDraw = areCardsRandomlyDrawn; + InitializeClassLife(playerMaxLife, enemyMaxLife); + TurnPanelControl.Initialize(showTurnsLeftUntilEvolve, showTurnsLeftUntilEvolve); + int maxEvolCount = (doesPlayerGoFirst ? FIRST_PLAYER_EP_NUM : SECOND_PLAYER_EP_NUM); + int maxEvolCount2 = ((!doesPlayerGoFirst) ? FIRST_PLAYER_EP_NUM : SECOND_PLAYER_EP_NUM); + InitializePlayer(BattlePlayer, playerEvolCount, maxEvolCount, playerEvolWaitTurnCount, playerInitialPp, playerInitialCemeteryAmount, playerCurrentLife, playerMaxLife); + InitializePlayer(BattleEnemy, enemyEvolCount, maxEvolCount2, enemyEvolWaitTurnCount, enemyInitialPp, enemyInitialCemeteryAmount, enemyCurrentLife, enemyMaxLife); + FirstTurn = currentTurnNumber; + SecondTurn = currentTurnNumber; + } + + public void SetupEvolCount(bool doesPlayerGoFirst) + { + BattlePlayerBase battlePlayerBase; + BattlePlayerBase battlePlayerBase2; + if (doesPlayerGoFirst) + { + battlePlayerBase = BattlePlayer; + battlePlayerBase2 = BattleEnemy; + } + else + { + battlePlayerBase = BattleEnemy; + battlePlayerBase2 = BattlePlayer; + } + SetPlayerInitialEp(battlePlayerBase, FIRST_PLAYER_EP_NUM, FIRST_PLAYER_EP_NUM, 5); + SetPlayerInitialEp(battlePlayerBase2, SECOND_PLAYER_EP_NUM, SECOND_PLAYER_EP_NUM, 4); + } + + public void SetPlayerInitialEp(BattlePlayerBase battlePlayerBase, int usableEp, int maxEp, int turnsLeftUntilCanEvolve) + { + battlePlayerBase.SetCurrentEpCount(usableEp); + battlePlayerBase.EpTotal = maxEp; + battlePlayerBase.EvolveWaitTurnCount = turnsLeftUntilCanEvolve; + } + + private void InitializeClassLife(int playerMaxLife, int enemyMaxLife) + { + ((ClassBattleCardBase)BattlePlayer.Class).InitBaseMaxLife(playerMaxLife); + ((ClassBattleCardBase)BattleEnemy.Class).InitBaseMaxLife(enemyMaxLife); + } + + private void InitializePlayer(BattlePlayerBase battlePlayerBase, int evolCount, int maxEvolCount, int evolWaitTurnCount, int initialPp, int initialCemeteryAmount, int currentLife, int maxLife) + { + SetPlayerInitialEp(battlePlayerBase, evolCount, maxEvolCount, evolWaitTurnCount); + battlePlayerBase.SetPpTotal(initialPp, isUpdatePp: true, null); + for (int i = 0; i < initialCemeteryAmount; i++) + { + BattleCardBase item = CardCreatorBase.CreateDummyInstance(); + battlePlayerBase.CemeteryList.Add(item); + } + if (currentLife < maxLife) + { + battlePlayerBase.Class.SkillApplyInformation.DamageLife(maxLife - currentLife, -1, isSelfTurn: false); + } + } + + protected virtual void SetupEvent() + { + BattlePlayer.OnTurnEndFinish += delegate + { + BattleResourceMgr.UnloadEffectBattle(); + BattlePlayer.PlayerBattleView.ResetTouchable(); + return NullVfx.GetInstance(); + }; + BattleEnemy.OnTurnEndFinish += delegate + { + BattleResourceMgr.UnloadEffectBattle(); + return NullVfx.GetInstance(); + }; + } + + public VfxBase ControlTurnStartPlayer() + { + return ControlTurnStart(BattleEnemy, BattlePlayer, IsFirst); + } + + public VfxBase ControlTurnStartOpponent() + { + return ControlTurnStart(BattlePlayer, BattleEnemy, !IsFirst); + } + + private VfxBase ControlTurnStart(BattlePlayerBase selfBattlePlayer, BattlePlayerBase opponentBattlePlayer, bool didPlayerGoFirst) + { + if (IsBattleEnd) + { + return NullVfx.GetInstance(); + } + int num = 0; + VfxBase result; + if (selfBattlePlayer.IsExtraTurn) + { + result = selfBattlePlayer.StartTurnControl("ExtraTurn"); + selfBattlePlayer.DecreasesExtraTurnCount(); + num = selfBattlePlayer.Turn; + } + else + { + result = opponentBattlePlayer.StartTurnControl("Normal"); + opponentBattlePlayer.DecreasesExtraTurnCount(); + num = opponentBattlePlayer.Turn; + } + if (num >= 1) + { + LocalLog.SetLastTraceLogTurn(num); + } + return result; + } + + public virtual void SetUpOperateEvent(OperateMgr operateMgr) + { + SetupEndTurnButtonEvents(operateMgr); + } + + public virtual void SetupBattlePlayersEvent() + { + BattlePlayer.OnSetupCardEvent += SetupCardEvent; + BattleEnemy.OnSetupCardEvent += SetupCardEvent; + BattlePlayer.OnSetupClassEvent += SetupPlayerClassEvent; + BattleEnemy.OnSetupClassEvent += SetupOpponentClassEvent; + BattlePlayer.Setup(BattleEnemy); + BattleEnemy.Setup(BattlePlayer); + BattlePlayer.OnTurnEnd += delegate + { + VfxMgr.Cancel(); + return NullVfx.GetInstance(); + }; + } + + public VfxBase LoadOpponentObjects() + { + VfxBase vfxBase = GetIns().SBattleLoad.NetworkBattleStartToLoadOpponentObjects(delegate + { + DelayLoadCompleteOpponentResources(); + }); + VfxMgr.RegisterSequentialVfx(vfxBase); + return vfxBase; + } + + protected virtual void DelayLoadCompleteOpponentResources() + { + SetupBattlePlayersEvent(); + } + + public virtual void SetupActionProcessorEvent(ActionProcessor processor, bool isPlayer) + { + GetBattlePlayer(isPlayer).SetupActionProcessorEvent(processor); + processor.OnAfterPlayCard += delegate + { + BattlePlayer.UpdateHandCardsPlayability(); + BattleEnemy.UpdateHandCardsPlayability(); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(BattlePlayer.UpdateInPlayBattleCardIconLabel()); + sequentialVfxPlayer.Register(JudgeBattleResult()); + return sequentialVfxPlayer; + }; + processor.OnBeforeAttack += JudgeBattleResult; + processor.OnAfterAttack += delegate + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(BattlePlayer.UpdateInPlayBattleCardIconLabel()); + sequentialVfxPlayer.Register(JudgeBattleResult()); + return sequentialVfxPlayer; + }; + processor.OnAfterEvolution += delegate + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(BattlePlayer.UpdateInPlayBattleCardIconLabel()); + sequentialVfxPlayer.Register(JudgeBattleResult()); + return sequentialVfxPlayer; + }; + processor.OnAfterFusion += delegate + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(BattlePlayer.UpdateInPlayBattleCardIconLabel()); + sequentialVfxPlayer.Register(JudgeBattleResult()); + return sequentialVfxPlayer; + }; + } + + protected virtual void SetupEndTurnButtonEvents(OperateMgr operateMgr) + { + SetupInstantEndTurnConditions(); + BattlePlayer.OnTurnStartAfterDraw += () => InstantVfx.Create(delegate + { + BattlePlayer.PlayerBattleView.UpdateTurnEndPulseEffect(); + }); + operateMgr.OnPlayerAttack += delegate + { + BattlePlayer.PlayerBattleView.UpdateTurnEndPulseEffect(); + BattlePlayer.UpdateHandCardsPlayability(); + return NullVfx.GetInstance(); + }; + operateMgr.OnPlayerEvolve += delegate + { + BattlePlayer.PlayerBattleView.UpdateTurnEndPulseEffect(); + return NullVfx.GetInstance(); + }; + operateMgr.OnPlayerFusion += delegate + { + BattlePlayer.PlayerBattleView.UpdateTurnEndPulseEffect(); + return NullVfx.GetInstance(); + }; + BattlePlayer.OnTurnEnd += delegate + { + BattlePlayer.PlayerBattleView.HideTurnEndPulseEffect(); + Prediction.Clear(); + return NullVfx.GetInstance(); + }; + } + + protected virtual void SetupInstantEndTurnConditions() + { + BattlePlayer.PlayerBattleView.OnCheckImmediateTurnEnd += delegate + { + if (BattlePlayer.CheckPlayableCards()) + { + return false; + } + return !BattlePlayer.CheckAttackableCards(); + }; + } + + public virtual VfxBase LoadTurnPanelResource() + { + return TurnPanelControl.LoadResource(); + } + + public void ReinitializeTurnPanelControl() + { + TurnPanelControl.Initialize(BattlePlayer.EvolveWaitTurnCount > 0, BattleEnemy.EvolveWaitTurnCount > 0); + } + + public virtual void Update(float dt) + { + VfxWith vfxWith = _phase.Update(dt); + VfxMgr.RegisterSequentialVfx(SequentialVfxPlayer.Create(vfxWith.Vfx, ChangePhase(vfxWith.Value))); + VfxMgr.Update(Time.deltaTime); + if (_backGround != null) + { + _backGround.UpdateFieldRandom(); + } + if (BattlePlayer.BattleView.PlayQueueView != null) + { + BattlePlayer.BattleView.PlayQueueView.UpdatePlayQueuePositions(Time.deltaTime); + } + if (BattleEnemy.BattleView.PlayQueueView != null) + { + BattleEnemy.BattleView.PlayQueueView.UpdatePlayQueuePositions(Time.deltaTime); + } + LocalLog.SubmitAccumulateLastTraceLog(); + } + + public virtual void Pause() + { + _phase.Pause(); + Prediction.Clear(); + } + + public IPhase GetCurrentPhase() + { + return _phase; + } + + public virtual void Resume() + { + } + + public virtual void FinishBattle() + { + } + + public void OnBattleSettingInfoClearIsNullClear() + { + this.OnBattleSettingInfoClear = null; + } + + public virtual void DisposeBattleGameObj() + { + BattleResourceMgr.Dispose(); + VfxMgr.Dispose(); + DetailMgr.Dispose(); + Data.BattleRecoveryInfo = null; + BattleLifeTimeSharedObject = null; + this.OnBattleSettingInfoClear.Call(); + BattleLogItem.ClearHeaderTextureCache(); + CardVoiceInfoCache.ClearCardVoiceInfo(); + NullBattleCardView.ReleaseSharedDummy(); + NullBattleCard.ReleaseSharedDummy(); + GameMgr.GetIns().GetEffectMgr().ClearBattleFeildEffect(); + GameMgr.GetIns().GetEffectMgr().RestUnneededEffect(); + _backGround.Dispose(); + _battleCamera.Dispose(); + Toolbox.ResourcesManager.RemoveAssetGroup(Toolbox.ResourcesManager.BattleListAssetPathList); + Toolbox.ResourcesManager.BattleListAssetPathList.Clear(); + RenderSettings.fog = false; + GameMgr.GetIns().GetEffectMgr().ImmediateDestroyBattleEffectContainer(); + if (PanelMgr != null) + { + DisposeBattleGameObj_DestroyImmediate(PanelMgr.gameObject); + } + DisposeBattleGameObj_DestroyImmediate(Battle3DContainer); + DisposeBattleGameObj_DestroyImmediate(BtlUIContainer); + DisposeBattleGameObj_DestroyImmediate(CutInContainer); + DisposeBattleGameObj_DestroyImmediate(SubParticleContainer); + DisposeBattleGameObj_DestroyImmediate(_unityEventAgentObject); + if (SubUI != null) + { + DisposeBattleGameObj_DestroyImmediate(SubUI.gameObject); + } + SBattleLoad.Dispoose(); + SBattleLoad = null; + BattlePlayer.Clear(); + BattleEnemy.Clear(); + BattlePlayer = null; + BattleEnemy = null; + EmoteUI = null; + _unityEventAgentObject = null; + PanelMgr = null; + PlayerCardParameterListInfo.Clear(); + EnemyCardParameterListInfo.Clear(); + PlayerCardParameterListInfo = null; + EnemyCardParameterListInfo = null; + TransformCardList.Clear(); + PublishedSkillList.Clear(); + Prediction.Dispose(); + Prediction = null; + TouchControl.Dispose(); + TouchControl = null; + EnemyAI = null; + BtlContainer = null; + BtlUIContainer = null; + CutInContainer = null; + CardHolder = null; + PCardPlace = null; + ECardHolder = null; + Arrow = null; + ArrowControl = null; + AttackArrowHead = null; + EvolutionArrowHead = null; + AlertDialogue = null; + TurnPanelControl = null; + BattleResult = null; + BattleResultControl = null; + BattleStart = null; + BattleStartControl = null; + MenuButtonObject = null; + Battle3DContainer = null; + SubUI = null; + SubParticleContainer = null; + UIManager.GetInstance().DestroyView(UIManager.ViewScene.Battle); + GameMgr.GetIns().GetPrefabMgr().DisposeAllClonedObject(); + GameMgr.GetIns().GetGameObjMgr().DisposeUIGameObj(); + GameMgr.GetIns().GetPrefabMgr().AllUnLoad(); + main = null; + } + + private void DisposeBattleGameObj_DestroyImmediate(GameObject obj) + { + if (obj != null) + { + UnityEngine.Object.DestroyImmediate(obj); + } + } + + public VfxBase TurnEnd(bool isPlayer) + { + IsTurnEnd = true; + VfxBase result = GetBattlePlayer(isPlayer).TurnEnd(); + IsTurnEnd = false; + return result; + } + + public virtual VfxBase StartBattle() + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + LocalLog.SetLastTraceLogTurn(1); + sequentialVfxPlayer.Register(ChangePhase(PhaseCreator.CreateMainPhase())); + if (IsRecovery) + { + return sequentialVfxPlayer; + } + if (IsFirst) + { + sequentialVfxPlayer.Register(BattlePlayer.StartTurnControl()); + } + else + { + sequentialVfxPlayer.Register(BattleEnemy.StartTurnControl()); + } + return sequentialVfxPlayer; + } + + public virtual VfxBase ChangePhase(IPhase phase) + { + if (phase == null) + { + return NullVfx.GetInstance(); + } + LocalLog.AccumulateLastTraceLog("ChangePhase" + phase.ToString()); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (_phase != null) + { + VfxBase vfx = _phase.Teardown(); + sequentialVfxPlayer.Register(vfx); + } + _phase = phase; + VfxBase vfx2 = _phase.Setup(); + sequentialVfxPlayer.Register(vfx2); + return sequentialVfxPlayer; + } + + public BattleControl GetBattleControl() + { + return GameMgr.GetIns().GetBattleCtrl(); + } + + public CardParameterListInfo GetCardParameterListInfo(bool isPlayer) + { + if (!isPlayer) + { + return EnemyCardParameterListInfo; + } + return PlayerCardParameterListInfo; + } + + public BattlePlayerBase GetBattlePlayer(bool isPlayer) + { + if (isPlayer) + { + return BattlePlayer; + } + return BattleEnemy; + } + + public BattlePlayerPair GetBattlePlayerPair(bool isPlayer) + { + BattlePlayerBase battlePlayer = GetBattlePlayer(isPlayer); + BattlePlayerBase battlePlayer2 = GetBattlePlayer(!isPlayer); + return new BattlePlayerPair(battlePlayer, battlePlayer2); + } + + public BattlePlayerReadOnlyInfoPair GetBattlePlayerInfoPair(bool isPlayer) + { + BattlePlayerBase battlePlayer = GetBattlePlayer(isPlayer); + BattlePlayerBase battlePlayer2 = GetBattlePlayer(!isPlayer); + return new BattlePlayerReadOnlyInfoPair(battlePlayer, battlePlayer2); + } + + public Transform GetBattle3DContainerChild(string childName) + { + return Battle3DContainer.transform.Find(childName); + } + + public virtual int StableRandom(int val) + { + if (IsForecast) + { + return 0; + } + stableRandomCount++; + randomResult = _stableRandom.NextDouble(); + return (int)Math.Floor((double)val * randomResult); + } + + public double StableRandomDouble() + { + if (IsForecast) + { + return 0.0; + } + stableRandomCount++; + randomResult = _stableRandom.NextDouble(); + return randomResult; + } + + public int StableRandomOnlySelf(int val) + { + if (IsForecast) + { + return 0; + } + return _stableRandomOnlySelf.Next(val); + } + + public BattleCardBase GetBattleCardIdx(IList list, int idx) + { + return list.SingleOrDefault((BattleCardBase c) => c.Index == idx); + } + + public virtual BattleCardBase MetamorphoseCard(int cardId, bool isPlayer, int addIndex, SkillBase skill, bool isFusion = false) + { + return CreateBattleCardWithGameObject(new CardCreateInfo(cardId, isPlayer, skill.ApplyingTargetFilter is SkillTargetChosenCardsFilter, NetworkBattleDefine.NetworkCardPlaceState.None, isReferenceOpponentCard: false, skill), new IndexInfo(addIndex)); + } + + public virtual BattleCardBase CreateBattleCardWithGameObject(CardCreateInfo info, IndexInfo indexInfo, int repeatCount = -1, bool isVirtual = false, bool isActualCard = false) + { + CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(info.Id); + BattlePlayerBase battlePlayer = GetBattlePlayer(info.IsPlayer); + int cardIndex = SetupCardIndex(battlePlayer, indexInfo.AddIndex); + GameObject cardGameObject = null; + if (!IsRecovery || !isVirtual) + { + cardGameObject = CreateBaseCardGameObject(cardParameterFromId, info.IsPlayer, cardIndex); + } + BattleCardBase battleCardBase = CreateBattleCard(info.Id, info.IsPlayer, cardGameObject, cardParameterFromId, battlePlayer, cardIndex, info.Cost); + SetupCardObjectMaterials(cardGameObject, battleCardBase); + return battleCardBase; + } + + public BattleCardBase CreateBattleCard(int cardId, bool isPlayer, GameObject cardGameObject, CardParameter cardParameter, BattlePlayerBase battlePlayer, int cardIndex, int cost = -1) + { + BattleCardBase battleCardBase = CardCreatorBase.CreateToken(CreateCardBuildInfo(cardGameObject, cardParameter, isPlayer, cardIndex, cardId), cardGameObject == null); + battleCardBase.IsTokenLoad = true; + battlePlayer.SetupCardEvent(battleCardBase); + if (cost != -1) + { + battleCardBase.CostModifierList.Add(new CostSetModifier(cost)); + } + return battleCardBase; + } + + public BattleCardBase CreateTransformCardRegisterVfx(BattleCardBase originalCard, int tokenId, bool isPlayer, VfxMgr predictionVfxMgr = null, bool isRecoveryFinish = false, bool isChoice = false) + { + BattleCardBase battleCardBase = null; + if (!IsRecovery || isRecoveryFinish) + { + battleCardBase = CreateTransformCardWithGameObject(tokenId, originalCard, isPlayer, isChoice); + } + else + { + battleCardBase = TransformCardList.FirstOrDefault((BattleCardBase c) => c.CardId == tokenId && c.IsPlayer == isPlayer); + if (battleCardBase == null) + { + CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(tokenId); + battleCardBase = CreateChoiceCard(tokenId, isPlayer, null, cardParameterFromId, GetBattlePlayer(isPlayer)); + } + } + battleCardBase.TransformInfo = new BattleCardBase.TransformInformation(battleCardBase.TransformInfo.Type, originalCard); + return battleCardBase; + } + + protected virtual BattleCardBase CreateTransformCardWithGameObject(int cardId, BattleCardBase originalCard, bool isPlayer, bool isChoice) + { + BattleCardBase battleCardBase = TransformCardList.FirstOrDefault((BattleCardBase c) => c.CardId == cardId && c.IsPlayer == isPlayer && (isChoice || c.TransformInfo.OriginalCard == originalCard)); + if (battleCardBase == null) + { + CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(cardId); + BattlePlayerBase battlePlayer = GetBattlePlayer(isPlayer); + GameObject cardGameObject = CreateBaseCardGameObject(cardParameterFromId, isPlayer, cardId); + battleCardBase = CreateChoiceCard(cardId, isPlayer, cardGameObject, cardParameterFromId, battlePlayer); + SetupCardObjectMaterials(cardGameObject, battleCardBase); + TransformCardList.Add(battleCardBase); + } + return battleCardBase; + } + + protected BattleCardBase CreateChoiceCard(int cardId, bool isPlayer, GameObject cardGameObject, CardParameter cardParameter, BattlePlayerBase battlePlayer) + { + BattleCardBase battleCardBase = CardCreatorBase.CreateToken(CreateCardBuildInfo(cardGameObject, cardParameter, isPlayer, cardId, cardId), cardGameObject == null); + battleCardBase.IsTokenLoad = true; + return battleCardBase; + } + + public BattleCardBase CreateFusionCard(int cardId, bool isPlayer) + { + CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(cardId); + return CardCreatorBase.CreateToken(CreateCardBuildInfo(null, cardParameterFromId, isPlayer, cardId, cardId), createNullView: true); + } + + public BattleCardBase ReplaceChoiceBraveCard(BattleCardBase originalCard, int cardId, BattleCardBase selectSkillCard) + { + BattleCardBase choiceBraveCard = originalCard.SelfBattlePlayer.CreateCard(cardId, originalCard.SelfBattlePlayer.Class.Index, isChoiceBrave: true); + choiceBraveCard.BattleCardView.GameObject.SetActive(value: false); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(ParallelVfxPlayer.Create(choiceBraveCard.SelfBattlePlayer.BattleMgr.LoadCardResources(new List { choiceBraveCard }), InstantVfx.Create(delegate + { + if (!IsRecovery) + { + Transform transform = choiceBraveCard.BattleCardView.Transform; + Transform transform2 = ((selectSkillCard != null) ? selectSkillCard.BattleCardView.Transform : originalCard.SelfBattlePlayer.BattleView.ChoiceBraveButtonTransform); + transform.position = ((selectSkillCard != null) ? transform2.position : new Vector3(transform2.position.x, transform2.position.y, 0f)); + transform.rotation = transform2.rotation; + transform.parent = originalCard.SelfBattlePlayer.BattleView.HandDeck.transform; + transform.localScale = transform2.localScale; + transform.SetSiblingIndex(transform2.GetSiblingIndex()); + choiceBraveCard.BattleCardView.GameObject.SetActive(value: true); + } + }))); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + if (selectSkillCard != null) + { + selectSkillCard.BattleCardView.GameObject.SetActive(value: false); + } + })); + choiceBraveCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(sequentialVfxPlayer); + return choiceBraveCard; + } + + protected GameObject CreateBaseCardGameObject(CardParameter cardParameter, bool isPlayer, int cardIndex) + { + GameObject gameObject = null; + if (cardParameter.CharType == CardBasePrm.CharaType.NORMAL) + { + gameObject = GameMgr.GetIns().GetPrefabMgr().CloneObjectToParent(SBattleLoad.UnitCardTemplate.gameObject, _backGround.m_Battle3DContainer); + } + else if (cardParameter.CharType == CardBasePrm.CharaType.SPELL) + { + gameObject = GameMgr.GetIns().GetPrefabMgr().CloneObjectToParent(SBattleLoad.SpellCardTemplate.gameObject, _backGround.m_Battle3DContainer); + } + else if (cardParameter.CharType == CardBasePrm.CharaType.FIELD || cardParameter.CharType == CardBasePrm.CharaType.CHANT_FIELD) + { + gameObject = GameMgr.GetIns().GetPrefabMgr().CloneObjectToParent(SBattleLoad.FieldCardTemplate.gameObject, _backGround.m_Battle3DContainer); + gameObject.transform.Find("CardObj/NormalField").gameObject.SetActive(value: false); + } + SetupCardObjectTags(gameObject, isPlayer, cardIndex); + return gameObject; + } + + private void SetupCardObjectTags(GameObject cardGameObject, bool isPlayer, int cardIndex) + { + string tag; + string text; + if (isPlayer) + { + tag = "PlayerToken"; + text = "P"; + } + else + { + tag = "Enemy"; + text = "E"; + } + cardGameObject.tag = tag; + cardGameObject.transform.Find("CardObj").tag = tag; + cardGameObject.transform.Find("Collider").tag = tag; + cardGameObject.name = text + cardIndex; + } + + protected void SetupCardObjectMaterials(GameObject cardGameObject, BattleCardBase battleCard) + { + cardGameObject.GetComponent().DynamicSetupMaterials(battleCard, BattleResourceMgr); + cardGameObject.SetActive(value: false); + cardGameObject.transform.localPosition = Vector3.zero; + cardGameObject.transform.localScale = Global.CARD_BATTLE_SCALE; + cardGameObject.transform.rotation = Quaternion.identity; + } + + protected int SetupCardIndex(BattlePlayerBase battlePlayer, int cardIndex) + { + if (cardIndex == -1) + { + cardIndex = battlePlayer.cardTotalNum; + battlePlayer.cardTotalNum++; + } + return cardIndex; + } + + private BattleCardBase.BuildInfo CreateCardBuildInfo(GameObject cardGameObject, CardParameter cardParameter, bool isPlayer, int cardIndex, int cardId) + { + SkillCreator.CardSkillsBuildInfo cardSkillsBuildInfo = SkillCreator.CreateBuildInfo(cardParameter); + IInnerOptionsBuilder innerOptionsBuilder = (isPlayer ? CreatePlayerInnerOptionsBuilder() : CreateEnemyInnerOptionsBuilder()); + bool isPlayer2 = isPlayer; + return new BattleCardBase.BuildInfo(cardGameObject, cardId, GetBattlePlayer(isPlayer), GetBattlePlayer(!isPlayer), GetBattlePlayer(isPlayer), cardSkillsBuildInfo.normalSkillBuildInfos, cardSkillsBuildInfo.evolveSkillBuildInfos, isPlayer2, cardIndex, innerOptionsBuilder.CreateCardOptions(), this, BattleResourceMgr); + } + + public virtual VfxBase JudgeBattleResult() + { + if (BattlePlayer.Class.IsDead && BattleEnemy.Class.IsDead) + { + return InstantVfx.Create(delegate + { + InitiateGameEndSequence(!BattlePlayer.IsSelfTurn); + }); + } + if (BattlePlayer.Class.IsDead) + { + return InstantVfx.Create(delegate + { + InitiateGameEndSequence(hasWon: false); + }); + } + if (BattleEnemy.Class.IsDead) + { + return InstantVfx.Create(delegate + { + InitiateGameEndSequence(hasWon: true); + }); + } + return NullVfx.GetInstance(); + } + + public VfxBase DeadClass(bool PlayerDead, FINISH_TYPE finishType) + { + ClassBattleCardBase classBattleCardBase = (ClassBattleCardBase)GetBattlePlayer(PlayerDead).Class; + if (GameMgr.GetIns().IsReplayBattle && !classBattleCardBase.ClassBattleCardView.InPlayModelActive) + { + return NullVfx.GetInstance(); + } + switch ((int)finishType) + { + case 0: + return classBattleCardBase.SelfBattlePlayer.CardManagement(classBattleCardBase, new SkillProcessor(), BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false); + case 1: + if (IsBothClassDead(PlayerDead)) + { + return NullVfx.GetInstance(); + } + classBattleCardBase.FlagCardAsDestroyedBySkill(); + return classBattleCardBase.Retire(); + case 2: + if (IsBothClassDead(PlayerDead)) + { + return NullVfx.GetInstance(); + } + return classBattleCardBase.DestroyBySpecialWin(); + default: + return classBattleCardBase.SelfBattlePlayer.CardManagement(classBattleCardBase, new SkillProcessor(), BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false); + } + } + + private bool IsBothClassDead(bool isPlayer) + { + ClassBattleCardBase obj = (ClassBattleCardBase)GetBattlePlayer(isPlayer).Class; + ClassBattleCardBase classBattleCardBase = (ClassBattleCardBase)GetBattlePlayer(!isPlayer).Class; + if (obj.IsDead && classBattleCardBase.IsDead) + { + return true; + } + return false; + } + + protected virtual int GetFirstAttack(int FirstAttack) + { + return UnityEngine.Random.Range(0, 2); + } + + public virtual void SetupEnemyAI() + { + EnemyAI = new EnemyAINull(); + } + + public virtual void SetupPlayerClassEvent() + { + } + + public virtual void SetupOpponentClassEvent() + { + } + + public virtual void SetupCardEvent(BattleCardBase card) + { + } + + public virtual void InitiateGameEndSequence(bool hasWon) + { + if (GameMgr.GetIns().IsReplayBattle && !GameMgr.GetIns().IsNewReplayBattle) + { + hasWon = Data.ReplayBattleInfo.is_win; + } + IResultPhase resultPhase = PhaseCreator.CreateResultPhase(hasWon); + if (hasWon) + { + resultPhase.OnSetupEnd += this.OnWin; + } + VfxBase vfx = ChangePhase(resultPhase); + VfxMgr.RegisterSequentialVfx(vfx); + this.OnBattleFinish.Call(hasWon); + } + + public virtual VfxBase PlaySpecialWin(BattlePlayerBase winPlayer) + { + GetIns().VfxMgr.RegisterImmediateVfx(new CanNotTouchCardVfx()); + bool playerDead = !winPlayer.IsPlayer; + return SequentialVfxPlayer.Create(DeadClass(playerDead, FINISH_TYPE.SPECIAL_WIN), InstantVfx.Create(delegate + { + InitiateGameEndSequence(winPlayer.IsPlayer); + })); + } + + public virtual void PlayRetire() + { + GetIns().VfxMgr.RegisterImmediateVfx(new CanNotTouchCardVfx()); + if (!GetBattlePlayer(isPlayer: true).Class.IsDead) + { + BattlePlayer.BattleView.HideTurnEndButton(); + IsPlayerRetire = true; + VfxMgr.RegisterSequentialVfx(DeadClass(PlayerDead: true, FINISH_TYPE.RETIRE)); + VfxMgr.RegisterSequentialVfx(InstantVfx.Create(delegate + { + InitiateGameEndSequence(hasWon: false); + })); + } + } + + public void MulliganSubmit() + { + VfxMgr.RegisterSequentialVfx(this.OnSubmitMulligan.GetAllFuncVfxResults()); + } + + public void ChangeCameraFieldOfView(float aspectRatio) + { + if ((bool)Battle3DContainer) + { + int num = CalculateCameraFieldOfView(aspectRatio); + int num2 = CalculateBackgroundCameraFieldOfView(aspectRatio); + Transform transform = Battle3DContainer.transform.Find("Camera"); + Camera component; + Camera camera = (component = transform.GetComponent()); + component.fieldOfView = num; + component = transform.Find("Camera 3DGround").GetComponent(); + component.fieldOfView = num2; + (_subParticleCamera = transform.Find("Camera SubParticles").GetComponent()).fieldOfView = num; + component = transform.Find("Camera BattleUnder").GetComponent(); + component.fieldOfView = num; + Transform transform2 = Battle3DContainer.transform.Find("Camera HighRankEvolve"); + if (transform2 == null) + { + transform2 = transform.transform.Find("Camera HighRankEvolve"); + } + Camera component2 = transform2.GetComponent(); + component2.fieldOfView = num; + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + if (dataMgr.Is3DSkin(isPlayer: true)) + { + component2.depth = 40f; + } + if (dataMgr.GetPlayerCharaData().IsNoEvolveShift) + { + component2.transform.SetParent(camera.transform); + } + component = CutInContainer.transform.Find("Camera").GetComponent(); + component.fieldOfView = num; + } + } + + private int CalculateCameraFieldOfView(float aspectRatio) + { + if (!(aspectRatio < 1.5f)) + { + _ = Global.NormalFieldOfView; + } + else + { + _ = Global.WideFieldOfView; + } + float num = aspectRatio - 1.5f; + return Mathf.Clamp((int)((float)(Global.WideFieldOfView + Global.NormalFieldOfView) / 2f * (1f - num)), Global.NormalFieldOfView, Global.WideFieldOfView); + } + + private int CalculateBackgroundCameraFieldOfView(float aspectRatio) + { + return CalculateCameraFieldOfView(aspectRatio); + } + + public bool CanOpenEvolutionConfirmation(BattleCardBase card) + { + if (IsStopOperate || !card.IsInplay || !card.SelfBattlePlayer.IsSelfTurn || !card.IsPlayer || !card.IsUnit || GameMgr.GetIns().IsWatchBattle) + { + return false; + } + return card.CanEvolution(isSkill: false, isSelfBattlePlayer: true); + } + + protected virtual SequentialVfxPlayer OnShortageDeck(BattlePlayerBase battlePlayer) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (battlePlayer.IsShortageDeckWin) + { + sequentialVfxPlayer.Register(new DeckOutWinVfx(battlePlayer)); + sequentialVfxPlayer.Register(DeadClass(!battlePlayer.IsPlayer, FINISH_TYPE.SPECIAL_WIN)); + battlePlayer.Class.OpponentBattlePlayer.Class.FlagCardAsDestroyedBySkill(); + } + else + { + if (battlePlayer.IsPlayer) + { + sequentialVfxPlayer.Register(new PlayerDeckOutVfx(BattlePlayer, this)); + BattlePlayer.SetIsShortageDeckLose(flag: true); + } + else + { + sequentialVfxPlayer.Register(new EnemyDeckOutVfx(BattleEnemy, this)); + BattleEnemy.SetIsShortageDeckLose(flag: true); + } + sequentialVfxPlayer.Register(DeadClass(battlePlayer.IsPlayer, FINISH_TYPE.NORMAL)); + } + return sequentialVfxPlayer; + } + + public SkillCardLimitUpperCountFilter CheackCalledCreateFilterDictionary(IReadOnlyBattleCardInfo ownerCard, string partText, string infoText) + { + SkillCardLimitUpperCountFilter result = null; + CalledCreateFilterPair calledFilterPair = new CalledCreateFilterPair(ownerCard, partText); + if (_calledCreateLimitFilterDictionary.Any((KeyValuePair c) => c.Key.Equal(calledFilterPair))) + { + KeyValuePair keyValuePair = _calledCreateLimitFilterDictionary.FirstOrDefault((KeyValuePair c) => c.Key.Equal(calledFilterPair)); + if (keyValuePair.Value != null) + { + result = keyValuePair.Value; + } + } + else if (SkillFilterCreator.COUNT_EXTENSIONS_FILTER_NAMES.Any((string n) => Regex.IsMatch(partText, "^" + n + "[<>!:=]=?"))) + { + SkillCardLimitUpperCountFilter skillCardLimitUpperCountFilter = new SkillCardLimitUpperCountFilter(infoText); + result = skillCardLimitUpperCountFilter; + if (!IsVirtualBattleEnemyTurn) + { + _calledCreateLimitFilterDictionary.Add(calledFilterPair, skillCardLimitUpperCountFilter); + } + } + else if (!IsVirtualBattleEnemyTurn) + { + _calledCreateLimitFilterDictionary.Add(calledFilterPair, null); + } + return result; + } + + public SkillOrFilter CheackCalledCreateOrFilterDictionary(IReadOnlyBattleCardInfo ownerCard, string partText, string infoText) + { + SkillOrFilter result = null; + CalledCreateFilterPair calledFilterPair = new CalledCreateFilterPair(ownerCard, partText); + if (_calledCreateOrFilterDictionary.Any((KeyValuePair c) => c.Key.Equal(calledFilterPair))) + { + KeyValuePair keyValuePair = _calledCreateOrFilterDictionary.FirstOrDefault((KeyValuePair c) => c.Key.Equal(calledFilterPair)); + if (keyValuePair.Value != null) + { + result = keyValuePair.Value; + } + } + else + { + string text = SkillFilterCreator.ContentKeyword.or.ToStringCustom(); + if (Regex.IsMatch(partText, "^" + text + "[<>!:=]=?")) + { + SkillOrFilter skillOrFilter = new SkillOrFilter(int.Parse(infoText)); + result = skillOrFilter; + if (!IsVirtualBattleEnemyTurn) + { + _calledCreateOrFilterDictionary.Add(calledFilterPair, skillOrFilter); + } + } + else if (!IsVirtualBattleEnemyTurn) + { + _calledCreateOrFilterDictionary.Add(calledFilterPair, null); + } + } + return result; + } + + public ISkillCardFilter CheackCalledCreateSkillCardFilterDictionary(IReadOnlyBattleCardInfo ownerCard, string partText, string infoText) + { + ISkillCardFilter result = null; + CalledCreateFilterPair calledFilterPair = new CalledCreateFilterPair(ownerCard, partText); + if (_calledCreateFilterDictionary.Any((KeyValuePair c) => c.Key.Equal(calledFilterPair))) + { + KeyValuePair keyValuePair = _calledCreateFilterDictionary.FirstOrDefault((KeyValuePair c) => c.Key.Equal(calledFilterPair)); + if (keyValuePair.Value != null) + { + result = keyValuePair.Value; + } + } + else if (SkillFilterCreator.CARD_PARAMETER_COMPARE_FILTER_NAMES.Any((string n) => Regex.IsMatch(partText, "^" + n + "[<>!:=]=?"))) + { + ISkillCardFilter skillCardFilter = SkillFilterCreator.CreateCardParameterCompareFilter(partText, ownerCard); + result = skillCardFilter; + if (!IsVirtualBattleEnemyTurn) + { + _calledCreateFilterDictionary.Add(calledFilterPair, skillCardFilter); + } + } + else if (!IsVirtualBattleEnemyTurn) + { + _calledCreateFilterDictionary.Add(calledFilterPair, null); + } + return result; + } + + public void RemoveUnUseCalledFilterDictionary() + { + if (IsVirtualBattleEnemyTurn) + { + return; + } + List list = new List(); + foreach (KeyValuePair item in new Dictionary(_calledCreateFilterDictionary)) + { + if (item.Key.HasOwnerCard()) + { + if (item.Key.IsOwnerCardDead()) + { + list.Add(item.Key); + } + } + else + { + list.Add(item.Key); + } + } + foreach (CalledCreateFilterPair item2 in list) + { + _calledCreateFilterDictionary.Remove(item2); + } + list.Clear(); + foreach (KeyValuePair item3 in new Dictionary(_calledCreateLimitFilterDictionary)) + { + if (item3.Key.HasOwnerCard()) + { + if (item3.Key.IsOwnerCardDead()) + { + list.Add(item3.Key); + } + } + else + { + list.Add(item3.Key); + } + } + foreach (CalledCreateFilterPair item4 in list) + { + _calledCreateLimitFilterDictionary.Remove(item4); + } + list.Clear(); + foreach (KeyValuePair item5 in new Dictionary(_calledCreateOrFilterDictionary)) + { + if (item5.Key.HasOwnerCard()) + { + if (item5.Key.IsOwnerCardDead()) + { + list.Add(item5.Key); + } + } + else + { + list.Add(item5.Key); + } + } + foreach (CalledCreateFilterPair item6 in list) + { + _calledCreateOrFilterDictionary.Remove(item6); + } + } + + protected void SetUpMyRotationBattle(int playerMaxLife, int enemyMaxLife) + { + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + MyRotationInfo myRotationInfo; + bool flag = dataMgr.TryGetPlayerMyRotationInfo(out myRotationInfo); + MyRotationInfo myRotationInfo2; + bool flag2 = dataMgr.TryGetEnemyMyRotationInfo(out myRotationInfo2); + if (!flag && !flag2) + { + return; + } + List list = new List(); + if (flag) + { + for (int i = 0; i < myRotationInfo.Abilities.Count; i++) + { + MyRotationInfo.MyRotationBonus myRotationBonus = myRotationInfo.Abilities[i]; + for (int j = 0; j < myRotationBonus.AttachAbilities.Length; j++) + { + AttachInfo attachInfo = AddAttachSkillToClass(isPlayer: true, myRotationBonus.AttachAbilities[j], myRotationBonus.AbilityId); + if (attachInfo != null) + { + list.Add(attachInfo); + } + } + BattlePlayer.PpTotal += myRotationBonus.AddStartPp; + playerMaxLife += myRotationBonus.AddStartLife; + BattlePlayer.BonusConditionList.Add(new BattlePlayerBase.MyRotationBonusCondition(myRotationBonus)); + } + } + if (flag2) + { + for (int k = 0; k < myRotationInfo2.Abilities.Count; k++) + { + MyRotationInfo.MyRotationBonus myRotationBonus2 = myRotationInfo2.Abilities[k]; + for (int l = 0; l < myRotationBonus2.AttachAbilities.Length; l++) + { + AttachInfo attachInfo2 = AddAttachSkillToClass(isPlayer: false, myRotationBonus2.AttachAbilities[l], myRotationBonus2.AbilityId); + if (attachInfo2 != null) + { + list.Add(attachInfo2); + } + } + BattleEnemy.PpTotal += myRotationBonus2.AddStartPp; + enemyMaxLife += myRotationBonus2.AddStartLife; + BattleEnemy.BonusConditionList.Add(new BattlePlayerBase.MyRotationBonusCondition(myRotationBonus2)); + } + } + for (int m = 0; m < list.Count; m++) + { + AttachInfo attachInfo3 = list[m]; + SkillBase attachSkill = Skill_attach_skill.CreateAndAttachSkill(attachInfo3._classCard, attachInfo3._attachSkill, attachInfo3._targetSkillBuildInfo); + IDetailPanelControl detailPanel = DetailMgr.DetailPanelControl; + if (!attachSkill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessRemoveAfterAction)) + { + continue; + } + attachSkill.OnSkillStart += delegate + { + attachSkill.OnSkillEnd += delegate + { + if (attachSkill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessRemoveAfterAction && (s as SkillPreprocessRemoveAfterAction).IsEnd())) + { + List list2 = (attachInfo3._classCard.IsPlayer ? BattlePlayer.BonusConditionList : BattleEnemy.BonusConditionList); + BattlePlayerBase.MyRotationBonusCondition myRotationBonusCondition = list2.FirstOrDefault((BattlePlayerBase.MyRotationBonusCondition b) => b.MyRotationBonus.AbilityId == attachInfo3._myRotationBonusId); + myRotationBonusCondition.ReduceSkillCount(); + myRotationBonusCondition.UseUpSkill(); + if (detailPanel._card != null && detailPanel._card.IsClass && detailPanel._card.IsPlayer == attachInfo3._classCard.IsPlayer) + { + detailPanel.UpdateBuffInfo(attachInfo3._classCard, list2); + } + } + return NullVfx.GetInstance(); + }; + }; + } + BattlePlayer.SetPpTotal(BattlePlayer.PpTotal, isUpdatePp: true, null); + BattleEnemy.SetPpTotal(BattleEnemy.PpTotal, isUpdatePp: true, null); + InitializeClassLife(playerMaxLife, enemyMaxLife); + } + + protected void SetupAvatarBattle(bool doesPlayerGoFirst) + { + if (Data.CurrentFormat == Format.Avatar) + { + GameMgr.GetIns().GetDataMgr(); + if (doesPlayerGoFirst) + { + SetupSpecifiedPlayerAvatarBattle(isPlayer: true); + SetupSpecifiedPlayerAvatarBattle(isPlayer: false); + } + else + { + SetupSpecifiedPlayerAvatarBattle(isPlayer: false); + SetupSpecifiedPlayerAvatarBattle(isPlayer: true); + } + } + } + + private void SetupSpecifiedPlayerAvatarBattle(bool isPlayer) + { + DataMgr dataMgr = GameMgr.GetIns().GetDataMgr(); + if ((!isPlayer) ? dataMgr.TryGetEnemyAvatarBattleInfo(out var avatarBattleInfo) : dataMgr.TryGetPlayerAvatarBattleInfo(out avatarBattleInfo)) + { + SetupPlayerAvatarBattle(isPlayer ? ((BattlePlayerBase)BattlePlayer) : ((BattlePlayerBase)BattleEnemy), avatarBattleInfo); + } + } + + private void SetupPlayerAvatarBattle(BattlePlayerBase battlePlayerBase, AvatarBattleInfo avatarBattleInfo) + { + battlePlayerBase.AvatarBattleInfo = avatarBattleInfo; + AvatarBattleInfo.AvatarBattleBonus bonus = avatarBattleInfo.Bonus; + string[] abilities = bonus.Abilities; + List list = new List(); + for (int i = 0; i < abilities.Length; i++) + { + AttachInfo attachInfo = AddAttachSkillToClass(battlePlayerBase is BattlePlayer, abilities[i]); + if (attachInfo != null) + { + list.Add(attachInfo); + } + } + for (int j = 0; j < list.Count; j++) + { + AttachInfo attachInfo2 = list[j]; + Skill_attach_skill.CreateAndAttachSkill(attachInfo2._classCard, attachInfo2._attachSkill, attachInfo2._targetSkillBuildInfo); + } + battlePlayerBase.AvatarBattlePassiveSkillDescInfo = new BattlePlayerBase.AvatarBattleDescInfo(avatarBattleInfo.Bonus.PassiveAbilityDesc, ""); + battlePlayerBase.ChoiceBraveSkillDescInfoList = new List(); + for (int k = 0; k < bonus.AbilityDesc.Count(); k++) + { + battlePlayerBase.ChoiceBraveSkillDescInfoList.Add(new BattlePlayerBase.AvatarBattleDescInfo(bonus.AbilityDesc[k], bonus.AbilityCosts[k])); + } + VfxMgr.RegisterImmediateVfx(battlePlayerBase.SetBp(battlePlayerBase.IsGameFirst ? bonus.BattleStartFirstPlayerTurnBp : bonus.BattleStartSecondPlayerTurnBp)); + ((ClassBattleCardBase)battlePlayerBase.Class).InitBaseMaxLife(bonus.BattleStartMaxLife); + } + + protected AttachInfo AddAttachSkillToClass(bool isPlayer, string skillText, string myRotationBonusId = "") + { + if (skillText == string.Empty) + { + return null; + } + SkillCreator.SkillBuildInfo targetSkillBuildInfo = Skill_attach_skill.CreateAttachSkillBuildInfo(skillText); + BattleCardBase battleCardBase = null; + battleCardBase = ((!isPlayer) ? BattleEnemy.ClassAndInPlayCardList.First((BattleCardBase c) => c is ClassBattleCardBase) : BattlePlayer.ClassAndInPlayCardList.First((BattleCardBase c) => c is ClassBattleCardBase)); + SkillCreator.SkillBuildInfo skillBuildInfo = new SkillCreator.SkillBuildInfo("attach_skill", "none", "character=me", "character=me&target=inplay&card_type=class", "skill=" + skillText, "none"); + SkillBase skillBase = battleCardBase.CreateSkillCreator(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer, BattleResourceMgr).Create(skillBuildInfo, null, isAttachSkill: true); + battleCardBase.NormalSkills.Add(skillBase); + battleCardBase.NormalSkillBuildInfos.Add(skillBuildInfo); + return new AttachInfo(battleCardBase, skillBase, targetSkillBuildInfo, myRotationBonusId); + } + + public static bool IsCardPrivate(BattleCardBase card) + { + if (!card.IsPlayer) + { + if (!card.IsInHand) + { + return card.IsInDeck; + } + return true; + } + return false; + } + + public VfxBase LoadCardResources(List cards, bool isRecoveryFinish = false) + { + if (cards.Count == 0) + { + return NullVfx.GetInstance(); + } + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + List list = new List(); + for (int i = 0; i < cards.Count; i++) + { + BattleCardBase battleCardBase = cards[i]; + if (battleCardBase != null) + { + parallelVfxPlayer.Register(battleCardBase.BattleCardView.GetResourcePathes(list)); + parallelVfxPlayer.Register(battleCardBase.BattleCardView.GetChoiceTransformCardsResourcePathes(battleCardBase, list, isRecoveryFinish)); + } + } + List list2 = new List(); + Action action = delegate + { + }; + for (int num = 0; num < list.Count; num++) + { + ResourceInfo info = list[num]; + if (info.ObjectPath != string.Empty) + { + string assetTypePath = Toolbox.ResourcesManager.GetAssetTypePath(info.ObjectPath, ResourcesManager.AssetLoadPathType.Effect2D); + if (!list2.Contains(assetTypePath)) + { + list2.Add(assetTypePath); + } + } + else if (!list2.Contains(info.ObjectFullPath)) + { + list2.Add(info.ObjectFullPath); + } + if (info.SePath != string.Empty) + { + string item = "s/" + info.SePath + ".acb"; + if (!list2.Contains(item)) + { + list2.Add(item); + } + } + if (info.IsEffectBattleInfoDictionary) + { + BattleResourceMgr.AddEffectBattleInfoDictionary(info.ObjectPath, info.SePath); + action = (Action)Delegate.Combine(action, (Action)delegate + { + BattleResourceMgr.SetEffectBattleInfoDictionary(info.ObjectPath, info.ObjectFullPath); + }); + } + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(new WaitLoadResourceVfx(list2, action)); + sequentialVfxPlayer.Register(parallelVfxPlayer); + return sequentialVfxPlayer; + } + + public VfxBase RecoveryInPlayAndHandCards() + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + List list = new List(); + for (int i = 0; i < BattlePlayer.InPlayCards.Count(); i++) + { + BattleCardBase battleCardBase = BattlePlayer.InPlayCards.ElementAt(i); + battleCardBase.BattleCardView.CardWrapObject.SetActive(value: true); + iTween.Stop(battleCardBase.BattleCardView.GameObject); + list.Add(battleCardBase); + parallelVfxPlayer.Register(battleCardBase.RecoveryInPlay(i, newReplayMoveTurn: true)); + } + for (int j = 0; j < BattleEnemy.InPlayCards.Count(); j++) + { + BattleCardBase battleCardBase2 = BattleEnemy.InPlayCards.ElementAt(j); + iTween.Stop(battleCardBase2.BattleCardView.GameObject); + list.Add(battleCardBase2); + parallelVfxPlayer.Register(battleCardBase2.RecoveryInPlay(j, newReplayMoveTurn: true)); + } + for (int k = 0; k < BattlePlayer.HandCardList.Count; k++) + { + BattleCardBase card = BattlePlayer.HandCardList[k]; + list.Add(card); + card.SetOnDraw(draw: false); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(card.BattleCardView.RecoveryInHand()); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + card.BattleCardView.GameObject.SetActive(value: false); + MotionUtils.SetLayerAll(card.BattleCardView.GameObject, 10); + card.BattleCardView.InitCostViewAnim(); + card.BattleCardView.Transform.parent = BattlePlayer.HandControl.Transform; + BattlePlayer.BattleView.HandView.AddCardToView(card.BattleCardView, 0f, isNewReplayMoveTurn: true); + card.BattleCardView.GameObject.SetActive(value: true); + card.BattleCardView.CardWrapObject.SetActive(value: true); + })); + parallelVfxPlayer.Register(sequentialVfxPlayer); + } + for (int num = 0; num < BattleEnemy.HandCardList.Count; num++) + { + BattleCardBase card2 = BattleEnemy.HandCardList[num]; + list.Add(card2); + SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create(); + sequentialVfxPlayer2.Register(InstantVfx.Create(delegate + { + card2.BattleCardView.GameObject.SetActive(value: false); + MotionUtils.SetLayerAll(card2.BattleCardView.GameObject, 10); + card2.BattleCardView.Transform.parent = BattleEnemy.HandControl.Transform; + BattleEnemy.BattleView.HandView.AddCardToView(card2.BattleCardView, 0f, isNewReplayMoveTurn: true); + card2.BattleCardView.GameObject.SetActive(value: true); + })); + parallelVfxPlayer.Register(sequentialVfxPlayer2); + } + return SequentialVfxPlayer.Create(LoadCardResources(list), parallelVfxPlayer); + } +} diff --git a/SVSim.BattleEngine/Engine/BattlePlayerBase.cs b/SVSim.BattleEngine/Engine/BattlePlayerBase.cs new file mode 100644 index 0000000..1ec0059 --- /dev/null +++ b/SVSim.BattleEngine/Engine/BattlePlayerBase.cs @@ -0,0 +1,4574 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Cute; +using UnityEngine; +using Wizard; +using Wizard.Battle; +using Wizard.Battle.Player.Emotion; +using Wizard.Battle.Resource; +using Wizard.Battle.UI; +using Wizard.Battle.View; +using Wizard.Battle.View.Vfx; + +public abstract class BattlePlayerBase : IBattlePlayerReadOnlyInfo +{ + public class TurnAndCard + { + public int Turn { get; private set; } + + public bool IsSelfTurn { get; private set; } + + public IReadOnlyBattleCardInfo Card { get; private set; } + + public bool IsTurnEnd { get; private set; } + + public TurnAndCard(int turn, bool isSelfTurn, IReadOnlyBattleCardInfo card, bool isTurnEnd) + { + Turn = turn; + Card = card; + IsSelfTurn = isSelfTurn; + IsTurnEnd = isTurnEnd; + } + } + + public class CardAndId + { + public IReadOnlyBattleCardInfo Card { get; private set; } + + public int Id { get; private set; } + + public CardAndId(IReadOnlyBattleCardInfo card, int id) + { + Card = card; + Id = id; + } + } + + public class CardAndTribe + { + public IReadOnlyBattleCardInfo Card { get; private set; } + + public List Tribes { get; private set; } + + public CardAndTribe(IReadOnlyBattleCardInfo card, List tribes) + { + Card = card; + Tribes = tribes; + } + } + + public class CardAndValue + { + public IReadOnlyBattleCardInfo Card { get; private set; } + + public int Value { get; private set; } + + public CardAndValue(IReadOnlyBattleCardInfo card, int value) + { + Card = card; + Value = value; + } + } + + public enum CARD_MANAGEMENT + { + NONE, + DESTROY, + BANISH, + RETURN, + FUSION_MATERIAL, + GETON, + GETOFF, + SUMMON + } + + public class SideLogInfo + { + public SkillBase Skill; + + public SideLogInfo(SkillBase skill) + { + Skill = skill; + } + } + + public class MyRotationBonusCondition + { + public MyRotationInfo.MyRotationBonus MyRotationBonus { get; } + + public int RemainingIncreaseAddPptotalTurn { get; private set; } + + public bool IsRemainIncreaseAddPptotalTurn { get; private set; } + + public int RemainingSkillCount { get; private set; } + + public bool IsRemainSkill { get; private set; } + + public MyRotationBonusCondition(MyRotationInfo.MyRotationBonus myRotationBonus) + { + MyRotationBonus = myRotationBonus; + RemainingIncreaseAddPptotalTurn = myRotationBonus.IncreaseAddPptotalTurn; + IsRemainIncreaseAddPptotalTurn = RemainingIncreaseAddPptotalTurn > 0; + RemainingSkillCount = myRotationBonus.AttachAbilities.Length; + IsRemainSkill = RemainingSkillCount > 0; + } + + public void SetConditionInReplay(NetworkBattleReceiver.MyRotationBonusInfo bonusInfo) + { + RemainingIncreaseAddPptotalTurn = bonusInfo.RemainingIncreaseAddPptotalTurn; + IsRemainIncreaseAddPptotalTurn = bonusInfo.IsRemainIncreaseAddPptotalTurn; + RemainingSkillCount = bonusInfo.RemainingSkillCount; + IsRemainSkill = bonusInfo.IsRemainSkill; + } + + public bool GetAndReduceAddPpTurn() + { + bool num = RemainingIncreaseAddPptotalTurn > 0; + if (num) + { + RemainingIncreaseAddPptotalTurn--; + } + return num; + } + + public void ReduceSkillCount() + { + RemainingSkillCount--; + } + + public void UseUpAddPpTotalBonus() + { + IsRemainIncreaseAddPptotalTurn = RemainingIncreaseAddPptotalTurn > 0; + } + + public void UseUpSkill() + { + IsRemainSkill = RemainingSkillCount > 0; + } + } + + public class AvatarBattleDescInfo + { + public string DescText; + + public string Cost; + + public List ReplaySkillDescriptionValueList; + + public AvatarBattleDescInfo(string descText, string cost) + { + DescText = descText; + Cost = cost; + ReplaySkillDescriptionValueList = new List(); + } + } + + public enum CEMETERY_TYPE + { + NORMAL, + FIELD_RETURN_HAND_OVER, + DECK_DRAW_HAND_OVER + } + + public class SummonInfo + { + public bool IsPlayer { get; private set; } + + public SkillBaseSummon.SummonedCardsList SummonedCardsList { get; private set; } + + public SkillBaseSummon.SUMMON_TYPE SummonType { get; private set; } + + public bool IsReanimate { get; private set; } + + public bool IsDeckSelfSummon { get; private set; } + + public SummonInfo(bool isPlayer, SkillBaseSummon.SummonedCardsList summonedCardsList, SkillBaseSummon.SUMMON_TYPE summonType, bool isReanimate = false, bool isDeckSelfSummon = false) + { + IsPlayer = isPlayer; + SummonedCardsList = summonedCardsList; + SummonType = summonType; + IsReanimate = isReanimate; + IsDeckSelfSummon = isDeckSelfSummon; + } + } + + public const int MAX_PP = 10; + + public List SelfDiscardList = new List(); + + protected BattlePlayerBase _opponentBattlePlayer; + + private List _skillList = new List(); + + protected IBattlePlayerVfxCreator m_vfxCreator; + + protected readonly IInnerOptionsBuilder _innerOptionsBuilder; + + private int _ppTotal; + + protected int m_EpTotal; + + private const int MAX_BP = 99; + + public bool CantPlayChoiceBrave; + + public HashSet PredictionWarningCards = new HashSet(); + + public Func OnTurnStartSkillAfter; + + public Func OnTurnEndSkillAfter; + + public Action OnTurnStartComplete; + + public Action OnPreTurnEndComplete; + + public Action OnPostTurnEndComplete; + + public Action OnEndOneSkillProcess; + + public List BonusConditionList; + + public List BossRushSpecialSkillList; + + public AvatarBattleDescInfo AvatarBattlePassiveSkillDescInfo; + + public List ChoiceBraveSkillDescInfoList; + + public const int MAX_NUM_HAND_CARDS = 9; + + public const int MAX_NUM_IN_PLAY_CARDS_WITH_CLASS = 6; + + public const int MAX_NUM_IN_PLAY_CARDS = 5; + + protected int _gameUsedEpCount; + + protected int _turnUsedEpCount; + + private const string TOKEN_EFFECT_PATH = "cmn_token_draw_1"; + + public BattleManagerBase BattleMgr { get; protected set; } + + public virtual bool IsGameFirst => false; + + public BattleCamera BattleCamera { get; private set; } + + public BackGroundBase BackGround { get; private set; } + + protected DataMgr _dataMgr { get; set; } + + public virtual bool IsPlayer => true; + + public virtual int Turn + { + get + { + if (!BattleMgr.IsFirst) + { + return BattleMgr.SecondTurn; + } + return BattleMgr.FirstTurn; + } + set + { + if (BattleMgr.IsFirst) + { + BattleMgr.FirstTurn = value; + } + else + { + BattleMgr.SecondTurn = value; + } + } + } + + public int Pp { get; set; } + + public int PpTotal + { + get + { + return _ppTotal; + } + set + { + _ppTotal = value; + } + } + + public int EpTotal + { + get + { + return m_EpTotal; + } + set + { + m_EpTotal = value; + } + } + + public int CurrentEpCount { get; private set; } + + public int EvolveWaitTurnCount { get; set; } + + public bool NowTurnEvol { get; set; } + + public bool IsEpEvolveThisTurn { get; set; } + + public bool IsEvolve + { + get + { + if (NowTurnEvol && CurrentEpCount > 0) + { + return EvolveWaitTurnCount <= 0; + } + return false; + } + } + + public bool IsExceptionEvolve + { + get + { + if (NowTurnEvol && EvolveWaitTurnCount <= 0) + { + return InPlayCards.Any((BattleCardBase c) => !c.IsEvolution && CheckNotConsumeEpCard(c)); + } + return false; + } + } + + public int GameUsedEpCount => _gameUsedEpCount; + + public int TurnUsedEpCount => _turnUsedEpCount; + + public int Bp { get; private set; } + + public bool IsAlreadyChoiceBraveInThisTurn { get; set; } = true; + + public bool IsChoiceBraveEffectTiming { get; set; } + + public List ChoiceBraveCards + { + get + { + List list = new List(); + SkillBase skillBase = Class.Skills.FirstOrDefault((SkillBase s) => s.OnWhenChoiceBrave != 0); + if (skillBase == null) + { + return list; + } + List list2 = SkillOptionValue.ParseOptionTokenID(skillBase.OptionValue.GetOption(SkillFilterCreator.ContentKeyword.card_id, "_OPT_NULL_")).ToList(); + for (int num = 0; num < list2.Count(); num++) + { + BattleCardBase item = BattleManagerBase.GetIns().CreateTransformCardRegisterVfx(Class, list2[num], IsPlayer, null, isRecoveryFinish: false, isChoice: true); + list.Add(item); + } + return list; + } + } + + public bool CanPlayAnyChoiceBraveCard + { + get + { + if (IsAlreadyChoiceBraveInThisTurn) + { + return false; + } + List choiceBraveCards = ChoiceBraveCards; + for (int i = 0; i < choiceBraveCards.Count(); i++) + { + if (choiceBraveCards[i].CanPlayAsChoiceBraveCard) + { + return true; + } + } + return false; + } + } + + public virtual bool CanChoiceBraveThisTurn + { + get + { + if (!IsAlreadyChoiceBraveInThisTurn) + { + return IsChoiceBraveEffectTiming; + } + return false; + } + } + + public virtual bool CanChoiceBrave + { + get + { + if (CanChoiceBraveThisTurn && CanPlayAnyChoiceBraveCard && BattleView.IsTouchable()) + { + return !BattleView.IsSelecting; + } + return false; + } + } + + public BattleCardBase LowestCostChoiceBraveCard => ChoiceBraveCards.OrderBy((BattleCardBase c) => c.Cost).FirstOrDefault(); + + public bool IsShortageDeckLose { get; protected set; } + + public bool IsShortageDeckWin => Class.SkillApplyInformation.IsShortageDeckWin; + + public bool IsChangeShortageDeck + { + get + { + if (!Class.SkillApplyInformation.IsShortageDeckWin) + { + return Class.Skills.Any((SkillBase s) => s.OnWhenShortageDeck != 0); + } + return false; + } + } + + public List HandCardList { get; private set; } + + public List DeckCardList { get; private set; } + + public List BattleStartDeckCardList { get; set; } + + public List DeckSkillCardList { get; private set; } + + public List ClassAndInPlayCardList { get; private set; } + + public List CemeteryList { get; private set; } + + public List BanishList { get; set; } + + public List FusionIngredientList { get; set; } + + public List TurnFusionCards { get; set; } + + public List NecromanceZoneList { get; set; } + + public List DiscardedCardList { get; set; } + + public List FusionIngredientAndDiscardedCardList { get; set; } + + public List ReservedCardList { get; set; } + + public List UniteList { get; set; } + + public List GetOnList { get; set; } + + public List BlackHole { get; set; } + + public List ChoiceBraveCardList { get; set; } + + public List PredictionCemeteryRandomCards { get; private set; } + + public List PredictionDamageRandomCards { get; private set; } + + public List PredictionBanishRandomCards { get; private set; } + + public virtual IStatusPanelControl StatusPanelControl + { + get + { + if ((bool)BattleView.StatusParentPanel) + { + return BattleView.StatusParentPanel.GetComponent(); + } + return new NullStatusPanelControl(); + } + } + + public IClassInfomationUI _classInfomationUI { get; protected set; } + + public ClassInformationUIController ClassInformationUIController { get; protected set; } + + public bool IsBuffDetail + { + get + { + if (IsShowBuffDetail || IsRecordingBuffDetail) + { + return !IsRecordingExceptBuffDetail; + } + return false; + } + } + + public bool IsShowBuffDetail { get; set; } + + public bool IsRecordingBuffDetail { get; set; } + + public bool IsRecordingExceptBuffDetail { get; set; } + + public SideLogInfo SideLogSkill { get; set; } + + protected BattleCardBase _class { get; set; } + + public HandControl HandControl => BattleView.HandControl; + + public abstract IBattlePlayerView BattleView { get; } + + public abstract IEmotion Emotion { get; } + + public bool IsSelfTurn { get; set; } + + public List ReturnList { get; set; } + + public List> LastTargetCardsList { get; set; } + + public List InHandCards { get; set; } + + public List SkillDiscards { get; set; } + + public List SkillBanishCards { get; set; } + + public List HealingCards { get; set; } + + public List SkillSummonedCards { get; set; } + + public List SummonedCards { get; set; } + + public BattleCardBase DrewSkillCard { get; set; } + + public BattleCardBase ReturnSkillCard { get; set; } + + public List EvolvedCards { get; set; } + + public List DestroyedWhenDestroyCards { get; set; } + + public List TurnPlayCardCountInfo { get; set; } + + public List TurnFusionCountInfo { get; set; } + + public List TurnEvolveCardCountInfo { get; set; } + + public int TurnNecromanceCount { get; set; } + + public int GameNecromanceCount { get; set; } + + public int GameUsedPpCount { get; set; } + + public BattleCardBase CardOnPlay { get; set; } + + public List TurnPlayCards { get; set; } + + public List TurnDrawCards { get; set; } + + public List TurnDrawTokenCardsWithId { get; set; } + + public List GameDrawCards { get; set; } + + public List GameDrawTokenCards { get; set; } + + public List GameAddUpdateDeckCards { get; set; } + + public List GameSummonCards { get; set; } + + public List GameSummonMomentTribe { get; set; } + + public List GamePlayMomentTribe { get; set; } + + public List GamePlayMomentSpellChargeCards { get; set; } + + public List GameUpdateDeckMomentTribe { get; set; } + + public List GamePlayCards { get; set; } + + public List GameTurnPlayCards { get; set; } + + public List GameEnhancePlayCards { get; set; } + + public List GameCrystallizedPlayCards { get; set; } + + public List GameLeftCards { get; set; } + + public List GameTurnLeftCards { get; set; } + + public List GameReturnedCards { get; set; } + + public List GameSuperSkyboundArtCards { get; set; } + + public List GameInplayMetamorphoseCards { get; set; } + + public List OkSkillInProcess { get; set; } + + public List TurnDestroyCards { get; set; } + + public List TurnWhenHealingCount { get; set; } + + public List GameBurialRiteCards { get; set; } + + public List TurnBurialRiteCards { get; set; } + + public List BurialRiteOrDiscardCardHandIndexList { get; set; } + + public List GameReanimatedCards { get; set; } + + protected List AddToDeckCardList { get; set; } + + public List TurnStartLifeList { get; protected set; } + + public int RallyCount { get; protected set; } + + public int DeckBanishCount { get; protected set; } + + public int GameResonanceStartCount { get; set; } + + public int TurnResonanceStartCount { get; set; } + + public int GameUsedWhiteRitualCount { get; set; } + + public int LastInplayWhiteRitualStack { get; set; } + + public List GameSkillReturnCardCountList { get; set; } + + public List GameSkillDiscardCountList { get; set; } + + public List GameSkillBuffCountList { get; set; } + + public List GameSkillMetamorphoseCountList { get; set; } + + public int GameSkillDiscardCount { get; set; } + + public List GameQuickAttackCards { get; set; } + + public IEnumerable SkillInfoDeckCards => ConvertToSkillInfoCollection(DeckCardList); + + public IEnumerable SkillInfoBattleStartDeckCards => ConvertToSkillInfoCollection(BattleStartDeckCardList); + + public IEnumerable SkillInfoHandCards => ConvertToSkillInfoCollection(HandCardList); + + public IEnumerable SkillInfoClassAndInPlayCards => ConvertToSkillInfoCollection(ClassAndInPlayCardList); + + public IEnumerable SkillInfoCemeterys => ConvertToSkillInfoCollection(CemeteryList); + + public IEnumerable SkillInfoBanishCards => ConvertToSkillInfoCollection(BanishList); + + public IEnumerable SkillInfoFusionIngredientList => ConvertToSkillInfoCollection(FusionIngredientList); + + public IEnumerable SkillInfoTurnFusionCards => ConvertToSkillInfoCollection(TurnFusionCards); + + public IEnumerable SkillInfoNecromanceZoneCards => ConvertToSkillInfoCollection(NecromanceZoneList); + + public IEnumerable SkillInfoInPlayCards => ConvertToSkillInfoCollection(InPlayCards); + + public IEnumerable> SkillInfoLastTargets => ConvertToSkillInfoCollectionList(LastTargetCardsList); + + public IEnumerable SkillInfoDiscards => ConvertToSkillInfoCollection(SkillDiscards); + + public IEnumerable SkillInfoDiscardedCards => ConvertToSkillInfoCollection(DiscardedCardList); + + public IEnumerable SkillInfoFusionIngredientAndDiscardedCards => ConvertToSkillInfoCollection(FusionIngredientAndDiscardedCardList); + + public IEnumerable SkillInfoReturnedCards => GameReturnedCards; + + public IEnumerable SkillInfoHealingCards => ConvertToSkillInfoCollection(HealingCards); + + public IEnumerable SkillInfoSkillSummonedCards => ConvertToSkillInfoCollection(SkillSummonedCards); + + public IEnumerable SkillInfoEvolvedCards => ConvertToSkillInfoCollection(EvolvedCards); + + public IEnumerable SkillInfoDestroyedWhenDestroyCards => ConvertToSkillInfoCollection(DestroyedWhenDestroyCards); + + public IEnumerable SkillInfoTurnPlayCards => ConvertToSkillInfoCollection(TurnPlayCards); + + public IEnumerable SkillInfoTurnDrawCards => ConvertToSkillInfoCollection(TurnDrawCards); + + public IEnumerable SkillInfoTurnDrawTokenCardsWithId => TurnDrawTokenCardsWithId; + + public IEnumerable SkillInfoGameSummonCards => GameSummonCards; + + public IEnumerable SkillInfoGamePlayCards => ConvertToSkillInfoCollection(GamePlayCards); + + public IEnumerable SkillInfoGameTurnPlayCards => GameTurnPlayCards; + + public IEnumerable SkillInfoGameEnhancePlayCards => GameEnhancePlayCards; + + public IEnumerable SkillInfoGameCrystallizedPlayCards => ConvertToSkillInfoCollection(GameCrystallizedPlayCards); + + public IEnumerable SkillInfoGameSkillActivated => ConvertToSkillInfoCollection(ChoiceBraveCardList); + + public IEnumerable SkillInfoInplayMetamorphosedCards => ConvertToSkillInfoCollection(GameInplayMetamorphoseCards); + + public IEnumerable SkillInfoGameBurialRiteCards => ConvertToSkillInfoCollection(GameBurialRiteCards); + + public IEnumerable SkillInfoTurnBurialRiteCards => ConvertToSkillInfoCollection(TurnBurialRiteCards); + + public IEnumerable SkillInfoGameReanimatedCards => GameReanimatedCards; + + public IEnumerable SkillInfoGameDrawCards => ConvertToSkillInfoCollection(GameDrawCards); + + public IEnumerable SkillInfoGameDrawTokenCards => ConvertToSkillInfoCollection(GameDrawTokenCards); + + public IEnumerable SkillInfoGameAddUpdateDeckCards => ConvertToSkillInfoCollection(GameAddUpdateDeckCards); + + public IEnumerable SkillInfoGameLeftCards => ConvertToSkillInfoCollection(GameLeftCards); + + public IEnumerable SkillInfoGameTurnLeftCards => GameTurnLeftCards; + + public IEnumerable SkillInfoGameSuperSkyboundArtCards => ConvertToSkillInfoCollection(GameSuperSkyboundArtCards); + + public IReadOnlyBattleCardInfo SkillInfoClass => Class; + + public IEnumerable SkillInfoGameQuickAttackCards => ConvertToSkillInfoCollection(GameQuickAttackCards); + + public AvatarBattleInfo AvatarBattleInfo { get; set; } + + public int extraTurnCount { get; set; } + + public bool IsExtraTurn => extraTurnCount > 0; + + public int cardTotalNum { get; set; } + + public bool IsShortageDeck { get; private set; } + + public int _cumulativeEvolutionCount { get; protected set; } + + public bool IsSkinEvolved + { + get + { + if (_dataMgr.IsEvolveSkin(IsPlayer)) + { + return _cumulativeEvolutionCount > 0; + } + return false; + } + } + + public IEnumerable AllCards + { + get + { + for (int i = 0; i < HandCardList.Count(); i++) + { + yield return HandCardList[i]; + } + for (int i = 0; i < ClassAndInPlayCardList.Count; i++) + { + yield return ClassAndInPlayCardList[i]; + } + for (int i = 0; i < DeckCardList.Count(); i++) + { + yield return DeckCardList[i]; + } + } + } + + public List AllCardsWithCemeteryAndBanish + { + get + { + List list = AllCards.ToList(); + list.AddRange(CemeteryList); + list.AddRange(NecromanceZoneList); + list.AddRange(BanishList); + return list; + } + } + + public List AllCardsWithSkillIngredient + { + get + { + List list = AllCardsWithCemeteryAndBanish.ToList(); + list.AddRange(FusionIngredientList); + list.AddRange(GetOnList); + list.AddRange(UniteList); + list.AddRange(ReservedCardList); + list.AddRange(BlackHole); + return list; + } + } + + public IEnumerable InPlayCards + { + get + { + for (int i = 0; i < ClassAndInPlayCardList.Count; i++) + { + if (!(ClassAndInPlayCardList[i] is ClassBattleCardBase)) + { + yield return ClassAndInPlayCardList[i]; + } + } + } + } + + public BattleCardBase Class => _class; + + public event Action OnTurnStartStart; + + public event Func OnTurnStartFinish; + + public event Action OnTurnEndStart; + + public event Func OnTurnEnd; + + public event Func OnTurnEndFinish; + + public event Func OnTurnStartBeforeDraw; + + public event Func OnTurnStartAfterDraw; + + public event Action OnNecromance; + + public event Action OnPickCard; + + public event Action OnAfterPickCard; + + public event Action OnSetupClassEvent; + + public event Action OnSetupCardEvent; + + public event Func OnShortageDeck; + + public event Action> OnMulliganStart; + + public event Action, IEnumerable> OnMulliganEnd; + + public event Action OnClearDeck; + + public event Action OnChangePP; + + public event Action OnAddPpTotal; + + public event Action OnAddPp; + + public event Action OnAddBp; + + public event Action OnEpModifier; + + public event Action OnAddHandCardEvent; + + public event Action OnAddCemeteryEvent; + + public event Action OnAddPlayCardEvent; + + public event Action OnAddBanishEvent; + + public event Action OnAddDeckEvent; + + public event Action OnAddUniteEvent; + + public event Action OnSpellPlayEvent; + + public event Action OnFusion; + + public event Action OnGeton; + + public event Action, List, SkillBase> OnGetoff; + + public event Action, SkillBase> OnAddBlackHole; + + public event Action OnAfterReturnCardEvent; + + public event Func, VfxBase> OnAfterSummonCardEvent; + + public event Action OnAddHandCardAfterEvent; + + public event Func OnAddCemeteryAfterEvent; + + public event Action OnAddPlayCardAfterEvent; + + public event Action OnAddBanishAfterEvent; + + public event Action OnAddUniteAfterEvent; + + public event Action OnLeaveAfterEvent; + + public event Action OnSummonAfterEvent; + + public event Action OnMetamorphoseAfterEvent; + + public event Action> OnChangeDeckAfterEvent; + + public event Action, BattlePlayerBase, bool> OnDrawCards; + + public event Action, List, bool, bool, bool> OnTokenDrawCards; + + public event Action, bool> OnCreateReservedCards; + + public event Action, bool, bool, bool> OnUpdateDeck; + + public event Action OnIndexChange; + + public event Action, List, bool, bool, bool, bool, bool> OnSummonTokenCards; + + public event Action, bool, bool, bool, bool> OnSummonCards; + + public event Action, List, List, List, bool, bool, bool> OnCostChange; + + public event Action, bool, bool> OnRemoveCostChange; + + public event Action, int, int, int, int, int> OnPowerUp; + + public event Action OnPowerDownStart; + + public event Action, int, int, int, bool> OnPowerDown; + + public event Action> OnDeprivePowerUp; + + public event Action> OnDeprivePowerDown; + + public event Action, List> OnSpellCharge; + + public event Action OnDrain; + + public event Action OnSkillDamageStart; + + public event Action, List, List> OnDamage; + + public event Action, List> OnHeal; + + public event Action> OnDiscard; + + public event Action OnStartLeaveCard; + + public event Action OnDestroy; + + public event Action OnSkillDestroyOrBanish; + + public event Action OnBanish; + + public event Action OnPlayVoiceOnDeath; + + public event Action OnReturn; + + public event Action OnSkillReturn; + + public event Action> OnBeforeSkillEvolve; + + public event Action OnEvolveMeWhenAttack; + + public event Action> OnAfterSkillEvolve; + + public event Action OnPlayCard; + + public event Action OnWhenPlayEffect; + + public event Action, int> OnChantCountChange; + + public event Action OnChangeWhiteRitualStack; + + public event Action, int> OnChangeMaxAttackableCount; + + public event Action, int> OnMetamorphose; + + public event Action OnFusionMetamorphose; + + public event Action OnOpenCard; + + public event Action, BattleCardBase> OnUnite; + + public event Action OnRemoveLatestOperationJsonData; + + public event Action OnPlayComplete; + + public event Action OnEmotion; + + public event Action OnClearDestroyedCardList; + + public void SetCurrentEpCount(int setCount) + { + CurrentEpCount = setCount; + } + + public void AddCurrentEpCount(int addCount = 1) + { + CurrentEpCount += addCount; + } + + public void GainCurrentEpCount(int gainCount = 1) + { + CurrentEpCount -= gainCount; + } + + public VfxBase SetBp(int value) + { + Bp = value; + Bp = Math.Max(0, Bp); + Bp = Math.Min(Bp, 99); + return BattleView.SetBp(value); + } + + public VfxBase AddBp(int value) + { + Bp += value; + Bp = Math.Max(0, Bp); + Bp = Math.Min(Bp, 99); + return BattleView.SetBp(Bp); + } + + public void SetIsShortageDeckLose(bool flag) + { + IsShortageDeckLose = flag; + } + + public void ResetIsShortageDeck() + { + IsShortageDeck = false; + } + + public void SetCumulativeEvolutionCount(int count) + { + _cumulativeEvolutionCount = count; + } + + public int AddDamageByClassUseCard(string damageType) + { + if (Class != null) + { + int num = 0; + for (int i = 0; i < Class.SkillApplyInformation.AddDamageList.Count; i++) + { + if (Class.SkillApplyInformation.AddDamageList[i] is AddDamageInfo addDamageInfo && addDamageInfo.IsEffective(damageType, Class.Clan, isUseClass: true)) + { + num += addDamageInfo.AddDamage; + } + } + return num; + } + return 0; + } + + protected BattlePlayerBase(BattleManagerBase battleMgr, BattleCamera battleCamera, BackGroundBase backGround, IInnerOptionsBuilder innerOptionsBuilder) + { + BattleMgr = battleMgr; + _dataMgr = GameMgr.GetIns().GetDataMgr(); + BattleCamera = battleCamera; + BackGround = backGround; + _innerOptionsBuilder = innerOptionsBuilder; + Initialize(); + HandCardList = new List(); + DeckCardList = new List(); + BattleStartDeckCardList = new List(); + DeckSkillCardList = new List(); + ClassAndInPlayCardList = new List(); + CemeteryList = new List(); + PredictionCemeteryRandomCards = new List(); + PredictionDamageRandomCards = new List(); + PredictionBanishRandomCards = new List(); + BanishList = new List(); + FusionIngredientList = new List(); + TurnFusionCards = new List(); + NecromanceZoneList = new List(); + DiscardedCardList = new List(); + FusionIngredientAndDiscardedCardList = new List(); + ReservedCardList = new List(); + UniteList = new List(); + GetOnList = new List(); + BlackHole = new List(); + ChoiceBraveCardList = new List(); + ReturnList = new List(); + HealingCards = new List(); + LastTargetCardsList = new List>(); + SkillSummonedCards = new List(); + SummonedCards = new List(); + EvolvedCards = new List(); + DestroyedWhenDestroyCards = new List(); + InHandCards = new List(); + SkillDiscards = new List(); + SkillBanishCards = new List(); + TurnPlayCards = new List(); + TurnDrawCards = new List(); + TurnDrawTokenCardsWithId = new List(); + GameSummonCards = new List(); + GameSummonMomentTribe = new List(); + GamePlayMomentTribe = new List(); + GamePlayMomentSpellChargeCards = new List(); + GameUpdateDeckMomentTribe = new List(); + GamePlayCards = new List(); + GameTurnPlayCards = new List(); + GameEnhancePlayCards = new List(); + GameCrystallizedPlayCards = new List(); + GameInplayMetamorphoseCards = new List(); + GameBurialRiteCards = new List(); + GameQuickAttackCards = new List(); + TurnBurialRiteCards = new List(); + BurialRiteOrDiscardCardHandIndexList = new List(); + GameReanimatedCards = new List(); + OkSkillInProcess = new List(); + TurnDestroyCards = new List(); + AddToDeckCardList = new List(); + GameDrawCards = new List(); + GameDrawTokenCards = new List(); + GameAddUpdateDeckCards = new List(); + TurnStartLifeList = new List(); + TurnWhenHealingCount = new List(); + TurnPlayCardCountInfo = new List(); + TurnFusionCountInfo = new List(); + TurnEvolveCardCountInfo = new List(); + GameLeftCards = new List(); + GameTurnLeftCards = new List(); + GameReturnedCards = new List(); + GameSuperSkyboundArtCards = new List(); + GameSkillReturnCardCountList = new List(); + GameSkillDiscardCountList = new List(); + GameSkillBuffCountList = new List(); + GameSkillMetamorphoseCountList = new List(); + BonusConditionList = new List(); + BossRushSpecialSkillList = new List(); + ChoiceBraveSkillDescInfoList = new List(); + NowTurnEvol = true; + m_vfxCreator = CreateVfxCreator(); + CreateSelfBattleCard(); + _class = ClassAndInPlayCardList[0]; + } + + protected abstract void Initialize(); + + protected abstract void CreateSelfBattleCard(); + + protected virtual IBattlePlayerVfxCreator CreateVfxCreator() + { + return new BattlePlayerVfxCreatorBase(BattleView); + } + + public virtual VfxBase LoadResources(IBattleResourceMgr resourceMgr) + { + long sleeveId = (IsPlayer ? _dataMgr.GetPlayerSleeveId() : _dataMgr.GetEnemySleeveId()); + return SequentialVfxPlayer.Create(resourceMgr.LoadSleeveMaterial(sleeveId, IsPlayer), ClassInformationUIController.LoadResources(StatusPanelControl.GetClassInfoAnchor(), IsPlayer)); + } + + public virtual void Setup(BattlePlayerBase opponentBattlePlayer) + { + IsShortageDeckLose = false; + extraTurnCount = 0; + _cumulativeEvolutionCount = 0; + _opponentBattlePlayer = opponentBattlePlayer; + _opponentBattlePlayer.Class.ChangeClassClanParameter(); + GameMgr ins = GameMgr.GetIns(); + List list = new List(); + BattleManagerBase ins2 = BattleManagerBase.GetIns(); + if (IsPlayer) + { + int key = (IsPlayer ? ins.GetNetworkUserInfoData().GetSelfChaosId() : ins.GetNetworkUserInfoData().GetOpponentChaosId()); + if (Data.Master.ClassInfomationOrder != null && Data.Master.ClassInfomationOrder.ContainsKey(key)) + { + List value = new List(); + int num = 1; + Data.Master.ClassInfomationOrder.TryGetValue(key, out value); + for (int i = 0; i < value.Count; i++) + { + list.Add(CreateClassInfomationUI(num, value.Count, value[i])); + num++; + } + } + else if (ins.GetDataMgr().GetPlayerSubClassId() != 10) + { + int num2 = 1; + List crossOverClassInfoListOrNull = Data.Master.GetCrossOverClassInfoListOrNull(ins.GetDataMgr().GetPlayerClassId(), ins.GetDataMgr().GetPlayerSubClassId()); + if (crossOverClassInfoListOrNull == null || crossOverClassInfoListOrNull.Count <= 0) + { + list.Add(CreateClassInfomationUI()); + } + else + { + for (int j = 0; j < crossOverClassInfoListOrNull.Count; j++) + { + list.Add(CreateClassInfomationUI(num2, crossOverClassInfoListOrNull.Count, crossOverClassInfoListOrNull[j])); + num2++; + } + } + } + else if (Data.CurrentFormat == Format.Avatar) + { + int key2 = ((ins2 is NetworkBattleManagerBase) ? int.Parse(ins.GetNetworkUserInfoData().GetSelfAvatarBattleId()) : ins.GetDataMgr().GetPlayerCharaId()); + List value2 = new List(); + Data.Master.AvatarClassInformationOrder.TryGetValue(key2, out value2); + for (int k = 0; k < value2.Count; k++) + { + list.Add(CreateClassInfomationUI(k + 1, value2.Count, value2[k])); + } + } + else if (ins2.IsPuzzleMgr) + { + int playerClass = (ins2 as PuzzleBattleManager).PuzzleQuestData.BattleData.PlayerClass; + list.Add(CreateClassInfomationUI(1, 1, playerClass)); + } + else + { + list.Add(CreateClassInfomationUI()); + } + } + else if (ins.GetDataMgr().GetEnemySubClassId() != 10) + { + int num3 = 1; + List crossOverClassInfoListOrNull2 = Data.Master.GetCrossOverClassInfoListOrNull(ins.GetDataMgr().GetEnemyClassId(), ins.GetDataMgr().GetEnemySubClassId()); + if (crossOverClassInfoListOrNull2 == null || crossOverClassInfoListOrNull2.Count <= 0) + { + list.Add(CreateClassInfomationUI()); + } + else + { + for (int l = 0; l < crossOverClassInfoListOrNull2.Count; l++) + { + list.Add(CreateClassInfomationUI(num3, crossOverClassInfoListOrNull2.Count, crossOverClassInfoListOrNull2[l])); + num3++; + } + } + } + else if (Data.CurrentFormat == Format.Avatar && ins2 is NetworkBattleManagerBase) + { + int key3 = int.Parse(ins.GetNetworkUserInfoData().GetOpponentAvatarBattleId()); + List value3 = new List(); + Data.Master.AvatarClassInformationOrder.TryGetValue(key3, out value3); + for (int m = 0; m < value3.Count; m++) + { + list.Add(CreateClassInfomationUI(m + 1, value3.Count, value3[m])); + } + } + else + { + list.Add(CreateClassInfomationUI()); + } + ClassInformationUIController = new ClassInformationUIController(list); + ClassInformationUIController.SetUpEvent(this); + SetUpClassEvent(); + foreach (BattleCardBase deckCard in DeckCardList) + { + SetupCardEvent(deckCard); + } + foreach (BattleCardBase handCard in HandCardList) + { + SetupCardEvent(handCard); + } + foreach (BattleCardBase classAndInPlayCard in ClassAndInPlayCardList) + { + SetupCardEvent(classAndInPlayCard); + } + OnNecromance += delegate(BattleCardBase necromanceCard, SkillProcessor skillProcessor, int necromanceCount, bool isFusion) + { + List list2 = ClassAndInPlayCardList.ToList(); + list2.AddRange(DeckSkillCardList); + foreach (BattleCardBase item in list2) + { + item.Necromance(necromanceCard, skillProcessor, necromanceCount); + } + if (BattleMgr is NetworkBattleManagerBase networkBattleManagerBase) + { + networkBattleManagerBase.RegisterActionManager.Add(new RegisterPlayerParameter(RegisterActionBase.ActionBaseParameter.cemetery, -1 * necromanceCount, necromanceCard.IsPlayer)); + } + }; + Emotion.OnPlay += (ClassCharaPrm.EmotionType emoteType) => opponentBattlePlayer.Emotion.ReceiveOpponentEmotion(emoteType); + OnNecromance += delegate + { + BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate + { + StatusPanelControl.SetGrave(CemeteryList.Count((BattleCardBase c) => !c.IsClass)); + UpdateHandCardsPlayability(); + })); + }; + OnAddPlayCardAfterEvent += delegate + { + UpdateStatusPanelHandCount(); + }; + OnAddHandCardAfterEvent += delegate + { + UpdateStatusPanelHandCount(); + }; + OnAddCemeteryAfterEvent += delegate + { + UpdateStatusPanelHandCount(); + return NullVfx.GetInstance(); + }; + OnAddCemeteryAfterEvent += delegate + { + BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate + { + if (StatusPanelControl != null) + { + StatusPanelControl.SetGrave(CemeteryList.Count((BattleCardBase c) => !c.IsClass)); + } + })); + return InstantVfx.Create(delegate + { + UpdateHandCardsPlayability(); + }); + }; + OnAddBanishAfterEvent += delegate + { + UpdateHandCardsPlayability(); + UpdateStatusPanelHandCount(); + }; + OnAddUniteAfterEvent += delegate + { + UpdateHandCardsPlayability(); + UpdateStatusPanelHandCount(); + }; + OnChangeDeckAfterEvent += delegate(int previousCount, SkillProcessor skillProcessor, List summonCards) + { + if (previousCount % 2 == 1 && DeckCardList.Count % 2 == 0) + { + int gameResonanceStartCount = GameResonanceStartCount; + GameResonanceStartCount = gameResonanceStartCount + 1; + gameResonanceStartCount = TurnResonanceStartCount; + TurnResonanceStartCount = gameResonanceStartCount + 1; + StartSkillWhenResonanceStart(skillProcessor, summonCards); + } + }; + OnChangeDeckAfterEvent += delegate + { + DeckSkillCardList.RemoveAll((BattleCardBase c) => !c.IsInDeck); + }; + OnMulliganEnd += delegate + { + DeckSkillCardList.RemoveAll((BattleCardBase c) => !c.IsInDeck); + }; + OnTurnStartComplete = (Action)Delegate.Combine(OnTurnStartComplete, new Action(AddToDeckCardIndexChange)); + OnTurnStartComplete = (Action)Delegate.Combine(OnTurnStartComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvent)); + OnPostTurnEndComplete = (Action)Delegate.Combine(OnPostTurnEndComplete, new Action(AddToDeckCardIndexChange)); + OnPreTurnEndComplete = (Action)Delegate.Combine(OnPreTurnEndComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvent)); + } + + private void UpdateStatusPanelHandCount() + { + if (StatusPanelControl != null && HandCardList != null) + { + StatusPanelControl.SetHandCount(HandCardList.Count); + } + } + + public void UpdateStatusPanel(int handCount, int cemeteryCount, int deckCount) + { + if (StatusPanelControl != null) + { + StatusPanelControl.SetHandCount(handCount); + StatusPanelControl.SetGrave(cemeteryCount); + StatusPanelControl.SetDeck(deckCount); + } + } + + public virtual IClassInfomationUI CreateClassInfomationUI(int orderCount = 1, int totalInfoNum = 1, int clanId = -1) + { + if (clanId == -1) + { + clanId = (IsPlayer ? _dataMgr.GetPlayerClassId() : _dataMgr.GetEnemyClassId()); + } + IBattlePlayerView battlePlayerView = (IsPlayer ? BattleView : _opponentBattlePlayer.BattleView); + IBattlePlayerView battleEnemyView = (IsPlayer ? _opponentBattlePlayer.BattleView : BattleView); + switch ((CardBasePrm.ClanType)clanId) + { + case CardBasePrm.ClanType.MIN: + return new ElfInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.ROYAL: + return new RoyalInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.WITCH: + if (IsPlayer || totalInfoNum > 1) + { + return new WitchInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + } + return new ClassInfomationUIBase(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.DRAGON: + return new DragonInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.NECRO: + return new NecromanceInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.VAMPIRE: + return new VampireInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.BISHOP: + return new BishopInfomationUI(this, battlePlayerView, battleEnemyView, orderCount, totalInfoNum); + case CardBasePrm.ClanType.NEMESIS: + return new NemesisInfomationUI(this, battlePlayerView, orderCount, totalInfoNum); + default: + return new ClassInfomationUIBase(this, battlePlayerView, orderCount, totalInfoNum); + } + } + + public VfxBase Recovery() + { + return SequentialVfxPlayer.Create(ClassInformationUIController.LoadResources(StatusPanelControl.GetClassInfoAnchor(), IsPlayer), InstantVfx.Create(delegate + { + ClassInformationUIController.ShowInfomation(playEffect: false); + })); + } + + public abstract void SetupClone(BattlePlayerBase sourceBattlePlayer, BattlePlayerBase virtualOpponentBattlePlayer, CloneActualFlags cloneFlags); + + public void SetupActionProcessorEvent(ActionProcessor processor) + { + processor.OnBeforePlayCard += delegate(BattleCardBase originalCard, BattleCardBase card, IEnumerable selectedCards) + { + if (!card.IsChoiceBraveSkillCard) + { + AddCurrentTrunPlayCount(1); + CardOnPlay = card; + TurnPlayCards.Add(card); + GamePlayCards.Add(card); + GameTurnPlayCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, card, BattleMgr.IsTurnEnd)); + GamePlayMomentTribe.Add(new CardAndTribe(card, card.Tribe)); + if (card.HasSpellCharge) + { + GamePlayMomentSpellChargeCards.Add(card); + } + if (card.CheckConditionFixedUseCost(isPrePlay: true)) + { + GameEnhancePlayCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, card, BattleMgr.IsTurnEnd)); + } + if (card.TransformInfo.Type == BattleCardBase.TransformType.Crystallize) + { + GameCrystallizedPlayCards.Add(card); + } + if (!BattleMgr.IsVirtualBattle) + { + BattleLogManager.GetInstance().AddLogDestFollower(BattleLogWindow.BattleLogType.PlayCardLog, card); + } + BattleView.HandView.RemoveCardFromView(card.BattleCardView, 0.3f); + } + }; + processor.OnAfterFusion += delegate + { + AddToDeckCardIndexChange(); + return NullVfx.GetInstance(); + }; + processor.OnPlayComplete = (Action)Delegate.Combine(processor.OnPlayComplete, new Action(AddToDeckCardIndexChange)); + processor.OnPlayComplete = (Action)Delegate.Combine(processor.OnPlayComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvent)); + processor.OnPlayComplete = (Action)Delegate.Combine(processor.OnPlayComplete, this.OnPlayComplete); + processor.OnPlayComplete = (Action)Delegate.Combine(processor.OnPlayComplete, (Action)delegate + { + CardOnPlay = null; + }); + processor.OnEvolutionComplete = (Action)Delegate.Combine(processor.OnEvolutionComplete, new Action(AddToDeckCardIndexChange)); + processor.OnEvolutionComplete = (Action)Delegate.Combine(processor.OnEvolutionComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvolutionEvent)); + processor.OnAttackComplete = (Action)Delegate.Combine(processor.OnAttackComplete, new Action(AddToDeckCardIndexChange)); + processor.OnAttackComplete = (Action)Delegate.Combine(processor.OnAttackComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvent)); + if (GameMgr.GetIns().IsWatchBattle && !GameMgr.GetIns().IsReplayBattle) + { + processor.OnFusionComplete = (Action)Delegate.Combine(processor.OnFusionComplete, new Action(BattleMgr.DetailMgr.DetailPanelControl.UpdateCardDescriptionOnEvent)); + } + } + + private void SetUpClassEvent() + { + this.OnSetupClassEvent.Call(); + } + + public virtual void SetupCardEvent(BattleCardBase card) + { + if (card.IsUnit) + { + card.OnEvolveEvent += delegate(bool isSkill) + { + EvolveProcess(card, isSkill); + }; + } + this.OnSetupCardEvent.Call(card); + if (card.IsSpell) + { + card.OnPlay += () => RemoveSpellCardFromHand(card); + card.OnFinishWhenPlaySkill += () => AddSpellCardToCemetery(card); + } + card.OnRemoveFromInPlayAfterOneTime += (bool flg, SkillProcessor skillProcessorOneTime) => flg ? NullVfx.GetInstance() : card.SkillApplyInformation.AllSkillEffectStop(); + } + + public virtual BattleCardBase CreateCard(int cardId, int cardIndex, bool isChoiceBrave = false) + { + BattleCardBase battleCardBase = CardCreatorBase.CreateCard(cardId, IsPlayer, cardIndex, BattleManagerBase.GetIns().SBattleLoad, BattleMgr, BattleManagerBase.GetIns().BattleResourceMgr, _innerOptionsBuilder, isChoiceBrave); + SetupCardEvent(battleCardBase); + return battleCardBase; + } + + public BattleCardBase CreateVirtualCard(int cardId, int cardIndex) + { + BattleCardBase battleCardBase = CardCreatorBase.CreateVirtualCard(cardId, cardIndex, IsPlayer, BattleMgr, this, _opponentBattlePlayer, _innerOptionsBuilder); + SetupCardEvent(battleCardBase); + return battleCardBase; + } + + public BattleCardBase CreateNextIndexCard(int cardId, bool isChoiceBrave = false) + { + BattleCardBase result = CreateCard(cardId, cardTotalNum, isChoiceBrave); + if (!isChoiceBrave) + { + cardTotalNum++; + } + return result; + } + + public VfxBase CardManagement(BattleCardBase card, SkillProcessor skillProcessor, CARD_MANAGEMENT management, bool isRandom, List fusionCards = null, BattleCardBase vehicleCard = null, SkillBase skill = null, SummonInfo summonInfo = null, bool isOpen = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + switch (management) + { + case CARD_MANAGEMENT.DESTROY: + if (card.SkillApplyInformation.IsBanishByDestroy && card.SkillApplyInformation.IsDestroyByBanish) + { + sequentialVfxPlayer.Register(DestroyManagement(card, skillProcessor, isRandom, skill)); + } + else if (!card.SkillApplyInformation.IsBanishByDestroy && card.SkillApplyInformation.IsDestroyByBanish) + { + if (card.SkillApplyInformation.IsIndestructible && card.IsDestroyedBySkill) + { + card.ResetFlagCardAsDestroyed(); + } + else + { + sequentialVfxPlayer.Register(BanishManagement(card, skillProcessor, skill, isReturn: false, isRandom, isOpen)); + } + } + else + { + sequentialVfxPlayer.Register(DestroyManagement(card, skillProcessor, isRandom, skill)); + } + break; + case CARD_MANAGEMENT.BANISH: + if (card.SkillApplyInformation.IsBanishByDestroy && card.SkillApplyInformation.IsDestroyByBanish) + { + sequentialVfxPlayer.Register(DestroyManagement(card, skillProcessor, isRandom, skill)); + } + else if (card.SkillApplyInformation.IsBanishByDestroy && !card.SkillApplyInformation.IsDestroyByBanish) + { + sequentialVfxPlayer.Register(DestroyManagement(card, skillProcessor, isRandom, skill)); + } + else + { + sequentialVfxPlayer.Register(BanishManagement(card, skillProcessor, skill, isReturn: false, isRandom, isOpen)); + } + break; + case CARD_MANAGEMENT.RETURN: + GameReturnedCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, card, BattleMgr.IsTurnEnd)); + card.SetReturnedSkill(skill); + if (card.SkillApplyInformation.IsReturnByBanish && card.SkillApplyInformation.IsBanishByDestroy) + { + if (card.SkillApplyInformation.IsIndestructible) + { + sequentialVfxPlayer.Register(ReturnCardManagement(card, skillProcessor, skill)); + break; + } + card.FlagCardAsDestroyedBySkill(); + sequentialVfxPlayer.Register(DestroyManagement(card, skillProcessor, isRandom, skill)); + } + else if (card.SkillApplyInformation.IsReturnByBanish) + { + sequentialVfxPlayer.Register(BanishManagement(card, skillProcessor, skill, isReturn: true, isRandom, isOpen)); + } + else + { + sequentialVfxPlayer.Register(ReturnCardManagement(card, skillProcessor, skill)); + } + break; + case CARD_MANAGEMENT.FUSION_MATERIAL: + sequentialVfxPlayer.Register(Fusion(card, fusionCards, skillProcessor)); + break; + case CARD_MANAGEMENT.GETON: + sequentialVfxPlayer.Register(GetOnCardManagement(card, skillProcessor, vehicleCard, skill)); + break; + case CARD_MANAGEMENT.GETOFF: + return GetOffCardManagement(summonInfo, skillProcessor, vehicleCard, skill); + case CARD_MANAGEMENT.SUMMON: + return SummonCardManagement(summonInfo, skillProcessor, skill); + } + return sequentialVfxPlayer; + } + + public void CallOnSummonTokenCards(BattleCardBase card, List summonCards, List overflowCards, bool isSelf, bool isOwnerEffect, bool isIgnoreVoice, bool isRandomVoice, bool isEvoVoice) + { + this.OnSummonTokenCards.Call(card, summonCards, overflowCards, isSelf, isOwnerEffect, isIgnoreVoice, isRandomVoice, isEvoVoice); + } + + public void CallOnSummonCards(BattleCardBase card, List cards, bool isSelf, bool isDeckSelf, bool isIgnoreVoice, bool isBurialRite = false) + { + this.OnSummonCards.Call(card, cards, isSelf, isDeckSelf, isIgnoreVoice, isBurialRite); + } + + protected VfxBase Fusion(BattleCardBase fusionCard, List ingredientCards, SkillProcessor skillProcessor) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (!fusionCard.IsFusionable) + { + return sequentialVfxPlayer; + } + if (!GameMgr.GetIns().IsAdminWatch && !GameMgr.GetIns().IsReplayBattle) + { + BattleLogManager.GetInstance().AddFusionIngredients(fusionCard, isCreateClone: false); + } + if (!BattleMgr.IsVirtualBattle && !BattleMgr.IsRecovery) + { + sequentialVfxPlayer.Register(BattleView.CreateBeforeFusionVfx(fusionCard, ingredientCards)); + } + new SkillConditionCheckerOption(); + SkillProcessor.ProcessInfo processInfo = fusionCard.Skills.CreateWhenFusionMetamorphoseInfo(ingredientCards, skillProcessor, new BattlePlayerPair(fusionCard.SelfBattlePlayer, fusionCard.OpponentBattlePlayer)); + skillProcessor.Register(processInfo); + bool flag = processInfo != null; + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + foreach (BattleCardBase ingredientCard in ingredientCards) + { + parallelVfxPlayer.Register(UseFusionIngredientManagement(ingredientCard, fusionCard, skillProcessor, isRandom: false, flag)); + } + sequentialVfxPlayer.Register(parallelVfxPlayer); + TurnFusionCards.Add(fusionCard); + AddCurrentTurnFusionCount(1); + if (GameMgr.GetIns().IsAdminWatch || GameMgr.GetIns().IsReplayBattle) + { + BattleLogManager.GetInstance().AddFusionIngredients(fusionCard, isCreateClone: true); + } + BattleCardBase originalCard = fusionCard; + fusionCard.CallOnFusionEvent(ingredientCards); + sequentialVfxPlayer.Register(skillProcessor.Process(new BattlePlayerPair(this, _opponentBattlePlayer))); + if (flag) + { + fusionCard = fusionCard.MetamorphoseCard; + } + sequentialVfxPlayer.Register(BattleView.ReturnActCardAfterFusion(fusionCard.BattleCardView, flag)); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + ImmediateVfxMgr.GetInstance().Register(new ShowSideLogVfx(originalCard, null, originalCard.SelfBattlePlayer.BattleView.GetSideLogControl(isSkillTargetSelect: false), originalCard.GetCardSkillDescription(new SideLogInfo(null)), 3f)); + })); + VfxBase vfx = fusionCard.Fusion(skillProcessor, ingredientCards, flag); + sequentialVfxPlayer.Register(vfx); + VfxBase vfx2 = skillProcessor.Process(new BattlePlayerPair(this, _opponentBattlePlayer)); + sequentialVfxPlayer.Register(vfx2); + return sequentialVfxPlayer; + } + + public VfxBase CardManagement(List cards, SkillProcessor skillProcessor, CARD_MANAGEMENT management, bool isRandom, SkillBase skill = null) + { + if (!BattleMgr.IsRecovery) + { + for (int i = 0; i < cards.Count; i++) + { + BurialRiteOrDiscardCardHandIndexList.Add(HandCardList.IndexOf(cards[i])); + } + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (management == CARD_MANAGEMENT.DESTROY) + { + sequentialVfxPlayer.Register(DestroyManagement(cards, skillProcessor, isRandom, skill)); + } + return sequentialVfxPlayer; + } + + protected VfxBase DestroyManagement(BattleCardBase card, SkillProcessor skillProcessor, bool isRandom, SkillBase destroyedSkill = null) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + bool num = ClassAndInPlayCardList.Contains(card); + bool flag = HandCardList.Contains(card); + if (num) + { + this.OnStartLeaveCard.Call(); + sequentialVfxPlayer.Register(DestroyCard(card, skillProcessor, isRandom, destroyedSkill)); + sequentialVfxPlayer.Register(card.DestroyInPlay(skillProcessor, useDestroy: true, destroyedSkill)); + this.OnDestroy.Call(card); + } + else if (flag) + { + sequentialVfxPlayer.Register(DestroyCard(card, skillProcessor, isRandom, destroyedSkill)); + sequentialVfxPlayer.Register(DisCard(card, new List { card }, skillProcessor, destroyedSkill)); + } + return sequentialVfxPlayer; + } + + protected VfxBase DestroyManagement(List cards, SkillProcessor skillProcessor, bool isRandom, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (HandCardList.Contains(cards.First())) + { + for (int i = 0; i < cards.Count; i++) + { + sequentialVfxPlayer.Register(DestroyCard(cards[i], skillProcessor, isRandom, skill)); + } + sequentialVfxPlayer.Register(DisCards(cards, skillProcessor, skill)); + } + return sequentialVfxPlayer; + } + + protected VfxBase BanishManagement(BattleCardBase card, SkillProcessor skillProcessor, SkillBase skill, bool isReturn = false, bool isRandom = false, bool isOpen = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + bool num = InPlayCards.Contains(card); + bool flag = HandCardList.Contains(card); + bool flag2 = DeckCardList.Contains(card); + this.OnStartLeaveCard.Call(); + if (num) + { + card.SetBanishedInfo(BattleCardBase.BanishInfo.BanishPlace.Field); + sequentialVfxPlayer.Register(card.SkillApplyInformation.AllSkillEffectStop()); + sequentialVfxPlayer.Register(BanishCard(card, skillProcessor, isRandom, skill, isOpen)); + sequentialVfxPlayer.Register(card.Banish(skillProcessor, isReturn)); + } + else if (flag) + { + card.SetBanishedInfo(BattleCardBase.BanishInfo.BanishPlace.Hand); + sequentialVfxPlayer.Register(BanishCard(card, skillProcessor, isRandom, skill, isOpen)); + VfxWithLoading vfxWithLoading = card.BanishInHand(skillProcessor); + sequentialVfxPlayer.Register(vfxWithLoading.LoadingVfx); + sequentialVfxPlayer.Register(vfxWithLoading.MainVfx); + } + else if (flag2) + { + card.SetBanishedInfo(BattleCardBase.BanishInfo.BanishPlace.Deck); + sequentialVfxPlayer.Register(BanishCard(card, skillProcessor, isRandom, skill, isOpen)); + sequentialVfxPlayer.Register(card.BanishInDeck(skillProcessor)); + } + this.OnBanish.Call(card); + return sequentialVfxPlayer; + } + + public VfxBase UseFusionIngredientManagement(BattleCardBase ingredientCard, BattleCardBase fusionCard, SkillProcessor skillProcessor, bool isRandom = false, bool isFusionMetamorphose = false) + { + if (FusionIngredientList.Any((BattleCardBase c) => c == fusionCard)) + { + return NullVfx.GetInstance(); + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + VfxWithLoading vfxWithLoading = ingredientCard.FusionMaterialized(skillProcessor, fusionCard, isFusionMetamorphose); + this.OnFusion.Call(ingredientCard); + HandCardList.Remove(ingredientCard); + CallSkill((IBattlePlayerSkill s) => s.StopBattleHandCard, ingredientCard); + FusionIngredientList.Add(ingredientCard); + FusionIngredientAndDiscardedCardList.Add(ingredientCard); + if (isRandom) + { + PredictionBanishRandomCards.Add(ingredientCard); + } + this.OnAddBanishAfterEvent.Call(fusionCard); + sequentialVfxPlayer.Register(ingredientCard.UnloadResource()); + sequentialVfxPlayer.Register(vfxWithLoading.LoadingVfx); + sequentialVfxPlayer.Register(vfxWithLoading.MainVfx); + return sequentialVfxPlayer; + } + + protected VfxBase ReturnCardManagement(BattleCardBase card, SkillProcessor skillProcessor, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + this.OnStartLeaveCard.Call(); + sequentialVfxPlayer.Register(ReturnCard(card, skillProcessor, skill)); + this.OnReturn.Call(card); + return sequentialVfxPlayer; + } + + protected VfxBase GetOnCardManagement(BattleCardBase getOnCard, SkillProcessor skillProcessor, BattleCardBase vehicleCard, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + vehicleCard.SkillApplyInformation.AddGetOnCard(getOnCard); + getOnCard.DeathTypeInfo.LeaveByGetOn = true; + sequentialVfxPlayer.Register(getOnCard.RemoveFromInPlay()); + sequentialVfxPlayer.Register(CardToVehicleZone(getOnCard, skill)); + SkillProcessor.ProcessInfo info = vehicleCard.Skills.CreateWhenGetOnInfo(skillProcessor, playerInfoPair); + sequentialVfxPlayer.Register(getOnCard.RemoveFromInPlayAfter(skillProcessor)); + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(null, null, skillProcessor)); + skillProcessor.Register(info); + sequentialVfxPlayer.Register(getOnCard.GetOn(vehicleCard.BattleCardView.Transform, vehicleCard.BattleCardView, skillProcessor)); + return sequentialVfxPlayer; + } + + protected VfxBase GetOffCardManagement(SummonInfo summonInfo, SkillProcessor skillProcessor, BattleCardBase vehicleCard, SkillBase skill) + { + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(); + foreach (BattleCardBase summonedCard in summonInfo.SummonedCardsList.summonedCards) + { + vfxWithLoadingSequential.RegisterVfxWithLoading(summonedCard.SkillPlayCard(IsPlayer, SkillBaseSummon.SUMMON_TYPE.TOKEN, skillProcessor, skill, isGetoff: true)); + } + vfxWithLoadingSequential.RegisterToLoadingVfx(BattleMgr.LoadCardResources(summonInfo.SummonedCardsList.summonedCards.ToList())); + vfxWithLoadingSequential.RegisterToLoadingVfx(BattleMgr.LoadCardResources(summonInfo.SummonedCardsList.overflowCards.ToList())); + this.OnGetoff.Call(summonInfo.SummonedCardsList.summonedCards.ToList(), summonInfo.SummonedCardsList.overflowCards.ToList(), skill); + vfxWithLoadingSequential.RegisterToMainVfx(StartSkillWhenChangeInplay(null, summonInfo.SummonedCardsList.summonedCards.ToList(), skillProcessor, isSummonCheck: false)); + vehicleCard.GetOffCards.AddRange(summonInfo.SummonedCardsList.summonedCards); + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + skillProcessor.Register(vehicleCard.Skills.CreateWhenGetOffInfo(skillProcessor, playerInfoPair), ignoreOwnerDeadCheck: true); + UpdateHandCardsPlayability(); + return vfxWithLoadingSequential; + } + + protected VfxBase SummonCardManagement(SummonInfo summonInfo, SkillProcessor skillProcessor, SkillBase skill) + { + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + if (summonInfo.IsReanimate) + { + skillConditionCheckerOption.ReanimatedCards = ConvertToSkillInfoCollection(summonInfo.SummonedCardsList); + } + if (summonInfo.IsDeckSelfSummon) + { + skillConditionCheckerOption.DeckSelfSummonedCards = ConvertToSkillInfoCollection(summonInfo.SummonedCardsList); + } + foreach (BattleCardBase summonedCard in summonInfo.SummonedCardsList.summonedCards) + { + vfxWithLoadingSequential.RegisterVfxWithLoading(summonedCard.SkillPlayCard(summonInfo.IsPlayer, summonInfo.SummonType, skillProcessor, skill, isGetoff: false, summonInfo.IsReanimate)); + } + vfxWithLoadingSequential.RegisterToLoadingVfx(BattleMgr.LoadCardResources(summonInfo.SummonedCardsList.summonedCards.ToList())); + SkillSummonedCards = new List(summonInfo.SummonedCardsList.summonedCards); + SummonedCards = new List(summonInfo.SummonedCardsList.ToList()); + vfxWithLoadingSequential.RegisterToLoadingVfx(BattleMgr.LoadCardResources(summonInfo.SummonedCardsList.overflowCards.ToList())); + vfxWithLoadingSequential.RegisterToMainVfx(StartSkillWhenChangeInplay(null, summonInfo.SummonedCardsList.summonedCards.ToList(), skillProcessor, isSummonCheck: true, null, skillConditionCheckerOption)); + for (int i = 0; i < SkillSummonedCards.Count; i++) + { + List list = new List(); + for (int j = i + 1; j < SkillSummonedCards.Count; j++) + { + list.Add(SkillSummonedCards[j]); + } + StartSkillWhenSummonOther(SkillSummonedCards[i], skillProcessor, summonInfo.IsReanimate, list); + } + BattleCardBase[] array = summonInfo.SummonedCardsList.Where((BattleCardBase c) => c.IsInplay && c.IsUnit).ToArray(); + for (int num = 0; num < array.Length; num++) + { + array[num].SelfBattlePlayer.AddRallyCount(1); + } + UpdateHandCardsPlayability(); + return vfxWithLoadingSequential; + } + + protected VfxBase DestroyCard(BattleCardBase destroyCard, SkillProcessor skillProcessor, bool isRandom, SkillBase skill) + { + bool flag = destroyCard.IsChantField && destroyCard.ChantCount <= 0; + if (destroyCard.SkillApplyInformation.IsIndestructible && destroyCard.IsDestroyedBySkill && !flag && !destroyCard.DeathTypeInfo.MysteriesDestroy && (!destroyCard.IsTribe(CardBasePrm.TribeType.WHITE_RITUAL) || destroyCard.SkillApplyInformation.WhiteRitualCount > 0 || (!(destroyCard is FieldBattleCard) && !(destroyCard is ChantFieldBattleCard)))) + { + destroyCard.ResetFlagCardAsDestroyed(); + if (!destroyCard.IsDead) + { + return NullVfx.GetInstance(); + } + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (skillProcessor != null) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + if (ClassAndInPlayCardList.Any((BattleCardBase c) => c == destroyCard)) + { + new SkillConditionCheckerOption().DestroyedCard = destroyCard; + TurnDestroyCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, destroyCard, BattleMgr.IsTurnEnd)); + GameLeftCards.Add(destroyCard); + GameTurnLeftCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, destroyCard, BattleMgr.IsTurnEnd)); + sequentialVfxPlayer.Register(destroyCard.RemoveFromInPlay()); + sequentialVfxPlayer.Register(CardToCemetery(destroyCard, skill, CEMETERY_TYPE.NORMAL, isRandom)); + SkillProcessor.ProcessInfo info = destroyCard.Skills.CreateWhenLeaveInfo(skillProcessor, playerInfoPair); + VfxWith info2 = destroyCard.Skills.CreateWhenDestroyInfo(destroyCard, skillProcessor, playerInfoPair); + if (destroyCard.HasSkillWhenDestroy && !DestroyedWhenDestroyCards.Any((BattleCardBase x) => x.Index == destroyCard.Index)) + { + DestroyedWhenDestroyCards.Add(destroyCard); + } + sequentialVfxPlayer.Register(destroyCard.RemoveFromInPlayAfter(skillProcessor)); + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(null, null, skillProcessor)); + skillProcessor.Register(info, ignoreOwnerDeadCheck: true); + skillProcessor.Register(info2.Value, ignoreOwnerDeadCheck: true); + destroyCard.OnDestroy += (BattleCardBase _card, SkillProcessor _skillProcessor) => info2.Vfx; + destroyCard.SetDestroyedBySkillList(skill); + StartSkillWhenDestroyOther(destroyCard, skillProcessor); + } + else if (HandCardList.Any((BattleCardBase c) => c == destroyCard)) + { + skillProcessor.Register(destroyCard.Skills.CreateDisCardInfo(skillProcessor, playerInfoPair)); + sequentialVfxPlayer.Register(CardToCemetery(destroyCard, skill)); + } + return sequentialVfxPlayer; + } + return CardToCemetery(destroyCard, skill); + } + + protected VfxBase BanishCard(BattleCardBase banishedCard, SkillProcessor skillProcessor, bool isRandom, SkillBase skill, bool isOpen) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + new SkillConditionCheckerOption(); + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + if (InPlayCards.Any((BattleCardBase c) => c == banishedCard)) + { + SkillProcessor.ProcessInfo info = banishedCard.Skills.CreateWhenLeaveInfo(skillProcessor, playerInfoPair); + SkillProcessor.ProcessInfo info2 = banishedCard.Skills.CreateWhenBanishInfo(banishedCard, skillProcessor, playerInfoPair); + skillProcessor.Register(info, ignoreOwnerDeadCheck: true); + skillProcessor.Register(info2, ignoreOwnerDeadCheck: true); + sequentialVfxPlayer.Register(banishedCard.RemoveFromInPlay()); + sequentialVfxPlayer.Register(CardToBanishZone(banishedCard, skill, registerEvent: true, isRandom, isOpen)); + sequentialVfxPlayer.Register(banishedCard.RemoveFromInPlayAfter(skillProcessor)); + StartSkillWhenBanishOther(banishedCard, skillProcessor, isInplay: true); + } + else if (HandCardList.Any((BattleCardBase c) => c == banishedCard)) + { + SkillProcessor.ProcessInfo info3 = banishedCard.Skills.CreateWhenBanishInfo(banishedCard, skillProcessor, playerInfoPair); + skillProcessor.Register(info3, ignoreOwnerDeadCheck: true); + sequentialVfxPlayer.Register(CardToBanishZone(banishedCard, skill, registerEvent: true, isRandom, isOpen)); + StartSkillWhenBanishOther(banishedCard, skillProcessor, isInplay: false); + } + else if (DeckCardList.Any((BattleCardBase c) => c == banishedCard)) + { + SkillProcessor.ProcessInfo info4 = banishedCard.Skills.CreateWhenBanishInfo(banishedCard, skillProcessor, playerInfoPair); + skillProcessor.Register(info4, ignoreOwnerDeadCheck: true); + sequentialVfxPlayer.Register(CardToBanishZone(banishedCard, skill, registerEvent: true, isRandom, isOpen)); + if (!BattleManagerBase.IsForecast) + { + sequentialVfxPlayer.Register(new DeckChangeVfx(this)); + sequentialVfxPlayer.Register(new DummyDeckRemoveCardVfx(IsPlayer, 1)); + } + } + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(null, null, skillProcessor)); + return sequentialVfxPlayer; + } + + protected VfxBase ReturnCard(BattleCardBase targetCard, SkillProcessor skillProcessor, SkillBase skill) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + List list = new List(); + bool flag = HandCardList.Count < 9; + if (flag) + { + list.Add(targetCard); + targetCard.DrawTurn = ((targetCard.SelfBattlePlayer.IsSelfTurn && !BattleMgr.IsTurnEnd) ? targetCard.SelfBattlePlayer.Turn : (targetCard.SelfBattlePlayer.Turn + 1)); + } + BattleCardBase battleCardBase = targetCard.VirtualClone(this, _opponentBattlePlayer); + GameLeftCards.Add(battleCardBase); + GameTurnLeftCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, battleCardBase, BattleMgr.IsTurnEnd)); + skillConditionCheckerOption.InHandCard = ConvertToSkillInfoCollection(list); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create(); + List list2 = new List(); + if (targetCard.SkillApplyInformation.IsSkillCantAtkAll) + { + list2.Add(targetCard); + } + SkillProcessor.ProcessInfo info = targetCard.Skills.CreateWhenLeaveInfo(skillProcessor, playerInfoPair); + skillProcessor.Register(info, ignoreOwnerDeadCheck: true); + SkillProcessor.ProcessInfo info2 = targetCard.Skills.CreateWhenReturnInfo(skillProcessor, playerInfoPair); + sequentialVfxPlayer2.Register(targetCard.ReturnCard(skillProcessor)); + parallelVfxPlayer.Register(ReturnToHand(targetCard, skill)); + sequentialVfxPlayer2.Register(targetCard.RemoveFromInPlayAfter(skillProcessor, isReturn: true)); + parallelVfxPlayer.Register(sequentialVfxPlayer2); + this.OnAfterReturnCardEvent.Call(targetCard); + this.OnLeaveAfterEvent.Call(targetCard); + skillProcessor.Register(info2, ignoreOwnerDeadCheck: true); + sequentialVfxPlayer.Register(parallelVfxPlayer); + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(new List { targetCard }, null, skillProcessor, isSummonCheck: true, flag ? ((Func)((SkillBase s) => s.OnWhenAddToHand)) : null, skillConditionCheckerOption)); + StartSkillWhenReturnOther(targetCard, skillProcessor, list2); + return sequentialVfxPlayer; + } + + public VfxBase UniteCard(BattleCardBase destroyCard, SkillProcessor skillProcessor, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + new SkillConditionCheckerOption(); + destroyCard.FlagCardAsDestroyedBySkill(); + sequentialVfxPlayer.Register(CardToUniteZone(destroyCard, skill)); + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(null, null, skillProcessor)); + return sequentialVfxPlayer; + } + + protected virtual VfxBase DisCard(BattleCardBase ownerCard, List targetCards, SkillProcessor skillProcessor, SkillBase discardedSkill) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + for (int i = 0; i < targetCards.Count; i++) + { + parallelVfxPlayer.Register(targetCards[i].DestroyInHand(skillProcessor)); + targetCards[i].SetDiscardedSkill(discardedSkill); + } + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true, containsDeck: false, (BattleCardBase card) => card != ownerCard && card.Skills.Any((SkillBase s) => s.OnDisCardOtherStart != 0)); + for (int num = 0; num < cardsOrderBySkillActivation.Count; num++) + { + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateDisCardOtherInfo(targetCards, cardsOrderBySkillActivation[num].IsPlayer, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2)); + } + return SequentialVfxPlayer.Create(parallelVfxPlayer); + } + + protected virtual VfxBase DisCards(List targetCards, SkillProcessor skillProcessor, SkillBase discardedSkill) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + BurialRiteOrDiscardCardHandIndexList.Clear(); + })); + for (int num = 0; num < targetCards.Count; num++) + { + parallelVfxPlayer.Register(targetCards[num].DestroyInHand(skillProcessor)); + targetCards[num].SetDiscardedSkill(discardedSkill); + } + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true, containsDeck: false, (BattleCardBase card) => !targetCards.Contains(card) && card.Skills.Any((SkillBase s) => s.OnDisCardOtherStart != 0)); + for (int num2 = 0; num2 < cardsOrderBySkillActivation.Count; num2++) + { + skillProcessor.Register(cardsOrderBySkillActivation[num2].Skills.CreateDisCardOtherInfo(targetCards, cardsOrderBySkillActivation[num2].IsPlayer, skillProcessor, (cardsOrderBySkillActivation[num2].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2)); + } + return SequentialVfxPlayer.Create(parallelVfxPlayer); + } + + protected virtual VfxBase ReturnToHand(BattleCardBase returnCard, SkillBase skill) + { + return FieldCardToHandCard(returnCard, skill); + } + + public VfxBase StartBattleMainView(bool playEffect = true) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + parallelVfxPlayer.Register(CreateUpdateClassInfoVfx(playEffect)); + for (int i = 0; i < InHandCards.Count; i++) + { + parallelVfxPlayer.Register(InHandCards.ToList()[i].BattleCardView.ShowHandCardInfo()); + } + return parallelVfxPlayer; + } + + public virtual VfxBase TurnStart() + { + foreach (BattleCardBase handCard in HandCardList) + { + handCard.SetOnDraw(draw: true); + } + IsSelfTurn = true; + _opponentBattlePlayer.IsSelfTurn = false; + this.OnTurnStartStart.Call(); + NowTurnEvol = true; + IsEpEvolveThisTurn = false; + TurnNecromanceCount = 0; + TurnPlayCards.Clear(); + TurnDrawCards.Clear(); + TurnDrawTokenCardsWithId.Clear(); + TurnBurialRiteCards.Clear(); + TurnFusionCards.Clear(); + if (!IsGameFirst || Turn != 1) + { + IsAlreadyChoiceBraveInThisTurn = false; + } + _turnUsedEpCount = 0; + TurnStartLifeList.Add(new TurnAndIntValue(Class.Life, BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn)); + _opponentBattlePlayer.TurnStartLifeList.Add(new TurnAndIntValue(_opponentBattlePlayer.Class.Life, BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn)); + SkillProcessor skillProcessor = new SkillProcessor(); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + _ = PpTotal; + GameMgr.GetIns().GetDataMgr(); + int num = 0; + IDetailPanelControl detailPanelControl = BattleMgr.DetailMgr.DetailPanelControl; + if (EvolveWaitTurnCount <= 0) + { + for (int i = 0; i < BonusConditionList.Count; i++) + { + if (BonusConditionList[i].GetAndReduceAddPpTurn()) + { + BonusConditionList[i].UseUpAddPpTotalBonus(); + if (detailPanelControl._card != null && detailPanelControl._card.IsClass && detailPanelControl._card.IsPlayer == IsPlayer) + { + detailPanelControl.UpdateBuffInfo(_class, BonusConditionList); + } + num += BonusConditionList[i].MyRotationBonus.IncreaseAddPptotalAmount; + } + } + } + int count = ((!Class.SkillApplyInformation.IsTurnStartFixedPP) ? (1 + num) : 0); + VfxBase vfx = AddPpTotal(count, isUpdatePp: true, skillProcessor); + sequentialVfxPlayer.Register(vfx); + BattleLogManager.GetInstance().AddLogTurn(IsPlayer); + BattleLogManager.GetInstance().BeginLogBlockTurnChangeReactive(); + VfxBase[] allFuncCallResults = this.OnTurnStartBeforeDraw.GetAllFuncCallResults(skillProcessor); + foreach (VfxBase vfx2 in allFuncCallResults) + { + sequentialVfxPlayer.Register(vfx2); + } + BattleCardBase[] array = HandCardList.ToArray(); + BattleCardBase[] array2 = _opponentBattlePlayer.HandCardList.ToArray(); + BattleCardBase[] array3 = ClassAndInPlayCardList.ToArray(); + BattleCardBase[] array4 = _opponentBattlePlayer.ClassAndInPlayCardList.ToArray(); + BattleCardBase[] array5 = DeckSkillCardList.ToArray(); + BattleCardBase[] array6 = _opponentBattlePlayer.DeckSkillCardList.ToArray(); + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + BattleCardBase[] array7 = array; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx3 = array7[j].TurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx3); + } + array7 = array2; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx4 = array7[j].OpponentTurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx4); + } + array7 = array3; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx5 = array7[j].TurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx5); + } + array7 = array4; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx6 = array7[j].OpponentTurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx6); + } + array7 = array5; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx7 = array7[j].TurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx7); + } + array7 = array6; + for (int j = 0; j < array7.Length; j++) + { + VfxBase vfx8 = array7[j].OpponentTurnStart(skillProcessor); + parallelVfxPlayer.Register(vfx8); + } + BattleMgr.OperateMgr.CallOnUpdateAttackableEffect(array3.Where((BattleCardBase c) => c.Attackable).ToList(), array4.Where((BattleCardBase c) => c.Attackable).ToList()); + sequentialVfxPlayer.Register(parallelVfxPlayer); + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + VfxBase vfx9 = skillProcessor.Process(battlePlayerPair); + sequentialVfxPlayer.Register(vfx9); + allFuncCallResults = OnTurnStartSkillAfter.GetAllFuncCallResults(skillProcessor); + foreach (VfxBase vfx10 in allFuncCallResults) + { + sequentialVfxPlayer.Register(vfx10); + } + if (IsGameFirst && Turn == 1) + { + for (int num2 = 0; num2 < HandCardList.Count(); num2++) + { + HandCardList[num2].Skills.CreateAndRegisterWhenChangeInplaySelfhandInfo(HandCardList, skillProcessor, battlePlayerPair); + } + BattlePlayerPair playerInfoPair = new BattlePlayerPair(_opponentBattlePlayer, this); + for (int num3 = 0; num3 < _opponentBattlePlayer.HandCardList.Count(); num3++) + { + _opponentBattlePlayer.HandCardList[num3].Skills.CreateAndRegisterWhenChangeInplaySelfhandInfo(_opponentBattlePlayer.HandCardList, skillProcessor, playerInfoPair); + } + } + sequentialVfxPlayer.Register(TurnStartDraw(skillProcessor)); + sequentialVfxPlayer.Register(skillProcessor.Process(battlePlayerPair)); + BattleUIContainer battleUIContainer = BattleManagerBase.GetIns().BattleUIContainer; + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + battleUIContainer.EnableMenu(); + })); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + BattleMgr.BattlePlayer.TurnStartEffectEnd(); + })); + BattleLogManager.GetInstance().EndLogBlockTurnChangeReactive(); + if (!BattleMgr.IsBattleEnd) + { + if (GameMgr.GetIns().IsNetworkBattle && IsPlayer) + { + NetworkBattleManagerBase networkBattleManagerBase = BattleManagerBase.GetIns() as NetworkBattleManagerBase; + if (networkBattleManagerBase.turnEndTimeController != null) + { + networkBattleManagerBase.turnEndTimeController.AddTurnEndTimerLog("Player SetActiveVFX"); + } + } + ParallelVfxPlayer parallelVfxPlayer2 = ParallelVfxPlayer.Create(); + parallelVfxPlayer2.Register(InstantVfx.Create(SetActive)); + sequentialVfxPlayer.Register(parallelVfxPlayer2); + } + VfxBase allFuncVfxResults = this.OnTurnStartAfterDraw.GetAllFuncVfxResults(); + sequentialVfxPlayer.Register(allFuncVfxResults); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + foreach (BattleCardBase handCard2 in HandCardList) + { + handCard2.SetOnDraw(draw: false); + } + UpdateHandCardsPlayability(); + })); + sequentialVfxPlayer.Register(UpdateHandCardsCost()); + sequentialVfxPlayer.Register(UpdateInPlayBattleCardIconLabel()); + sequentialVfxPlayer.Register(this.OnTurnStartFinish.GetAllFuncVfxResults()); + OnTurnStartComplete.Call(); + return sequentialVfxPlayer; + } + + public abstract VfxBase StartTurnControl(string log = ""); + + public SequentialVfxPlayer TurnEvolveControl(GameObject eqIcon) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + bool firstEvolve = false; + if (EvolveWaitTurnCount > 0) + { + if (EvolveWaitTurnCount == 1) + { + firstEvolve = true; + } + EvolveWaitTurnCount--; + } + if (BattleMgr.IsRecovery || BattleMgr.IsPuzzleMgr) + { + sequentialVfxPlayer.Register(m_vfxCreator.CreateUpdateEp(CurrentEpCount, EvolveWaitTurnCount)); + if (NowTurnEvol && CurrentEpCount > 0 && EvolveWaitTurnCount <= 0) + { + sequentialVfxPlayer.Register(new TurnStartEvolveVfx(eqIcon, firstEvolve)); + } + } + else + { + sequentialVfxPlayer.Register(BattleMgr.LoadTurnPanelResource()); + sequentialVfxPlayer.Register(m_vfxCreator.CreateUpdateEp(CurrentEpCount, EvolveWaitTurnCount)); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_YOURTURN); + BattleMgr.TurnPanelControl.StartUI(Turn, EvolveWaitTurnCount, IsPlayer); + if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle) + { + BattleView.TurnEndButtonUI.GameObject.SetActive(value: true); + BattleView.TurnEndButtonUI.ChangeButtonView(IsPlayer); + } + })); + if (NowTurnEvol && CurrentEpCount > 0 && EvolveWaitTurnCount <= 0) + { + sequentialVfxPlayer.Register(new TurnStartEvolveVfx(eqIcon, firstEvolve)); + } + sequentialVfxPlayer.Register(WaitVfx.Create(1.6f)); + } + return sequentialVfxPlayer; + } + + public virtual VfxBase TurnStartDraw(SkillProcessor skillProcessor) + { + DeckCardList.Sort((BattleCardBase a, BattleCardBase b) => a.Index - b.Index); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (!Class.IsDead && !_opponentBattlePlayer.Class.IsDead && !BattleManagerBase.GetIns().IsPuzzleMgr) + { + sequentialVfxPlayer.Register(TurnStartDrawCard(skillProcessor)); + } + return sequentialVfxPlayer; + } + + protected abstract VfxBase TurnStartDrawCard(SkillProcessor skillProcessor); + + protected abstract void SetActive(); + + public abstract BattlePlayerBase CreateVirtualPlayer(); + + public VfxBase AddPpTotal(int count, bool isUpdatePp, SkillProcessor skillProcessor, BattleCardBase ownerCard = null, bool bySkill = false) + { + string text = ""; + bool flag = false; + if (Turn <= 1 && !IsPlayer) + { + flag = true; + } + if (flag) + { + text = text + "AddPpTotal " + count + "isUpdatePp " + isUpdatePp + "NotPPcounter " + Class.SkillApplyInformation.NotDecreasePPCounter + "IsTurnStartFixedPP " + Class.SkillApplyInformation.IsTurnStartFixedPP + ":" + StackTraceUtility.ExtractStackTrace(); + } + if (count < 0 && Class.SkillApplyInformation.NotDecreasePPCounter > 0) + { + if (flag) + { + LocalLog.AccumulateLastTraceLog(text); + } + return NullVfx.GetInstance(); + } + new SkillConditionCheckerOption(); + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + int ppTotal = PpTotal; + PpTotal += count; + if (PpTotal > 10) + { + PpTotal = 10; + } + else if (PpTotal < 0) + { + PpTotal = 0; + } + int num = PpTotal; + if (flag) + { + text = text + "DecreaseList " + Class.SkillApplyInformation.DecreaseTurnStartPPList.Count; + } + for (int i = 0; i < Class.SkillApplyInformation.DecreaseTurnStartPPList.Count; i++) + { + if (flag) + { + text = text + "Decrease:" + Class.SkillApplyInformation.DecreaseTurnStartPPList[i]; + } + num -= Class.SkillApplyInformation.DecreaseTurnStartPPList[i]; + if (num < 0) + { + num = 0; + } + } + Pp = (isUpdatePp ? num : Math.Min(Pp, PpTotal)); + if (flag) + { + text = text + "nowPP " + Pp; + LocalLog.AccumulateLastTraceLog(text); + } + parallelVfxPlayer.Register(new PpChangeVfx(this)); + this.OnChangePP.Call(PpTotal - ppTotal); + this.OnAddPpTotal.Call(PpTotal - ppTotal, Pp, IsPlayer, ownerCard, bySkill); + if (skillProcessor != null) + { + StartSkillWhenChangePPTotal(skillProcessor); + } + return parallelVfxPlayer; + } + + public VfxBase SetPpTotal(int pp, bool isUpdatePp, SkillProcessor skillProcessor) + { + return AddPpTotal(pp - PpTotal, isUpdatePp, skillProcessor); + } + + public SkillProcessor GetTurnEndSkillProcess() + { + SkillProcessor skillProcessor = new SkillProcessor(); + List list = new List(); + list.AddRange(HandCardList); + list.AddRange(_opponentBattlePlayer.HandCardList); + list.AddRange(ClassAndInPlayCardList); + list.AddRange(_opponentBattlePlayer.ClassAndInPlayCardList); + list.AddRange(DeckSkillCardList); + list.AddRange(_opponentBattlePlayer.DeckSkillCardList); + int num = list.Count(); + for (int i = 0; i < num; i++) + { + list[i].TurnEndSkillProcess(skillProcessor); + } + return skillProcessor; + } + + public virtual VfxBase TurnEnd() + { + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + SequentialVfxPlayer turnEndVfx = SequentialVfxPlayer.Create(); + if (this.OnTurnEndStart != null) + { + this.OnTurnEndStart.Call(); + } + BattleLogManager.GetInstance().BeginLogBlockTurnChangeReactive(); + turnEndVfx.Register(BattleView.SetIsNowTurnEnd(flg: true)); + SkillProcessor turnEndSkillProcess = GetTurnEndSkillProcess(); + VfxBase vfx = turnEndSkillProcess.Process(battlePlayerPair); + turnEndVfx.Register(vfx); + List list = new List(); + list.AddRange(ClassAndInPlayCardList); + list.AddRange(_opponentBattlePlayer.ClassAndInPlayCardList); + for (int i = 0; i < list.Count; i++) + { + list[i].CheckPreviousTurnAttacked(); + } + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + foreach (BattleCardBase inPlayCard in InPlayCards) + { + parallelVfxPlayer.Register(inPlayCard.TurnEndPostProcess()); + } + turnEndVfx.Register(parallelVfxPlayer); + VfxBase[] allFuncCallResults = this.OnTurnEnd.GetAllFuncCallResults(turnEndSkillProcess); + foreach (VfxBase vfx2 in allFuncCallResults) + { + turnEndVfx.Register(vfx2); + } + allFuncCallResults = OnTurnEndSkillAfter.GetAllFuncCallResults(turnEndSkillProcess); + foreach (VfxBase vfx3 in allFuncCallResults) + { + turnEndVfx.Register(vfx3); + } + turnEndVfx.Register(turnEndSkillProcess.Process(battlePlayerPair)); + turnEndVfx.Register(UpdateInPlayBattleCardIconLabel()); + turnEndVfx.Register(InstantVfx.Create(delegate + { + if (HandCardList.Count <= 0) + { + turnEndVfx.Register(BattleView.HandUnfocus()); + } + })); + TurnPlayCards.Clear(); + TurnDrawCards.Clear(); + TurnDrawTokenCardsWithId.Clear(); + TurnBurialRiteCards.Clear(); + TurnFusionCards.Clear(); + TurnNecromanceCount = 0; + _turnUsedEpCount = 0; + TurnResonanceStartCount = 0; + _opponentBattlePlayer.TurnResonanceStartCount = 0; + BattleLogManager.GetInstance().EndLogBlockTurnChangeReactive(); + turnEndVfx.Register(BattleMgr.JudgeBattleResult()); + if (!BattleMgr.IsRecovery) + { + turnEndVfx.Register(InstantVfx.Create(delegate + { + int count = ClassAndInPlayCardList.Count; + for (int k = 0; k < count; k++) + { + BattleCardBase card = ClassAndInPlayCardList[k]; + if (!card.BattleCardView.GameObject.activeSelf) + { + turnEndVfx.Register(InstantVfx.Create(delegate + { + card.BattleCardView.GameObject.SetActive(value: true); + if (card.IsInplay) + { + card.SetOnDraw(draw: false); + } + })); + } + } + })); + } + OnPreTurnEndComplete.Call(); + if (!Class.IsDead && !_opponentBattlePlayer.Class.IsDead) + { + IsSelfTurn = false; + VfxBase allFuncVfxResults = this.OnTurnEndFinish.GetAllFuncVfxResults(); + turnEndVfx.Register(allFuncVfxResults); + } + OnPostTurnEndComplete.Call(); + turnEndVfx.Register(BattleView.SetIsNowTurnEnd(flg: false)); + LocalLog.RecordTurnEndIfLoadErrorOccured(); + return turnEndVfx; + } + + public void DecreasesExtraTurnCount() + { + extraTurnCount = Math.Max(0, extraTurnCount - 1); + } + + public void Clear() + { + ClearSpineObject(); + ClearClassAndMainPlace(); + ClearBattleCount(); + } + + protected void ClearSpineObject() + { + if (Class is ClassBattleCardBase classBattleCardBase) + { + classBattleCardBase.ClearSpineObject(); + } + } + + public void ClearClassAndMainPlace() + { + HandCardList.Clear(); + DeckCardList.Clear(); + BattleStartDeckCardList.Clear(); + DeckSkillCardList.Clear(); + ClassAndInPlayCardList.Clear(); + } + + public void ClearBattleCount() + { + CemeteryList.Clear(); + PredictionCemeteryRandomCards.Clear(); + PredictionDamageRandomCards.Clear(); + PredictionBanishRandomCards.Clear(); + BanishList.Clear(); + NecromanceZoneList.Clear(); + UniteList.Clear(); + GetOnList.Clear(); + BlackHole.Clear(); + ChoiceBraveCardList.Clear(); + ReturnList.Clear(); + HealingCards.Clear(); + LastTargetCardsList.Clear(); + SkillSummonedCards.Clear(); + SummonedCards.Clear(); + EvolvedCards.Clear(); + DestroyedWhenDestroyCards.Clear(); + InHandCards.Clear(); + SkillDiscards.Clear(); + SkillBanishCards.Clear(); + DrewSkillCard = null; + TurnPlayCards.Clear(); + TurnDrawCards.Clear(); + TurnDrawTokenCardsWithId.Clear(); + GamePlayCards.Clear(); + GameTurnPlayCards.Clear(); + GameEnhancePlayCards.Clear(); + GameCrystallizedPlayCards.Clear(); + OkSkillInProcess.Clear(); + TurnDestroyCards.Clear(); + AddToDeckCardList.Clear(); + GameSummonCards.Clear(); + GameSummonMomentTribe.Clear(); + GamePlayMomentTribe.Clear(); + GamePlayMomentSpellChargeCards.Clear(); + GameUpdateDeckMomentTribe.Clear(); + GameDrawCards.Clear(); + GameDrawTokenCards.Clear(); + GameAddUpdateDeckCards.Clear(); + GameQuickAttackCards.Clear(); + TurnBurialRiteCards.Clear(); + GameReanimatedCards.Clear(); + TurnWhenHealingCount.Clear(); + GameLeftCards.Clear(); + GameTurnLeftCards.Clear(); + GameReturnedCards.Clear(); + GameSuperSkyboundArtCards.Clear(); + TurnPlayCardCountInfo.Clear(); + TurnFusionCountInfo.Clear(); + TurnNecromanceCount = 0; + GameNecromanceCount = 0; + GameUsedPpCount = 0; + RallyCount = 0; + DeckBanishCount = 0; + GameResonanceStartCount = 0; + TurnResonanceStartCount = 0; + GameUsedWhiteRitualCount = 0; + LastInplayWhiteRitualStack = 0; + _turnUsedEpCount = 0; + GameSkillReturnCardCountList.Clear(); + GameSkillDiscardCountList.Clear(); + GameSkillBuffCountList.Clear(); + GameSkillMetamorphoseCountList.Clear(); + GameSkillDiscardCount = 0; + DiscardedCardList.Clear(); + FusionIngredientList.Clear(); + FusionIngredientAndDiscardedCardList.Clear(); + ReservedCardList.Clear(); + TurnEvolveCardCountInfo.Clear(); + GameInplayMetamorphoseCards.Clear(); + GameBurialRiteCards.Clear(); + TurnStartLifeList.Clear(); + TurnFusionCards.Clear(); + } + + public BattleCardBase FindCardFromGameObject(GameObject cardObject) + { + return AllCards.FirstOrDefault((BattleCardBase s) => s.BattleCardView.GameObject == cardObject); + } + + protected void AddInplayCard(BattleCardBase card, bool isGetoff = false, bool isReanimate = false) + { + ClassAndInPlayCardList.Add(card); + if (!card.IsClass && !isGetoff) + { + GameSummonCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, card, BattleMgr.IsTurnEnd)); + GameSummonMomentTribe.Add(new CardAndTribe(card, card.Tribe)); + if (isReanimate) + { + GameReanimatedCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, card, BattleMgr.IsTurnEnd)); + } + } + } + + public void AddRallyCount(int addCount) + { + RallyCount += addCount; + } + + public VfxBase PickCard(BattleCardBase unit, SkillBase skill, SkillBaseSummon.SUMMON_TYPE summonType = SkillBaseSummon.SUMMON_TYPE.HAND, bool isGetoff = false, bool isReanimate = false) + { + this.OnPickCard.Call(unit); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + switch (summonType) + { + case SkillBaseSummon.SUMMON_TYPE.HAND: + HandCardToField(unit, skill); + break; + case SkillBaseSummon.SUMMON_TYPE.DECK: + DeckCardToField(unit, skill); + sequentialVfxPlayer.Register(new DeckChangeVfx(this)); + sequentialVfxPlayer.Register(new DummyDeckRemoveCardVfx(IsPlayer, 1)); + break; + case SkillBaseSummon.SUMMON_TYPE.TOKEN: + TokenToField(unit, skill, isGetoff, isReanimate); + break; + case SkillBaseSummon.SUMMON_TYPE.DESTROYED: + DestroyedToField(unit, skill); + break; + } + this.OnAfterPickCard.Call(); + return sequentialVfxPlayer; + } + + public virtual void HandCardToField(BattleCardBase targetCard, SkillBase skill = null) + { + BattleCardBase battleCardBase = HandCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + if (battleCardBase == null) + { + throw new Exception("Target card was not found in hand cards."); + } + this.OnAddPlayCardEvent.Call(battleCardBase, arg2: false, skill); + AddInplayCard(battleCardBase); + HandCardList.Remove(battleCardBase); + CallSkill((IBattlePlayerSkill s) => s.StopBattleHandCard, battleCardBase); + this.OnAddPlayCardAfterEvent.Call(); + this.OnSummonAfterEvent.Call(battleCardBase); + } + + private bool TokenToField(BattleCardBase targetCard, SkillBase skill, bool isGetoff = false, bool isReanimate = false) + { + if (InPlayCards.Count() < 6) + { + this.OnAddPlayCardEvent.Call(targetCard, isGetoff, skill); + AddInplayCard(targetCard, isGetoff, isReanimate); + this.OnSummonAfterEvent.Call(targetCard); + return true; + } + return false; + } + + public bool CemeteryConsumption(int num, BattleCardBase necromanceCard, SkillProcessor skillprocessor, bool isFusion) + { + if (CemeteryList.Count < num) + { + return false; + } + if (num == -1) + { + num = 0; + } + for (int i = 0; i < num; i++) + { + BattleCardBase item = CemeteryList.First(); + NecromanceZoneList.Add(item); + CemeteryList.Remove(item); + } + SuccessNecromance(necromanceCard, skillprocessor, num, isFusion); + return true; + } + + public void SuccessNecromance(BattleCardBase necromanceCard, SkillProcessor skillprocessor, int necromanceCount, bool isFusion) + { + int turnNecromanceCount = TurnNecromanceCount + 1; + TurnNecromanceCount = turnNecromanceCount; + GameNecromanceCount += necromanceCount; + this.OnNecromance.Call(necromanceCard, skillprocessor, necromanceCount, isFusion); + } + + public VfxBase GainCemetery(int gainCount) + { + if (gainCount > CemeteryList.Count()) + { + gainCount = CemeteryList.Count(); + } + for (int i = 0; i < gainCount; i++) + { + BattleCardBase item = CemeteryList.First(); + NecromanceZoneList.Add(item); + CemeteryList.Remove(item); + } + return this.OnAddCemeteryAfterEvent.GetAllFuncVfxResults(); + } + + protected VfxBase FieldCardToHandCard(BattleCardBase targetCard, SkillBase skill) + { + BattleCardBase battleCardBase = ClassAndInPlayCardList.Single((BattleCardBase c) => c == targetCard); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(battleCardBase.RemoveFromInPlay()); + if (HandCardList.Count >= 9) + { + VfxBase vfx = CardToCemetery(battleCardBase, skill, CEMETERY_TYPE.FIELD_RETURN_HAND_OVER); + sequentialVfxPlayer.Register(vfx); + return sequentialVfxPlayer; + } + ClassAndInPlayCardList.Remove(battleCardBase); + HandCardAddList(battleCardBase, NetworkBattleDefine.NetworkCardPlaceState.Field, skill); + return sequentialVfxPlayer; + } + + protected void HandCardAddList(BattleCardBase targetCard, NetworkBattleDefine.NetworkCardPlaceState fromState, SkillBase skill, bool isOpen = false) + { + InHandCards.Add(targetCard); + this.OnAddHandCardEvent.Call(targetCard, fromState, isOpen, skill); + HandCardList.Add(targetCard); + CallSkill((IBattlePlayerSkill s) => s.StartBattleHandCard, targetCard); + this.OnAddHandCardAfterEvent.Call(); + } + + public VfxBase CardToCemetery(BattleCardBase targetCard, SkillBase skill, CEMETERY_TYPE cemeteryType = CEMETERY_TYPE.NORMAL, bool wasRandom = false) + { + if (CemeteryList.Any((BattleCardBase c) => c == targetCard)) + { + return NullVfx.GetInstance(); + } + BattleCardBase battleCardBase = ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + BattleCardBase battleCardBase2 = HandCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + BattleCardBase battleCardBase3 = DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + if (battleCardBase == null && battleCardBase2 == null && battleCardBase3 == null) + { + return NullVfx.GetInstance(); + } + this.OnAddCemeteryEvent.Call(targetCard, cemeteryType, arg3: false, skill); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + BattleCardBase battleCardBase4 = null; + if (battleCardBase != null) + { + ClassAndInPlayCardList.Remove(battleCardBase); + battleCardBase4 = battleCardBase; + if (battleCardBase.IsUnit && cemeteryType != CEMETERY_TYPE.FIELD_RETURN_HAND_OVER && !BattleMgr.IsVirtualBattle) + { + BattleLogManager.GetInstance().AddLogDestFollower(BattleLogWindow.BattleLogType.Destruction, battleCardBase); + } + } + else + { + battleCardBase4 = ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + } + if (battleCardBase4 == null && battleCardBase2 != null) + { + HandCardList.Remove(battleCardBase2); + CallSkill((IBattlePlayerSkill s) => s.StopBattleHandCard, battleCardBase2); + battleCardBase4 = battleCardBase2; + } + if (battleCardBase4 == null && battleCardBase3 != null) + { + DeckCardList.Remove(battleCardBase3); + sequentialVfxPlayer.Register(CreateUpdateDeckCountLabelVfx()); + battleCardBase4 = battleCardBase3; + } + VfxBase vfxBase = NullVfx.GetInstance(); + if (battleCardBase4 != null) + { + CemeteryList.Add(battleCardBase4); + if (!battleCardBase4.IsClass) + { + vfxBase = battleCardBase4.UnloadResource(); + sequentialVfxPlayer.Register(this.OnAddCemeteryAfterEvent.GetAllFuncVfxResults()); + this.OnLeaveAfterEvent.Call(battleCardBase4); + } + if (wasRandom) + { + PredictionCemeteryRandomCards.Add(battleCardBase4); + } + } + return SequentialVfxPlayer.Create(vfxBase, sequentialVfxPlayer); + } + + public VfxBase CardToVehicleZone(BattleCardBase targetCard, SkillBase skill) + { + if (CemeteryList.Any((BattleCardBase c) => c == targetCard)) + { + return NullVfx.GetInstance(); + } + if (!ClassAndInPlayCardList.Any((BattleCardBase c) => c == targetCard)) + { + return NullVfx.GetInstance(); + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + this.OnGeton.Call(targetCard, skill); + ClassAndInPlayCardList.Remove(targetCard); + GetOnList.Add(targetCard); + sequentialVfxPlayer.Register(targetCard.UnloadResource()); + return sequentialVfxPlayer; + } + + public VfxBase DummyCardToCemetery(BattleCardBase targetCard, SkillBase skill = null) + { + this.OnAddCemeteryEvent.Call(targetCard, CEMETERY_TYPE.NORMAL, arg3: false, skill); + CemeteryList.Add(targetCard); + return this.OnAddCemeteryAfterEvent.GetAllFuncVfxResults(); + } + + public VfxBase ClearDestroyedAndDiscardedCardList(SkillBase skill) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + int count = CemeteryList.Count; + this.OnAddBlackHole.Call(CemeteryList, skill); + this.OnAddBlackHole.Call(NecromanceZoneList, skill); + BlackHole.AddRange(CemeteryList); + BlackHole.AddRange(NecromanceZoneList); + CemeteryList.Clear(); + NecromanceZoneList.Clear(); + DestroyedWhenDestroyCards.Clear(); + for (int i = 0; i < DiscardedCardList.Count; i++) + { + FusionIngredientAndDiscardedCardList.Remove(DiscardedCardList[i]); + } + DiscardedCardList.Clear(); + for (int j = 0; j < count; j++) + { + parallelVfxPlayer.Register(DummyCardToCemetery(CardCreatorBase.GetDummyInstance(), skill)); + } + return parallelVfxPlayer; + } + + public VfxBase RemoveSpellCardFromHand(BattleCardBase targetSpellCard) + { + if (targetSpellCard.IsChoiceBraveSkillCard) + { + return NullVfx.GetInstance(); + } + BattleCardBase battleCardBase = HandCardList.SingleOrDefault((BattleCardBase c) => c == targetSpellCard); + if (battleCardBase == null) + { + throw new Exception("Target card was not found in hand cards."); + } + this.OnSpellPlayEvent.Call(battleCardBase); + HandCardList.Remove(battleCardBase); + return NullVfx.GetInstance(); + } + + public VfxBase AddSpellCardToCemetery(BattleCardBase targetSpellCard) + { + if (CemeteryList.Any((BattleCardBase c) => c == targetSpellCard)) + { + return NullVfx.GetInstance(); + } + if (!targetSpellCard.IsChoiceBraveSkillCard) + { + CemeteryList.Add(targetSpellCard); + } + else + { + ChoiceBraveCardList.Add(targetSpellCard); + } + BattleMgr.VfxMgr.RegisterImmediateVfx(this.OnAddCemeteryAfterEvent.GetAllFuncVfxResults()); + return targetSpellCard.UnloadResource(); + } + + public VfxBase CardToBanishZone(BattleCardBase targetCard, SkillBase skill, bool registerEvent = true, bool wasRandom = false, bool isOpen = false) + { + targetCard.DeathTypeInfo.BanishDestroy = true; + if (BanishList.Any((BattleCardBase c) => c == targetCard)) + { + return NullVfx.GetInstance(); + } + if (registerEvent) + { + bool arg = isOpen || (skill is Skill_banish && skill.OnSelfTurnEndStart != 0 && skill.ConditionFilterCollection.VariableCompareFilter.Any((SkillVariableComareFilter f) => f.Text.Contains("hand_self"))); + this.OnAddBanishEvent.Call(targetCard, skill, arg); + } + BattleCardBase battleCardBase = null; + if (ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + battleCardBase = ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + ClassAndInPlayCardList.Remove(ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c == targetCard)); + BattleCardBase battleCardBase2 = battleCardBase.VirtualClone(this, _opponentBattlePlayer); + GameLeftCards.Add(battleCardBase2); + GameTurnLeftCards.Add(new TurnAndCard(IsSelfTurn ? Turn : BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn, battleCardBase2, BattleMgr.IsTurnEnd)); + } + else if (HandCardList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + battleCardBase = HandCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + HandCardList.Remove(battleCardBase); + CallSkill((IBattlePlayerSkill s) => s.StopBattleHandCard, battleCardBase); + } + else if (DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + battleCardBase = DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + if (battleCardBase == null) + { + throw new Exception("Target card was not found in either field, hand or deck."); + } + DeckCardList.Remove(battleCardBase); + battleCardBase.SelfBattlePlayer.DeckBanishCount++; + } + if (battleCardBase == null) + { + return NullVfx.GetInstance(); + } + BanishList.Add(battleCardBase); + SkillBanishCards.Add(battleCardBase); + if (wasRandom) + { + PredictionBanishRandomCards.Add(battleCardBase); + } + this.OnAddBanishAfterEvent.Call(targetCard); + this.OnLeaveAfterEvent.Call(targetCard); + return battleCardBase.UnloadResource(); + } + + public VfxBase CardToUniteZone(BattleCardBase targetCard, SkillBase skill) + { + targetCard.DeathTypeInfo.BanishDestroy = true; + if (UniteList.Any((BattleCardBase c) => c == targetCard)) + { + return NullVfx.GetInstance(); + } + this.OnAddUniteEvent.Call(targetCard, skill); + ClassAndInPlayCardList.Remove(targetCard); + UniteList.Add(targetCard); + this.OnAddUniteAfterEvent.Call(targetCard); + this.OnLeaveAfterEvent.Call(targetCard); + return targetCard.UnloadResource(); + } + + private void DeckCardToField(BattleCardBase targetCard, SkillBase skill) + { + BattleCardBase battleCardBase = DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard); + if (battleCardBase == null) + { + throw new Exception("Target card is not found from deck cards."); + } + this.OnAddPlayCardEvent.Call(battleCardBase, arg2: false, skill); + AddInplayCard(battleCardBase); + DeckCardList.Remove(battleCardBase); + this.OnSummonAfterEvent.Call(battleCardBase); + } + + private void DestroyedToField(BattleCardBase targetCard, SkillBase skill) + { + BattleCardBase battleCardBase = null; + battleCardBase = CemeteryList.SingleOrDefault((BattleCardBase c) => c == targetCard); + if (battleCardBase == null) + { + battleCardBase = NecromanceZoneList.SingleOrDefault((BattleCardBase c) => c == targetCard); + } + if (battleCardBase == null) + { + throw new Exception("Target card is not found from destroyed cards."); + } + this.OnAddPlayCardEvent.Call(battleCardBase, arg2: false, skill); + AddInplayCard(battleCardBase); + CemeteryList.Remove(battleCardBase); + NecromanceZoneList.Remove(battleCardBase); + this.OnSummonAfterEvent.Call(battleCardBase); + } + + public virtual VfxBase CardDrawVfx(IEnumerable DrawList, bool skipShuffle = false, bool isOpenDrawSkill = false) + { + return NullVfx.GetInstance(); + } + + private VfxBase DrawCard(BattleCardBase targetCard, SkillBase skill, bool isOpen = false, bool isToken = false, bool isReservation = false) + { + bool flag = false; + if (!isToken && DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + DeckCardList.Remove(targetCard); + if (!BattleMgr.IsVirtualBattle) + { + flag = true; + StatusPanelControl.SetDeck(DeckCardList.Count); + } + } + if (HandCardList.Count >= 9) + { + return NullVfx.GetInstance(); + } + if (isToken) + { + HandCardAddList(targetCard, isReservation ? NetworkBattleDefine.NetworkCardPlaceState.Reservation : NetworkBattleDefine.NetworkCardPlaceState.None, skill, isOpen); + return CreateUpdateDeckCountLabelVfx(); + } + targetCard.ResetCardParameterInHand(); + HandCardAddList(targetCard, NetworkBattleDefine.NetworkCardPlaceState.Deck, skill, isOpen); + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + if (DeckCardList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + DeckCardList.Remove(targetCard); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + StatusPanelControl.SetDeck(DeckCardList.Count); + })); + } + else if (NecromanceZoneList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + NecromanceZoneList.Remove(targetCard); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + targetCard.BattleCardView.ResetCardView(targetCard.BaseParameter); + })); + } + else if (CemeteryList.SingleOrDefault((BattleCardBase c) => c == targetCard) != null) + { + CemeteryList.Remove(targetCard); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + targetCard.BattleCardView.ResetCardView(targetCard.BaseParameter); + })); + } + if (flag) + { + return parallelVfxPlayer; + } + return SequentialVfxPlayer.Create(parallelVfxPlayer, CreateUpdateDeckCountLabelVfx()); + } + + public virtual VfxBase CreateUpdateDeckCountLabelVfx() + { + return InstantVfx.Create(delegate + { + StatusPanelControl.SetDeck(DeckCardList.Count); + }); + } + + protected virtual VfxBase CreateUpdateClassInfoVfx(bool playEffect) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + StatusPanelControl.SetHandCount(HandCardList.Count); + })); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + ClassInformationUIController.ShowInfomation(playEffect); + })); + return parallelVfxPlayer; + } + + private void EvolveProcess(BattleCardBase card, bool isSkill) + { + if (!CheckNotConsumeEpCard(card)) + { + GainCurrentEpCount(card.SkillApplyInformation.GetEp()); + _gameUsedEpCount += card.SkillApplyInformation.GetEp(); + _turnUsedEpCount += card.SkillApplyInformation.GetEp(); + } + if (!isSkill) + { + _cumulativeEvolutionCount++; + } + } + + public bool UseEpCount(int count) + { + if (CurrentEpCount >= count) + { + GainCurrentEpCount(count); + _gameUsedEpCount += count; + _turnUsedEpCount += count; + return true; + } + return false; + } + + public VfxBase AddDeckTokenCards(List cards, SkillProcessor skillProcessor, string updateType, SkillBase skill, bool isOpen) + { + if (updateType == "change") + { + DeckClear(skill); + } + for (int i = 0; i < cards.Count; i++) + { + AddToDeck(cards[i], callEvent: true, skill); + } + this.OnUpdateDeck.Call(skill.SkillPrm.ownerCard, cards, IsPlayer, updateType == "change", isOpen); + return NullVfx.GetInstance(); + } + + public void CallOnChangeDeckAfterEvent(int previousCount, SkillProcessor skillProcessor, List summonCards) + { + this.OnChangeDeckAfterEvent.Call(previousCount, skillProcessor, summonCards); + } + + public void DeckClear(SkillBase skill) + { + this.OnClearDeck.Call(); + this.OnAddBlackHole.Call(DeckCardList, skill); + BlackHole.AddRange(DeckCardList); + DeckCardList.Clear(); + } + + public void AddToDeck(BattleCardBase card, bool callEvent = false, SkillBase skill = null) + { + if (callEvent) + { + this.OnAddDeckEvent.Call(card, skill); + } + DeckCardList.Add(card); + if (card.HasDeckSelfSkill) + { + AddDeckSkillCard(card); + } + if (BattleMgr.XorShiftRandom(card.IsPlayer) != null && BattleMgr.XorShiftRandom(card.IsPlayer).IsActive && BattleMgr.IsMulliganEnd) + { + AddToDeckCardList.Add(card); + } + } + + public void AddDeckSkillCard(BattleCardBase card) + { + DeckSkillCardList.Add(card); + DeckSkillCardList = DeckSkillCardList.OrderBy((BattleCardBase c) => c.Index).ToList(); + } + + public void RemoveOriginalAndAddDeckSkillCard(BattleCardBase card) + { + DeckSkillCardList.RemoveAll((BattleCardBase c) => c.Index == card.Index); + AddDeckSkillCard(card); + } + + private void AddToDeckCardIndexChange() + { + if (AddToDeckCardList.Count == 0 && _opponentBattlePlayer.AddToDeckCardList.Count == 0) + { + return; + } + if (AddToDeckCardList.Count > 0 && BattleMgr.XorShiftRandom(AddToDeckCardList.First().IsPlayer) != null && BattleMgr.XorShiftRandom(AddToDeckCardList.First().IsPlayer).IsActive && BattleMgr.IsMulliganEnd) + { + for (int i = 0; i < AddToDeckCardList.Count; i++) + { + if (AddToDeckCardList[i].IsInDeck) + { + int changeInt = BattleMgr.XorShiftRandom(AddToDeckCardList[i].IsPlayer).GetChangeInt(DeckCardList.Count()); + BattleCardBase battleCardBase = DeckCardList[changeInt]; + int index = AddToDeckCardList[i].Index; + AddToDeckCardList[i].SetIndex(battleCardBase.Index); + this.OnIndexChange.Call(index, battleCardBase.Index, IsPlayer); + battleCardBase.SetIndex(index); + DeckCardList.Sort((BattleCardBase a, BattleCardBase b) => a.Index - b.Index); + } + } + } + AddToDeckCardList.Clear(); + if (_opponentBattlePlayer.AddToDeckCardList.Count > 0) + { + _opponentBattlePlayer.AddToDeckCardIndexChange(); + } + } + + public VfxBase ReplaceInPlay(BattleCardBase originalCard, BattleCardBase newCard, SkillProcessor skillProcessor, bool isMetamorphose = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + ClassAndInPlayCardList.Insert(ClassAndInPlayCardList.IndexOf(originalCard), newCard); + ClassAndInPlayCardList.Remove(originalCard); + sequentialVfxPlayer.Register(originalCard.RemoveFromInPlay()); + sequentialVfxPlayer.Register(originalCard.RemoveFromInPlayAfter(skillProcessor)); + sequentialVfxPlayer.Register(StartSkillWhenChangeInplay(null, new List { newCard }, skillProcessor, !isMetamorphose, null, null, isReplace: true)); + if (isMetamorphose) + { + this.OnMetamorphoseAfterEvent.Call(originalCard, newCard); + } + return sequentialVfxPlayer; + } + + public VfxBase ReplaceInHand(BattleCardBase originalCard, BattleCardBase newCard, SkillProcessor skillProcessor) + { + SequentialVfxPlayer result = SequentialVfxPlayer.Create(); + HandCardList.Insert(HandCardList.IndexOf(originalCard), newCard); + HandCardList.Remove(originalCard); + StartSkillWhenChangeInplaySelfHand(new List { newCard }, skillProcessor); + return result; + } + + public void RegisterSkill(IBattlePlayerSkill battlePlayerSkill) + { + _skillList.Add(battlePlayerSkill); + } + + public void UnregisterSkill(IBattlePlayerSkill battlePlayerSkill) + { + _skillList.Remove(battlePlayerSkill); + } + + private void CallSkill(Func> getFunc, BattleCardBase targetCard) + { + foreach (IBattlePlayerSkill skill in _skillList) + { + getFunc(skill)(targetCard); + } + } + + public virtual VfxBase UsePp(int pp, bool isNewReplayMoveTurn = false) + { + Pp -= pp; + AddGameUsedPp(pp); + return NullVfx.GetInstance(); + } + + public void AddGameUsedPp(int pp) + { + GameUsedPpCount += pp; + } + + public VfxBase UseBp(int bp, bool isVariableCost, bool isSelf) + { + Bp -= bp; + int bp2 = Bp; + return m_vfxCreator.CreateUseBp(bp2, bp, () => BattleView.GetBPLabelPosition(), isVariableCost, isSelf); + } + + public virtual VfxBase MoveToHand(List cardsToMoveToHand) + { + return NullVfx.GetInstance(); + } + + public virtual VfxBase MoveToDeck(List cardsToMoveToDeck) + { + return new MoveToDeckVfx(cardsToMoveToDeck, IsPlayer); + } + + protected virtual VfxWith> LotteryRandomDrawCard(int drawCount, SkillProcessor skillProcessor) + { + List list = new List(); + if (CheckShortageDeck(drawCount, skillProcessor, out var _)) + { + return new VfxWith>(SendShortageDeck(), list); + } + if (BattleManagerBase.IsRandomDraw) + { + list = SkillRandomSelectFilter.Filtering(drawCount, DeckCardList, BattleMgr).ToList(); + } + else + { + int num = Math.Min(drawCount, DeckCardList.Count); + for (int i = 0; i < num; i++) + { + list.Add(DeckCardList[i]); + } + } + return new VfxWith>(NullVfx.GetInstance(), list); + } + + public VfxWith> RandomCardDraw(int drawCount, SkillProcessor skillProcessor) + { + VfxWith> vfxWith = LotteryRandomDrawCard(drawCount, skillProcessor); + VfxWith> vfxWith2 = DrawCards(vfxWith.Value, skillProcessor); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + sequentialVfxPlayer.Register(vfxWith2.Vfx); + sequentialVfxPlayer.Register(vfxWith.Vfx); + return new VfxWith>(sequentialVfxPlayer, vfxWith2.Value); + } + + public VfxWith> DrawManagement(List drawCards, SkillProcessor skillProcessor, bool isVisible, bool shortageDeck, SkillBase.SkillResultInfo resultInfo, SkillBase skill) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + VfxWith> vfxWith = DrawCards(drawCards, skillProcessor, isVisible, isMulligan: false, isToken: false, skill != null, skill, isReservation: false, resultInfo); + if (vfxWith.Value.Count() <= 0 && !shortageDeck) + { + resultInfo.drawCards = new List(); + return new VfxWith>(NullVfxWithLoading.GetInstance(), new List()); + } + if (resultInfo != null) + { + resultInfo.drawCards = ConvertToSkillInfoCollection(vfxWith.Value); + } + if (IsPlayer || GameMgr.GetIns().IsAdminWatch || isVisible || BattleMgr is SingleBattleMgr) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + foreach (BattleCardBase card in drawCards) + { + int cost = card.Cost; + List costList = card.BattleCardView.GetUseCostList(card.Cost); + bool isInHand = card.IsInHand; + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + if (card.BaseCost != cost) + { + card.BattleCardView.UpdateCost(costList, isGenerateInHand: true, playEffect: true, isInHand); + } + })); + } + sequentialVfxPlayer.Register(parallelVfxPlayer); + } + if (IsPlayer) + { + sequentialVfxPlayer.Register(new PlayerDrawCardVfx(drawCards, isVisible)); + sequentialVfxPlayer.Register(new PlayerEndDrawVfx(drawCards)); + } + else + { + if (!(GameMgr.GetIns().IsAdminWatch && isVisible)) + { + sequentialVfxPlayer.Register(new OpponentDrawCardVfx(drawCards, isVisible)); + } + sequentialVfxPlayer.Register(new OpponentDrawCardToHandVfx(drawCards, 0.4f, isVisible)); + } + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(); + vfxWithLoadingSequential.RegisterToMainVfx(InstantVfx.Create(delegate + { + foreach (BattleCardBase drawCard in drawCards) + { + drawCard.BattleCardView.HideCanPlayEffect(); + } + })); + vfxWithLoadingSequential.RegisterToMainVfx(vfxWith.Vfx); + vfxWithLoadingSequential.RegisterToMainVfx(sequentialVfxPlayer); + if (shortageDeck) + { + vfxWithLoadingSequential.RegisterToMainVfx(SendShortageDeck()); + } + vfxWithLoadingSequential.RegisterToMainVfx(InstantVfx.Create(delegate + { + UpdateHandCardsPlayability(); + })); + return new VfxWith>(vfxWithLoadingSequential, vfxWith.Value); + } + + public VfxWith> DrawCards(IEnumerable drawList, SkillProcessor skillProcessor, bool isOpen = false, bool isMulligan = false, bool isToken = false, bool isSkillDraw = false, SkillBase skill = null, bool isReservation = false, SkillBase.SkillResultInfo skillResultInfo = null, int tokenDrawSkillId = -1) + { + if (skillResultInfo != null) + { + skillResultInfo.drewOverHandLimitCards = new List(); + } + if (!drawList.Any()) + { + return new VfxWith>(NullVfx.GetInstance(), drawList); + } + int count = DeckCardList.Count; + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + ParallelVfxPlayer parallelVfxPlayer2 = ParallelVfxPlayer.Create(); + foreach (BattleCardBase card in drawList) + { + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + List list = new List(); + list.Add(card); + bool num = HandCardList.Count >= 9; + if (num) + { + list.RemoveAt(0); + this.OnAddCemeteryEvent.Call(card, CEMETERY_TYPE.DECK_DRAW_HAND_OVER, isOpen, skill); + CemeteryList.Add(card); + skillConditionCheckerOption.DrewOverHandLimitCards.Add(card); + skillResultInfo?.drewOverHandLimitCards.Add(card); + BattleMgr.VfxMgr.RegisterImmediateVfx(this.OnAddCemeteryAfterEvent.GetAllFuncVfxResults()); + int cost = card.Cost; + List costList = card.BattleCardView.GetUseCostList(card.Cost); + parallelVfxPlayer.Register(InstantVfx.Create(delegate + { + if (card.BaseCost != cost) + { + card.BattleCardView.UpdateCost(costList, isGenerateInHand: true, playEffect: true, isForceUpdate: true); + } + })); + } + skillConditionCheckerOption.InHandCard = ConvertToSkillInfoCollection(list); + parallelVfxPlayer.Register(DrawCard(card, skill, isOpen, isToken, isReservation)); + parallelVfxPlayer2.Register(card.StartHandEffect()); + if (!isMulligan) + { + StartSkillWhenChangeInplaySelfHand(new List { card }, skillProcessor); + } + if (!num) + { + StartSkillWhenAddToHand(skillProcessor, skillConditionCheckerOption); + } + } + if (!isToken) + { + CallOnChangeDeckAfterEvent(count, skillProcessor, new List()); + } + sequentialVfxPlayer.Register(SequentialVfxPlayer.Create(parallelVfxPlayer, parallelVfxPlayer2)); + if (!isMulligan) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + SkillConditionCheckerOption skillConditionCheckerOption2 = new SkillConditionCheckerOption(); + if (skill != null) + { + DrewSkillCard = skill.SkillPrm.ownerCard; + } + List list2 = new List(); + List list3 = new List(); + if (isToken) + { + list2.AddRange(drawList); + skillConditionCheckerOption2.TokenDrewCards.AddRange(list2); + } + else + { + list3.AddRange(drawList); + skillConditionCheckerOption2.DeckDrewCards.AddRange(list3); + } + foreach (BattleCardBase item in drawList.Where((BattleCardBase c) => c.IsInHand)) + { + skillProcessor.Register(item.Skills.CreateWhenDraw(skillProcessor, playerInfoPair, skillConditionCheckerOption2)); + item.DrawTurn = ((item.SelfBattlePlayer.IsSelfTurn && !BattleMgr.IsTurnEnd) ? item.SelfBattlePlayer.Turn : (item.SelfBattlePlayer.Turn + 1)); + } + if (!IsPlayer) + { + IEnumerable enumerable = drawList.Where((BattleCardBase c) => c.Skills.Any((SkillBase s) => s.OnWhenDraw != 0 && s.PreprocessList.Any((SkillPreprocessBase p) => p is SkillPreprocessOpenCard))); + foreach (BattleCardBase item2 in enumerable) + { + item2.LastDrawOpenCard = enumerable.LastOrDefault(); + } + } + List list4 = new List(HandCardList); + list4.AddRange(ClassAndInPlayCardList); + foreach (BattleCardBase item3 in list4.Where((BattleCardBase c) => !drawList.Contains(c))) + { + SkillProcessor.ProcessInfo info = item3.Skills.CreateWhenDrawOther(list3, list2, skillProcessor, new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer), isSkillDraw); + skillProcessor.Register(info); + } + if (!isToken) + { + int count2 = TurnDrawCards.Count; + TurnDrawCards.AddRange(drawList); + GameDrawCards.AddRange(drawList); + this.OnDrawCards.Call(count2, TurnDrawCards.Count, drawList.ToList(), this, isOpen); + } + else + { + GameDrawTokenCards.AddRange(drawList); + if (tokenDrawSkillId != -1) + { + for (int num2 = 0; num2 < drawList.Count(); num2++) + { + TurnDrawTokenCardsWithId.Add(new CardAndId(drawList.ElementAt(num2), tokenDrawSkillId)); + } + } + } + } + VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(); + vfxWithLoadingSequential.RegisterVfxWithLoading(VfxWithLoading.Create(BattleMgr.LoadCardResources(drawList.ToList()))); + vfxWithLoadingSequential.RegisterToMainVfx(sequentialVfxPlayer); + return new VfxWith>(vfxWithLoadingSequential, drawList); + } + + public bool CheckShortageDeck(int drawNum, SkillProcessor skillProcessor, out bool isActiveChangeShortageDeck) + { + bool flag = drawNum > DeckCardList.Count; + isActiveChangeShortageDeck = false; + if (!IsChangeShortageDeck) + { + IsShortageDeck = flag; + return IsShortageDeck; + } + if (IsChangeShortageDeck && flag) + { + StartSkillWhenShortageDeck(skillProcessor); + isActiveChangeShortageDeck = true; + } + return false; + } + + public void CallRecordingMulliganStart(List cards) + { + this.OnMulliganStart.Call(this, cards); + } + + public virtual VfxBase CallRecordingMulligan(IList abandonCards, IList completeCards) + { + this.OnMulliganEnd.Call(abandonCards, completeCards); + return NullVfx.GetInstance(); + } + + protected virtual void PlayerActive() + { + } + + public virtual void UpdateHandCardsPlayability(bool areArrowsForcedOff = false) + { + } + + public VfxBase UpdateHandCardsCost(bool playEffect = true, bool isOnlyFixedUseCost = false) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + int i = 0; + for (int count = HandCardList.Count; i < count; i++) + { + parallelVfxPlayer.Register(HandCardList[i].CalcHandCost(playEffect, isOnlyFixedUseCost)); + } + return parallelVfxPlayer; + } + + public void ApplyFixedUseCostInfo() + { + HandParameter.IconLayout currentIconLayout = BattleCardView.GetCurrentIconLayout(); + HandControl.ArrangeType type = (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.FIXEDUSE_COST_INFO) ? HandControl.ArrangeType.Flat : HandControl.ArrangeType.Fan); + NetworkBattleManagerBase networkBattleMgr = BattleManagerBase.GetIns() as NetworkBattleManagerBase; + UpdateHandCostViewStrategy(); + InitHandParameterIconPos(currentIconLayout); + BattleView.HandView.ChangeArrangeType(type); + if (networkBattleMgr != null && networkBattleMgr.IsSkillSelectTiming) + { + BattleMgr.VfxMgr.RegisterImmediateVfx(SequentialVfxPlayer.Create(UpdateHandCardsCost(playEffect: false, isOnlyFixedUseCost: true), WaitEventVfx.Create(() => !networkBattleMgr.IsSkillSelectTiming), UpdateHandCardsCost(playEffect: false))); + } + else + { + BattleMgr.VfxMgr.RegisterImmediateVfx(UpdateHandCardsCost(playEffect: false)); + } + } + + private void UpdateHandCostViewStrategy() + { + int i = 0; + for (int count = HandCardList.Count; i < count; i++) + { + HandCardList[i].UpdateCostViewStrategy(); + } + } + + public void InitHandParameterIconPos(HandParameter.IconLayout layout) + { + int i = 0; + for (int count = HandCardList.Count; i < count; i++) + { + HandCardList[i].InitHandParameterIconPos(layout); + } + } + + public VfxWithLoadingSequential AddSpellChargeCountVfx(List targetCardList, List addCountList) + { + List list = new List(); + List list2 = new List(); + List list3 = new List(); + for (int i = 0; i < targetCardList.Count; i++) + { + BattleCardBase battleCardBase = targetCardList[i]; + int num = addCountList[i]; + battleCardBase.AddSpellChargeCount(num); + if ((!battleCardBase.IsPlayer && !GameMgr.GetIns().IsAdminWatch) || battleCardBase.IsInDeck) + { + continue; + } + for (int j = 0; j < num; j++) + { + list.Add(battleCardBase); + if (num >= Skill_spell_charge.SPELL_CHARGE_SUMMARY_COUNT) + { + list2.Add(num); + list3.Add(Skill_spell_charge.SPELL_CHARGE_SUMMARY_INTERVAL); + break; + } + list2.Add(1); + list3.Add(Skill_spell_charge.SPELL_CHARGE_INTERVAL); + } + } + return new SpellChargeSkillActivationVfx(list, list2, list3); + } + + public abstract EffectBattle GetSkillEffect(string skillEffectPath); + + public abstract Vector3 GetFieldCenterPosition(); + + public void StartSkillWhenChangeInplaySelfHand(List inHandCards, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + cardsOrderBySkillActivation[i].Skills.CreateAndRegisterWhenChangeInplaySelfhandInfo(inHandCards, skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2); + } + } + + public VfxBase StartSkillWhenChangeInplay(List inHandCards, List inPlayCards, SkillProcessor skillProcessor, bool isSummonCheck = true, Func inplayCheckFunc = null, SkillConditionCheckerOption option = null, bool isReplace = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + BattlePlayerPair battlePlayerPair2 = new BattlePlayerPair(_opponentBattlePlayer, this); + if (inPlayCards != null && !isReplace && isSummonCheck) + { + sequentialVfxPlayer.Register(this.OnAfterSummonCardEvent.GetAllFuncVfxResults(skillProcessor, inPlayCards)); + } + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true); + List cardsOrderBySkillActivation2 = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: true, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation2.Count; i++) + { + sequentialVfxPlayer.Register(cardsOrderBySkillActivation2[i].Skills.RegisterAndProcessWhenChangeInplayImmediateInfo((cardsOrderBySkillActivation2[i].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2)); + } + for (int j = 0; j < cardsOrderBySkillActivation.Count; j++) + { + cardsOrderBySkillActivation[j].Skills.CreateAndRegisterWhenChangeInplaySelfhandInfo(inHandCards, skillProcessor, (cardsOrderBySkillActivation[j].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2); + } + for (int k = 0; k < cardsOrderBySkillActivation2.Count; k++) + { + cardsOrderBySkillActivation2[k].Skills.CreateAndRegisterWhenChangeInplayInfo(inPlayCards, skillProcessor, (cardsOrderBySkillActivation2[k].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2, isSummonCheck, inplayCheckFunc, option); + } + return sequentialVfxPlayer; + } + + public VfxBase StartSkillWhenChangeClassLife(SkillProcessor skillProcessor) + { + SequentialVfxPlayer result = SequentialVfxPlayer.Create(); + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + BattlePlayerPair battlePlayerPair2 = new BattlePlayerPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true); + List cardsOrderBySkillActivation2 = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: false, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + cardsOrderBySkillActivation[i].Skills.CreateAndRegisterWhenChangeClassLifeSelfHandInfo(skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2); + } + for (int j = 0; j < cardsOrderBySkillActivation2.Count; j++) + { + cardsOrderBySkillActivation2[j].Skills.CreateAndRegisterWhenChangeClassLifeInplayInfo(skillProcessor, (cardsOrderBySkillActivation2[j].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2); + } + return result; + } + + public VfxBase StartSkillWhenChangePPTotal(SkillProcessor skillProcessor) + { + SequentialVfxPlayer result = SequentialVfxPlayer.Create(); + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + BattlePlayerPair battlePlayerPair2 = new BattlePlayerPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: false, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + cardsOrderBySkillActivation[i].Skills.CreateAndRegisterWhenChangePPTotalInfo(skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2); + } + return result; + } + + public void StartSkillWhenAddToHand(SkillProcessor skillProcessor, SkillConditionCheckerOption option) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, BattleMgr is SingleBattleMgr, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + cardsOrderBySkillActivation[i].Skills.CreateAndRegisterWhenAddToHandInfo(skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, option); + } + } + + public void StartSkillWhenDestroyOther(BattleCardBase destroyCard, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: true, containsHand: false, containsClass: false, containsInplay: false, containsDeck: false, (BattleCardBase card) => card != destroyCard); + for (int num = 0; num < cardsOrderBySkillActivation.Count; num++) + { + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateWhenDestroyOtherInfo(destroyCard, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2)); + } + } + + public void StartSkillWhenReturnOther(BattleCardBase returnedCard, SkillProcessor skillProcessor, List cantAttackAllReturnCards) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true, containsDeck: false, (BattleCardBase card) => card != returnedCard); + for (int num = 0; num < cardsOrderBySkillActivation.Count; num++) + { + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateWhenReturnOtherInfo(returnedCard, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, cantAttackAllReturnCards)); + } + } + + public void StartSkillWhenReturnSkillActivate(List returnedCards, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenReturnSkillActivateInfo(returnedCards, skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2)); + } + } + + public VfxBase StartSkillWhenPlayOtherEnhanceAndAccelerateAndCrystallize(BattleCardBase playedCard, bool isEnhance, SkillProcessor skillProcessor) + { + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + if (playedCard.IsChoiceBraveSkillCard) + { + return parallelVfxPlayer; + } + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + foreach (BattleCardBase item in SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: true, containsHand: false, containsClass: false, containsInplay: false, containsDeck: false, (BattleCardBase card) => card != playedCard)) + { + foreach (SkillBase skill in item.Skills) + { + VfxWith vfxWith = item.Skills.CreateWhenPlayOtherEnhanceAndAccelerateAndCrystallizeInfo(skill, playedCard, isEnhance ? playedCard : null, skillProcessor, (item.SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2); + skillProcessor.Register(vfxWith.Value); + parallelVfxPlayer.Register(vfxWith.Vfx); + } + } + return parallelVfxPlayer; + } + + public VfxBase StartSkillWhenSummonOther(BattleCardBase summonedCard, SkillProcessor skillProcessor, bool isReanimate = false, List ignoreCheckCard = null) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true, containsDeck: false, (BattleCardBase card) => ignoreCheckCard == null || ignoreCheckCard.Count == 0 || !ignoreCheckCard.Contains(card)); + for (int num = 0; num < cardsOrderBySkillActivation.Count; num++) + { + if (cardsOrderBySkillActivation[num] != summonedCard) + { + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateWhenSummonOtherInfo(summonedCard, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, isReanimate)); + } + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateWhenSummonSelfAndOtherInfo(summonedCard, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, isReanimate)); + } + return NullVfx.GetInstance(); + } + + public void StartSkillWhenFusionOther(List fusionIngredientCards, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = new List(); + list.AddRange(ClassAndInPlayCardList); + foreach (BattleCardBase item in list) + { + skillProcessor.Register(item.Skills.CreateWhenFusionOtherInfo(skillProcessor, playerInfoPair, fusionIngredientCards)); + } + } + + public void StartSkillWhenUseEpSelfAndOther(SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenUseEpSelfAndOtherInfo(skillProcessor, playerInfoPair)); + } + } + + public VfxBase StartSkillWhenHealingSelfAndOther(List healingCards, SkillProcessor skillProcessor, List healAmountList) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true); + if (cardsOrderBySkillActivation.Any()) + { + TurnAndIntValue turnAndIntValue = TurnWhenHealingCount.FirstOrDefault((TurnAndIntValue t) => t.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && t.Turn == Turn); + if (turnAndIntValue != null) + { + turnAndIntValue.Increment(); + } + else + { + TurnWhenHealingCount.Add(new TurnAndIntValue(1, Turn, BattleMgr.BattlePlayer.IsSelfTurn)); + } + } + for (int num = 0; num < cardsOrderBySkillActivation.Count; num++) + { + skillProcessor.Register(cardsOrderBySkillActivation[num].Skills.CreateWhenHealingSelfAndOtherInfo(healingCards, skillProcessor, (cardsOrderBySkillActivation[num].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, healAmountList)); + } + return NullVfx.GetInstance(); + } + + public VfxBase StartSkillWhenDamageSelfAndOther(SkillBase skill, List damageCards, SkillProcessor skillProcessor, int defDamage, int fixedDamage) + { + if (damageCards != null) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true, containsDeck: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenDamageSelfAndOtherInfo(skill, damageCards, skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, defDamage, fixedDamage)); + } + } + return NullVfx.GetInstance(); + } + + public void StartSkillWhenBurialRiteOther(BattleCardBase burialRiteCard, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: true, containsInplay: true, containsDeck: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenBurialRiteOther(burialRiteCard, skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2)); + } + } + + public void StartSkillWhenBanishOther(BattleCardBase banishedCard, SkillProcessor skillProcessor, bool isInplay) + { + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + BattlePlayerReadOnlyInfoPair battlePlayerReadOnlyInfoPair2 = new BattlePlayerReadOnlyInfoPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: true, containsClass: true, containsInplay: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenBanishOther(banishedCard, skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerReadOnlyInfoPair : battlePlayerReadOnlyInfoPair2, isInplay)); + } + } + + public void StartSkillWhenUseWhiteRitualStack(SkillProcessor skillProcessor, SkillConditionCheckerOption checkerOption) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = HandCardList.ToList(); + list.AddRange(ClassAndInPlayCardList); + list.AddRange(DeckSkillCardList); + for (int i = 0; i < list.Count; i++) + { + skillProcessor.Register(list[i].Skills.CreateWhenUseWhiteRitualStackInfo(skillProcessor, playerInfoPair, checkerOption)); + } + } + + public void StartSkillWhenResonanceStart(SkillProcessor skillProcessor, List SummonCardList) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = HandCardList.ToList(); + list.AddRange(ClassAndInPlayCardList); + list.AddRange(DeckSkillCardList); + for (int i = 0; i < list.Count; i++) + { + BattleCardBase card = list[i]; + if (!SummonCardList.Any((BattleCardBase s) => s == card)) + { + skillProcessor.Register(card.Skills.CreateWhenResonanceStart(skillProcessor, playerInfoPair)); + } + } + } + + public VfxBase StartSkillWhenPpHealing(SkillProcessor skillProcessor) + { + List list = ClassAndInPlayCardList.ToList(); + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + for (int i = 0; i < list.Count; i++) + { + skillProcessor.Register(list[i].Skills.CreateWhenPpHealingInfo(skillProcessor, playerInfoPair)); + } + return NullVfx.GetInstance(); + } + + public void StartSkillWhenBuffDebuffSelfAndOther(IEnumerable targetCards, IEnumerable inplayTargetCards, SkillProcessor skillProcessor) + { + if (targetCards.Count() != 0) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = ClassAndInPlayCardList.ToList(); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + List inplayDebuffingCards = (skillConditionCheckerOption.InplayBuffingCards = ConvertToSkillInfoCollection(inplayTargetCards)); + skillConditionCheckerOption.InplayDebuffingCards = inplayDebuffingCards; + for (int i = 0; i < list.Count; i++) + { + skillProcessor.Register(list[i].Skills.CreateWhenBuffDebuffSelfAndOtherInfo(skillProcessor, playerInfoPair, skillConditionCheckerOption)); + } + } + } + + public void StartSkillWhenBuffSelfAndOther(IEnumerable buffingCards, IEnumerable inplayBuffingCards, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = ClassAndInPlayCardList.ToList(); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + skillConditionCheckerOption.InplayBuffingCards = ConvertToSkillInfoCollection(inplayBuffingCards); + if (buffingCards.Count() > 0) + { + for (int i = 0; i < list.Count; i++) + { + skillProcessor.Register(list[i].Skills.CreateWhenBuffSelfAndOtherInfo(skillProcessor, playerInfoPair, skillConditionCheckerOption)); + } + } + } + + public void StartSkillWhenDebuffSelfAndOther(IEnumerable debuffingCards, IEnumerable inplayDebuffingCards, SkillProcessor skillProcessor) + { + if (debuffingCards.Count() != 0) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + List list = ClassAndInPlayCardList.ToList(); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + skillConditionCheckerOption.InplayDebuffingCards = ConvertToSkillInfoCollection(inplayDebuffingCards); + for (int i = 0; i < list.Count; i++) + { + skillProcessor.Register(list[i].Skills.CreateWhenDebuffSelfAndOtherInfo(skillProcessor, playerInfoPair, skillConditionCheckerOption)); + } + } + } + + public void StartSkillWhenDebuffIncludeSetMaxLife(BattleCardBase debuffingCard, IEnumerable inplayDebuffingCards, SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + skillConditionCheckerOption.InplayDebuffingCards = ConvertToSkillInfoCollection(inplayDebuffingCards); + skillProcessor.Register(debuffingCard.Skills.CreateWhenDebuffIncludeSetMaxLifeInfo(skillProcessor, playerInfoPair, skillConditionCheckerOption)); + } + + public void StartSkillWhenShortageDeck(SkillProcessor skillProcessor) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(this, _opponentBattlePlayer); + skillProcessor.Register(Class.Skills.CreateWhenShortageDeck(skillProcessor, playerInfoPair)); + } + + public void StartSkillWhenShortageDeckWinSkillActivate(List shortageDeckWinCards, SkillProcessor skillProcessor) + { + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + BattlePlayerPair battlePlayerPair2 = new BattlePlayerPair(_opponentBattlePlayer, this); + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + skillConditionCheckerOption.ShortageDeckWinCards = ConvertToSkillInfoCollection(shortageDeckWinCards); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenShortageDeckWinSkillActivate(skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2, skillConditionCheckerOption)); + } + } + + public VfxBase StartSkillWhenBattleStart(SkillProcessor skillProcessor) + { + BattlePlayerPair battlePlayerPair = new BattlePlayerPair(this, _opponentBattlePlayer); + BattlePlayerPair battlePlayerPair2 = new BattlePlayerPair(_opponentBattlePlayer, this); + List cardsOrderBySkillActivation = SkillCollectionBase.GetCardsOrderBySkillActivation(this, _opponentBattlePlayer, isAll: false, containsHand: false, containsClass: true); + for (int i = 0; i < cardsOrderBySkillActivation.Count; i++) + { + skillProcessor.Register(cardsOrderBySkillActivation[i].Skills.CreateWhenBattleStartInfo(skillProcessor, (cardsOrderBySkillActivation[i].SelfBattlePlayer == this) ? battlePlayerPair : battlePlayerPair2)); + } + return skillProcessor.Process(battlePlayerPair); + } + + public static List ConvertToSkillInfoCollection(IEnumerable cards) + { + if (cards == null) + { + return new List(); + } + List list = new List(); + foreach (BattleCardBase card in cards) + { + list.Add(card); + } + return list; + } + + public static List> ConvertToSkillInfoCollectionList(List> cardsList) + { + if (cardsList == null) + { + return new List>(); + } + List> list = new List>(); + foreach (List cards in cardsList) + { + List item = cards.ToList().ConvertAll(ConvertIReadOnlyBattleCardInfo); + list.Add(item); + } + return list; + } + + public static IReadOnlyBattleCardInfo ConvertIReadOnlyBattleCardInfo(BattleCardBase card) + { + return card; + } + + public void AddLastTargetCardsList(BattleCardBase addCard) + { + if (LastTargetCardsList.Count > 0) + { + LastTargetCardsList.First().Add(addCard); + return; + } + List list = new List(); + List item = new List(); + list.Add(addCard); + LastTargetCardsList.Add(list); + _opponentBattlePlayer.LastTargetCardsList.Add(item); + } + + public List GetLastTargetCardsList(int index) + { + if (0 <= index && index < LastTargetCardsList.Count) + { + return LastTargetCardsList[index]; + } + return new List(); + } + + public void SkillsEndProcess() + { + ReturnList.Clear(); + LastTargetCardsList.Clear(); + InHandCards.Clear(); + HealingCards.Clear(); + SkillSummonedCards.Clear(); + SummonedCards.Clear(); + SkillDiscards.Clear(); + SkillBanishCards.Clear(); + DrewSkillCard = null; + OkSkillInProcess.Clear(); + LastInplayWhiteRitualStack = 0; + Class.SkillApplyInformation.ReservationAllDepriveRepeatSkill(); + } + + public void OnCallOneSkillProcess() + { + if (OnEndOneSkillProcess != null) + { + OnEndOneSkillProcess(); + OnEndOneSkillProcess = null; + } + } + + public VfxBase SendShortageDeck() + { + return this.OnShortageDeck.GetAllFuncVfxResults(); + } + + public void CopyToVirtualBase(BattlePlayerBase target, BattlePlayerBase virtualOpponentBattlePlayer, CloneActualFlags cloneFlags) + { + target._opponentBattlePlayer = virtualOpponentBattlePlayer; + target._skillList = _skillList.ToList(); + target.Pp = Pp; + target._ppTotal = _ppTotal; + target.SetCurrentEpCount(CurrentEpCount); + target.EvolveWaitTurnCount = EvolveWaitTurnCount; + target.NowTurnEvol = NowTurnEvol; + target._gameUsedEpCount = _gameUsedEpCount; + target._turnUsedEpCount = _turnUsedEpCount; + target.HandCardList = CloneCardList(HandCardList, target, virtualOpponentBattlePlayer, cloneFlags.Hand); + target.DeckCardList = CloneCardList(DeckCardList, target, virtualOpponentBattlePlayer, cloneFlags.Deck); + target.BattleStartDeckCardList = CloneCardList(BattleStartDeckCardList, target, virtualOpponentBattlePlayer, cloneFlags.Deck); + target.ClassAndInPlayCardList = CloneCardList(ClassAndInPlayCardList, target, virtualOpponentBattlePlayer, cloneFlags.InPlay); + target.CemeteryList = CloneCardList(CemeteryList, target, virtualOpponentBattlePlayer, cloneFlags.Cemetery); + if (target.ClassAndInPlayCardList.Count > 0 && target.ClassAndInPlayCardList[0] is ClassBattleCardBase) + { + target._class = target.ClassAndInPlayCardList[0]; + } + else + { + BattleCardBase battleCardBase = target.CemeteryList.FirstOrDefault((BattleCardBase c) => c is ClassBattleCardBase); + if (battleCardBase != null) + { + target._class = battleCardBase; + } + else + { + target._class = _class.VirtualClone(target, virtualOpponentBattlePlayer); + } + } + target.BanishList = CloneCardList(BanishList, target, virtualOpponentBattlePlayer, cloneFlags.Banish); + target.FusionIngredientList = CloneCardList(FusionIngredientList, target, virtualOpponentBattlePlayer, cloneFlags.FusionMaterial); + target.NecromanceZoneList = CloneCardList(NecromanceZoneList, target, virtualOpponentBattlePlayer, cloneFlags.NecromanceZone); + target.UniteList = CloneCardList(UniteList, target, virtualOpponentBattlePlayer, cloneFlags.Unite); + target.GetOnList = CloneCardList(GetOnList, target, virtualOpponentBattlePlayer, cloneFlags.GetOn); + target.SummonedCards = CloneCardList(SummonedCards, target, virtualOpponentBattlePlayer, isActualClone: true); + target.IsSelfTurn = IsSelfTurn; + target.DrewSkillCard = DrewSkillCard; + List list = new List(); + list.AddRange(target.HandCardList); + list.AddRange(target.ClassAndInPlayCardList); + list.AddRange(target.DeckCardList); + list.AddRange(target.CemeteryList); + list.AddRange(target.BanishList); + list.AddRange(target.NecromanceZoneList); + list.AddRange(target.FusionIngredientList); + list.AddRange(target.UniteList); + list.AddRange(target.GetOnList); + target.ReturnList = FindClonedIdCards(list, ReturnList); + List> list2 = new List>(); + foreach (List lastTargetCards in LastTargetCardsList) + { + list2.Add(FindClonedIdCards(list, lastTargetCards)); + } + target.LastTargetCardsList = list2; + target.InHandCards = FindClonedIdCards(list, InHandCards); + target.SkillDiscards = FindClonedIdCards(list, SkillDiscards); + target.SkillBanishCards = FindClonedIdCards(list, SkillBanishCards); + target.TurnPlayCards = FindClonedIdCards(list, TurnPlayCards); + target.TurnDrawCards = FindClonedIdCards(list, TurnDrawCards); + target.TurnDrawTokenCardsWithId = new List(); + int i; + for (i = 0; i < TurnDrawTokenCardsWithId.Count; i++) + { + target.TurnDrawTokenCardsWithId.Add(new CardAndId(list.FirstOrDefault((BattleCardBase c) => c.EquelsID(TurnDrawTokenCardsWithId[i].Card)), TurnDrawTokenCardsWithId[i].Id)); + } + target.GamePlayCards = FindClonedIdCards(list, GamePlayCards); + target.GameCrystallizedPlayCards = FindClonedIdCards(list, GameCrystallizedPlayCards); + target.OkSkillInProcess = OkSkillInProcess.ToList(); + target.GameInplayMetamorphoseCards = FindClonedIdCards(list, GameInplayMetamorphoseCards); + target.GameBurialRiteCards = FindClonedIdCards(list, GameBurialRiteCards); + target.TurnBurialRiteCards = FindClonedIdCards(list, TurnBurialRiteCards); + target.EvolvedCards = FindClonedIdCards(AllCards, EvolvedCards); + target.GameDrawCards = FindClonedIdCards(list, GameDrawCards); + target.GameDrawTokenCards = FindClonedIdCards(list, GameDrawTokenCards); + target.GameAddUpdateDeckCards = FindClonedIdCards(list, GameAddUpdateDeckCards); + target.GameLeftCards = FindClonedIdCards(list, GameLeftCards); + target.GameSuperSkyboundArtCards = FindClonedIdCards(list, GameSuperSkyboundArtCards); + List list3 = FindClonedIdCards(list, GameTurnLeftCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num = 0; num < list3.Count; num++) + { + target.GameTurnLeftCards.Add(new TurnAndCard(GameTurnLeftCards[num].Turn, GameTurnLeftCards[num].IsSelfTurn, list3[num], GameTurnLeftCards[num].IsTurnEnd)); + } + List list4 = FindClonedIdCards(list, GameSummonCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num2 = 0; num2 < list4.Count; num2++) + { + target.GameSummonCards.Add(new TurnAndCard(GameSummonCards[num2].Turn, GameSummonCards[num2].IsSelfTurn, list4[num2], GameSummonCards[num2].IsTurnEnd)); + } + for (int num3 = 0; num3 < GameSummonMomentTribe.Count; num3++) + { + target.GameSummonMomentTribe.Add(new CardAndTribe(GameSummonMomentTribe[num3].Card, GameSummonMomentTribe[num3].Tribes)); + } + for (int num4 = 0; num4 < GamePlayMomentTribe.Count; num4++) + { + target.GamePlayMomentTribe.Add(new CardAndTribe(GamePlayMomentTribe[num4].Card, GamePlayMomentTribe[num4].Tribes)); + } + for (int num5 = 0; num5 < GamePlayMomentSpellChargeCards.Count; num5++) + { + target.GamePlayMomentSpellChargeCards.Add(GamePlayMomentSpellChargeCards[num5].Card); + } + for (int num6 = 0; num6 < GameUpdateDeckMomentTribe.Count; num6++) + { + target.GameUpdateDeckMomentTribe.Add(new CardAndTribe(GameUpdateDeckMomentTribe[num6].Card, GameUpdateDeckMomentTribe[num6].Tribes)); + } + List list5 = FindClonedIdCards(list, GameReanimatedCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num7 = 0; num7 < list5.Count; num7++) + { + target.GameReanimatedCards.Add(new TurnAndCard(GameReanimatedCards[num7].Turn, GameReanimatedCards[num7].IsSelfTurn, list5[num7], GameReanimatedCards[num7].IsTurnEnd)); + } + List list6 = FindClonedIdCards(list, GameReturnedCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num8 = 0; num8 < list6.Count; num8++) + { + target.GameReturnedCards.Add(new TurnAndCard(GameReturnedCards[num8].Turn, GameReturnedCards[num8].IsSelfTurn, list6[num8], GameReturnedCards[num8].IsTurnEnd)); + } + List list7 = FindClonedIdCards(list, GameTurnPlayCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num9 = 0; num9 < list7.Count; num9++) + { + target.GameTurnPlayCards.Add(new TurnAndCard(GameTurnPlayCards[num9].Turn, GameTurnPlayCards[num9].IsSelfTurn, list7[num9], GameTurnPlayCards[num9].IsTurnEnd)); + } + List list8 = FindClonedIdCards(list, GameEnhancePlayCards.Select((TurnAndCard c) => c.Card as BattleCardBase)); + for (int num10 = 0; num10 < list8.Count; num10++) + { + target.GameEnhancePlayCards.Add(new TurnAndCard(GameEnhancePlayCards[num10].Turn, GameEnhancePlayCards[num10].IsSelfTurn, list8[num10], GameEnhancePlayCards[num10].IsTurnEnd)); + } + for (int num11 = 0; num11 < TurnPlayCardCountInfo.Count; num11++) + { + TurnAndIntValue turnAndIntValue = TurnPlayCardCountInfo[num11]; + target.TurnPlayCardCountInfo.Add(new TurnAndIntValue(turnAndIntValue.Value, turnAndIntValue.Turn, turnAndIntValue.IsSelfTurn)); + } + for (int num12 = 0; num12 < TurnFusionCountInfo.Count; num12++) + { + TurnAndIntValue turnAndIntValue2 = TurnFusionCountInfo[num12]; + target.TurnFusionCountInfo.Add(new TurnAndIntValue(turnAndIntValue2.Value, turnAndIntValue2.Turn, turnAndIntValue2.IsSelfTurn)); + } + target.extraTurnCount = extraTurnCount; + target.cardTotalNum = cardTotalNum; + for (int num13 = 0; num13 < TurnEvolveCardCountInfo.Count; num13++) + { + TurnAndIntValue turnAndIntValue3 = TurnEvolveCardCountInfo[num13]; + target.TurnEvolveCardCountInfo.Add(new TurnAndIntValue(turnAndIntValue3.Value, turnAndIntValue3.Turn, turnAndIntValue3.IsSelfTurn)); + } + target.IsShortageDeck = IsShortageDeck; + target.RallyCount = RallyCount; + target.DeckBanishCount = DeckBanishCount; + target.GameResonanceStartCount = GameResonanceStartCount; + target.TurnResonanceStartCount = TurnResonanceStartCount; + target.GameNecromanceCount = GameNecromanceCount; + target.GameUsedPpCount = GameUsedPpCount; + target.GameUsedWhiteRitualCount = GameUsedWhiteRitualCount; + target.LastInplayWhiteRitualStack = LastInplayWhiteRitualStack; + for (int num14 = 0; num14 < GameSkillReturnCardCountList.Count; num14++) + { + TurnAndIntValue turnAndIntValue4 = GameSkillReturnCardCountList[num14]; + target.GameSkillReturnCardCountList.Add(new TurnAndIntValue(turnAndIntValue4.Value, turnAndIntValue4.Turn, turnAndIntValue4.IsSelfTurn)); + } + for (int num15 = 0; num15 < GameSkillDiscardCountList.Count; num15++) + { + TurnAndIntValue turnAndIntValue5 = GameSkillDiscardCountList[num15]; + target.GameSkillDiscardCountList.Add(new TurnAndIntValue(turnAndIntValue5.Value, turnAndIntValue5.Turn, turnAndIntValue5.IsSelfTurn)); + } + for (int num16 = 0; num16 < GameSkillBuffCountList.Count; num16++) + { + TurnAndIntValue turnAndIntValue6 = GameSkillBuffCountList[num16]; + target.GameSkillBuffCountList.Add(new TurnAndIntValue(turnAndIntValue6.Value, turnAndIntValue6.Turn, turnAndIntValue6.IsSelfTurn)); + } + for (int num17 = 0; num17 < GameSkillMetamorphoseCountList.Count; num17++) + { + TurnAndIntValue turnAndIntValue7 = GameSkillMetamorphoseCountList[num17]; + target.GameSkillMetamorphoseCountList.Add(new TurnAndIntValue(turnAndIntValue7.Value, turnAndIntValue7.Turn, turnAndIntValue7.IsSelfTurn)); + } + target.GameSkillDiscardCount = GameSkillDiscardCount; + } + + private List CloneCardList(ICollection sourceCards, BattlePlayerBase virtualSelfBattlePlayer, BattlePlayerBase virtualOpponentBattlePlayer, bool isActualClone) + { + if (isActualClone) + { + List list = new List(sourceCards.Count); + for (int i = 0; i < sourceCards.Count; i++) + { + list.Add(sourceCards.ElementAt(i).VirtualClone(virtualSelfBattlePlayer, virtualOpponentBattlePlayer)); + } + return list; + } + List list2 = new List(sourceCards.Count); + for (int j = 0; j < sourceCards.Count; j++) + { + list2.Add(CardCreatorBase.CreateDummyInstance()); + } + return list2; + } + + private List FindClonedIdCards(IEnumerable clonedCardList, IEnumerable findIdCardList) + { + List list = new List(); + if (findIdCardList == null) + { + return list; + } + foreach (BattleCardBase uniqId in findIdCardList) + { + if (uniqId != null) + { + BattleCardBase battleCardBase = clonedCardList.SingleOrDefault((BattleCardBase c) => c.EquelsID(uniqId)); + if (battleCardBase != null) + { + list.Add(battleCardBase); + } + } + } + return list; + } + + public bool CheckPlayableCards() + { + List handCardList = HandCardList; + for (int i = 0; i < handCardList.Count; i++) + { + if (handCardList[i].Movable(isCheckOnDraw: false, isSkipSelecting: true)) + { + return true; + } + } + return false; + } + + public bool CheckAttackableCards() + { + List inPlayCardList = InPlayCards.ToList(); + int i = 0; + while (i < inPlayCardList.Count) + { + if (inPlayCardList[i].Attackable) + { + IEnumerable source = _opponentBattlePlayer.InPlayCards.Where((BattleCardBase c) => c.IsUnit && !c.CantBeFocusedAttack(inPlayCardList[i])); + if (!inPlayCardList[i].IsCantAttackClass || source.Any()) + { + IEnumerable source2 = source.Where((BattleCardBase c) => c.SkillApplyInformation.IsGuard); + if ((!inPlayCardList[i].SkillApplyInformation.IsSkillCantAtkUnitNotHasGuard || source2.Any() || !inPlayCardList[i].IsCantAttackClass) && (!inPlayCardList[i].SkillApplyInformation.IsSkillCantAtkUnit || !source2.Any() || inPlayCardList[i].SkillApplyInformation.IsIgnoreGuard) && (!inPlayCardList[i].SkillApplyInformation.IsSkillCantAtkUnitBaseCardId || ((!source2.Any() || !source2.All((BattleCardBase c) => inPlayCardList[i].SkillApplyInformation.CantAtkUnitBaseCardIdList.Contains(c.BaseParameter.BaseCardId)) || inPlayCardList[i].SkillApplyInformation.IsIgnoreGuard) && (!source.Any() || !source.All((BattleCardBase c) => inPlayCardList[i].SkillApplyInformation.CantAtkUnitBaseCardIdList.Contains(c.BaseParameter.BaseCardId)) || !inPlayCardList[i].IsCantAttackClass)))) + { + return true; + } + } + } + int num = i + 1; + i = num; + } + return false; + } + + public bool CheckNotConsumeEpCard(BattleCardBase card) + { + foreach (BattleCardBase inPlayCard in InPlayCards) + { + if (inPlayCard.SkillApplyInformation.CheckNotConsumeEpCard(card)) + { + return true; + } + } + return false; + } + + public IEnumerable GetSpecificTurnDestroyCards(TurnPlayerInfo turnPlayerInfo) + { + BattleManagerBase ins = BattleManagerBase.GetIns(); + bool isCheckSelf = IsPlayer == turnPlayerInfo.IsSelfPlayer; + int turn = (isCheckSelf ? ins.BattlePlayer.Turn : ins.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return from c in TurnDestroyCards + where c.IsSelfTurn == isCheckSelf && c.Turn == turn + select c.Card; + } + + public VfxBase UpdateInPlayBattleCardIconLabel() + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + for (int i = 1; i < ClassAndInPlayCardList.Count; i++) + { + if (!(ClassAndInPlayCardList[i].BattleCardView.BattleCardIconAnimations == null) && ClassAndInPlayCardList[i].BattleCardView.BattleCardIconAnimations.HasInductionNumberSkill()) + { + sequentialVfxPlayer.Register(ClassAndInPlayCardList[i].BattleCardView.UpdateBattleCardIconLabelNumber(ClassAndInPlayCardList[i], ClassAndInPlayCardList[i].Skills)); + } + } + return sequentialVfxPlayer; + } + + public int GetSpecificTurnWhenHealingCount(TurnPlayerInfo turnPlayerInfo, bool isTextKeyword) + { + bool isCheckSelf = IsPlayer == turnPlayerInfo.IsSelfPlayer; + if (isTextKeyword && isCheckSelf == IsPlayer && !IsSelfTurn) + { + return 0; + } + int turn = (isCheckSelf ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return TurnWhenHealingCount.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == isCheckSelf && c.Turn == turn)?.Value ?? 0; + } + + public int GetSpecificTurnSkillReturnCardCount(TurnPlayerInfo turnPlayerInfo) + { + bool isCheckSelf = turnPlayerInfo.IsSelfPlayer; + int turn = ((IsPlayer == isCheckSelf) ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return GameSkillReturnCardCountList.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == isCheckSelf && c.Turn == turn)?.Value ?? 0; + } + + public int GetSpecificTurnSkillDiscardCount(TurnPlayerInfo turnPlayerInfo) + { + bool isCheckSelf = turnPlayerInfo.IsSelfPlayer; + int turn = ((IsPlayer == isCheckSelf) ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return GameSkillDiscardCountList.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == isCheckSelf && c.Turn == turn)?.Value ?? 0; + } + + public int GetSpecificTurnEnhanceCardCount(TurnPlayerInfo turnPlayerInfo) + { + bool isSelfPlayer = turnPlayerInfo.IsSelfPlayer; + int num = ((IsPlayer == isSelfPlayer) ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + num -= turnPlayerInfo.TurnOffset; + List list = new List(); + for (int i = 0; i < GameEnhancePlayCards.Count; i++) + { + if (GameEnhancePlayCards[i].Turn == num && GameEnhancePlayCards[i].IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn) + { + list.Add(GameEnhancePlayCards[i].Card); + } + } + return list.Count; + } + + public int GetCurrentTurnPlayCount() + { + return TurnPlayCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && c.Turn == BattleMgr.CurrentTurn)?.Value ?? 0; + } + + public void AddCurrentTrunPlayCount(int count) + { + TurnAndIntValue turnAndIntValue = TurnPlayCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && c.Turn == BattleMgr.CurrentTurn); + if (turnAndIntValue != null) + { + turnAndIntValue.AddValue(count); + } + else + { + TurnPlayCardCountInfo.Add(new TurnAndIntValue(count, BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn)); + } + } + + public int GetSpecificTurnPlayCount(TurnPlayerInfo turnPlayerInfo) + { + bool isCheckSelf = IsPlayer == turnPlayerInfo.IsSelfPlayer; + int turn = (isCheckSelf ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return TurnPlayCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == isCheckSelf && c.Turn == turn)?.Value ?? 0; + } + + public void AddCurrentTurnFusionCount(int count) + { + TurnAndIntValue turnAndIntValue = TurnFusionCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && c.Turn == BattleMgr.CurrentTurn); + if (turnAndIntValue != null) + { + turnAndIntValue.AddValue(count); + } + else + { + TurnFusionCountInfo.Add(new TurnAndIntValue(count, BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn)); + } + } + + public void AddCurrentEvolvePlayCount(int count) + { + TurnAndIntValue turnAndIntValue = TurnEvolveCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && c.Turn == BattleMgr.CurrentTurn); + if (turnAndIntValue != null) + { + turnAndIntValue.AddValue(count); + } + else + { + TurnEvolveCardCountInfo.Add(new TurnAndIntValue(count, BattleMgr.CurrentTurn, BattleMgr.BattlePlayer.IsSelfTurn)); + } + } + + public int GetCurrentTurnEvolveCount() + { + return TurnEvolveCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == BattleMgr.BattlePlayer.IsSelfTurn && c.Turn == BattleMgr.CurrentTurn)?.Value ?? 0; + } + + public int GetSpecificTurnEvolveCount(TurnPlayerInfo turnPlayerInfo) + { + bool isCheckSelf = IsPlayer == turnPlayerInfo.IsSelfPlayer; + int turn = (isCheckSelf ? BattleMgr.BattlePlayer.Turn : BattleMgr.BattleEnemy.Turn); + turn -= turnPlayerInfo.TurnOffset; + return TurnEvolveCardCountInfo.FirstOrDefault((TurnAndIntValue c) => c.IsSelfTurn == isCheckSelf && c.Turn == turn)?.Value ?? 0; + } + + public int GetAttachTurnBySkillId(string id) + { + for (int i = 0; i < Class.Skills.Count(); i++) + { + if (Class.Skills.ElementAt(i).GetAttachSkill is Skill_attach_skill skill_attach_skill && skill_attach_skill.SaveTurnSkillId == id) + { + return skill_attach_skill.AttachedTurn; + } + } + return 0; + } + + public VfxWithLoading CreateTokenSpawnVfx(BattleCardBase firstToken) + { + Color color; + switch (firstToken.Clan) + { + case CardBasePrm.ClanType.MIN: + color = Global.EFFECT_COLOR_ELF; + break; + case CardBasePrm.ClanType.ROYAL: + color = Global.EFFECT_COLOR_ROYAL; + break; + case CardBasePrm.ClanType.WITCH: + color = Global.EFFECT_COLOR_WITCH_1; + break; + case CardBasePrm.ClanType.DRAGON: + color = Global.EFFECT_COLOR_DRAGON; + break; + case CardBasePrm.ClanType.NECRO: + color = Global.EFFECT_COLOR_NECROMANCER; + break; + case CardBasePrm.ClanType.VAMPIRE: + color = Global.EFFECT_COLOR_VANPIRE; + break; + case CardBasePrm.ClanType.BISHOP: + color = Global.EFFECT_COLOR_BISHOP; + break; + case CardBasePrm.ClanType.NEMESIS: + color = Global.EFFECT_COLOR_NEMESIS; + break; + default: + color = Color.clear; + break; + } + Func getEffectSpawnPoint = () => firstToken.BattleCardView.GameObject.transform.position; + EffectBattle effectBattle = null; + SkillBase.WaitEffectLoadVfx loadingVfx = new SkillBase.WaitEffectLoadVfx("cmn_token_draw_1", EffectMgr.EngineType.SHURIKEN, "se_cmn_token_draw_1", BattleMgr.BattleResourceMgr, delegate(EffectBattle eb) + { + effectBattle = eb; + }); + DelaySetupVfx mainVfx = new DelaySetupVfx(() => new SkillEffectBattleVfx(effectBattle, firstToken.BattleCardView, BattleMgr.BattleResourceMgr, getEffectSpawnPoint, getEffectSpawnPoint, 0f, 0f, EffectMgr.MoveType.DIRECT, IsPlayer, color)); + return VfxWithLoading.Create(loadingVfx, mainVfx); + } + + public void CallOnTokenDraw(BattleCardBase owner, List drawList, List targets, bool isPlayer, bool isOpen, bool isReserved) + { + this.OnTokenDrawCards.Call(owner, drawList, targets, isPlayer, isOpen, isReserved); + } + + public void CallOnCreateReservedCards(BattleCardBase owner, List drawList, bool isPlayer) + { + this.OnCreateReservedCards.Call(owner, drawList, isPlayer); + } + + public void CallOnCostChange(BattleCardBase card, List targets, List addList, List setList, List isCostUpList, bool isHalf, bool isSpellCharge, bool isOpenCard) + { + this.OnCostChange.Call(card, targets, addList, setList, isCostUpList, isHalf, isSpellCharge, isOpenCard); + } + + public void CallOnRemoveCostChange(List targetList, bool isSpellCharge, bool isAdd) + { + this.OnRemoveCostChange.Call(targetList, isSpellCharge, isAdd); + } + + public void CallOnPowerUp(BattleCardBase card, List cards, int offense, int life, int multiplyOffense, int multiplyLife, int maxLife) + { + this.OnPowerUp.Call(card, cards, offense, life, multiplyOffense, multiplyLife, maxLife); + } + + public void CallOnPowerDownStart() + { + this.OnPowerDownStart.Call(); + } + + public void CallOnPowerDown(BattleCardBase card, List cards, int offense, int life, int maxLife, bool isSet) + { + this.OnPowerDown.Call(card, cards, offense, life, maxLife, isSet); + } + + public void CallOnDeprivePowerUp(List targetList) + { + this.OnDeprivePowerUp.Call(targetList); + } + + public void CallOnDeprivePowerDown(List targetList) + { + this.OnDeprivePowerDown.Call(targetList); + } + + public void CallOnSpellCharge(BattleCardBase card, List targets, List addList) + { + this.OnSpellCharge.Call(card, targets, addList); + } + + public void CallOnDrain(int heal) + { + this.OnDrain.Call(heal); + } + + public void CallOnSkillDamageStart(BattleCardBase card) + { + this.OnSkillDamageStart.Call(card); + } + + public void CallOnDamage(List cards, List effectTargets, List damageList) + { + this.OnDamage.Call(cards, effectTargets, damageList); + } + + public void CallOnHeal(BattleCardBase ownerCard, List cards, List healList) + { + this.OnHeal.Call(ownerCard, cards, healList); + } + + public void CallOnDiscard(List targets) + { + this.OnDiscard.Call(targets); + } + + public void CallOnSkillDestroyOrBanish(BattleCardBase card, bool isBurialRite = false, bool isOpen = false) + { + this.OnSkillDestroyOrBanish.Call(card, isBurialRite, isOpen); + } + + public void CallOnPlayVoiceOnDeath(BattleCardBase card) + { + this.OnPlayVoiceOnDeath.Call(card); + } + + public void CallOnSkillReturn() + { + this.OnSkillReturn.Call(); + } + + public void CallOnAddPp(int addPpCount, BattleCardBase card) + { + this.OnAddPp.Call(addPpCount, IsPlayer, card); + } + + public void CallOnAddBp(int addBpCount, BattleCardBase card) + { + this.OnAddBp.Call(addBpCount, IsPlayer, card); + } + + public void CallOnEpModifier(BattleCardBase card, int epCount, bool isAdd) + { + this.OnEpModifier.Call(card, epCount, IsPlayer, isAdd); + } + + public void CallOnBeforeSkillEvolve(BattleCardBase card, List targets) + { + this.OnBeforeSkillEvolve.Call(card, targets); + } + + public void CallOnEvolveMeWhenAttack(BattleCardBase card) + { + this.OnEvolveMeWhenAttack.Call(card); + } + + public void CallOnAfterSkillEvolve(List targets) + { + this.OnAfterSkillEvolve.Call(targets); + } + + public void CallOnPlayCard(BattleCardBase originalCard, BattleCardBase playCard, bool isChoiceBrave) + { + this.OnPlayCard.Call(originalCard, playCard, isChoiceBrave); + } + + public void CallOnWhenPlayEffect(SkillCollectionBase.WhenPlayEffectType whenPlayEffectType, BattleCardBase target, bool isInvoked) + { + this.OnWhenPlayEffect.Call(whenPlayEffectType, target, isInvoked); + } + + public void CallOnChantCountChange(BattleCardBase card, List targets, int changeCount) + { + this.OnChantCountChange.Call(card, targets, changeCount); + } + + public void CallOnChangeWhiteRitualStack(BattleCardBase target, int changeCount, bool isDestroy = false) + { + this.OnChangeWhiteRitualStack.Call(target, changeCount, isDestroy); + } + + public void CallOnChangeMaxAttackableCount(BattleCardBase card, List targets, int changeCount) + { + this.OnChangeMaxAttackableCount.Call(card, targets, changeCount); + } + + public void CallOnMetamorphose(BattleCardBase card, List targets, int cardId) + { + this.OnMetamorphose.Call(card, targets, cardId); + } + + public void CallOnFusionMetamorphose(int fusionMetamorphoseCardId) + { + this.OnFusionMetamorphose.Call(fusionMetamorphoseCardId); + } + + public void CallOnOpenCard(BattleCardBase card) + { + this.OnOpenCard.Call(card); + } + + public void CallOnUnite(BattleCardBase ownerCard, List targets, BattleCardBase uniteCard) + { + this.OnUnite.Call(ownerCard, targets, uniteCard); + } + + public void CallOnRemoveLatestOperationJsonData(NetworkBattleReceiver.ReplayOperationType type) + { + this.OnRemoveLatestOperationJsonData.Call(type); + } + + public void CallOnEmotion(ClassCharaPrm.EmotionType emotionType) + { + this.OnEmotion.Call(emotionType, IsPlayer); + } + + public void CallOnClearDestroyedCardList(bool isPlayer) + { + this.OnClearDestroyedCardList.Call(isPlayer); + } +} diff --git a/SVSim.BattleEngine/Engine/SkillCreator.cs b/SVSim.BattleEngine/Engine/SkillCreator.cs new file mode 100644 index 0000000..0ac1761 --- /dev/null +++ b/SVSim.BattleEngine/Engine/SkillCreator.cs @@ -0,0 +1,2227 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using Wizard; +using Wizard.Battle.Resource; +using Wizard.Battle.View; + +public class SkillCreator +{ + public class SkillBuildInfo + { + public readonly string _type = ""; + + public readonly string _timing = ""; + + public readonly string _condition = ""; + + public readonly List _parsedConditionOld; + + public readonly List _parsedConditionNew; + + public readonly string _target = ""; + + public readonly List _parsedTargetOld; + + public readonly List _parsedTargetNew; + + public readonly SkillFilterCreator.ContentInfo[] _parsedOption; + + public readonly string _option = ""; + + public readonly string _preprocess = ""; + + public readonly SkillFilterCreator.ContentInfo[] _parsedPreprocess; + + public readonly HandCardFrameEffectType _handCardFrameEffectType = HandCardFrameEffectType.NULL; + + public readonly string _icon = ""; + + public readonly string _effectPath = ""; + + public readonly EffectMgr.EngineType _engineType; + + public readonly string _sePath = ""; + + public readonly float _effectTime; + + public readonly EffectMgr.MoveType _effectMoveType; + + public readonly EffectMgr.TargetType _effectTargetType; + + public BattleCardBase _previousSkillOwner; + + public readonly string _voice = string.Empty; + + public readonly List _checkTargetKeywords = new List(); + + public SkillBuildInfo(string type, string timing, string condition, string target, string option, string preprocess, HandCardFrameEffectType frameEffectType = HandCardFrameEffectType.NONE, string icon = "", int[] tokenID = null, string effectPath = "", EffectMgr.EngineType engineType = EffectMgr.EngineType.NONE, string sePath = "", float effectTime = 0f, EffectMgr.MoveType effectMoveType = EffectMgr.MoveType.NONE, EffectMgr.TargetType effectTargetType = EffectMgr.TargetType.NONE, string voice = "") + { + _type = type; + _timing = timing; + _condition = condition; + _target = target; + _option = option; + _preprocess = preprocess; + _handCardFrameEffectType = frameEffectType; + _icon = icon; + _effectPath = effectPath; + _engineType = engineType; + _sePath = sePath; + _effectTime = effectTime; + _effectMoveType = effectMoveType; + _effectTargetType = effectTargetType; + _voice = voice; + ParseOption(option, ref _parsedOption); + ParseCondition(condition, ref _parsedConditionOld, ref _parsedConditionNew); + ParseTarget(target, ref _parsedTargetOld, ref _parsedTargetNew, ref _checkTargetKeywords); + ParsePreprocess(preprocess, ref _parsedPreprocess); + } + + public bool IsSameSkill(SkillBuildInfo info) + { + if (_type == info._type && _timing == info._timing && _condition == info._condition && _target == info._target && _option == info._option) + { + return _preprocess == info._preprocess; + } + return false; + } + } + + public class CardSkillsBuildInfo + { + public List normalSkillBuildInfos; + + public List evolveSkillBuildInfos; + } + + public static string[] NEWSTYLE_HEAD_TEXT = new string[13] + { + SkillFilterCreator.ContentKeyword.me.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.op.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.both.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.self.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.attacker.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.be_attacked.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.summoned_card.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.played_card.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.skill_drew_card.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.skill_update_deck_card.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.last_target.ToStringCustom() + ".", + SkillFilterCreator.ContentKeyword.in_hand.ToStringCustom() + ".", + "{" + }; + + protected readonly BattleCardBase _ownerCard; + + protected readonly BattlePlayerBase _selfBattlPlayer; + + protected readonly BattlePlayerBase _opponentBattlePlayer; + + protected readonly IBattleResourceMgr _battleResourceMgr; + + private const string PARSE_CONTENTINFO_PATTERN = "\\(.+?\\)"; + + public SkillCreator(BattleCardBase ownerCard, BattlePlayerBase selfBattlePlayer, BattlePlayerBase opponentBattlePlayer, IBattleResourceMgr battleResourceMgr) + { + _ownerCard = ownerCard; + _selfBattlPlayer = selfBattlePlayer; + _opponentBattlePlayer = opponentBattlePlayer; + _battleResourceMgr = battleResourceMgr; + } + + private SkillBase CreateSkillFactory(string skillName, SkillBuildInfo buildInfo, SkillParameter skillParam) + { + SkillKeywordInfo.SkillKeyword keyword = SkillKeywordInfo.GetKeyword(skillName); + bool flag = skillParam.ownerCard.SelfBattlePlayer.BattleMgr is NetworkBattleManagerBase && !GameMgr.GetIns().IsAINetwork; + switch (keyword) + { + case SkillKeywordInfo.SkillKeyword.damage_modifier: + if (!flag) + { + return new Skill_damage_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_damage_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.attach_skill: + if (!flag) + { + return new SingleSkill_attach_skill(skillParam, buildInfo._option); + } + return new NetworkSkill_attach_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.attack_by_life: + if (!flag) + { + return new Skill_attack_by_life(skillParam, buildInfo._option); + } + return new NetworkSkill_attack_by_life(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.attack_count: + if (!flag) + { + return new Skill_attack_count(skillParam, buildInfo._option); + } + return new NetworkSkill_attack_count(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.banish: + if (!flag) + { + return new Skill_banish(skillParam, buildInfo._option); + } + return new NetworkSkill_banish(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_activate_fanfare: + if (!flag) + { + return new Skill_cant_activate_fanfare(skillParam, buildInfo._option); + } + return new NetworkSkill_cant_activate_fanfare(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_activate_shortage_deck_win: + return new Skill_cant_activate_shortage_deck_win(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_attack: + if (!flag) + { + return new Skill_cant_attack(skillParam, buildInfo._option); + } + return new NetworkSkill_cant_attack(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_summon: + return new Skill_cant_summon(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_play: + if (!flag) + { + return new Skill_cant_play(skillParam, buildInfo._option); + } + return new NetworkSkill_cant_play(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_affiliation: + if (!flag) + { + return new Skill_change_affiliation(skillParam, buildInfo._option); + } + return new NetworkSkill_change_affiliation(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_cemetery: + if (!flag) + { + return new Skill_change_cemetery(skillParam, buildInfo._option); + } + return new NetworkSkill_change_cemetery(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_rally_count: + return new Skill_change_rally_count(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.update_deck: + if (!flag) + { + return new Skill_update_deck(skillParam, buildInfo._option); + } + return new NetworkSkill_update_deck(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.chant_count_change: + if (!flag) + { + return new Skill_chant_count_change(skillParam, buildInfo._option); + } + return new NetworkSkill_chant_count_change(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.consume_ep_modifier: + if (!flag) + { + return new Skill_consume_ep_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_consume_ep_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cost_change: + if (!flag) + { + return new Skill_cost_change(skillParam, buildInfo._option); + } + return new NetworkSkill_cost_change(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.damage: + if (!flag) + { + return new Skill_damage(skillParam, buildInfo._option); + } + return new NetworkSkill_damage(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.damage_cut: + if (!flag) + { + return new Skill_damage_cut(skillParam, buildInfo._option); + } + return new NetworkSkill_damage_cut(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.destroy: + if (!flag) + { + return new Skill_destroy(skillParam, buildInfo._option); + } + return new NetworkSkill_destroy(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.discard: + if (!flag) + { + return new Skill_discard(skillParam, buildInfo._option); + } + return new NetworkSkill_discard(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.drain: + if (!flag) + { + return new Skill_drain(skillParam, buildInfo._option); + } + return new NetworkSkill_drain(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.draw: + return new Skill_draw(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.evolve: + if (!flag) + { + return new Skill_evolve(skillParam, buildInfo._option); + } + return new NetworkSkill_evolve(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.extra_turn: + if (!flag) + { + return new Skill_extra_turn(skillParam, buildInfo._option); + } + return new NetworkSkill_extra_turn(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.force_berserk: + if (!flag) + { + return new Skill_force_berserk(skillParam, buildInfo._option); + } + return new NetworkSkill_force_berserk(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.force_skill_target: + if (!flag) + { + return new Skill_force_skill_target(skillParam, buildInfo._option); + } + return new NetworkSkill_force_skill_target(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.attract_skill_target: + if (!flag) + { + return new Skill_attract_skill_target(skillParam, buildInfo._option); + } + return new NetworkSkill_attract_skill_target(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.force_avarice: + if (!flag) + { + return new Skill_force_avarice(skillParam, buildInfo._option); + } + return new NetworkSkill_force_avarice(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.force_wrath: + if (!flag) + { + return new Skill_force_wrath(skillParam, buildInfo._option); + } + return new NetworkSkill_force_wrath(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.guard: + if (!flag) + { + return new Skill_guard(skillParam, buildInfo._option); + } + return new NetworkSkill_guard(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.heal: + if (!flag) + { + return new Skill_heal(skillParam, buildInfo._option); + } + return new NetworkSkill_heal(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.ignore_guard: + if (!flag) + { + return new Skill_ignore_guard(skillParam, buildInfo._option); + } + return new NetworkSkill_ignore_guard(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.independent: + if (!flag) + { + return new Skill_independent(skillParam, buildInfo._option); + } + return new NetworkSkill_independent(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.not_be_debuffed: + return new Skill_not_be_debuffed(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.indestructible: + if (!flag) + { + return new Skill_indestructible(skillParam, buildInfo._option); + } + return new NetworkSkill_indestructible(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.killer: + if (!flag) + { + return new Skill_killer(skillParam, buildInfo._option); + } + return new NetworkSkill_killer(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.lose: + if (!flag) + { + return new Skill_lose(skillParam, buildInfo._option); + } + return new NetworkSkill_lose(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.metamorphose: + if (!flag) + { + return new Skill_metamorphose(skillParam, buildInfo._option); + } + return new NetworkSkill_metamorphose(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.fusion_metamorphose: + if (!flag) + { + return new Skill_fusion_metamorphose(skillParam, buildInfo._option); + } + return new NetworkSkill_fusion_metamorphose(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.transform: + return new Skill_transform(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.none: + return new Skill_none(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.not_be_attacked: + if (!flag) + { + return new Skill_not_be_attacked(skillParam, buildInfo._option); + } + return new NetworkSkill_not_be_attacked(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.play_count_change: + if (!flag) + { + return new Skill_play_count_change(skillParam, buildInfo._option); + } + return new NetworkSkill_play_count_change(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.possess_ep_modifier: + if (!flag) + { + return new Skill_possess_ep_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_possess_ep_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.power_down: + if (!flag) + { + return new Skill_power_down(skillParam, buildInfo._option); + } + return new NetworkSkill_power_down(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.powerup: + if (!flag) + { + return new Skill_powerup(skillParam, buildInfo._option); + } + return new NetworkSkill_powerup(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.power_modifier: + if (!flag) + { + return new Skill_power_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_power_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.pp_fixeduse: + return new Skill_pp_fixeduse(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.pp_modifier: + if (!flag) + { + return new Skill_pp_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_pp_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.bp_modifier: + if (!flag) + { + return new Skill_bp_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_bp_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.quick: + if (!flag) + { + return new Skill_quick(skillParam, buildInfo._option); + } + return new NetworkSkill_quick(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.reflection: + if (!flag) + { + return new Skill_reflection(skillParam, buildInfo._option); + } + return new NetworkSkill_reflection(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.remove_by_banish: + if (!flag) + { + return new Skill_remove_by_banish(skillParam, buildInfo._option); + } + return new NetworkSkill_remove_by_banish(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.remove_by_destroy: + if (!flag) + { + return new Skill_remove_by_destroy(skillParam, buildInfo._option); + } + return new NetworkSkill_remove_by_destroy(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.return_card: + if (!flag) + { + return new Skill_return_card(skillParam, buildInfo._option); + } + return new NetworkSkill_return_card(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.rush: + if (!flag) + { + return new Skill_rush(skillParam, buildInfo._option); + } + return new NetworkSkill_rush(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.select: + if (!flag) + { + return new Skill_select(skillParam, buildInfo._option); + } + return new NetworkSkill_select(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.shield: + if (!flag) + { + return new Skill_shield(skillParam, buildInfo._option); + } + return new NetworkSkill_shield(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.sneak: + if (!flag) + { + return new Skill_sneak(skillParam, buildInfo._option); + } + return new NetworkSkill_sneak(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.special_win: + if (!flag) + { + return new Skill_special_win(skillParam, buildInfo._option); + } + return new NetworkSkill_special_win(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.special_lose: + if (!flag) + { + return new Skill_special_lose(skillParam, buildInfo._option); + } + return new NetworkSkill_special_lose(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.spell_charge: + if (!flag) + { + return new Skill_spell_charge(skillParam, buildInfo._option); + } + return new NetworkSkill_spell_charge(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.summon_card: + if (!flag) + { + return new Skill_summon_card(skillParam, buildInfo._option); + } + return new NetworkSkill_summon_card(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.summon_token: + if (!flag) + { + return new Skill_summon_token(skillParam, buildInfo._option); + } + return new NetworkSkill_summon_token(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.token_draw: + if (!flag) + { + return new Skill_token_draw(skillParam, buildInfo._option); + } + return new NetworkSkill_token_draw(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.special_token_draw: + return new Skill_special_token_draw(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.trigger: + if (!flag) + { + return new Skill_trigger(skillParam, buildInfo._option); + } + return new NetworkSkill_trigger(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.turn_start_fixed_pp: + return new Skill_turn_start_fixed_pp(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.unite: + if (!flag) + { + return new Skill_unite(skillParam, buildInfo._option); + } + return new NetworkSkill_unite(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.untouchable: + if (!flag) + { + return new Skill_untouchable(skillParam, buildInfo._option); + } + return new NetworkSkill_untouchable(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.repeat_skill: + if (!flag) + { + return new Skill_repeat_skill(skillParam, buildInfo._option); + } + return new NetworkSkill_repeat_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.choice: + return new Skill_choice(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.shortage_deck_win: + if (!flag) + { + return new Skill_shortage_deck_win(skillParam, buildInfo._option); + } + return new NetworkSkill_shortage_deck_win(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.generic_value_modifier: + if (!flag) + { + return new Skill_generic_value_modifier(skillParam, buildInfo._option); + } + return new NetworkSkill_generic_value_modifier(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_union_burst_count: + if (!flag) + { + return new Skill_change_union_burst_count(skillParam, buildInfo._option); + } + return new NetworkSkill_change_union_burst_count(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_skybound_art_count: + return new Skill_change_skybound_art_count(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_super_skybound_art_count: + if (!flag) + { + return new Skill_change_super_skybound_art_count(skillParam, buildInfo._option); + } + return new NetworkSkill_change_super_skybound_art_count(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.change_white_ritual_stack: + if (!flag) + { + return new Skill_change_white_ritual_stack(skillParam, buildInfo._option); + } + return new NetworkSkill_change_white_ritual_stack(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.stack_white_ritual: + if (!flag) + { + return new Skill_stack_white_ritual(skillParam, buildInfo._option); + } + return new NetworkSkill_stack_white_ritual(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.rob_skill: + if (!flag) + { + return new Skill_rob_skill(skillParam, buildInfo._option); + } + return new NetworkSkill_rob_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.random_array: + if (!flag) + { + return new Skill_random_array(skillParam, buildInfo._option); + } + return new NetworkSkill_random_array(skillParam.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase, skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.no_duplication_random_array: + return new Skill_no_duplication_random_array(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.cant_evolution: + if (!flag) + { + return new Skill_cant_evolution(skillParam, buildInfo._option); + } + return new NetworkSkill_cant_evolution(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.invoke_skill: + if (!flag) + { + return new Skill_invoke_skill(skillParam, buildInfo._option); + } + return new NetworkSkill_invoke_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.token_draw_modifier: + return new Skill_token_draw_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.fusion: + return new Skill_fusion(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.random_attack: + return new Skill_random_attack(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.clear_destroyed_and_discarded_card_list: + if (!flag) + { + return new Skill_clear_destroyed_and_discarded_card_list(skillParam, buildInfo._option); + } + return new NetworkSkill_clear_destroyed_and_discarded_card_list(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.clear_summoned_card_list: + return new Skill_clear_summoned_card_list(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.geton: + return new Skill_geton(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.getoff: + return new Skill_getoff(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.not_decrease_pp: + return new Skill_not_decrease_pp(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.heal_modifier: + return new Skill_heal_modifier(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.life_zero_activate_leon_skill: + return new Skill_life_zero_activate_leon_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.copy_skill: + if (!flag) + { + return new Skill_copy_skill(skillParam, buildInfo._option); + } + return new NetworkSkill_copy_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.loop_skill: + return new Skill_loop_skill(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.evolve_to_other: + return new Skill_evolve_to_other(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.not_attached_resident_chant_count_change: + return new Skill_not_attached_resident_chant_count_change(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.invoke_emote: + return new Skill_invoke_emote(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.invoke_voice: + return new Skill_invoke_voice(skillParam, buildInfo._option); + case SkillKeywordInfo.SkillKeyword.can_play_self: + return new Skill_can_play_self(skillParam, buildInfo._option); + default: + return new Skill_none(skillParam, buildInfo._option); + } + } + + public SkillBase Create(SkillBuildInfo buildInfo, IEnumerable lastSkillPreprocessCollection = null, bool isAttachSkill = false, SkillBase attachSkill = null) + { + string skillName = buildInfo._type; + string text = "1"; + int num = buildInfo._type.IndexOf('@'); + if (num >= 0) + { + skillName = buildInfo._type.Substring(0, num); + text = buildInfo._type.Substring(num + 1); + } + SkillParameter skillParameter = new SkillParameter(); + skillParameter.selfBattlePlayer = _selfBattlPlayer; + skillParameter.opponentBattlePlayer = _opponentBattlePlayer; + skillParameter.ownerCard = _ownerCard; + skillParameter.buildInfo = buildInfo; + skillParameter.afterFallPos = () => _ownerCard.BattleCardView.CardWrapObject.transform.position; + skillParameter.resourceMgr = _battleResourceMgr; + SkillBase skillBase = CreateSkillFactory(skillName, buildInfo, skillParameter); + if (attachSkill != null) + { + Skill_attach_skill.GiveIndividualId(attachSkill, skillBase); + } + skillBase.CallCountTextValue = text; + skillBase.SetCallCountText(text); + SetupSkillTiming(skillBase, buildInfo._timing); + skillBase.SetIsOnceCallTiming(); + SetupSkillConditionOld(skillBase.ConditionFilterCollection, buildInfo._parsedConditionOld, _ownerCard, skillBase); + SetupSkillConditionNew(skillBase, _ownerCard, buildInfo._parsedConditionNew); + SetupSkillTargetNew(skillBase, _ownerCard, buildInfo._parsedTargetNew); + SetupSkillTargetOld(skillBase.ApplyFilterCollection, _ownerCard, buildInfo._parsedTargetOld, skillBase); + SetupSkillPreprocess(skillBase, buildInfo._parsedPreprocess, lastSkillPreprocessCollection); + skillBase.SetIsAttachSkill(isAttachSkill, _ownerCard.IsInplay); + skillBase.SkillCreateEnd(); + return skillBase; + } + + private static void SetupSkillTiming(SkillBase skill, string timing) + { + skill.SkillTimingText = timing; + if (timing != null) + { + switch (timing) + { + case "none": + break; + case "when_play": + skill.OnWhenPlayStart |= CreateStartMethod(); + break; + case "when_hand_to_not_play": + skill.OnWhenHandToNotPlayStart |= CreateStartMethod(); + break; + case "when_destroy": + skill.OnWhenDestroyStart |= CreateStartMethod(); + break; + case "when_destroy_other": + skill.OnWhenDestroyOtherStart |= CreateStartMethod(); + break; + case "when_discard": + skill.OnDisCardStart |= CreateStartMethod(); + break; + case "when_discard_other": + skill.OnDisCardOtherStart |= CreateStartMethod(); + break; + case "when_necromance": + skill.OnWhenNecromance |= CreateStartMethod(); + break; + case "when_use_white_ritual_stack": + skill.OnWhenUseWhiteRitualStack |= CreateStartMethod(); + break; + case "when_summon": + skill.OnWhenSummonStart |= CreateStartMethod(); + break; + case "self_turn_start": + skill.OnSelfTurnStartStart |= CreateStartMethod(); + break; + case "turn_start": + skill.OnSelfTurnStartStart |= CreateStartMethod(); + break; + case "when_turn_start_immediate": + skill.OnWhenTurnStartStartImmediate |= CreateStartMethod(); + break; + case "self_turn_end": + skill.OnSelfTurnEndStart |= CreateStartMethod(); + break; + case "op_turn_start": + skill.OnOpponentTurnStartStart |= CreateStartMethod(); + break; + case "op_turn_end": + skill.OnOpponentTurnEndStart |= CreateStartMethod(); + break; + case "when_attack": + skill.OnBeforeAttackStart |= CreateStartMethod(); + break; + case "when_attack_self_and_other": + skill.OnBeforeAttackSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_attack_after": + skill.OnAfterAttackStart |= CreateStartMethod(); + break; + case "when_attack_self_and_other_after": + skill.OnAfterAttackSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_use_ep_self_and_other": + skill.OnWhenUseEpSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_evolve": + skill.OnWhenEvolveStart |= CreateStartMethod(); + break; + case "when_evolve_other": + skill.OnWhenEvolveOtherStart |= CreateStartMethod(); + break; + case "when_evolve_self_and_other": + skill.OnWhenEvolveSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_evolve_before": + skill.OnWhenEvolveBeforeStart |= CreateStartMethod(); + break; + case "when_play_other": + skill.OnWhenPlayOtherStart |= CreateStartMethod(); + break; + case "when_summon_other": + skill.OnWhenSummonOtherStart |= CreateStartMethod(); + break; + case "when_summon_self_and_other": + skill.OnWhenSummonSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_spell_charge": + skill.OnWhenSpellChargeStart |= CreateStartMethod(); + break; + case "when_skill_chant_count_gain": + skill.OnWhenChantCountChangeStart |= CreateStartMethod(); + break; + case "when_chant_count_gain": + skill.OnWhenChantCountGain |= CreateStartMethod(); + break; + case "when_chant_count_gain_self_and_other": + skill.OnWhenChantCountGainSelfAndOther |= CreateStartMethod(); + break; + case "when_healing_self_and_other": + skill.OnWhenHealingSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_healing_other": + skill.OnWhenHealOtherStart |= CreateStartMethod(); + break; + case "when_damage": + skill.OnWhenDamageStart |= CreateStartMethod(); + break; + case "when_damage_self_and_other": + skill.OnWhenDamageSelfAndOtherStart |= CreateStartMethod(); + break; + case "when_fight": + skill.OnWhenFightStart |= CreateStartMethod(); + break; + case "when_buff": + skill.OnWhenBuffStart |= CreateStartMethod(); + break; + case "when_return": + skill.OnWhenReturnStart |= CreateStartMethod(); + break; + case "when_return_other": + skill.OnWhenReturnOtherStart |= CreateStartMethod(); + break; + case "when_return_skill_activate": + skill.OnWhenReturnSkillActivateStart |= CreateStartMethod(); + break; + case "when_add_to_deck": + skill.OnWhenAddToDeckStart |= CreateStartMethod(); + break; + case "when_enhance": + skill.OnWhenEnhanceStart |= CreateStartMethod(); + break; + case "when_accelerate_other": + skill.OnWhenAccelerateStart |= CreateStartMethod(); + break; + case "when_crystallize_other": + skill.OnWhenCrystallizeStart |= CreateStartMethod(); + break; + case "when_burial_rite_other": + skill.OnWhenBurialRiteOther |= CreateStartMethod(); + break; + case "when_choice_play": + skill.OnWhenChoicePlayStart |= CreateStartMethod(); + break; + case "when_choice_evolve": + skill.OnWhenChoiceEvolveStart |= CreateStartMethod(); + break; + case "when_choice_brave": + skill.OnWhenChoiceBrave |= CreateStartMethod(); + break; + case "when_banish": + skill.OnWhenBanish |= CreateStartMethod(); + break; + case "when_banish_other": + skill.OnWhenBanishOther |= CreateStartMethod(); + break; + case "when_resonance_start": + skill.OnWhenResonanceStart |= CreateStartMethod(); + break; + case "when_accelerate": + skill.OnWhenAccelerate |= CreateStartMethod(); + break; + case "when_crystallize": + skill.OnWhenCrystallize |= CreateStartMethod(); + break; + case "when_leave": + skill.OnWhenLeave |= CreateStartMethod(); + break; + case "when_draw": + skill.OnWhenDraw |= CreateStartMethod(); + break; + case "when_draw_other": + skill.OnWhenDrawOtherStart |= CreateStartMethod(); + break; + case "when_pp_healing": + skill.OnWhenPpHealStart |= CreateStartMethod(); + break; + case "when_fusion": + skill.OnWhenFusion |= CreateStartMethod(); + break; + case "when_fusioned": + skill.OnWhenFusioned |= CreateStartMethod(); + break; + case "when_fusion_metamorphose": + skill.OnWhenFusionMetamorphose |= CreateStartMethod(); + break; + case "when_fight_after": + skill.OnAfterFightStart |= CreateStartMethod(); + break; + case "when_fusion_other": + skill.OnWhenFusionOtherStart |= CreateStartMethod(); + break; + case "when_geton": + skill.OnWhenGetOnStart |= CreateStartMethod(); + break; + case "when_getoff": + skill.OnWhenGetOff |= CreateStartMethod(); + break; + case "when_leave_other": + skill.OnWhenLeaveOther |= CreateStartMethod(); + break; + case "when_attach_ability": + skill.OnWhenAttachAbility |= CreateStartMethod(); + break; + case "when_buff_self_and_other": + skill.OnWhenBuffSelfAndOther |= CreateStartMethod(); + break; + case "when_debuff_self_and_other": + skill.OnWhenDebuffSelfAndOther |= CreateStartMethod(); + break; + case "when_debuff_include_set_max_life": + skill.OnWhenDebuffIncludeSetMaxLife |= CreateStartMethod(); + break; + case "when_healing": + skill.OnWhenHealing |= CreateStartMethod(); + break; + case "when_shortage_deck": + skill.OnWhenShortageDeck |= CreateStartMethod(); + break; + case "when_shortage_deck_win_skill_activate": + skill.OnWhenShortageDeckWinSkillActivate |= CreateStartMethod(); + break; + case "when_special_lose": + skill.OnWhenSpecialLose |= CreateStartMethod(); + break; + case "when_change_inplay_immediate": + skill.OnWhenChangeInPlayImmediate |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_change_inplay_selfhand": + skill.OnWhenChangeInplaySelfhand |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_change_inplay": + skill.OnWhenChangeInPlay |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_change_class_life_inplay": + skill.OnWhenChangeClassLifeInplay |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_change_pptotal": + skill.OnWhenChangePPTotal |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_change_class_life_selfhand": + skill.OnWhenChangeClassLifeSelfhand |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_add_to_hand": + skill.OnWhenAddToHand |= CreateStartMethod(); + skill.PreprocessList.Add(new SkillResidentPreprocessReturnHandActiveReset(skill)); + break; + case "when_battle_start": + skill.OnWhenBattleStart |= CreateStartMethod(); + break; + } + } + } + + private static uint CreateStartMethod() + { + return 1u; + } + + public static bool IsNewStyle(string text) + { + return NEWSTYLE_HEAD_TEXT.Any(text.StartsWith); + } + + private static string[] DivideContents(string content) + { + List list = new List(); + int num = 0; + int num2 = 0; + int num3 = 0; + for (int i = 0; i < content.Length; i++) + { + if (content[i] == '{') + { + num++; + } + if (content[i] == '}') + { + num2++; + } + if (content[i] == '&' && num == num2) + { + list.Add(content.Substring(num3, i - num3)); + num3 = i + 1; + } + } + list.Add(content.Substring(num3, content.Length - num3)); + return list.ToArray(); + } + + private static void ParsePreprocess(string preprocess, ref SkillFilterCreator.ContentInfo[] retInfos) + { + retInfos = ParseContentInfos(preprocess); + } + + private static void ParseOption(string option, ref SkillFilterCreator.ContentInfo[] retInfos) + { + retInfos = ParseContentInfos(option); + } + + public static void ParseCondition(string condition, ref List retOldInfos, ref List retNewInfos) + { + string[] array = DivideContents(condition); + retNewInfos = new List(); + retOldInfos = new List(); + int i = 0; + for (int num = array.Length; i < num; i++) + { + if (IsNewStyle(array[i])) + { + retNewInfos.Add(array[i]); + continue; + } + SkillFilterCreator.ParseContentInfo(array[i], out var retParsedInfo); + retOldInfos.Add(retParsedInfo); + } + } + + public static void ParseTarget(string target, ref List retOldInfos, ref List retNewInfos, ref List checkKeywords) + { + string[] array = DivideContents(target); + retNewInfos = new List(); + retOldInfos = new List(); + int i = 0; + for (int num = array.Length; i < num; i++) + { + if (IsNewStyle(array[i])) + { + retNewInfos.Add(array[i]); + checkKeywords.AddRange(GetCheckKeywords(array[i])); + continue; + } + SkillFilterCreator.ParseContentInfo(array[i], out var retParsedInfo); + retOldInfos.Add(retParsedInfo); + if (retParsedInfo.Name != SkillFilterCreator.ContentKeyword.exclution) + { + checkKeywords.AddRange(GetCheckKeywords(retParsedInfo.Value.ToString())); + checkKeywords.AddRange(GetCheckKeywords(retParsedInfo.ValueStr)); + } + } + } + + private static string[] GetCheckKeywords(string str) + { + return str.Replace("{", string.Empty).Replace("}", string.Empty).Split('.'); + } + + private static void SetupSkillConditionNew(SkillBase skill, BattleCardBase ownerCard, List parsedInfos) + { + if (parsedInfos != null) + { + int i = 0; + for (int count = parsedInfos.Count; i < count; i++) + { + SkillFilterCreator.SetupCondition(skill.ConditionFilterCollection, parsedInfos[i], ownerCard, skill); + } + } + } + + public static void SetupSkillConditionOld(ConditionSkillFilterCollection conditionFilterCollection, List parsedInfos, BattleCardBase ownerCard, SkillBase skill) + { + if (parsedInfos == null) + { + return; + } + bool flag = true; + int i = 0; + for (int count = parsedInfos.Count; i < count; i++) + { + SkillFilterCreator.ContentInfo info = parsedInfos[i]; + switch (info.Name) + { + case SkillFilterCreator.ContentKeyword.character: + conditionFilterCollection.BattlePlayerFilter = SkillFilterCreator.CreateBattlePlayerFilter(info.Value); + break; + case SkillFilterCreator.ContentKeyword.target: + conditionFilterCollection.TargetFilter = CreateTargetFilterOld(info, info.Value, ownerCard, skill); + break; + case SkillFilterCreator.ContentKeyword.card_type: + conditionFilterCollection.CardFilterList.Add(SkillFilterCreator.CreateCardTypeFilter(info.Value)); + flag = false; + break; + case SkillFilterCreator.ContentKeyword.tribe: + conditionFilterCollection.CardFilterList.Add(SkillFilterCreator.CreateTribeFilter(info)); + break; + case SkillFilterCreator.ContentKeyword.summon_moment_tribe: + conditionFilterCollection.CardFilterList.Add(new SkillSummonMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.play_moment_tribe: + conditionFilterCollection.CardFilterList.Add(new SkillPlayMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.play_moment_spell_charge: + conditionFilterCollection.CardFilterList.Add(new SkillPlayMomentSpellChargeFilter()); + break; + case SkillFilterCreator.ContentKeyword.update_deck_moment_tribe: + conditionFilterCollection.CardFilterList.Add(new SkillUpdateDeckMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.clan: + conditionFilterCollection.CardFilterList.Add(SkillFilterCreator.CreateClanFilter(info, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.ability: + conditionFilterCollection.CardFilterList.Add(SkillFilterCreator.CreateAbilityFilter(info.Value, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.evolution: + conditionFilterCollection.CardFilterList.Add(new SkillEvolutionCardFilter(SkillFilterCreator.ParseBoolean(info.ValueStr))); + break; + case SkillFilterCreator.ContentKeyword.chant_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterChantCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.buff_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterBuffCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.buff_life_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterBuffLifeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_cost: + conditionFilterCollection.CardFilterList.Add(new SkillParameterCostFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_offense: + conditionFilterCollection.CardFilterList.Add(new SkillParameterOffenseFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_life: + conditionFilterCollection.CardFilterList.Add(new SkillParameterLifeFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.id: + conditionFilterCollection.CardFilterList.Add(new SkillParameterIdFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_card_id: + conditionFilterCollection.CardFilterList.Add(new SkillParameterBaseCardIdFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.destroy: + conditionFilterCollection.CardFilterList.Add(new SkillParameterDestroyFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.previous_turn_attacked: + conditionFilterCollection.CardFilterList.Add(new SkillParameterPreviousTurnAttackedFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.has_skill: + conditionFilterCollection.CardFilterList.Add(new SkillParameterHasSkillFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by: + conditionFilterCollection.CardFilterList.Add(new SkillParameterDestroyedByFilter(info.Value)); + break; + case SkillFilterCreator.ContentKeyword.returned_by: + conditionFilterCollection.CardFilterList.Add(new SkillParameterReturnedByFilter(ownerCard, info.Value)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_ability: + conditionFilterCollection.CardFilterList.Add(new SkillParameterDestroyedByAbilityFilter(info.Value)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_card_id: + conditionFilterCollection.CardFilterList.Add(new SkillParameterDestroyedByCardIdFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_card_id_and_ability: + conditionFilterCollection.CardFilterList.Add(new SkillParameterDestroyedByCardIdAndAbilityFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.attack_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterAttackCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.max_attack_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterMaxAttackCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.berserk: + { + SkillConditionHalfLife item10 = new SkillConditionHalfLife(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item10); + break; + } + case SkillFilterCreator.ContentKeyword.avarice: + { + SkillConditionAvarice item9 = new SkillConditionAvarice(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item9); + break; + } + case SkillFilterCreator.ContentKeyword.wrath: + { + SkillConditionWrath item8 = new SkillConditionWrath(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item8); + break; + } + case SkillFilterCreator.ContentKeyword.awake: + { + SkillConditionAwake item7 = new SkillConditionAwake(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item7); + break; + } + case SkillFilterCreator.ContentKeyword.evolvable_turn: + { + SkillConditionEvolvableTurn item6 = new SkillConditionEvolvableTurn(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item6); + break; + } + case SkillFilterCreator.ContentKeyword.resonance: + { + SkillConditionResonance item5 = new SkillConditionResonance(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item5); + break; + } + case SkillFilterCreator.ContentKeyword.burial_rite: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionBurialRite(ownerCard, info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.pp_count: + { + SkillConditionPP item4 = new SkillConditionPP(ownerCard, int.Parse(info.ValueStr), info.Operator); + conditionFilterCollection.ConditionCheckerFilterList.Add(item4); + break; + } + case SkillFilterCreator.ContentKeyword.trigger: + { + SkillConditionTrigger item3 = new SkillConditionTrigger(ownerCard, info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item3); + break; + } + case SkillFilterCreator.ContentKeyword.play_count: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionPlayCount(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.cemetery_count: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillCemeteryFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.attacker: + conditionFilterCollection.ConditionCheckerFilterList.Add(CreateAttackerChecker(info.Value, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.be_attacked: + conditionFilterCollection.ConditionCheckerFilterList.Add(CreateBeAttackedChecker(info.Value, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.in_hand: + conditionFilterCollection.ConditionCheckerFilterList.Add(CreateInHandChecker(info.Value, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.necromance: + conditionFilterCollection.ConditionCheckerFilterList.Add(CreateNecromanceChecker(info.Value, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.turn: + { + SkillConditionTurn item2 = new SkillConditionTurn(info.ValueStr, ownerCard); + conditionFilterCollection.ConditionCheckerFilterList.Add(item2); + break; + } + case SkillFilterCreator.ContentKeyword.last_life: + conditionFilterCollection.CardFilterList.Add(new SkillParameterLastLifeFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.game_changed_max_life_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterChangeMaxLifeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_offense: + conditionFilterCollection.CardFilterList.Add(new SkillParameterBaseOffenseFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_life: + conditionFilterCollection.CardFilterList.Add(new SkillParameterBaseLifeFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.shortage_deck_win: + { + SkillConditionShortageDeckWin item = new SkillConditionShortageDeckWin(info.ValueStr); + conditionFilterCollection.ConditionCheckerFilterList.Add(item); + break; + } + case SkillFilterCreator.ContentKeyword.reanimated_card: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionReanimatedSelf(ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.deck_summoned_card: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionDeckSelfSummonedSelf(ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.attaching_ability: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionAttachingAbility(info.Value)); + break; + case SkillFilterCreator.ContentKeyword.is_odd_spell_charge: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionOddEvenSpellCharge(ownerCard, info.ValueStr, isOdd: true)); + break; + case SkillFilterCreator.ContentKeyword.is_even_spell_charge: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionOddEvenSpellCharge(ownerCard, info.ValueStr, isOdd: false)); + break; + case SkillFilterCreator.ContentKeyword.is_odd_offense: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionOddEvenOffense(ownerCard, info.ValueStr, isOdd: true)); + break; + case SkillFilterCreator.ContentKeyword.is_even_offense: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionOddEvenOffense(ownerCard, info.ValueStr, isOdd: false)); + break; + case SkillFilterCreator.ContentKeyword.display_other_users_message: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionDisplayOtherUsersMessage(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.me_language: + conditionFilterCollection.ConditionCheckerFilterList.Add(new SkillConditionMeLanguage(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.charge_count: + conditionFilterCollection.CardFilterList.Add(new SkillParameterChargeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.is_inplay: + conditionFilterCollection.CardFilterList.Add(new SkillConditionIsInplayCardFilter(SkillFilterCreator.ParseBoolean(info.ValueStr))); + break; + case SkillFilterCreator.ContentKeyword.select_cardlist: + conditionFilterCollection.CardFilterList.Add(new SkillOnlyOneCardFilter(int.Parse(info.ValueStr))); + break; + case SkillFilterCreator.ContentKeyword.load_target: + conditionFilterCollection.CardFilterList.Add(new SkillLoadTargetFilter(ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.not_unique_base_card_id_card: + conditionFilterCollection.CardFilterList.Add(new SkillTargetNotUniqueBaseCardIdFilter()); + break; + case SkillFilterCreator.ContentKeyword.attacked: + if (BattleManagerBase.GetIns() is SingleBattleMgr) + { + conditionFilterCollection.CardFilterList.Add(new SkillAttackedCardFilter(info.ValueStr)); + } + break; + } + } + conditionFilterCollection.BattlePlayerFilter = conditionFilterCollection.BattlePlayerFilter ?? new SelfBattlePlayerFilter(); + conditionFilterCollection.TargetFilter = conditionFilterCollection.TargetFilter ?? new SkillTargetSelfFilter(ownerCard); + if (flag) + { + if (ownerCard.IsUnit) + { + conditionFilterCollection.CardFilterList.Add(new SkillUnitFilter()); + } + else if (ownerCard.IsSpell) + { + conditionFilterCollection.CardFilterList.Add(new SkillSpellFilter()); + } + else if (ownerCard.IsChantField) + { + conditionFilterCollection.CardFilterList.Add(new SkillChantFieldFilter()); + } + else if (ownerCard.IsField) + { + conditionFilterCollection.CardFilterList.Add(new SkillFieldFilter()); + } + else if (ownerCard.IsClass) + { + conditionFilterCollection.CardFilterList.Add(new SkillClassFilter()); + } + } + conditionFilterCollection.CardFilterList.TrimExcess(); + conditionFilterCollection.ConditionCheckerFilterList.TrimExcess(); + } + + private static ISkillCustomSelectFilter CreateCustomSelectFilter(SkillFilterCreator.ContentInfo info, SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.over_cost_from_last_target => new SkillTargetOverCostFromLastTargetFilter(), + SkillFilterCreator.ContentKeyword.equal_or_less_cost_from_last_target => new SkillTargetEqualOrLessCostFromLastTarget(info.CusomValue), + SkillFilterCreator.ContentKeyword.in_order_from_oldest => new SkillInOrderFromOldestFilter(), + _ => null, + }; + } + + private static void SetupSkillTargetNew(SkillBase skill, BattleCardBase ownerCard, List parsedInfos) + { + if (parsedInfos != null) + { + int i = 0; + for (int count = parsedInfos.Count; i < count; i++) + { + SkillFilterCreator.SetupTarget(skill.ApplyFilterCollection, parsedInfos[i], ownerCard, skill); + } + } + } + + private static ISkillTargetFilter CreateTargetFilterOld(SkillFilterCreator.ContentInfo info, SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard, SkillBase skill) + { + bool flag = BattleManagerBase.GetIns() is NetworkBattleManagerBase && !GameMgr.GetIns().IsAINetwork; + switch (keyword) + { + case SkillFilterCreator.ContentKeyword.inplay: + return new SkillTargetInPlayFilter(); + case SkillFilterCreator.ContentKeyword.deck: + return new SkillTargetDeckFilter(); + case SkillFilterCreator.ContentKeyword.battle_start_deck: + return new SkillTargetBattleStartDeckFilter(); + case SkillFilterCreator.ContentKeyword.cemetery: + return new SkillTargetCemeteryFilter(); + case SkillFilterCreator.ContentKeyword.hand: + return new SkillTargetHandFilter(); + case SkillFilterCreator.ContentKeyword.hand_self: + return new SkillTargetHandSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.hand_other_self: + return new SkillTargetHandOtherSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.hand_other_oldest: + return new SkillTargetHandOtherOldestFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.return_card: + return new SkillTargetReturnCardFilter(); + case SkillFilterCreator.ContentKeyword.cant_attack_all_return_card: + return new SkillTargetCantAttackAllReturnCardFilter(); + case SkillFilterCreator.ContentKeyword.self: + return new SkillTargetSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.deck_self: + return new SkillTargetDeckSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.inplay_self: + return new SkillTargetInPlaySelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.inplay_other_self: + return new SkillTargetInPlayOtherSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.newer_inplay_other_self: + return new SkillTargetNewerInPlayOtherSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.attacker: + return new SkillTargetAttackerFilter(); + case SkillFilterCreator.ContentKeyword.be_attacked: + return new SkillTargetBeAttackedFilter(); + case SkillFilterCreator.ContentKeyword.other_than_be_attacked: + return new SkillTargetOtherThanBeAttackedFilter(); + case SkillFilterCreator.ContentKeyword.necromance: + return new SkillTargetNecromanceFilter(); + case SkillFilterCreator.ContentKeyword.played_card: + return new SkillTargetPlayedCardFilter(); + case SkillFilterCreator.ContentKeyword.enhance_card: + return new SkillTargetEnhanceCardfilter(); + case SkillFilterCreator.ContentKeyword.accelerated_card: + return new SkillTargetAcceleratedCardfilter(); + case SkillFilterCreator.ContentKeyword.crystallized_card: + return new SkillTargetCrystallizedCardfilter(); + case SkillFilterCreator.ContentKeyword.summoned_card: + return new SkillTargetSummonedCardFilter(); + case SkillFilterCreator.ContentKeyword.burial_rite_card: + return new SkillTargetBurialRiteCardFilter(); + case SkillFilterCreator.ContentKeyword.burial_rite_card_list: + return new SkillTargetBurialRiteCardListFilter(); + case SkillFilterCreator.ContentKeyword.burial_rite_this_turn_card_list: + return new SkillTargetBurialRiteThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.reanimated_this_turn_card_list: + return new SkillTargetReanimatedThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.banished_card: + return new SkillTargetBanishedCardFilter(); + case SkillFilterCreator.ContentKeyword.inplay_banished_card: + return new SkillTargetInplayBanishedCardFilter(); + case SkillFilterCreator.ContentKeyword.hand_banished_card: + return new SkillTargetHandBanishedCardFilter(); + case SkillFilterCreator.ContentKeyword.inplay_banished_this_turn_card_list: + return new SkillTargetInplayBanishedThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.hand_banished_this_turn_card_list: + return new SkillTargetHandBanishedThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.inplay_banished_card_list: + return new SkillTargetInplayBanishedCardListFilter(); + case SkillFilterCreator.ContentKeyword.return_this_turn_card_list: + return new SkillTargetReturnThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.destroyed_card: + return new SkillTargetDestroyedCardFilter(); + case SkillFilterCreator.ContentKeyword.destroyed_card_list: + return new SkillTargetDestroyedCardListFilter(); + case SkillFilterCreator.ContentKeyword.turn_destroyed_cards: + return new SkillTurnDestroyedFilter(info.ValueStr); + case SkillFilterCreator.ContentKeyword.lastword_card_list: + return new SkillTargetDestroyedWhenDestroyCardListFilter(); + case SkillFilterCreator.ContentKeyword.destroyed_this_turn_card_list: + return new SkillTargetDestroyedThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.discard_this_turn_card_list: + return new SkillTargetDiscardThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.discarded_card: + return new SkillTargetDiscardedCardFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.damaged_card: + return new SkillTargetDamagedCardFilter(); + case SkillFilterCreator.ContentKeyword.not_damaged_card: + return new SkillTargetNotDamagedCardFilter(); + case SkillFilterCreator.ContentKeyword.skill_drew_card: + return new SkillTargetSkillDrewCardFilter(); + case SkillFilterCreator.ContentKeyword.skill_update_deck_card: + return new SkillTargetSkillUpdateDeckCardFilter(); + case SkillFilterCreator.ContentKeyword.last_target: + if (!flag) + { + return new SkillTargetLastTargetFilter(info.CusomValue); + } + return new NetworkSkillTargetLastTargetFilter(info.CusomValue, skill); + case SkillFilterCreator.ContentKeyword.inplay_last_target: + return new SkillTargetInplayLastTargetFilter(info.CusomValue); + case SkillFilterCreator.ContentKeyword.destroyed_last_target: + return new SkillTargetDestroyedLastTargetFilter(info.CusomValue); + case SkillFilterCreator.ContentKeyword.banished_last_target: + return new SkillTargetBanishedLastTargetFilter(info.CusomValue); + case SkillFilterCreator.ContentKeyword.cant_attack_all_last_target: + return new SkillTargetCantAttackAllLastTargetFilter(info.CusomValue); + case SkillFilterCreator.ContentKeyword.in_hand: + return new SkillTargetInHandCardFilter(); + case SkillFilterCreator.ContentKeyword.skill_summoned_card: + return new SkillTargetSkillSummonedCardFilter(); + case SkillFilterCreator.ContentKeyword.healing_card: + return new SkillTargetHealingCardFilter(); + case SkillFilterCreator.ContentKeyword.received_damage_card: + return new SkillTargetReceivedDamageCardFilter(); + case SkillFilterCreator.ContentKeyword.give_damage_card: + return new SkillTargetGiveDamageCardFilter(); + case SkillFilterCreator.ContentKeyword.evolution_card: + return new SkillTargetEvolutionCardFilter(); + case SkillFilterCreator.ContentKeyword.fusion_ingrediented_card: + return new SkillTargetFusionIngredientCardsFilter(); + case SkillFilterCreator.ContentKeyword.through_fusion_ingrediented_card: + return new SkillTargetThroughFusionIngredientedCardFilter(ownerCard, info.ValueStr); + case SkillFilterCreator.ContentKeyword.fusion_ingrediented_card_list_include_this_fusion: + return new SkillTargetFusionIngredientedCardListIncludeThisFusion(ownerCard); + case SkillFilterCreator.ContentKeyword.game_fusion_ingrediented_cards: + return new SkillTargetGameFusionIngredientedCards(); + case SkillFilterCreator.ContentKeyword.game_fusion_ingrediented_and_discard_cards: + return new SkillTargetGameFusionIngredientedAndDiscardCards(); + case SkillFilterCreator.ContentKeyword.evolved_card_list: + return new SkillTargetEvolvedCardListFilter(); + case SkillFilterCreator.ContentKeyword.discard: + return new SkillTargetDiscardFilter(); + case SkillFilterCreator.ContentKeyword.unique_base_card_id_card: + return new SkillTargetUniqueBaseCardIDCardFilter(); + case SkillFilterCreator.ContentKeyword.fight_target: + return new SkillTargetFightTargetFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.selected_cards: + return new SkillTargetSelectedCardsFilter(); + case SkillFilterCreator.ContentKeyword.chosen_cards: + return new SkillTargetChosenCardsFilter(); + case SkillFilterCreator.ContentKeyword.turn_play_cards: + return new SkillTargetTurnPlayCardsFilter(); + case SkillFilterCreator.ContentKeyword.turn_draw_cards: + return new SkillTargetTurnDrawCardsFilter(); + case SkillFilterCreator.ContentKeyword.turn_token_draw_skill_id: + return new SkillTargetTurnTokenDrawSkillIdFilter(info.ValueStr); + case SkillFilterCreator.ContentKeyword.turn_summon_cards: + return new SkillTargetTurnSummonCardsFilter(); + case SkillFilterCreator.ContentKeyword.past_summon_cards: + return new SkillTargetPastSummonCardsFilter(ownerCard, info.ValueStr); + case SkillFilterCreator.ContentKeyword.turn_play_cards_other_self: + return new SkillTargetTurnPlayCardsOtherSelfFilter(ownerCard, info.ValueStr); + case SkillFilterCreator.ContentKeyword.game_play_cards_other_self: + return new SkillTargetGamePlayCardsOtherSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.game_play_cards: + return new SkillTargetGamePlayCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_summon_cards: + return new SkillTargetGameSummonCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_summon_cards_other: + return new SkillTargetGameSummonCardsOtherFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.inplay_self_and_class: + return new SkillTargetInplaySelfAndClassFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.token_draw_card: + return new SkillTargetTokenDrawCardFilter(); + case SkillFilterCreator.ContentKeyword.inplay_and_hand: + return new SkillTargetInplayAndHandFilter(); + case SkillFilterCreator.ContentKeyword.reanimated_card: + return new SkillTargetReanimatedCardFilter(); + case SkillFilterCreator.ContentKeyword.game_accelerated_cards: + return new SkillTargetGameAcceleratedCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_accelerated_cards_other_self: + return new SkillTargetGameAcceleratedCardsOtherSelfFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.game_crystallized_cards: + return new SkillTargetGameCrystallizedCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_skill_activated: + return new SkillTargetGameSkillActivatedFilter(); + case SkillFilterCreator.ContentKeyword.deck_draw_card: + return new SkillTargetDeckDrawCardFilter(); + case SkillFilterCreator.ContentKeyword.drew_over_hand_limit: + return new SkillTargetDrewOverHandLimitFilter(); + case SkillFilterCreator.ContentKeyword.left_cards: + return new SkillTargetLeftCardsFilter(); + case SkillFilterCreator.ContentKeyword.inplay_buffing_cards: + return new SkillTargetInplayBuffingCardsFilter(); + case SkillFilterCreator.ContentKeyword.inplay_debuffing_cards: + return new SkillTargetInplayDebuffingCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_deck_draw_cards: + return new SkillTargetGameDeckDrawCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_draw_cards: + return new SkillTargetGameDrawCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_add_update_deck_cards: + return new SkillTargetGameAddUpdateDeckCardsFilter(); + case SkillFilterCreator.ContentKeyword.game_left_cards: + return new SkillTargetGameLeftCardsFilter(); + case SkillFilterCreator.ContentKeyword.left_this_turn_card_list: + return new SkillTargetLeftThisTurnCardListFilter(); + case SkillFilterCreator.ContentKeyword.before_transform_card: + return new SkillTargetBeforeTransformCardFilter(ownerCard); + case SkillFilterCreator.ContentKeyword.discard_card_list: + return new SkillTargetDiscardCardListFilter(); + case SkillFilterCreator.ContentKeyword.chant_count_change_cards: + return new SkillTargetChantCountChangeCardsFilter(); + case SkillFilterCreator.ContentKeyword.shortage_deck_win_cards: + return new SkillTargetShortageDeckWinCards(); + case SkillFilterCreator.ContentKeyword.load_target: + return new SkillTargetLoadTargetFilter(ownerCard); + default: + return null; + } + } + + private static ISkillConditionChecker CreateAttackerChecker(SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.self => new SkillConditionAttackerIsSelf(ownerCard), + SkillFilterCreator.ContentKeyword.other => new SkillConditionAttackerIsOther(ownerCard), + _ => null, + }; + } + + private static ISkillConditionChecker CreateBeAttackedChecker(SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.self => new SkillConditionBeAttackedIsSelf(ownerCard), + SkillFilterCreator.ContentKeyword.other => new SkillConditionBeAttackedIsOther(ownerCard), + SkillFilterCreator.ContentKeyword.destroy => new SkillConditionBeAttackedIsDestroy(), + _ => null, + }; + } + + private static ISkillConditionChecker CreateHealingCardChecker(SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.self_class => new SkillConditionHealingCardIsClass(ownerCard, isSelf: true), + SkillFilterCreator.ContentKeyword.opp_class => new SkillConditionHealingCardIsClass(ownerCard, isSelf: false), + _ => null, + }; + } + + private static ISkillConditionChecker CreateInHandChecker(SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.self => new SkillConditionInHandIsSelf(ownerCard), + SkillFilterCreator.ContentKeyword.other => new SkillConditionInHandIsOther(ownerCard), + _ => null, + }; + } + + private static ISkillConditionChecker CreateNecromanceChecker(SkillFilterCreator.ContentKeyword keyword, BattleCardBase ownerCard) + { + return keyword switch + { + SkillFilterCreator.ContentKeyword.self => new SkillConditionBeAttackedIsSelf(ownerCard), + SkillFilterCreator.ContentKeyword.other => new SkillConditionBeAttackedIsOther(ownerCard), + _ => null, + }; + } + + public void SetupSkillTargetOld(ApplySkillTargetFilterCollection filterCollection, BattleCardBase ownerCard, List parsedInfo, SkillBase skill) + { + bool flag = true; + int i = 0; + for (int count = parsedInfo.Count; i < count; i++) + { + SkillFilterCreator.ContentInfo info = parsedInfo[i]; + switch (info.Name) + { + case SkillFilterCreator.ContentKeyword.character: + filterCollection.BattlePlayerFilter = SkillFilterCreator.CreateBattlePlayerFilter(info.Value); + break; + case SkillFilterCreator.ContentKeyword.target: + filterCollection.TargetFilter = CreateTargetFilterOld(info, info.Value, ownerCard, skill); + break; + case SkillFilterCreator.ContentKeyword.turn_destroyed_cards: + filterCollection.CardFilterList.Add(new SkillCardTurnDestroyedFilter(ownerCard, info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.custom_select: + filterCollection.ApplyCustomSelectFilterList.Add(CreateCustomSelectFilter(info, info.Value, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.card_type: + filterCollection.CardFilterList.Add(SkillFilterCreator.CreateCardTypeFilter(info.Value)); + flag = false; + break; + case SkillFilterCreator.ContentKeyword.tribe: + filterCollection.CardFilterList.Add(SkillFilterCreator.CreateTribeFilter(info)); + break; + case SkillFilterCreator.ContentKeyword.summon_moment_tribe: + filterCollection.CardFilterList.Add(new SkillSummonMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.play_moment_tribe: + filterCollection.CardFilterList.Add(new SkillPlayMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.play_moment_spell_charge: + filterCollection.CardFilterList.Add(new SkillPlayMomentSpellChargeFilter()); + break; + case SkillFilterCreator.ContentKeyword.update_deck_moment_tribe: + filterCollection.CardFilterList.Add(new SkillUpdateDeckMomentTribeFilter(SkillFilterCreator.ParseEnum(info.ValueStr, CardBasePrm.TribeType.MAX), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.clan: + filterCollection.CardFilterList.Add(SkillFilterCreator.CreateClanFilter(info, ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.ability: + filterCollection.CardFilterList.Add(SkillFilterCreator.CreateAbilityFilter(info.Value, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.evolution: + filterCollection.CardFilterList.Add(new SkillEvolutionCardFilter(SkillFilterCreator.ParseBoolean(info.ValueStr))); + break; + case SkillFilterCreator.ContentKeyword.is_inplay: + filterCollection.CardFilterList.Add(new SkillConditionIsInplayCardFilter(SkillFilterCreator.ParseBoolean(info.ValueStr))); + break; + case SkillFilterCreator.ContentKeyword.random_count: + filterCollection.ApplySelectFilter = CreateRandomSelectFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.random_count_until: + filterCollection.ApplySelectFilter = CreateRandomSelectUntilFilter(info.ValueStr, ownerCard.SelfBattlePlayer, skill); + break; + case SkillFilterCreator.ContentKeyword.id_no_duplication_random_count: + filterCollection.ApplySelectFilter = CreateIdNoDuplicationRandomSelectFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.no_duplication_random_count_in_order: + filterCollection.ApplySelectFilter = CreateNoDuplicationRandomSelectInOrderFilter(info.ValueStr, skill); + break; + case SkillFilterCreator.ContentKeyword.cost_no_duplication_random_count: + filterCollection.ApplySelectFilter = CreateCostNoDuplicationRandomSelectFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.select_count: + filterCollection.ApplySelectFilter = new SkillUserSelectFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.choice_count: + filterCollection.ApplySelectFilter = new SkillChoiceSelectFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.each_same_base_card_id_count_until: + filterCollection.ApplySelectFilter = CreateSkillRandomEachSameBaseCardIdFilter(int.Parse(info.ValueStr), ownerCard.SelfBattlePlayer, skill); + break; + case SkillFilterCreator.ContentKeyword.chant_count: + filterCollection.CardFilterList.Add(new SkillParameterChantCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.buff_count: + filterCollection.CardFilterList.Add(new SkillParameterBuffCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.buff_life_count: + filterCollection.CardFilterList.Add(new SkillParameterBuffLifeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_cost: + filterCollection.CardFilterList.Add(new SkillParameterCostFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_cost: + filterCollection.CardFilterList.Add(new SkillParameterBaseCostFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_offense: + filterCollection.CardFilterList.Add(new SkillParameterOffenseFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.status_life: + filterCollection.CardFilterList.Add(new SkillParameterLifeFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_offense: + filterCollection.CardFilterList.Add(new SkillParameterBaseOffenseFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_life: + filterCollection.CardFilterList.Add(new SkillParameterBaseLifeFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.id: + filterCollection.CardFilterList.Add(new SkillParameterIdFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.base_card_id: + filterCollection.CardFilterList.Add(new SkillParameterBaseCardIdFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.destroy: + filterCollection.CardFilterList.Add(new SkillParameterDestroyFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.previous_turn_attacked: + filterCollection.CardFilterList.Add(new SkillParameterPreviousTurnAttackedFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.has_skill: + filterCollection.CardFilterList.Add(new SkillParameterHasSkillFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by: + filterCollection.CardFilterList.Add(new SkillParameterDestroyedByFilter(info.Value)); + break; + case SkillFilterCreator.ContentKeyword.returned_by: + filterCollection.CardFilterList.Add(new SkillParameterReturnedByFilter(ownerCard, info.Value)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_ability: + filterCollection.CardFilterList.Add(new SkillParameterDestroyedByAbilityFilter(info.Value)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_card_id: + filterCollection.CardFilterList.Add(new SkillParameterDestroyedByCardIdFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.destroyed_by_card_id_and_ability: + filterCollection.CardFilterList.Add(new SkillParameterDestroyedByCardIdAndAbilityFilter(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.exclution: + filterCollection.ApplyExclutionFilterList.Add(CreateExclutionFilter(info.ValueStr, skill)); + break; + case SkillFilterCreator.ContentKeyword.attack_count: + filterCollection.CardFilterList.Add(new SkillParameterAttackCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.max_attack_count: + filterCollection.CardFilterList.Add(new SkillParameterMaxAttackCountFilter(info.ValueStr, info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.none: + filterCollection.BattlePlayerFilter = filterCollection.BattlePlayerFilter ?? new NullBattlePlayerFilter(); + filterCollection.TargetFilter = filterCollection.TargetFilter ?? new SkillTargetNullFilter(); + filterCollection.CardFilterList.Add(new SkillNullFilter()); + filterCollection.ApplyExclutionFilterList.Add(new SkillExclutionNoneFilter()); + filterCollection.ApplySelectFilter = filterCollection.ApplySelectFilter ?? new SkillSelectNullFilter(); + flag = false; + break; + case SkillFilterCreator.ContentKeyword.last_life: + filterCollection.CardFilterList.Add(new SkillParameterLastLifeFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.game_changed_max_life_count: + filterCollection.CardFilterList.Add(new SkillParameterChangeMaxLifeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.select_index: + filterCollection.ApplySelectFilter = new SkillSelectIndexFilter(int.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.select_cardlist: + filterCollection.ApplySelectFilter = new SkillOnlyOneFilter(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.limit_upper_count_from_oldest: + filterCollection.ApplySelectFilter = new SkillLimitUpperCountFromOldestFilter(int.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.limit_upper_count_from_newest: + filterCollection.ApplySelectFilter = new SkillLimitUpperCountFromNewestFilter(int.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.charge_count: + filterCollection.CardFilterList.Add(new SkillParameterChargeCountFilter(int.Parse(info.ValueStr), info.Operator)); + break; + case SkillFilterCreator.ContentKeyword.life_is_larger: + filterCollection.CardFilterList.Add(new SkillLifeIsLarger()); + break; + case SkillFilterCreator.ContentKeyword.attack_is_larger: + filterCollection.CardFilterList.Add(new SkillAttackIsLarger()); + break; + case SkillFilterCreator.ContentKeyword.load_target: + filterCollection.CardFilterList.Add(new SkillLoadTargetFilter(ownerCard)); + break; + case SkillFilterCreator.ContentKeyword.not_unique_base_card_id_card: + filterCollection.CardFilterList.Add(new SkillTargetNotUniqueBaseCardIdFilter()); + break; + case SkillFilterCreator.ContentKeyword.attacked: + if (BattleManagerBase.GetIns() is SingleBattleMgr) + { + filterCollection.CardFilterList.Add(new SkillAttackedCardFilter(info.ValueStr)); + } + break; + } + } + filterCollection.BattlePlayerFilter = filterCollection.BattlePlayerFilter ?? new SelfBattlePlayerFilter(); + filterCollection.TargetFilter = filterCollection.TargetFilter ?? new SkillTargetSelfFilter(ownerCard); + if (flag) + { + filterCollection.CardFilterList.Add(new SkillUnitFilter()); + } + filterCollection.ApplySelectFilter = filterCollection.ApplySelectFilter ?? new SkillSelectAllFilter(); + } + + protected virtual ISkillSelectFilter CreateRandomSelectFilter(string count) + { + return new SkillRandomSelectFilter(count); + } + + protected virtual ISkillSelectFilter CreateRandomSelectUntilFilter(string count, BattlePlayerBase player, SkillBase skill) + { + if (!(BattleManagerBase.GetIns() is NetworkBattleManagerBase) || GameMgr.GetIns().IsAINetwork) + { + return new SkillRandomSelectUntilFilter(count, player); + } + return new NetworkSkillRandomSelectUntilFilter(count, player, skill); + } + + protected virtual ISkillSelectFilter CreateIdNoDuplicationRandomSelectFilter(string count) + { + return new SkillIdNoDuplicationRandomSelectFilter(count); + } + + protected virtual ISkillSelectFilter CreateNoDuplicationRandomSelectInOrderFilter(string option, SkillBase skill) + { + return new SkillNoDuplicationRandomSelectInOrderFilter(option, skill); + } + + protected virtual ISkillSelectFilter CreateCostNoDuplicationRandomSelectFilter(string count) + { + return new SkillCostNoDuplicationRandomSelectFilter(count); + } + + protected virtual ISkillSelectFilter CreateSkillRandomEachSameBaseCardIdFilter(int count, BattlePlayerBase player, SkillBase skill) + { + if (!(BattleManagerBase.GetIns() is NetworkBattleManagerBase) || GameMgr.GetIns().IsAINetwork) + { + return new SkillRandomEachSameBaseCardIdFilter(count, player); + } + return new NetworkSkillRandomEachSameBaseCardIdFilter(count, player, skill); + } + + protected virtual ISkillExclutionFilter CreateExclutionFilter(string text, SkillBase skill) + { + if (text.First() == '{') + { + return new SkillExclutionApplyFilter(_ownerCard, text, skill); + } + return new SkillExclutionNoneFilter(); + } + + private static SkillPreprocessBase MakeSkillPreprocess(SkillBase skill, SkillFilterCreator.ContentInfo info, ref bool isExecutionCheck, ref bool isReferencePreviousPreprocess) + { + bool flag = BattleManagerBase.GetIns() is NetworkBattleManagerBase && !GameMgr.GetIns().IsAINetwork; + SkillPreprocessBase skillPreprocessBase = null; + switch (info.Name) + { + case SkillFilterCreator.ContentKeyword.use_pp: + skillPreprocessBase = new SkillPreprocessUsePp(int.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.necromance: + skillPreprocessBase = new SkillPreprocessNecromance(skill, info.ValueStr, info.Operator); + break; + case SkillFilterCreator.ContentKeyword.burial_rite: + skillPreprocessBase = new SkillPreprocessBurialRite(skill, skill.SkillPrm.ownerCard); + break; + case SkillFilterCreator.ContentKeyword.skill_random_count: + skillPreprocessBase = new SkillPreprocessRandomCount(skill.SkillPrm.ownerCard, int.Parse(info.ValueStr)); + isExecutionCheck = true; + break; + case SkillFilterCreator.ContentKeyword.fixed_generic_value: + case SkillFilterCreator.ContentKeyword.fixed_generic_value_initial: + skillPreprocessBase = new SkillPreprocessFixedGenericValue(skill.SkillPrm.ownerCard, info.Operator, int.Parse(info.ValueStr)); + isExecutionCheck = true; + break; + case SkillFilterCreator.ContentKeyword.destroy_tribe: + skillPreprocessBase = new SkillPreprocessDestroyTribe(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_start_skill: + skillPreprocessBase = new SkillPreprocessTurnStartSkill(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_start_stop: + skillPreprocessBase = new SkillPreprocessTurnStartStop(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_start_skill_after_stop: + skillPreprocessBase = new SkillPreprocessTurnStartSkillAfterStop(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_end_skill_after_stop: + skillPreprocessBase = new SkillPreprocessTurnEndSkillAfterStop(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_end_stop: + skillPreprocessBase = new SkillPreprocessTurnEndStop(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_end_remove: + skillPreprocessBase = new SkillPreprocessTurnEndRemove(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.self_turn_end_remove: + skillPreprocessBase = new SkillPreprocessSelfTurnEndRemove(skill, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.remove_from_inplay_stop: + skillPreprocessBase = new SkillPreprocessRemoveFromInPlayStop(); + break; + case SkillFilterCreator.ContentKeyword.evolution_end_stop: + skillPreprocessBase = new SkillPreprocessEvolutionEndStop(skill.SkillPrm.ownerCard); + break; + case SkillFilterCreator.ContentKeyword.damage_after_stop: + skillPreprocessBase = new SkillPreprocessDamageAfterStop(); + break; + case SkillFilterCreator.ContentKeyword.damage_give_stop: + skillPreprocessBase = new SkillPreprocessDamageGiveStop(); + break; + case SkillFilterCreator.ContentKeyword.reflection_after_stop: + skillPreprocessBase = new SkillPreprocessReflectionAfterStop(); + break; + case SkillFilterCreator.ContentKeyword.remove_after_action: + skillPreprocessBase = new SkillPreprocessRemoveAfterAction(info.ValueStr, skill); + break; + case SkillFilterCreator.ContentKeyword.evolution_end_remove: + skillPreprocessBase = new SkillPreprocessWhenEvolveEndRemove(skill); + break; + case SkillFilterCreator.ContentKeyword.unit_attack_stop: + skillPreprocessBase = new SkillPreprocessUnitAttackStop(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.dont_select_start: + skillPreprocessBase = new SkillPreprocessDontSelectStart(); + break; + case SkillFilterCreator.ContentKeyword.inplay_period_of_time: + skillPreprocessBase = new SkillPreprocessInPlayPeriodOfTime(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_end_period_of_stop_time: + skillPreprocessBase = new SkillPreprocessTurnEndPeriodOfStopTime(skill, skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_start_skill_after_period_of_stop_time: + skillPreprocessBase = new SkillPreprocessTurnStartSkillAfterPeriodOfStopTime(skill, skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.turn_end_stop_and_remove: + skillPreprocessBase = new SkillPreprocessTurnEndStopAndRemove(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword._ref_prev: + skillPreprocessBase = new SkillPreprocessReferencePrevious(); + isReferencePreviousPreprocess = true; + break; + case SkillFilterCreator.ContentKeyword.per_turn: + skillPreprocessBase = new SkillPreprocessTimesPerTurn(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.per_game: + skillPreprocessBase = new SkillPreprocessTimesPerGame(int.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.any_condition: + { + List list = new List(); + string preprocess = info.ValueStr.Substring(1, info.ValueStr.Length - 2); + SkillFilterCreator.ContentInfo[] retInfos = null; + ParsePreprocess(preprocess, ref retInfos); + bool isExecutionCheck2 = false; + bool isReferencePreviousPreprocess2 = false; + SkillFilterCreator.ContentInfo[] array = retInfos; + foreach (SkillFilterCreator.ContentInfo info2 in array) + { + SkillPreprocessBase skillPreprocessBase2 = MakeSkillPreprocess(skill, info2, ref isExecutionCheck2, ref isReferencePreviousPreprocess2); + if (skillPreprocessBase2 != null) + { + list.Add(skillPreprocessBase2); + if (isExecutionCheck2) + { + isExecutionCheck = true; + } + if (isReferencePreviousPreprocess2) + { + isReferencePreviousPreprocess2 = true; + } + } + } + skillPreprocessBase = new SkillPreprocessAnyCondition(list); + break; + } + case SkillFilterCreator.ContentKeyword.none: + return null; + case SkillFilterCreator.ContentKeyword.use_ep: + skillPreprocessBase = new SkillPreprocessUseEvolutionPoint(int.Parse(info.ValueStr), skill.SkillPrm.ownerCard); + break; + case SkillFilterCreator.ContentKeyword.once_per_action: + skillPreprocessBase = new SkillPreprocessOncePerAction(skill); + break; + case SkillFilterCreator.ContentKeyword.open_card: + skillPreprocessBase = new SkillPreprocessOpenCard(skill.SkillPrm.ownerCard); + break; + case SkillFilterCreator.ContentKeyword.only_random_index: + skillPreprocessBase = new SkillPreprocessRandomArrayIndex(skill.SkillPrm.ownerCard, info.ValueStr.Split(':').Select(int.Parse).ToArray()); + isExecutionCheck = true; + break; + case SkillFilterCreator.ContentKeyword.preprocess_condition: + skillPreprocessBase = (flag ? new NetworkSkillPreprocessConditionCheck(skill, info.ValueStr) : new SkillPreprocessConditionCheck(skill, info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.dont_activate: + skillPreprocessBase = new SkillPreprocessDontActivate(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.wrapping_and_adding_skill_activated_count: + skillPreprocessBase = new SkillPreprocessWrappingAndAddingSkillActivatedCount(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.skill_activate_count_by_simultaneous_destroyed_card_list: + skillPreprocessBase = new SkillPreprocessSkillActivateCountBySimultaneousDestroyedCardList(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.skill_activate_count_by_simultaneous_buffing_cards: + skillPreprocessBase = new SkillPreprocessSkillActivateCountBySimultaneousBuffingCards(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.skill_activate_count_by_simultaneous_summoned_card: + skillPreprocessBase = new SkillPreprocessSkillActivateCountBySimultaneousSummonedCard(skill.SkillPrm.ownerCard, info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.skill_id: + skillPreprocessBase = new SkillPreprocessSkillId(long.Parse(info.ValueStr)); + break; + case SkillFilterCreator.ContentKeyword.skill_stop_and_remove_by_when_summon_other: + skillPreprocessBase = new SkillPreprocessSkillStopAndRemoveByWhenSummonOther(info.ValueStr); + break; + case SkillFilterCreator.ContentKeyword.is_activate_summon_card: + skillPreprocessBase = new SkillPreprocessIsActivateSummonCard(skill, info.ValueStr); + break; + default: + return null; + } + return skillPreprocessBase; + } + + private static void SetupSkillPreprocess(SkillBase skill, SkillFilterCreator.ContentInfo[] parsedInfo, IEnumerable lastSkillPreprocessCollection) + { + try + { + int i = 0; + for (int num = parsedInfo.Length; i < num; i++) + { + SkillFilterCreator.ContentInfo info = parsedInfo[i]; + bool isReferencePreviousPreprocess = false; + bool isExecutionCheck = false; + SkillPreprocessBase skillPreprocessBase = MakeSkillPreprocess(skill, info, ref isExecutionCheck, ref isReferencePreviousPreprocess); + if (skillPreprocessBase == null) + { + continue; + } + if (isReferencePreviousPreprocess) + { + foreach (SkillPreprocessBase item in lastSkillPreprocessCollection) + { + if (!(item is SkillPreprocessReferencePrevious)) + { + skill.ConditionCheckerList.Add(item); + } + } + } + else if (!isExecutionCheck) + { + skill.ConditionCheckerList.Add(skillPreprocessBase); + } + skill.PreprocessList.Add(skillPreprocessBase); + } + } + catch (Exception ex) + { + Debug.LogError("Preprocessのマスター記述にエラーがあります。" + ex); + } + } + + public static SkillFilterCreator.ContentInfo[] ParseContentInfos(string text) + { + if (Regex.Match(text, "\\(.+?\\)").Value == "") + { + string[] array = null; + array = ((!text.Contains(SkillFilterCreator.ContentKeyword.preprocess_condition.ToString())) ? text.Split('&') : ParenthesisParseContentInfos(text)); + SkillFilterCreator.ContentInfo[] array2 = new SkillFilterCreator.ContentInfo[array.Count()]; + int i = 0; + for (int num = array.Length; i < num; i++) + { + SkillFilterCreator.ParseContentInfo(array[i], out array2[i]); + } + return array2; + } + string[] array3 = ParenthesisParseContentInfos(text); + SkillFilterCreator.ContentInfo[] array4 = new SkillFilterCreator.ContentInfo[array3.Count()]; + int j = 0; + for (int num2 = array3.Length; j < num2; j++) + { + SkillFilterCreator.ParseContentInfo(array3[j], out array4[j]); + } + return array4; + } + + public static string[] ParenthesisParseContentInfos(string text) + { + int num = 0; + int num2 = 0; + List list = new List(); + int i; + for (i = 0; i < text.Length; i++) + { + if (num == 0 && text[i] == '&') + { + list.Add(text.Substring((num2 == 0) ? num2 : (num2 + 1), i - ((num2 == 0) ? num2 : (num2 + 1)))); + num2 = i; + } + if (text[i] == '(') + { + num++; + } + if (text[i] == ')') + { + num--; + } + } + if (text[num2] == '&') + { + list.Add(text.Substring(num2 + 1, i - (num2 + 1))); + } + else + { + list.Add(text.Substring(num2, i)); + } + return list.ToArray(); + } + + public static CardSkillsBuildInfo CreateBuildInfo(CardParameter cardParameter) + { + string[] array = SplitBothSkillText(cardParameter.Skill); + string[] array2 = SplitBothSkillText(cardParameter.SkillTiming); + string[] array3 = SplitBothSkillText(cardParameter.SkillCondition); + string[] array4 = SplitBothSkillText(cardParameter.SkillTarget); + string[] array5 = SplitBothSkillText(cardParameter.SkillOption); + string[] array6 = SplitBothSkillText(cardParameter.SkillPreprocess); + string[] array7 = CardIconControl.SplitAndCompleteIconStr(cardParameter.SkillIcon, array); + CardSkillsBuildInfo cardSkillsBuildInfo = new CardSkillsBuildInfo(); + cardSkillsBuildInfo.normalSkillBuildInfos = CreateOneCardSkillBuildInfo(array[0], array2[0], array3[0], array4[0], array5[0], array6[0], cardParameter.SkillHandCardFrameEffectType, array7[0], cardParameter.SkillEffectPath, cardParameter.SkillEffectEnginType, cardParameter.SkillSe, cardParameter.SkillEffectTime, cardParameter.SkillMoveType, cardParameter.SkillEffectTargetType); + if (array.Length >= 2) + { + cardSkillsBuildInfo.evolveSkillBuildInfos = CreateOneCardSkillBuildInfo(array[1], array2[1], array3[1], array4[1], array5[1], array6[1], new HandCardFrameEffectType[1], array7[1], cardParameter.EvoSkillEffectPath, cardParameter.EvoSkillEffectEnginType, cardParameter.EvoSkillSe, cardParameter.EvoSkillEffectTime, cardParameter.EvoSkillMoveType, cardParameter.EvoSkillEffectTargetType); + } + else + { + cardSkillsBuildInfo.evolveSkillBuildInfos = new List(); + } + return cardSkillsBuildInfo; + } + + public static string[] SplitBothSkillText(string text) + { + if (text == null) + { + return new string[1] { "none" }; + } + text = text.Replace(" ", ""); + if (string.IsNullOrEmpty(text)) + { + return new string[1] { "none" }; + } + return text.Split(new string[1] { "//" }, StringSplitOptions.RemoveEmptyEntries); + } + + private static List CreateOneCardSkillBuildInfo(string type, string timing, string condition, string target, string option, string preprocess, HandCardFrameEffectType[] frameEffectType, string icon, string[] effectPath, EffectMgr.EngineType[] engineType, string[] sePath, string[] effectTime, EffectMgr.MoveType[] effectMoveType, EffectMgr.TargetType[] effectTargetType) + { + string[] array = type.Split(','); + string[] array2 = timing.Split(','); + string[] array3 = condition.Split(','); + string[] array4 = target.Split(','); + string[] array5 = option.Split(','); + string[] array6 = preprocess.Split(','); + string[] array7 = icon.Split(','); + List list = new List(array.Length); + for (int i = 0; i < array.Length; i++) + { + list.Add(new SkillBuildInfo(GetElementAtString(array, i), GetElementAtString(array2, i), GetElementAtString(array3, i), GetElementAtString(array4, i), GetElementAtString(array5, i), GetElementAtString(array6, i), GetElementAt(frameEffectType, i, HandCardFrameEffectType.NONE), GetElementAtString(array7, i), null, GetElementAtString(effectPath, i), GetElementAt(engineType, i, EffectMgr.EngineType.NONE), GetElementAtString(sePath, i), GetElementAtFloat(effectTime, i), GetElementAt(effectMoveType, i, EffectMgr.MoveType.NONE), GetElementAt(effectTargetType, i, EffectMgr.TargetType.NONE))); + } + return list; + } + + public static float GetElementAtFloat(string[] array, int index) + { + float elementAt = GetElementAt(array, index, float.Parse, float.NegativeInfinity); + if (elementAt < 0f) + { + elementAt = GetElementAt(array, 0, float.Parse, 0f); + } + return elementAt; + } + + public static string GetElementAtString(string[] array, int index) + { + return GetElementAt(array, index, (string s) => s, ""); + } + + public static T GetElementAt(string[] array, int index, Func converter, T defaultValue) + { + if (array == null) + { + return defaultValue; + } + if (array.Length <= index) + { + return defaultValue; + } + try + { + return converter(array[index]); + } + catch (Exception) + { + return defaultValue; + } + } + + public static T GetElementAt(T[] array, int index, T defaultValue) + { + if (array == null) + { + return defaultValue; + } + if (array.Length <= index) + { + return defaultValue; + } + return array[index]; + } +} diff --git a/SVSim.BattleEngine/Engine/Wizard.Battle/ActionProcessor.cs b/SVSim.BattleEngine/Engine/Wizard.Battle/ActionProcessor.cs new file mode 100644 index 0000000..29bdbdf --- /dev/null +++ b/SVSim.BattleEngine/Engine/Wizard.Battle/ActionProcessor.cs @@ -0,0 +1,897 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Cute; +using UnityEngine; +using Wizard.Battle.Resource; +using Wizard.Battle.UI; +using Wizard.Battle.View; +using Wizard.Battle.View.Vfx; + +namespace Wizard.Battle; + +public class ActionProcessor +{ + private readonly BattlePlayerPair _pair; + + public Action OnPlayComplete; + + public Action OnEvolutionComplete; + + public Action OnAttackComplete; + + public Action OnFusionComplete; + + public Action OnAttackDamageComplete; + + public Action OnAttackProcessComplete; + + public Action OnAttackStart; + + private const float ADMIN_WATCH_CARD_ROTATION_Y = 180f; + + public const float ACCELERATE_WAITTIME = 0.4f; + + public const float CRYSTALLIZE_WAITTIME_BEFORE = 0.2f; + + public const float CRYSTALLIZE_WAITTIME_AFTER = 0.3f; + + public static readonly Vector3 ACCELERATE_POSITION_OFFSET = new Vector3(0f, 0f, -0.03f); + + public event Action> OnBeforePlayCard; + + public event Action> OnBeforeChosenPlayCard; + + public event Action, bool> OnBeforeBurialRitePlayCard; + + public event Func OnAfterPlayCard; + + public event Func OnBeforeAttack; + + public event Func OnBeforeAttackSkillComplete; + + public event Func OnAfterAttack; + + public event Action> OnBeforeEvolution; + + public event Action> OnBeforeChosenEvolution; + + public event Action OnJustBeforeEvolution; + + public event Action OnRightAfterEvolution; + + public event Func OnAfterEvolution; + + public event Action> OnBeforeFusion; + + public event Func OnAfterFusion; + + public event Action OnTransform; + + public event Action OnSpecialAccelerate; + + public ActionProcessor(BattlePlayerPair pair) + { + _pair = pair; + } + + private void GetSelectTargetBySelectList(SkillBase selectSkill, List selectList, List selectTargets, ref int skillIndex) + { + BattlePlayerPair playerInfoPair = new BattlePlayerPair(selectSkill.SkillPrm.ownerCard.SelfBattlePlayer, selectSkill.SkillPrm.ownerCard.OpponentBattlePlayer); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + int skillSelectCount = selectSkill.GetSkillSelectCount(); + int num = 1; + if (skillSelectCount >= 2) + { + NetworkBattleManagerBase networkBattleManagerBase = selectSkill.SkillPrm.selfBattlePlayer.BattleMgr as NetworkBattleManagerBase; + num = ((selectSkill.SkillPrm.selfBattlePlayer.IsPlayer || networkBattleManagerBase == null || GameMgr.GetIns().IsAdminWatch || !RegisterValidate.IsValidateCard(selectSkill)) ? Math.Min(skillSelectCount, selectSkill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: true).Count()) : (from n in networkBattleManagerBase.GetValidateTargetSkillIndexList() + where n == NetworkBattleGenericTool.GetSkillIndex(selectSkill) + select n).Count()); + } + for (int num2 = 0; num2 < num; num2++) + { + if (skillIndex >= selectList.Count) + { + break; + } + selectTargets.Add(new SkillConditionCheckerOption.SkillAndSelectTarget(selectList[skillIndex], selectSkill)); + skillIndex++; + } + } + + private VfxBase SetSkillConditionCheckeroptionSelectCards(BattleCardBase card, SkillConditionCheckerOption option, IEnumerable cards, bool isEvolve, List selectChoiceCardIdList, bool isFusion = false, bool isChoiceBrave = false) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + SkillCollectionBase skillCollectionBase = (isEvolve ? card.EvolutionSkills : card.Skills); + bool isChoiceTransform = false; + List list = null; + if (cards != null) + { + list = cards.ToList(); + } + if (!isFusion && skillCollectionBase.Any((SkillBase s) => s is Skill_transform)) + { + BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(card.SelfBattlePlayer, card.OpponentBattlePlayer); + CardMaster instanceForBattle = CardMaster.GetInstanceForBattle(); + for (int num = 1; num < skillCollectionBase.Count(); num++) + { + if (skillCollectionBase.Get(num) is Skill_transform skill_transform) + { + Skill_pp_fixeduse skill_pp_fixeduse = skillCollectionBase.Get(num - 1) as Skill_pp_fixeduse; + if (false || (skill_transform.TransformId != -1 && skill_pp_fixeduse != null && skill_pp_fixeduse.IsMutationFixedUseCost && skill_pp_fixeduse.CheckCondition(playerInfoPair, option, isPrePlay: true) && card.GetAccelerateOrCrystallizeTransformSkill() != null)) + { + BattleCardBase.TransformType transformType = ((skill_transform.OnWhenAccelerate != 0) ? BattleCardBase.TransformType.Accelerate : BattleCardBase.TransformType.Crystallize); + sequentialVfxPlayer.Register(SwapTransformCard(card, card.BaseParameter.IsFoil ? instanceForBattle.GetCardParameterFromId(skill_transform.TransformId).FoilCardId : skill_transform.TransformId, option, transformType, selectChoiceCardIdList, list)); + this.OnSpecialAccelerate.Call(skill_pp_fixeduse); + this.OnSpecialAccelerate.Call(skill_transform); + } + if (skillCollectionBase.Get(num - 1) is Skill_choice skill_choice && skill_choice.CheckCondition(playerInfoPair, option, isPrePlay: true)) + { + isChoiceTransform = true; + } + } + } + } + if (cards == null && selectChoiceCardIdList == null) + { + return sequentialVfxPlayer; + } + SkillBase skillBase = card.GetSelectTypeSkill(isEvolve, isFusion: false, isRegister: false, isEvolutionSimpleProcessor: false, isChoiceCheck: true).FirstOrDefault((SkillBase s) => s is Skill_choice); + int num2 = 1; + if (skillBase != null) + { + num2 = SetupChoiceCard(card, option, selectChoiceCardIdList, skillBase, list, isChoiceTransform, sequentialVfxPlayer, isChoiceBrave); + } + if (list != null && list.Count > 0) + { + BattleCardBase battleCardBase = card; + if (option.PlayedCard != null && card != option.PlayedCard) + { + battleCardBase = option.PlayedCard; + } + IEnumerable selectTypeSkill = battleCardBase.GetSelectTypeSkill(isEvolve, isFusion: false, isRegister: true); + int num3 = selectTypeSkill.Where((SkillBase s) => s.IsBurialRite).Count(); + List list2 = selectTypeSkill.Where((SkillBase s) => !(s is Skill_none)).ToList(); + int skillIndex = num3; + for (int num4 = 0; num4 < list2.Count; num4++) + { + if (list2[num4].IsChoiceType) + { + num4 += num2 - 1; + } + else if (list2[num4].IsBurialRite) + { + if (list2[num4].IsUserSelectType) + { + GetSelectTargetBySelectList(list2[num4], list, option.SelectedCards, ref skillIndex); + } + } + else + { + GetSelectTargetBySelectList(list2[num4], list, option.SelectedCards, ref skillIndex); + } + } + for (int num5 = 0; num5 < num3; num5++) + { + option.BurialRiteCards.Add(list[num5]); + } + if (num3 > 0) + { + card.SkillApplyInformation.ClearLastBurialRiteCardList(); + card.SkillApplyInformation.AddLastBurialRiteCardList(list); + } + } + return sequentialVfxPlayer; + } + + private int SetupChoiceCard(BattleCardBase card, SkillConditionCheckerOption option, List selectChoiceCardIdList, SkillBase selectChoiceSkill, List selectList, bool isChoiceTransform, SequentialVfxPlayer vfx, bool isChoiceBrave) + { + int num = 1; + if (option.PlayedCard == null) + { + option.PlayedCard = card; + } + int num2 = -1; + if (selectChoiceSkill.ApplySelectFilter is SkillChoiceSelectFilter) + { + num = ((SkillChoiceSelectFilter)selectChoiceSkill.ApplySelectFilter).CalcCount(selectChoiceSkill.OptionValue); + } + if (selectChoiceCardIdList != null && selectChoiceCardIdList.Count >= 1) + { + foreach (int selectChoiceCardId in selectChoiceCardIdList) + { + num2 = selectChoiceCardId; + option.ChosenCards.Add(num2); + } + } + else if (selectList != null && selectList.Count > 0) + { + for (int i = 0; i < num; i++) + { + BattleCardBase battleCardBase = selectList[i]; + num2 = battleCardBase.BaseParameter.CardId; + option.ChosenCards.Add(num2); + if (isChoiceTransform || isChoiceBrave) + { + selectList.Remove(battleCardBase); + } + } + } + if (num2 >= 0 && isChoiceTransform) + { + vfx.Register(SwapTransformCard(card, num2, option, BattleCardBase.TransformType.Choice, selectChoiceCardIdList, selectList)); + } + return num; + } + + private VfxBase SwapTransformCard(BattleCardBase originalCard, int transformCardID, SkillConditionCheckerOption option, BattleCardBase.TransformType transformType, List selectChoiceCardIdList, List selectList) + { + bool isMutation = transformType == BattleCardBase.TransformType.Accelerate || transformType == BattleCardBase.TransformType.Crystallize; + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create(); + BattleCardBase transformCard = originalCard.SelfBattlePlayer.CreateCard(transformCardID, originalCard.Index); + transformCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate + { + transformCard.BattleCardView.GameObject.SetActive(value: false); + })); + sequentialVfxPlayer2.Register(InstantVfx.Create(delegate + { + if (!BattleManagerBase.GetIns().IsRecovery) + { + Transform transform = transformCard.BattleCardView.Transform; + Transform transform2 = originalCard.BattleCardView.Transform; + transform.position = transform2.position; + transform.rotation = transform2.rotation; + if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle) + { + transform.parent = originalCard.SelfBattlePlayer.BattleView.HandDeck.transform; + } + else + { + transform.parent = transform2.parent; + } + transform.localScale = transform2.localScale; + transform.SetSiblingIndex(transform2.GetSiblingIndex()); + if (!isMutation) + { + transformCard.BattleCardView.CardTemplate.DynamicSetupMaterials(transformCard, BattleManagerBase.GetIns().BattleResourceMgr); + originalCard.BattleCardView.GameObject.SetActive(value: false); + transformCard.BattleCardView.GameObject.SetActive(value: true); + } + } + })); + if (isMutation) + { + sequentialVfxPlayer.Register(sequentialVfxPlayer2); + } + else + { + transformCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(sequentialVfxPlayer2); + } + transformCard.SetOnDraw(draw: false); + originalCard.MetamorphoseCard = transformCard; + transformCard.TransformInfo = new BattleCardBase.TransformInformation(transformType, originalCard); + option.PlayedCard = transformCard; + option.SummonedCard = transformCard; + SkillBase skillBase = transformCard.GetSelectTypeSkill().FirstOrDefault((SkillBase s) => s is Skill_choice); + if (skillBase != null) + { + SetupChoiceCard(transformCard, option, selectChoiceCardIdList, skillBase, selectList, isChoiceTransform: false, sequentialVfxPlayer, isChoiceBrave: false); + } + this.OnTransform.Call(originalCard, transformCardID, !isMutation); + return sequentialVfxPlayer; + } + + private VfxBase SetupPlayCard(BattleCardBase originalCard, BattleCardBase playCard, SkillProcessor skillProcessor, bool isChoiceBrave) + { + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + bool isMutation = originalCard.CheckConditionFixedUseCost(isPrePlay: true) && originalCard.CalcFixedUseCost(originalCard.SelfBattlePlayer.Pp) < originalCard.Cost; + GameMgr gameMgr = GameMgr.GetIns(); + bool isAdminWatch = gameMgr.IsAdminWatch; + BattleManagerBase battleMgr = BattleManagerBase.GetIns(); + if (!isChoiceBrave) + { + sequentialVfxPlayer.Register(playCard.SelfBattlePlayer.ReplaceInHand(originalCard, playCard, skillProcessor)); + } + if (isMutation) + { + sequentialVfxPlayer.Register(battleMgr.LoadCardResources(new List { playCard })); + } + if (!battleMgr.IsRecovery) + { + playCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate + { + originalCard.SelfBattlePlayer.BattleView.HandView.RemoveCardFromView(originalCard.BattleCardView, 0.3f); + })); + } + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + if (!battleMgr.IsRecovery) + { + playCard.SelfBattlePlayer.BattleView.PlayQueueView.RemoveCardFromView(originalCard.BattleCardView, (isAdminWatch && isMutation) || isChoiceBrave); + if (isMutation) + { + playCard.BattleCardView.CardTemplate.DynamicSetupMaterials(playCard, battleMgr.BattleResourceMgr); + } + } + })); + if (!isMutation) + { + sequentialVfxPlayer.Register(battleMgr.OperateMgr.InitSetCard(playCard, playCard.SelfBattlePlayer.IsPlayer, isSelect: false, isRecovery: false, isChoiceSelect: true, isAccelerateSelect: false, registerDirectlyToVfxManager: true, isFusionWait: false, isChoiceBrave)); + } + else + { + bool isChoice = playCard.GetSelectTypeSkill().Any((SkillBase s) => s is Skill_choice); + sequentialVfxPlayer.Register(playCard.SelfBattlePlayer.BattleView.PlayQueueView.InstantAddCardToViewVfx(playCard.BattleCardView, forceCardIntoPlayQueue: false, isChoice)); + if (isMutation) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + Vector3 position = originalCard.BattleCardView.GameObject.transform.position; + position += ACCELERATE_POSITION_OFFSET; + Quaternion rot = originalCard.BattleCardView.GameObject.transform.rotation; + if (!playCard.IsSpell && playCard.SelfBattlePlayer.BattleView.PlayQueueView.IsCardInQueue(playCard.BattleCardView)) + { + Vector3 localEulerAngles = originalCard.BattleCardView.GameObject.transform.localEulerAngles; + rot = Quaternion.Euler(localEulerAngles.x, 0f, localEulerAngles.z); + } + gameMgr.GetEffectMgr().Start(playCard.IsSpell ? EffectMgr.EffectType.CMN_CARD_ACCELERATE_1 : EffectMgr.EffectType.CMN_CARD_CRYSTALLIZE_1, playCard.IsSpell ? position : originalCard.BattleCardView.GameObject.transform.position, rot, 31); + })); + sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0.2f)); + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + CardTemplate cardTemplate = originalCard.BattleCardView.CardTemplate; + cardTemplate.SetEffectStyle(UILabel.Effect.None); + if (originalCard is UnitBattleCard) + { + cardTemplate.NormalAtkLabelTemp.effectStyle = UILabel.Effect.None; + cardTemplate.NormalLifeLabelTemp.effectStyle = UILabel.Effect.None; + } + })); + sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0f)); + } + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + if (!battleMgr.IsRecovery && isMutation) + { + Transform transform = playCard.BattleCardView.Transform; + Transform transform2 = originalCard.BattleCardView.Transform; + if (playCard.IsSpell || playCard.SelfBattlePlayer.BattleView.PlayQueueView.IsCardInQueue(playCard.BattleCardView)) + { + MotionUtils.SetLayerAll(playCard.BattleCardView.CardWrapObject, 31); + playCard.BattleCardView.Transform.SetParent(battleMgr.CutInContainer.transform, worldPositionStays: false); + } + if (playCard.IsSpell) + { + transform.position = transform2.position; + transform.localScale = transform2.localScale; + originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform); + originalCard.BattleCardView.GameObject.SetActive(value: false); + playCard.BattleCardView.GameObject.SetActive(value: true); + playCard.BattleCardView.ShowInHandFrameEffect(enable: true, HandCardFrameEffectType.LIGHT_BLUE); + originalCard.BattleCardView.CardTemplate.SetEffectStyle(UILabel.Effect.None); + } + else + { + transform.position = transform2.position; + transform.localScale = transform2.localScale; + originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform); + originalCard.BattleCardView.GameObject.SetActive(value: false); + playCard.BattleCardView.GameObject.SetActive(value: true); + originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform); + } + } + })); + if (isMutation) + { + sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0.3f)); + if (!playCard.IsSpell) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + originalCard.BattleCardView.GameObject.SetActive(value: false); + MotionUtils.SetLayerAll(playCard.BattleCardView.CardWrapObject, 10); + })); + } + } + } + return sequentialVfxPlayer; + } + + public VfxBase PlayCard(BattleCardBase card, IEnumerable selectedCards, List selectChoiceId = null, bool isChoiceBrave = false) + { + if (selectedCards != null) + { + foreach (BattleCardBase selectedCard in selectedCards) + { + selectedCard.SelfBattlePlayer.AddLastTargetCardsList(selectedCard); + } + } + SetIndividualId(card.NormalSkills); + if (card.NormalSkills.Any((SkillBase s) => s.HasIndividualId)) + { + card.SelfBattlePlayer.BattleMgr.IncrementIndividualId(); + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + SkillProcessor skillProcessor = new SkillProcessor(); + BattleCardBase battleCardBase = card; + SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption(); + skillConditionCheckerOption.PlayedCard = card; + skillConditionCheckerOption.SummonedCard = card; + if (isChoiceBrave) + { + card.SelfBattlePlayer.IsAlreadyChoiceBraveInThisTurn = true; + card.SelfBattlePlayer.BattleView.UpdateChoiceBraveButtonPulsateEffectAndSprite(); + card.SelfBattlePlayer.BattleView.UpdateChoiceBraveActivatingEffect(isActivating: false); + int cardId = ((selectChoiceId != null && selectChoiceId.Count > 0) ? selectChoiceId[0] : selectedCards.First().CardId); + BattleCardBase selectSkillCard = (CardMaster.IsChoiceBraveCardCheck(card.CardId) ? card : ((selectedCards != null && selectedCards.Count() > 1 && (card.IsPlayer || GameMgr.GetIns().IsAdminWatch)) ? selectedCards.First() : null)); + skillConditionCheckerOption.PlayedCard = card.SelfBattlePlayer.BattleMgr.ReplaceChoiceBraveCard(card, cardId, selectSkillCard); + } + sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(card, skillConditionCheckerOption, selectedCards, isEvolve: false, selectChoiceId, isFusion: false, isChoiceBrave)); + if (battleCardBase != skillConditionCheckerOption.PlayedCard) + { + if (battleCardBase.SkillApplyInformation.SkillRandomArray == null) + { + skillConditionCheckerOption.PlayedCard.SkillApplyInformation.GiveSkillRandomArray(battleCardBase.SkillApplyInformation.SkillRandomArray); + } + battleCardBase = skillConditionCheckerOption.PlayedCard; + sequentialVfxPlayer.Register(SetupPlayCard(card, battleCardBase, skillProcessor, isChoiceBrave)); + BattleManagerBase.GetIns().PSideLogControl.RemoveAllLog(); + } + battleCardBase.SetPlayedTurnNow(); + int count = skillConditionCheckerOption.ChosenCards.Count; + int num = selectedCards?.Count() ?? 0; + if (count > 0 && num - count < 0) + { + List list = ((selectedCards != null) ? selectedCards.ToList() : new List()); + foreach (int chosenCard in skillConditionCheckerOption.ChosenCards) + { + BattleCardBase item = BattleManagerBase.GetIns().CreateTransformCardRegisterVfx(skillConditionCheckerOption.PlayedCard, chosenCard, skillConditionCheckerOption.PlayedCard.IsPlayer); + list.Insert(0, item); + } + selectedCards = list; + } + this.OnBeforePlayCard.Call(card, battleCardBase, selectedCards); + this.OnBeforeChosenPlayCard.Call(card, battleCardBase, skillConditionCheckerOption.ChosenCards); + if (skillConditionCheckerOption.BurialRiteCards != null && skillConditionCheckerOption.BurialRiteCards.Count > 0) + { + this.OnBeforeBurialRitePlayCard.Call(battleCardBase, selectedCards, arg3: false); + } + bool isEnhance = battleCardBase.CheckConditionFixedUseCost(isPrePlay: true); + VfxWith vfxWith = card.PlayChoiceCard(skillProcessor, skillConditionCheckerOption); + VfxWith vfxWith2 = battleCardBase.PlayCard(skillProcessor, skillConditionCheckerOption, isInplayGeneration: false, card); + VfxBase vfx = battleCardBase.SelfBattlePlayer.StartSkillWhenChangeInplay(null, new List { battleCardBase }, skillProcessor); + skillProcessor.Register(vfxWith.Value); + skillProcessor.Register(vfxWith2.Value); + VfxBase vfx2 = _pair.Self.StartSkillWhenPlayOtherEnhanceAndAccelerateAndCrystallize(battleCardBase, isEnhance, skillProcessor); + VfxBase vfx3 = _pair.Self.StartSkillWhenSummonOther(battleCardBase, skillProcessor); + VfxBase vfx4 = skillProcessor.Process(_pair); + if (card != battleCardBase && card.Skills.HaveBeforeChoiceSkill()) + { + BattleLogManager.GetInstance().AddLogPlayAsChoiceTransform(battleCardBase); + } + VfxBase vfxBase = battleCardBase.FinishWhenPlaySkill(); + VfxBase allFuncVfxResults = this.OnAfterPlayCard.GetAllFuncVfxResults(battleCardBase); + BattleUIContainer battleUIContainer = BattleManagerBase.GetIns().BattleUIContainer; + bool isSelfTurn = BattleManagerBase.GetIns().BattlePlayer.IsSelfTurn; + if (isSelfTurn) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + battleUIContainer.PlayerCardPlaying = true; + if (battleUIContainer.IsEnableMenu()) + { + battleUIContainer.DisableMenu(); + } + })); + } + sequentialVfxPlayer.Register(vfxWith2.Vfx); + sequentialVfxPlayer.Register(vfx); + sequentialVfxPlayer.Register(battleCardBase.StopSpellCharge()); + sequentialVfxPlayer.Register(vfx2); + sequentialVfxPlayer.Register(vfx3); + sequentialVfxPlayer.Register(vfx4); + if (vfxBase != null) + { + sequentialVfxPlayer.Register(vfxBase); + } + if (allFuncVfxResults.IsVfxNonEmpty()) + { + sequentialVfxPlayer.Register(allFuncVfxResults); + } + Action handleBattleMenu = delegate + { + }; + if (isSelfTurn) + { + handleBattleMenu = delegate + { + battleUIContainer.PlayerCardPlaying = false; + if (BattleManagerBase.GetIns().BattlePlayer.BattleView.PlayQueueView.QueueCount() == 0 && !battleUIContainer.IsEnableMenu()) + { + battleUIContainer.RequestEnableMenuWhenTouchable(); + } + }; + } + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + BattlePlayer battlePlayer = BattleManagerBase.GetIns().BattlePlayer; + handleBattleMenu(); + int num2 = battlePlayer.BattleView.PlayQueueView.QueueCount(); + bool isSelecting = battlePlayer.BattleView.IsSelecting; + if (num2 == 0 && !isSelecting && !battlePlayer.IsDuringChoiceBrave) + { + battlePlayer.BattleView.ClearSelectCardList(); + } + })); + OnPlayComplete.Call(); + return sequentialVfxPlayer; + } + + private void SetIndividualId(SkillCollectionBase skills) + { + for (int i = 0; i < skills.Count(); i++) + { + skills.ElementAt(i).InitSetIndividualId(); + } + } + + public VfxBase Attack(IBattleCardUniqueID attackCardId, IBattleCardUniqueID targetCardId) + { + BattleCardBase attackCard = _pair.Self.InPlayCards.SingleOrDefault((BattleCardBase c) => c.EquelsID(attackCardId)); + IfNullCardThenException(attackCard, attackCardId, "場"); + if (attackCard.SkillApplyInformation.IsQuick) + { + attackCard.SelfBattlePlayer.GameQuickAttackCards.Add(attackCard); + } + BattleCardBase battleCardBase = ((targetCardId.IsPlayer == _pair.Self.IsPlayer) ? _pair.Self.ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c.EquelsID(targetCardId)) : _pair.Opponent.ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c.EquelsID(targetCardId))); + IfNullCardThenException(battleCardBase, targetCardId, "場"); + attackCard.BattleCardView._inPlayFrameEffect.HideFrameEffect(); + OnAttackStart.Call(attackCard, battleCardBase); + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + SkillProcessor skillProcessor = new SkillProcessor(); + SkillCollectionBase skills = attackCard.Skills; + foreach (SkillBase item in skills) + { + if (item.IsBeforAttackSkill) + { + VfxWith vfxWith = skills.CreateBeforeAttackInfo(item, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer)); + skillProcessor.Register(vfxWith.Value); + sequentialVfxPlayer.Register(vfxWith.Vfx); + if (vfxWith.Value != null) + { + attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard); + } + } + if (item.IsWhenFightSkill) + { + VfxWith vfxWith2 = skills.CreateBeforeFightInfo(item, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer)); + skillProcessor.Register(vfxWith2.Value); + sequentialVfxPlayer.Register(vfxWith2.Vfx); + if (vfxWith2.Value != null) + { + attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard); + } + } + } + SkillCollectionBase skills2 = battleCardBase.Skills; + foreach (SkillBase item2 in skills2) + { + if (item2.IsWhenFightSkill) + { + VfxWith vfxWith3 = skills2.CreateBeforeFightInfo(item2, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer)); + skillProcessor.Register(vfxWith3.Value); + sequentialVfxPlayer.Register(vfxWith3.Vfx); + if (vfxWith3.Value != null) + { + attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard); + } + } + } + foreach (BattleCardBase item3 in from c in _pair.Self.ClassAndInPlayCardList.Concat(_pair.Opponent.ClassAndInPlayCardList) + where c.Skills._skillTimingInfo.IsBeforeAttackSelfAndOther + select c) + { + SkillCollectionBase skills3 = item3.Skills; + foreach (SkillBase item4 in skills3) + { + if (item4.IsBeforeAttackSelfAndOtherSkill) + { + VfxWith vfxWith4 = skills3.CreateBeforeAttackSelfAndOtherInfo(item4, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(item3.SelfBattlePlayer, item3.OpponentBattlePlayer)); + skillProcessor.Register(vfxWith4.Value); + sequentialVfxPlayer.Register(vfxWith4.Vfx); + if (vfxWith4.Value != null) + { + item3.SelfBattlePlayer.PredictionWarningCards.Add(item3); + } + } + } + } + VfxBase allFuncVfxResults = this.OnBeforeAttack.GetAllFuncVfxResults(); + sequentialVfxPlayer.Register(allFuncVfxResults); + sequentialVfxPlayer.Register(attackCard.SelfBattlePlayer.BattleView.PrepareCardsForAttackSequenceVfx(attackCard.BattleCardView, battleCardBase.BattleCardView)); + VfxBase vfx = skillProcessor.Process(_pair); + sequentialVfxPlayer.Register(vfx); + VfxBase allFuncVfxResults2 = this.OnBeforeAttackSkillComplete.GetAllFuncVfxResults(); + sequentialVfxPlayer.Register(allFuncVfxResults2); + BattleCardBase battleCardBase2 = (attackCard.IsDead ? null : attackCard.GetDamageReflectionTarget(isSkillDamage: false)); + int damage = battleCardBase.DamageCalculationAtkTypeBeAttacked.Damage; + int num = attackCard.CalculateFinalDamageAmount(damage); + BattleCardBase battleCardBase3 = (battleCardBase.IsDead ? null : battleCardBase.GetDamageReflectionTarget(isSkillDamage: false)); + int damage2 = attackCard.DamageCalculationAtkTypeAttack.Damage; + int num2 = battleCardBase.CalculateFinalDamageAmount(damage2); + OnAttackDamageComplete.Call(attackCard, battleCardBase, num2, num); + bool flag = !attackCard.IsDead && !battleCardBase.IsDead && !attackCard.SelfBattlePlayer.Class.IsDead && !battleCardBase.SelfBattlePlayer.Class.IsDead && attackCard.IsInplay && battleCardBase.IsInplay; + if (flag) + { + VfxBase vfx2 = attackCard.StartAttack(battleCardBase, _pair); + sequentialVfxPlayer.Register(vfx2); + } + else + { + if (attackCard.SkillApplyInformation.IsSneak) + { + sequentialVfxPlayer.Register(attackCard.SkillApplyInformation.FourceDepriveSneak()); + } + attackCard.AttackableCount--; + if (!attackCard.Attackable) + { + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + attackCard.BattleCardView._inPlayFrameEffect.HideFrameEffect(); + })); + } + AttackSelectControl attackSelectControl = attackCard.SelfBattlePlayer.BattleView.AttackSelectControl; + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + if (!attackCard.IsDead && attackCard.IsInplay) + { + IBattleCardView battleCardView = attackCard.BattleCardView; + parallelVfxPlayer.Register(attackSelectControl.ResetCardAfterAttack(battleCardView)); + } + if (!battleCardBase.IsDead && battleCardBase.IsInplay) + { + IBattleCardView battleCardView2 = battleCardBase.BattleCardView; + parallelVfxPlayer.Register(attackSelectControl.ResetCardAfterAttack(battleCardView2)); + } + sequentialVfxPlayer.Register(parallelVfxPlayer); + } + sequentialVfxPlayer.Register(InstantVfx.Create(delegate + { + attackCard.BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect(); + })); + if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle) + { + bool num3 = attackCard.SelfBattlePlayer.BattleMgr.DetailMgr.DetailPanelControl.IsShow && attackCard.SelfBattlePlayer.BattleMgr.DetailMgr.DetailPanelControl._card == attackCard; + bool flag2 = attackCard.SelfBattlePlayer.IsSelfTurn && attackCard.IsPlayer && attackCard.IsInplay && attackCard.AttackableCount <= 0; + if (num3 && flag2) + { + sequentialVfxPlayer.Register(attackCard.BattleCardView.ShowAttackFinished()); + } + } + OnAttackProcessComplete.Call(attackCard); + if (flag) + { + SkillProcessor skillProcessor2 = new SkillProcessor(); + attackCard.SelfBattlePlayer.StartSkillWhenDamageSelfAndOther(null, (battleCardBase3 != null) ? new List { battleCardBase3 } : null, skillProcessor2, damage2, num2); + if (battleCardBase is UnitBattleCard) + { + attackCard.SelfBattlePlayer.StartSkillWhenDamageSelfAndOther(null, (battleCardBase2 != null) ? new List { battleCardBase2 } : null, skillProcessor2, damage, num); + } + for (int num4 = 0; num4 < attackCard.Skills.Count(); num4++) + { + SkillBase skillBase = attackCard.Skills.ElementAt(num4); + if (skillBase.OnAfterAttackStart != 0) + { + SkillProcessor.ProcessInfo info = attackCard.Skills.CreateAfterAttackInfo(skillBase, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer)); + skillProcessor2.Register(info); + } + if (skillBase.OnAfterFightStart != 0) + { + SkillProcessor.ProcessInfo info2 = attackCard.Skills.CreateAfterFightInfo(skillBase, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer)); + skillProcessor2.Register(info2); + } + } + for (int num5 = 0; num5 < battleCardBase.Skills.Count(); num5++) + { + SkillBase skillBase2 = battleCardBase.Skills.ElementAt(num5); + if (skillBase2.OnAfterFightStart != 0) + { + SkillProcessor.ProcessInfo info3 = battleCardBase.Skills.CreateAfterFightInfo(skillBase2, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer)); + skillProcessor2.Register(info3); + } + } + foreach (BattleCardBase item5 in from c in _pair.Self.ClassAndInPlayCardList.Concat(_pair.Opponent.ClassAndInPlayCardList) + where c.Skills._skillTimingInfo.IsAfterAttackSelfAndOther + select c) + { + SkillCollectionBase skills4 = item5.Skills; + foreach (SkillBase item6 in skills4) + { + if (item6.IsAfterAttackSelfAndOtherSkill) + { + VfxWith vfxWith5 = skills4.CreateAfterAttackSelfAndOtherInfo(item6, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(item5.SelfBattlePlayer, item5.OpponentBattlePlayer)); + skillProcessor2.Register(vfxWith5.Value); + sequentialVfxPlayer.Register(vfxWith5.Vfx); + if (vfxWith5.Value != null) + { + item5.SelfBattlePlayer.PredictionWarningCards.Add(item5); + } + } + } + } + VfxBase vfx3 = skillProcessor2.Process(_pair); + sequentialVfxPlayer.Register(vfx3); + } + VfxBase allFuncVfxResults3 = this.OnAfterAttack.GetAllFuncVfxResults(attackCard, battleCardBase, flag); + sequentialVfxPlayer.Register(allFuncVfxResults3); + OnAttackComplete.Call(); + return sequentialVfxPlayer; + } + + public VfxBase Evolve(IBattleCardUniqueID cardId, Func, SkillBase, Func, VfxBase>, VfxBase> selectSkillTargetCards) + { + BattleCardBase card = _pair.Self.InPlayCards.SingleOrDefault((BattleCardBase c) => c.EquelsID(cardId)); + IfNullCardThenException(card, cardId, "場"); + return CallCardSkill(card.EvolutionSkills, (IEnumerable selectedCards) => Evolution(card, selectedCards), selectSkillTargetCards); + } + + public VfxBase Evolution(BattleCardBase card, IEnumerable selectedCards, List selectChoiceId = null) + { + BattleCardBase battleCardBase = card; + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + if (BattleManagerBase.GetIns().BattlePlayer.Class.IsDead || BattleManagerBase.GetIns().BattleEnemy.Class.IsDead || card.IsEvolution || !card.SelfBattlePlayer.IsSelfTurn) + { + return NullVfx.GetInstance(); + } + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(card, option, selectedCards, isEvolve: true, selectChoiceId)); + SkillProcessor skillProcessor = new SkillProcessor(); + if (option.PlayedCard != null && card.EvolutionSkills.Any((SkillBase s) => s is Skill_transform)) + { + battleCardBase = option.PlayedCard; + sequentialVfxPlayer.Register(battleCardBase.SelfBattlePlayer.ReplaceInPlay(card, battleCardBase, skillProcessor)); + sequentialVfxPlayer.Register(battleCardBase.SetUpInplay()); + BattlePlayerPair playerInfoPair = new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer); + sequentialVfxPlayer.Register(battleCardBase.Skills.RegisterAndProcessWhenChangeInplayImmediateInfo(playerInfoPair)); + battleCardBase.Skills.CreateAndRegisterWhenChangeInplayInfo(new List { battleCardBase }, skillProcessor, playerInfoPair); + sequentialVfxPlayer.Register(card.RemoveFromInPlay()); + } + BattlePlayerReadOnlyInfoPair pair = new BattlePlayerReadOnlyInfoPair(card.SelfBattlePlayer, card.OpponentBattlePlayer); + SkillBase skillBase = card.EvolutionSkills.FirstOrDefault((SkillBase s) => s.OnWhenEvolveBeforeStart != 0 && s is Skill_evolve_to_other && s.CheckCondition(pair, option, isPrePlay: true)); + if (skillBase != null) + { + IBattleResourceMgr battleResourceMgr = card.SelfBattlePlayer.BattleMgr.BattleResourceMgr; + ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(); + UnitBattleCardView unitBattleCardView = card.BattleCardView as UnitBattleCardView; + parallelVfxPlayer.Register(battleResourceMgr.DecrementEffectBattleRefCount(card.BaseParameter.AtkEffectParameter.GetEffectPath(isEvolve: false))); + parallelVfxPlayer.Register(battleResourceMgr.DecrementEffectBattleRefCount(card.BaseParameter.AtkEffectParameter.GetEffectPath(isEvolve: true))); + if (option.ChosenCards.Count > 0) + { + card.UpdateBuildInfoAndSkillCollection(option.ChosenCards[0], isFoil: false); + } + else + { + card.UpdateBuildInfoAndSkillCollection(skillBase.OptionValue.GetInt(SkillFilterCreator.ContentKeyword.card_id, -1), card.BaseParameter.IsFoil); + } + card.BattleCardView.InitializeVoiceInfo(card.CardId); + for (int num = 0; num < card.NormalSkills.Count(); num++) + { + card.NormalSkills.ElementAt(num).SetInductionVoiceIndex(); + } + for (int num2 = 0; num2 < card.EvolutionSkills.Count(); num2++) + { + card.EvolutionSkills.ElementAt(num2).SetInductionVoiceIndex(); + } + if (unitBattleCardView != null) + { + parallelVfxPlayer.Register(unitBattleCardView.LoadAttackEffect(card.BaseParameter.AtkEffectParameter, isEvolve: false)); + parallelVfxPlayer.Register(unitBattleCardView.LoadAttackEffect(card.BaseParameter.AtkEffectParameter, isEvolve: true)); + } + sequentialVfxPlayer.Register(parallelVfxPlayer); + } + if (option.ChosenCards.Count > 0 && selectedCards.Count() <= 0) + { + List list = selectedCards.ToList(); + foreach (int chosenCard in option.ChosenCards) + { + BattleCardBase item = BattleManagerBase.GetIns().CreateTransformCardRegisterVfx(card, chosenCard, option.PlayedCard.IsPlayer); + list.Add(item); + } + selectedCards = list; + } + SetIndividualId(card.EvolutionSkills); + if (card.EvolutionSkills.Any((SkillBase s) => s.HasIndividualId)) + { + card.SelfBattlePlayer.BattleMgr.IncrementIndividualId(); + } + this.OnBeforeEvolution.Call(card, battleCardBase, selectedCards); + this.OnBeforeChosenEvolution.Call(card, battleCardBase, option.ChosenCards); + if (option.BurialRiteCards != null && option.BurialRiteCards.Count > 0) + { + this.OnBeforeBurialRitePlayCard.Call(battleCardBase, selectedCards, arg3: true); + } + this.OnJustBeforeEvolution.Call(battleCardBase); + VfxBase vfx = battleCardBase.Evolution(isSkill: false, skillProcessor, option); + sequentialVfxPlayer.Register(vfx); + this.OnRightAfterEvolution.Call(battleCardBase); + VfxBase vfx2 = skillProcessor.Process(_pair); + sequentialVfxPlayer.Register(vfx2); + VfxBase allFuncVfxResults = this.OnAfterEvolution.GetAllFuncVfxResults(battleCardBase); + sequentialVfxPlayer.Register(allFuncVfxResults); + OnEvolutionComplete.Call(); + return sequentialVfxPlayer; + } + + public VfxBase Fusion(BattleCardBase fusionCard, List selectedCards) + { + BattleManagerBase ins = BattleManagerBase.GetIns(); + if (ins.BattlePlayer.Class.IsDead || ins.BattleEnemy.Class.IsDead || fusionCard.IsEvolution || !fusionCard.SelfBattlePlayer.IsSelfTurn) + { + return NullVfx.GetInstance(); + } + SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create(); + SkillConditionCheckerOption option = new SkillConditionCheckerOption(); + this.OnBeforeFusion.Call(fusionCard, selectedCards); + sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(fusionCard, option, selectedCards, isEvolve: false, new List(), isFusion: true)); + sequentialVfxPlayer.Register(fusionCard.SelfBattlePlayer.CardManagement(fusionCard, new SkillProcessor(), BattlePlayerBase.CARD_MANAGEMENT.FUSION_MATERIAL, isRandom: false, selectedCards)); + VfxBase allFuncVfxResults = this.OnAfterFusion.GetAllFuncVfxResults(fusionCard); + sequentialVfxPlayer.Register(allFuncVfxResults); + OnFusionComplete.Call(); + return sequentialVfxPlayer; + } + + private VfxBase CallCardSkill(SkillCollectionBase skills, Func, VfxBase> standardCall, Func, SkillBase, Func, VfxBase>, VfxBase> selectSkillTargetCards, bool isNotSelect = false) + { + SkillBase actSkill = null; + IEnumerable skillUserSelectableTargets = GetSkillUserSelectableTargets(skills, _pair, ref actSkill); + if (isNotSelect || skillUserSelectableTargets == null) + { + return standardCall(null); + } + return selectSkillTargetCards(skillUserSelectableTargets, actSkill, standardCall); + } + + private static void IfNullCardThenException(BattleCardBase card, IBattleCardUniqueID cardId, string positionName) + { + if (card == null) + { + throw new ArgumentException("カード " + cardId.GetName() + " は" + positionName + "に見つかりませんでした"); + } + } + + public static IEnumerable GetSkillUserSelectableTargets(SkillBase skill, BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option = null, List selectedCards = null) + { + if (skill == null || !skill.DoesSkillFulfillActivationConditions(playerInfoPair, ignoreHandSkill: true, isPrePlay: true)) + { + return null; + } + if (option == null) + { + option = new SkillConditionCheckerOption(); + } + IEnumerable selectableCards = skill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: false, selectedCards); + if (!selectableCards.Any()) + { + selectableCards = skill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: true, selectedCards); + } + if (!selectableCards.Any()) + { + return null; + } + return selectableCards; + } + + public static IEnumerable GetSkillUserSelectableTargets(SkillCollectionBase skills, BattlePlayerReadOnlyInfoPair playerInfoPair, ref SkillBase actSkill) + { + IEnumerable source = skills.Where(delegate(SkillBase s) + { + BattlePlayerReadOnlyInfoPair playerInfoPair2 = new BattlePlayerReadOnlyInfoPair(s.SkillPrm.ownerCard.SelfBattlePlayer, s.SkillPrm.ownerCard.OpponentBattlePlayer); + return s.IsUserSelectType && s.CheckCondition(playerInfoPair2, new SkillConditionCheckerOption(), isPrePlay: true); + }); + if (source.Count() > 0) + { + actSkill = ((source.Count() > 1) ? source.ToList().Last() : source.ToList().First()); + } + return GetSkillUserSelectableTargets(actSkill, playerInfoPair); + } +} diff --git a/SVSim.BattleEngine/Shim/UnityEngine/Primitives.cs b/SVSim.BattleEngine/Shim/UnityEngine/Primitives.cs new file mode 100644 index 0000000..8479fbc --- /dev/null +++ b/SVSim.BattleEngine/Shim/UnityEngine/Primitives.cs @@ -0,0 +1,35 @@ +// AUTHORED SHIM (not copied). Minimal no-op UnityEngine surface. Grows via the +// Task 4 compile loop -- add only members the compiler actually demands. +namespace UnityEngine +{ + public struct Vector2 { public float x, y; public Vector2(float x, float y){ this.x=x; this.y=y; } } + public struct Vector3 + { + public float x, y, z; + public Vector3(float x, float y, float z){ this.x=x; this.y=y; this.z=z; } + public static Vector3 zero => new Vector3(0,0,0); + public static Vector3 operator +(Vector3 a, Vector3 b) => new Vector3(a.x+b.x, a.y+b.y, a.z+b.z); + } + public struct Quaternion + { + public float x, y, z, w; + public static Quaternion identity => new Quaternion(); + public static Quaternion Euler(float x, float y, float z) => new Quaternion(); + } + public struct Color { public float r, g, b, a; public Color(float r,float g,float b,float a){ this.r=r; this.g=g; this.b=b; this.a=a; } } + public static class Mathf + { + public const float PI = 3.14159265f; + public static float Floor(float f) => (float)System.Math.Floor(f); + public static int FloorToInt(float f) => (int)System.Math.Floor(f); + public static float Max(float a, float b) => System.Math.Max(a, b); + public static float Min(float a, float b) => System.Math.Min(a, b); + public static float Clamp(float v, float lo, float hi) => System.Math.Max(lo, System.Math.Min(hi, v)); + } + public static class Debug + { + public static void Log(object m) { } + public static void LogWarning(object m) { } + public static void LogError(object m) { } + } +}