0d9d8acae0
Compile-driven bulk-copy loop (tools/engine-port/m1_copy_loop.py) pulled the precise reference closure of the battle-core roots, stopping at the classify god-object/View-VFX-UI boundary. 782 files; no re-explosion (M0 had estimated ~order 1000). Residual frontier = 52 shim-classified + 80 external (Unity/BCL) types to author next.
366 lines
13 KiB
C#
366 lines
13 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Wizard;
|
|
using Wizard.Battle;
|
|
using Wizard.Battle.View.Vfx;
|
|
|
|
public class NetworkExecutionInfoCreator : ExecutionInfoCreatorBase
|
|
{
|
|
private NetworkBattleManagerBase _networkBattleMgr;
|
|
|
|
private IEnumerable<BattleCardBase> replaceCards;
|
|
|
|
private bool _validateSkillCheckFlag;
|
|
|
|
private bool _playSkill;
|
|
|
|
private bool _notPlaySkill;
|
|
|
|
private bool _isReceiveSkillConditionCheck;
|
|
|
|
private bool _isUnapprovedSkill;
|
|
|
|
private bool _isAllHandCardTarget;
|
|
|
|
private bool _isAllDeckCardTarget;
|
|
|
|
private bool _isUseUListOnlySelfTurnWhenAdmin;
|
|
|
|
private bool _isCheckOppoActionData;
|
|
|
|
private int _skillMovementNum;
|
|
|
|
private bool _notNetwrokConditionCheck;
|
|
|
|
public const int SIDEN_NO_KOKUHYOU = 112241030;
|
|
|
|
public bool IsNotCheckBuriaRiteCondition { get; private set; }
|
|
|
|
public NetworkExecutionInfoCreator(SkillBase skill)
|
|
: base(skill)
|
|
{
|
|
_networkBattleMgr = (NetworkBattleManagerBase)skill.SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr;
|
|
}
|
|
|
|
public override bool CheckScanCondition(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, bool isPrePlay)
|
|
{
|
|
return base.CheckCondition(playerInfoPair, option, isPrePlay);
|
|
}
|
|
|
|
public override bool CheckCondition(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, bool isPrePlay, bool isSkipTarget = false)
|
|
{
|
|
bool result = base.CheckCondition(playerInfoPair, option, isPrePlay, isSkipTarget);
|
|
if (_notNetwrokConditionCheck)
|
|
{
|
|
return result;
|
|
}
|
|
NetworkBattleManagerBase networkBattleManagerBase = _skill.SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase;
|
|
if (_playSkill)
|
|
{
|
|
return true;
|
|
}
|
|
if (_notPlaySkill)
|
|
{
|
|
return false;
|
|
}
|
|
if (_isCheckOppoActionData && networkBattleManagerBase.networkBattleData.GetReceiveData().OpponentTargetDataList.Count() == 0)
|
|
{
|
|
if (_skill.ApplyingTargetFilter is SkillTargetInPlayFilter || _skill.ApplyingTargetFilter is SkillTargetInPlayOtherSelfFilter || _skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessNecromance))
|
|
{
|
|
return false;
|
|
}
|
|
return result;
|
|
}
|
|
if (IsNotCheckBuriaRiteCondition)
|
|
{
|
|
if (NetworkBattleGenericTool.IsReceiveSelectDataOnBurialRite(networkBattleManagerBase, _skill))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (_validateSkillCheckFlag)
|
|
{
|
|
return networkBattleManagerBase.GetValidateTargetSkillIndexList().Contains(NetworkBattleGenericTool.GetSkillIndex(_skill));
|
|
}
|
|
if (networkBattleManagerBase == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (IsUnapprovedSkill())
|
|
{
|
|
NetworkBattleReceiver.ReceiveData receiveData = networkBattleManagerBase.networkBattleData.GetReceiveData();
|
|
if (receiveData != null)
|
|
{
|
|
BattleCardBase owner = _skill.SkillPrm.ownerCard;
|
|
SkillCollectionBase skills = owner.Skills;
|
|
bool flag = false;
|
|
if (skills.Any((SkillBase s) => s.ConditionTargetFilter is SkillTargetDeckSelfFilter) && owner.IsInDeck)
|
|
{
|
|
CardDataModel cardDataModel = receiveData.unapprovedList.Find((CardDataModel x) => x.Index == owner.Index);
|
|
if (cardDataModel == null)
|
|
{
|
|
return false;
|
|
}
|
|
_skill.SetPublishedActiveSkillCount(cardDataModel.publishedActiveSkillCount);
|
|
flag = true;
|
|
}
|
|
NetworkBattleManagerBase networkBattleManagerBase2 = _skill.SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase;
|
|
if (RegisterValidate.IsDeckParamVariable(_skill))
|
|
{
|
|
return true;
|
|
}
|
|
if (networkBattleManagerBase2.IsContainUnapprovedSkill(_skill, _skill.SkillPrm.ownerCard.Index, NetworkBattleGenericTool.GetPublishSkillCount(_skill), _skillMovementNum))
|
|
{
|
|
if (flag || !_skill.IsOnceCallTiming)
|
|
{
|
|
return result;
|
|
}
|
|
return true;
|
|
}
|
|
if ((_skill.IsUserSelectType || _skill.IsBurialRite) && ((GameMgr.GetIns().IsWatchBattle && _skill.SkillPrm.ownerCard.IsPlayer) || GameMgr.GetIns().IsAdminWatch))
|
|
{
|
|
return result;
|
|
}
|
|
if (RegisterSkillConditionCheck.IsSkillConditionCheck(_skill, GameMgr.GetIns().IsAdmin))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (_isReceiveSkillConditionCheck)
|
|
{
|
|
if (networkBattleManagerBase.IsSkillConditionCheckSkill(_skill.SkillPrm.ownerCard.Index))
|
|
{
|
|
return networkBattleManagerBase.IsReceivedSkillConditionCheck(_skillMovementNum, _skill);
|
|
}
|
|
if (RegisterSkillConditionCheck.IsHighlander(_skill.ConditionFilterCollection) || RegisterSkillConditionCheck.IsHighlanderPreprocessConditionCheck(_skill))
|
|
{
|
|
bool num = networkBattleManagerBase.networkBattleData.GetReceiveData().GetReceiveCardList().Any((CardDataModel c) => c.IsHighlander);
|
|
bool flag2 = (RegisterSkillConditionCheck.IsHighlander(_skill.ConditionFilterCollection) ? _skill.ConditionFilterCollection : (_skill.ConditionFilterCollection.ConditionCheckerFilterList.ElementAt(0) as NetworkSkillPreprocessConditionCheck).GetConditionSkillFilterCollection()).VariableCompareFilter.Any((SkillVariableComareFilter x) => x.Compare == "=");
|
|
return num == flag2;
|
|
}
|
|
return false;
|
|
}
|
|
if (!_skill.SkillPrm.ownerCard.IsPlayer && ((_skill.OnWhenDraw != 0 && _skill.SkillPrm.ownerCard.Skills.Any((SkillBase s) => s.PreprocessList.Any((SkillPreprocessBase p) => p is SkillPreprocessOpenCard))) || _skill.OnDisCardStart != 0))
|
|
{
|
|
if (!networkBattleManagerBase.networkBattleData.GetReceiveData().GetReceiveCardList().Any((CardDataModel c) => c.IsOpen && c.Index == _skill.SkillPrm.ownerCard.Index))
|
|
{
|
|
return false;
|
|
}
|
|
return result;
|
|
}
|
|
if (!_skill.SkillPrm.ownerCard.IsPlayer && RegisterValidate.IsSendOpenMyCardsSkill(_skill) && _skill.OnSelfTurnEndStart != 0)
|
|
{
|
|
if (!networkBattleManagerBase.networkBattleData.GetReceiveData().GetReceiveCardList().Any((CardDataModel c) => c.Index == _skill.SkillPrm.ownerCard.Index))
|
|
{
|
|
return false;
|
|
}
|
|
return result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public override List<BattleCardBase> GetSelectableCards(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, bool isSkipForceSelect = false, List<BattleCardBase> selectedCards = null)
|
|
{
|
|
if (_validateSkillCheckFlag)
|
|
{
|
|
IEnumerable<IBattlePlayerReadOnlyInfo> battlePlayerInfos = _skill.ApplyBattlePlayerFilter.Filtering(playerInfoPair);
|
|
IEnumerable<IReadOnlyBattleCardInfo> enumerable = _skill.FilteringByTargetFilter(playerInfoPair, option);
|
|
int i = 0;
|
|
for (int count = _skill.ApplyCustomSelectFilterList.Count; i < count; i++)
|
|
{
|
|
enumerable = _skill.ApplyCustomSelectFilterList[i].Filtering(enumerable, battlePlayerInfos, option);
|
|
}
|
|
return enumerable.Cast<BattleCardBase>().ToList();
|
|
}
|
|
return (from c in base.GetSelectableCards(playerInfoPair, option, isSkipForceSelect, selectedCards)
|
|
select (!GameMgr.GetIns().IsAdminWatch && !GameMgr.GetIns().IsReplayBattle && !c.IsPlayer && !c.IsInplay && !c.Card.IsInplay && !_skill.ApplyAndFilter.Any((ApplySkillTargetFilterCollection f) => f.TargetFilter is SkillTargetTurnPlayCardsOtherSelfFilter) && !_skill.ApplyAndFilter.Any((ApplySkillTargetFilterCollection f) => f.BattlePlayerFilter is OpponentBattlePlayerFilter && f.TargetFilter is SkillTargetGamePlayCardsOtherSelfFilter)) ? c.Card : c).ToList();
|
|
}
|
|
|
|
public override IEnumerable<BattleCardBase> CalcApplyTargets(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, ref int targetCount, bool isCheckInHand = false)
|
|
{
|
|
bool flag = false;
|
|
NetworkBattleManagerBase networkBattleManagerBase = _skill.SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr as NetworkBattleManagerBase;
|
|
if (_isCheckOppoActionData && networkBattleManagerBase.networkBattleData.GetReceiveData().OpponentTargetDataList.Count() == 0)
|
|
{
|
|
flag = ((!(_skill.ApplyingTargetFilter is SkillTargetInPlayFilter) && !(_skill.ApplyingTargetFilter is SkillTargetInPlayOtherSelfFilter)) ? true : false);
|
|
}
|
|
if (flag)
|
|
{
|
|
return new List<BattleCardBase>();
|
|
}
|
|
if (_isAllHandCardTarget)
|
|
{
|
|
return _skill.SkillPrm.selfBattlePlayer.HandCardList;
|
|
}
|
|
if (_isAllDeckCardTarget)
|
|
{
|
|
return _skill.SkillPrm.selfBattlePlayer.DeckCardList;
|
|
}
|
|
if (option.SelectedCards.Count < 0 || !option.SelectedCards.Any((SkillConditionCheckerOption.SkillAndSelectTarget s) => s.SelectSkill == _skill && s.SelectCard != null))
|
|
{
|
|
if (IsUnapprovedSkill() && !isCheckInHand)
|
|
{
|
|
List<BattleCardBase> list = CalculationUnapprovedCardList(NetworkBattleGenericTool.GetPublishSkillCount(_skill));
|
|
_skill.CallOnCalcApplyTargets(_skill, list);
|
|
return list;
|
|
}
|
|
IEnumerable<BattleCardBase> selectableCards = _skill.GetSelectableCards(playerInfoPair, option);
|
|
return _skill.ApplySelectFilter.Filtering(selectableCards, _skill.OptionValue, option);
|
|
}
|
|
return IfNeededSelectCardCheck(playerInfoPair, option);
|
|
}
|
|
|
|
public override VfxWith<List<BattleCardBase>, Dictionary<int, BattleCardBase>> FixedSkillApplyTarget(BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option, ref int targetCount)
|
|
{
|
|
VfxWith<List<BattleCardBase>, Dictionary<int, BattleCardBase>> vfxWith;
|
|
if ((_skill.SkillPrm.ownerCard.IsPlayer && (!GameMgr.GetIns().IsWatchBattle || _networkBattleMgr.IsRecovery)) || GameMgr.GetIns().IsReplayBattle)
|
|
{
|
|
IEnumerable<BattleCardBase> source = CalcApplyTargets(playerInfoPair, option, ref targetCount);
|
|
vfxWith = NotIndependentCardFiltering(source.ToList());
|
|
return new VfxWith<List<BattleCardBase>, Dictionary<int, BattleCardBase>>(vfxWith.Vfx, SkillAllowTargetFiltering(vfxWith.Value_1), vfxWith.Value_2);
|
|
}
|
|
UnknownReplaceCard(NetworkBattleGenericTool.GetPublishSkillCount(_skill));
|
|
IEnumerable<BattleCardBase> replaceCard = GetReplaceCard();
|
|
IEnumerable<BattleCardBase> enumerable;
|
|
if (replaceCard != null && replaceCard.Count() >= 1)
|
|
{
|
|
enumerable = GetReplaceCard().ToList();
|
|
}
|
|
else
|
|
{
|
|
enumerable = CalcApplyTargets(playerInfoPair, option, ref targetCount);
|
|
if (_skill.SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr is NetworkBattleManagerBase networkBattleManagerBase && targetCount > 0)
|
|
{
|
|
networkBattleManagerBase.RecoveryRecordSkillTarget(enumerable);
|
|
enumerable = networkBattleManagerBase.RecoverySkillTarget(enumerable, targetCount);
|
|
}
|
|
}
|
|
ClearReplaceCard();
|
|
vfxWith = NotIndependentCardFiltering(enumerable.ToList());
|
|
return new VfxWith<List<BattleCardBase>, Dictionary<int, BattleCardBase>>(vfxWith.Vfx, SkillAllowTargetFiltering(vfxWith.Value_1), vfxWith.Value_2);
|
|
}
|
|
|
|
private void UnknownReplaceCard(int publishedActiveCount)
|
|
{
|
|
if (_skill is Skill_summon_card)
|
|
{
|
|
replaceCards = null;
|
|
SetReplaceCards(CalculationUnapprovedCardList(publishedActiveCount));
|
|
}
|
|
}
|
|
|
|
public IEnumerable<BattleCardBase> GetReplaceCard()
|
|
{
|
|
return replaceCards;
|
|
}
|
|
|
|
public void SetReplaceCards(IEnumerable<BattleCardBase> target)
|
|
{
|
|
replaceCards = target;
|
|
}
|
|
|
|
public void ClearReplaceCard()
|
|
{
|
|
replaceCards = null;
|
|
}
|
|
|
|
public void SetReceiveSkillConditionCheck()
|
|
{
|
|
_isReceiveSkillConditionCheck = true;
|
|
}
|
|
|
|
public void SetUnapproved()
|
|
{
|
|
_isUnapprovedSkill = true;
|
|
}
|
|
|
|
private bool IsUnapprovedSkill()
|
|
{
|
|
if (GameMgr.GetIns().IsWatchBattle)
|
|
{
|
|
if (_isUseUListOnlySelfTurnWhenAdmin)
|
|
{
|
|
if (_isUnapprovedSkill)
|
|
{
|
|
return _skill.SkillPrm.ownerCard.SelfBattlePlayer.IsSelfTurn;
|
|
}
|
|
return false;
|
|
}
|
|
return _isUnapprovedSkill;
|
|
}
|
|
if (_isUnapprovedSkill && _networkBattleMgr.BattleEnemy.IsSelfTurn)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void SetHandAllSelect()
|
|
{
|
|
_isAllHandCardTarget = true;
|
|
}
|
|
|
|
public void SetDeckAllSelect()
|
|
{
|
|
_isAllDeckCardTarget = true;
|
|
}
|
|
|
|
public void SetUseUListOnlySelfTurn()
|
|
{
|
|
_isUseUListOnlySelfTurnWhenAdmin = true;
|
|
}
|
|
|
|
public void SetValidateConditionCheckSkill()
|
|
{
|
|
_validateSkillCheckFlag = true;
|
|
}
|
|
|
|
public void SetNotCheckBuriaRiteCondition(bool value)
|
|
{
|
|
IsNotCheckBuriaRiteCondition = value;
|
|
}
|
|
|
|
public void SetPlaySkill()
|
|
{
|
|
_playSkill = true;
|
|
}
|
|
|
|
public void SetNotPlaySkill()
|
|
{
|
|
_notPlaySkill = true;
|
|
}
|
|
|
|
public void SetCheckOppoActionData()
|
|
{
|
|
_isCheckOppoActionData = true;
|
|
}
|
|
|
|
public void AddSkillMovementNum()
|
|
{
|
|
_skillMovementNum++;
|
|
}
|
|
|
|
public void ClearSkillMovementNum()
|
|
{
|
|
_skillMovementNum = 0;
|
|
}
|
|
|
|
public int GetSkillMovementNum()
|
|
{
|
|
return _skillMovementNum;
|
|
}
|
|
|
|
public void SetNotNetwrokConditionCheck(bool flag)
|
|
{
|
|
_notNetwrokConditionCheck = flag;
|
|
}
|
|
|
|
private List<BattleCardBase> CalculationUnapprovedCardList(int skillIndex)
|
|
{
|
|
BattlePlayerBase selfBattlePlayer = _skill.SkillPrm.ownerCard.SelfBattlePlayer;
|
|
return (selfBattlePlayer.BattleMgr as NetworkBattleManagerBase).GetUnapprovedCardObj(selfBattlePlayer, _skill.SkillPrm.ownerCard.Index, skillIndex, _skillMovementNum, _skill);
|
|
}
|
|
}
|