957af3d1ec
Authored Unity primitive/object-model shim, VFX layer (control-flow-preserving, InstantVfx never invokes its action -- headless suppression), god-object stubs (GameMgr/EffectMgr/UIManager with faithfully-extracted nested enums), View/UI/Touch tree, LitJson+BetterList+Tuple copied, third-party stubs. Discovered Roslyn header-error masking: fixing class-header type errors unmasks body references, so the true copy closure is ~2570 files (was 782 under masking). Errors: masked-25720 -> 268; our shim files compile clean. Remaining: ~50 residual shim/external types, 24 NGUI UI-base overrides, static-type fixes, plus likely 1-2 more unmask waves.
853 lines
30 KiB
C#
853 lines
30 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Wizard;
|
|
using Wizard.Battle.View.Vfx;
|
|
|
|
public class NetworkBattleGenericTool
|
|
{
|
|
public static NetworkBattleDefine.NetworkCardPlaceState GetCardPlaceState(BattlePlayerBase player, int index)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState result = NetworkBattleDefine.NetworkCardPlaceState.None;
|
|
if (player.HandCardList != null && player.HandCardList.SingleOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
}
|
|
else if (player.DeckCardList != null && player.DeckCardList.SingleOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
}
|
|
else if (player.ClassAndInPlayCardList != null && player.ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Field;
|
|
}
|
|
else if (player.CemeteryList != null && player.CemeteryList.FirstOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Cemetery;
|
|
}
|
|
else if (player.BanishList != null && player.BanishList.FirstOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Banish;
|
|
}
|
|
else if (player.FusionIngredientList != null && player.FusionIngredientList.SingleOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.FusionIngredient;
|
|
}
|
|
if (player.UniteList != null && player.UniteList.FirstOrDefault((BattleCardBase c) => c.Index == index) != null)
|
|
{
|
|
result = NetworkBattleDefine.NetworkCardPlaceState.Unite;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static BattleCardBase GetIndexToCardBase(BattleManagerBase battleManagerBase, BattlePlayerBase player, int index)
|
|
{
|
|
BattleCardBase battleCardBase = null;
|
|
if (player.HandCardList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.HandCardList, index);
|
|
}
|
|
if (battleCardBase == null && player.DeckCardList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.DeckCardList, index);
|
|
}
|
|
if (battleCardBase == null && player.ClassAndInPlayCardList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.ClassAndInPlayCardList, index);
|
|
}
|
|
if (battleCardBase == null && player.CemeteryList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.CemeteryList, index);
|
|
}
|
|
if (battleCardBase == null && player.NecromanceZoneList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.NecromanceZoneList, index);
|
|
}
|
|
if (battleCardBase == null && player.BanishList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.BanishList, index);
|
|
}
|
|
if (battleCardBase == null && player.FusionIngredientList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.FusionIngredientList, index);
|
|
}
|
|
if (battleCardBase == null && player.ClassAndInPlayCardList != null)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>(player.ClassAndInPlayCardList);
|
|
if (player.CemeteryList != null)
|
|
{
|
|
list.AddRange(player.CemeteryList);
|
|
}
|
|
if (player.BanishList != null)
|
|
{
|
|
list.AddRange(player.BanishList);
|
|
}
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
BattleCardBase battleCardBase2 = list[i];
|
|
if (!(battleCardBase2 is NullBattleCard))
|
|
{
|
|
battleCardBase = battleCardBase2.GetOnCards.FirstOrDefault((BattleCardBase c) => c.Index == index);
|
|
if (battleCardBase != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (battleCardBase == null && player.UniteList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.UniteList, index);
|
|
}
|
|
if (battleCardBase == null && player.GetOnList != null)
|
|
{
|
|
battleCardBase = battleManagerBase.GetBattleCardIdx(player.GetOnList, index);
|
|
}
|
|
return battleCardBase;
|
|
}
|
|
|
|
public static List<BattleCardBase> GetOpposingCardObjTarget(BattleManagerBase battleManagerBase, List<NetworkBattleReceiver.TargetData> actions)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
foreach (NetworkBattleReceiver.TargetData action in actions)
|
|
{
|
|
int targetIndex = action.TargetIndex;
|
|
bool isSelf = action.IsSelf;
|
|
BattleCardBase battleCardBase = null;
|
|
battleCardBase = ((!isSelf) ? battleManagerBase.GetBattleCardIdx(battleManagerBase.BattlePlayer.AllCards.ToList(), targetIndex) : GetIndexToCardBase(battleManagerBase, battleManagerBase.BattleEnemy, targetIndex));
|
|
if (battleCardBase != null)
|
|
{
|
|
list.Add(battleCardBase);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static List<BattleCardBase> LookForActionDataToTargetCard(BattleManagerBase battleManagerBase, List<NetworkBattleReceiver.TargetData> actions)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
foreach (NetworkBattleReceiver.TargetData action in actions)
|
|
{
|
|
int targetIndex = action.TargetIndex;
|
|
bool isSelf = action.IsSelf;
|
|
BattleCardBase battleCardBase = null;
|
|
battleCardBase = ((!isSelf) ? GetIndexToCardBase(battleManagerBase, battleManagerBase.BattlePlayer, targetIndex) : battleManagerBase.GetBattleCardIdx(battleManagerBase.BattleEnemy.ClassAndInPlayCardList, targetIndex));
|
|
list.Add(battleCardBase);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static bool IsAttachedSkill(SkillBase skill)
|
|
{
|
|
ISkillApplyInformation skillApplyInformation = skill.SkillPrm.ownerCard.SkillApplyInformation;
|
|
if (skillApplyInformation != null && skillApplyInformation.AttachedSkillsInfo != null && skillApplyInformation.AttachedSkillsInfo.AttachedSkills != null && skillApplyInformation.AttachedSkillsInfo.AttachedSkills.ToList().Count > 0)
|
|
{
|
|
foreach (SkillBase attachedSkill in skillApplyInformation.AttachedSkillsInfo.AttachedSkills)
|
|
{
|
|
if (attachedSkill == skill)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static SkillBase SearchPublishedSkillCountToSkill(BattleCardBase card, int skillId)
|
|
{
|
|
foreach (SkillBase skill in card.Skills)
|
|
{
|
|
if (GetPublishSkillCount(skill) == skillId)
|
|
{
|
|
return skill;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static int GetSkillIndex(SkillBase skill)
|
|
{
|
|
int num = 0;
|
|
SkillCollectionBase skillCollectionBase = skill.SkillPrm.ownerCard.Skills;
|
|
if (skill.OnWhenEvolveStart != 0 || skill.OnWhenEvolveOtherStart != 0 || skill.OnWhenEvolveSelfAndOtherStart != 0 || skill.OnWhenChoiceEvolveStart != 0 || skill.OnWhenEvolveBeforeStart != 0)
|
|
{
|
|
skillCollectionBase = skill.SkillPrm.ownerCard.EvolutionSkills;
|
|
}
|
|
foreach (SkillBase item in skillCollectionBase)
|
|
{
|
|
if (!(item is Skill_none))
|
|
{
|
|
if (item == skill)
|
|
{
|
|
break;
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static SkillBase SerchIndexToSkill(SkillCollectionBase skills, int skillIndex)
|
|
{
|
|
int num = 0;
|
|
foreach (SkillBase skill in skills)
|
|
{
|
|
if (!(skill is Skill_none))
|
|
{
|
|
if (num == skillIndex)
|
|
{
|
|
return skill;
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static SkillBase SearchCardSkillIndex(BattleCardBase card, int skillIndex, bool isEvol)
|
|
{
|
|
int num = 0;
|
|
SkillCollectionBase skillCollectionBase = card.NormalSkills;
|
|
if (card.IsSpell)
|
|
{
|
|
skillIndex++;
|
|
}
|
|
if (isEvol)
|
|
{
|
|
skillCollectionBase = card.EvolutionSkills;
|
|
if (skillCollectionBase.Count() == 0)
|
|
{
|
|
skillCollectionBase = card.NormalSkills;
|
|
}
|
|
}
|
|
foreach (SkillBase item in skillCollectionBase)
|
|
{
|
|
if (!(item is Skill_none))
|
|
{
|
|
if (num == skillIndex)
|
|
{
|
|
return item;
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static string MakeLogCode(SkillBase skill)
|
|
{
|
|
BattleCardBase ownerCard = skill.SkillPrm.ownerCard;
|
|
return string.Concat(string.Concat("" + CardMaster.GetInstanceForBattle().GetCardParameterFromId(ownerCard.CardId).BaseCardId + "|", GetSkillIndex(skill).ToString(), "|"), ownerCard.IsEvolution ? "1" : "0");
|
|
}
|
|
|
|
public static bool IsBurialRite(SkillBase skill, bool notCheckPrevious = false)
|
|
{
|
|
if (skill.PreprocessList != null)
|
|
{
|
|
if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessBurialRite))
|
|
{
|
|
return true;
|
|
}
|
|
if (!notCheckPrevious && skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessReferencePrevious) && SkillPreprocessReferencePrevious.GetPreviousSkill(skill.SkillPrm.ownerCard.EvolutionSkills.Contains(skill) ? skill.SkillPrm.ownerCard.EvolutionSkills : skill.SkillPrm.ownerCard.NormalSkills, skill).PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessBurialRite))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsReceiveSelectDataOnBurialRite(BattleManagerBase mgr, SkillBase skill)
|
|
{
|
|
NetworkBattleManagerBase networkBattleManagerBase = mgr as NetworkBattleManagerBase;
|
|
NetworkBattleReceiver.ReceiveData receiveData = networkBattleManagerBase.networkBattleData.GetReceiveData();
|
|
if (receiveData != null)
|
|
{
|
|
if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessReferencePrevious))
|
|
{
|
|
skill = SkillPreprocessReferencePrevious.GetPreviousSkill(skill.SkillPrm.ownerCard.EvolutionSkills.Contains(skill) ? skill.SkillPrm.ownerCard.EvolutionSkills : skill.SkillPrm.ownerCard.NormalSkills, skill);
|
|
}
|
|
int index = skill.SkillPrm.ownerCard.Skills.IndexOf(skill);
|
|
List<NetworkBattleReceiver.TargetData> opponentTargetDataList = receiveData.OpponentTargetDataList;
|
|
if (opponentTargetDataList != null && opponentTargetDataList.Any((NetworkBattleReceiver.TargetData t) => t.SelectSkillIndexList.Contains(index)) && GetOpposingCardObjTarget(networkBattleManagerBase, opponentTargetDataList).Count >= 1)
|
|
{
|
|
return true;
|
|
}
|
|
List<NetworkBattleReceiver.TargetData> playerTargetDataList = receiveData.PlayerTargetDataList;
|
|
if (playerTargetDataList != null && playerTargetDataList.Any((NetworkBattleReceiver.TargetData t) => t.SelectSkillIndexList.Contains(index)) && GetOpposingCardObjTarget(networkBattleManagerBase, playerTargetDataList).Count >= 1)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsOpenChoiceSkillCard(BattleCardBase card, bool isEvolve)
|
|
{
|
|
foreach (SkillBase item in isEvolve ? card.EvolutionSkills : card.Skills)
|
|
{
|
|
if (IsOpenChoiceSkill(item))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsOpenChoiceSkill(SkillBase skill)
|
|
{
|
|
if (skill.ApplyingTargetFilter is SkillTargetChosenCardsFilter && !(skill is Skill_token_draw) && !(skill is Skill_update_deck))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsChoiceCard(BattleCardBase card, bool isEvol = false)
|
|
{
|
|
return GetChoiceSkill(card, isEvol) != null;
|
|
}
|
|
|
|
public static SkillBase GetChoiceSkill(BattleCardBase card, bool isEvol = false)
|
|
{
|
|
SkillCollectionBase skillCollectionBase = card.Skills;
|
|
if (isEvol)
|
|
{
|
|
skillCollectionBase = card.EvolutionSkills;
|
|
}
|
|
foreach (SkillBase item in skillCollectionBase)
|
|
{
|
|
if (item.IsTargetChoiceSelectSkill)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static bool IsAcceleratedCard(BattleCardBase card)
|
|
{
|
|
for (int i = 0; i < card.Skills.Count(); i++)
|
|
{
|
|
if (card.Skills.Get(i) is Skill_pp_fixeduse { IsMutationFixedUseCost: not false } && card.Skills.Get(i + 1) is Skill_transform { TransformId: not -1 } skill_transform && CardMaster.GetInstanceForBattle().GetCardParameterFromId(skill_transform.TransformId).CharType == CardBasePrm.CharaType.SPELL)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsCrystallizeCard(BattleCardBase card)
|
|
{
|
|
for (int i = 0; i < card.Skills.Count(); i++)
|
|
{
|
|
if (card.Skills.Get(i) is Skill_pp_fixeduse { IsMutationFixedUseCost: not false } && card.Skills.Get(i + 1) is Skill_transform { TransformId: not -1 } skill_transform && (CardMaster.GetInstanceForBattle().GetCardParameterFromId(skill_transform.TransformId).CharType == CardBasePrm.CharaType.CHANT_FIELD || CardMaster.GetInstanceForBattle().GetCardParameterFromId(skill_transform.TransformId).CharType == CardBasePrm.CharaType.FIELD))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static SkillBase GetMutationPpFixedUseSkill(BattleCardBase card)
|
|
{
|
|
foreach (SkillBase skill in card.Skills)
|
|
{
|
|
if (skill is Skill_pp_fixeduse && (skill as Skill_pp_fixeduse).IsMutationOnCost)
|
|
{
|
|
return skill;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static bool IsIncludedCard(List<int> checkIndexList, IEnumerable<BattleCardBase> cards)
|
|
{
|
|
foreach (BattleCardBase card in cards)
|
|
{
|
|
if (checkIndexList.Contains(card.Index))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static int GetSkillMovementNum(SkillBase skillBase)
|
|
{
|
|
if (GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
return -1;
|
|
}
|
|
return (skillBase._executionInfoCreator as NetworkExecutionInfoCreator).GetSkillMovementNum();
|
|
}
|
|
|
|
public static int GetPublishSkillCount(SkillBase skill)
|
|
{
|
|
int result = -1;
|
|
if (GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
return result;
|
|
}
|
|
if (skill != null)
|
|
{
|
|
result = skill.PublishedActiveSkillCount;
|
|
if (skill.PublishedActiveSkillCount == -1)
|
|
{
|
|
BattleCardBase skillCard = skill.SkillPrm.ownerCard;
|
|
SkillBase skillBase = BattleManagerBase.GetIns().PublishedSkillList.FindAll((SkillBase x) => x.GetType() == skill.GetType() && x.SkillTimingText == skill.SkillTimingText).FindLast((SkillBase x) => x.SkillPrm.ownerCard.Index == skillCard.Index && x.SkillPrm.ownerCard.IsPlayer == skillCard.IsPlayer);
|
|
if (skillBase != null)
|
|
{
|
|
result = skillBase.PublishedActiveSkillCount;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsUnapprovedTarget(SkillBase skill)
|
|
{
|
|
bool isOnFusion = skill.OnWhenFusion != 0;
|
|
bool flag = IsUnapprovedTarget(skill.ApplyingTargetFilter, skill, isOnFusion);
|
|
bool flag2 = skill is NetworkSkill_attach_skill && skill.ApplyingTargetFilter is NetworkSkillTargetLastTargetFilter;
|
|
if (skill.ApplyAndFilter.Count > 0)
|
|
{
|
|
for (int i = 0; i < skill.ApplyAndFilter.Count; i++)
|
|
{
|
|
flag |= IsUnapprovedTarget(skill.ApplyAndFilter[i].TargetFilter, skill, isOnFusion);
|
|
flag2 |= skill is NetworkSkill_attach_skill && skill.ApplyAndFilter[i].TargetFilter is NetworkSkillTargetLastTargetFilter;
|
|
}
|
|
}
|
|
if (flag2)
|
|
{
|
|
SkillBase lastTargetSkillReferenceSkill = GetLastTargetSkillReferenceSkill(skill);
|
|
if (lastTargetSkillReferenceSkill != null)
|
|
{
|
|
flag |= IsUnapprovedTarget(lastTargetSkillReferenceSkill);
|
|
flag = flag || lastTargetSkillReferenceSkill is Skill_return_card;
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
public static SkillBase GetLastTargetSkillReferenceSkill(SkillBase lastTargetSkill)
|
|
{
|
|
SkillCollectionBase skillCollectionBase = lastTargetSkill.SkillPrm.ownerCard.NormalSkills;
|
|
int num = skillCollectionBase.IndexOf(lastTargetSkill);
|
|
if (num == -1)
|
|
{
|
|
skillCollectionBase = lastTargetSkill.SkillPrm.ownerCard.EvolutionSkills;
|
|
num = skillCollectionBase.IndexOf(lastTargetSkill);
|
|
}
|
|
num--;
|
|
while (num > -1)
|
|
{
|
|
if (skillCollectionBase.ElementAt(num).ApplyingTargetFilter is NetworkSkillTargetLastTargetFilter)
|
|
{
|
|
num--;
|
|
continue;
|
|
}
|
|
return skillCollectionBase.ElementAt(num);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static bool IsUnapprovedTarget(ISkillTargetFilter skillTargetFilter, SkillBase skill, bool isOnFusion = false)
|
|
{
|
|
if (!(skillTargetFilter is SkillTargetDeckFilter) && !(skillTargetFilter is SkillTargetHandFilter) && !(skillTargetFilter is SkillTargetHandOtherSelfFilter) && !(skillTargetFilter is SkillTargetSkillDrewCardFilter) && !(skillTargetFilter is SkillTargetDiscardCardListFilter) && !(skillTargetFilter is SkillTargetHandBanishedCardListFilter) && !(skillTargetFilter is SkillTargetDeckBanishedCardListFilter) && (!isOnFusion || !(skillTargetFilter is SkillTargetSelfFilter)))
|
|
{
|
|
if (skill.OnWhenDraw != 0 && skill is NetworkSkill_attach_skill)
|
|
{
|
|
return skillTargetFilter is SkillTargetHandSelfFilter;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static bool IsNeedUnapprovedListSkill(SkillBase skill)
|
|
{
|
|
bool flag = RegisterTool.IsSkillRandom(skill);
|
|
if (skill.IsRandomUntilDrawSkill)
|
|
{
|
|
return true;
|
|
}
|
|
if (skill.ApplyAndFilter.Count > 0)
|
|
{
|
|
for (int i = 0; i < skill.ApplyAndFilter.Count; i++)
|
|
{
|
|
if (IsUnapprovedTarget(skill.ApplyAndFilter[i].TargetFilter, skill) && !IsOnlyAllCardFilter(skill.ApplyAndFilter[i].CardFilterList) && flag)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (!IsUnapprovedTarget(skill))
|
|
{
|
|
return false;
|
|
}
|
|
if (IsOnlyAllCardFilter(skill.ApplyCardFilterList))
|
|
{
|
|
return false;
|
|
}
|
|
if (!flag)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool IsTargetDeckOrHand(ISkillTargetFilter applyingTargetFilter)
|
|
{
|
|
if (!(applyingTargetFilter is SkillTargetDeckFilter) && !(applyingTargetFilter is SkillTargetHandFilter))
|
|
{
|
|
return applyingTargetFilter is SkillTargetHandOtherSelfFilter;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool IsOnlyAllCardFilter(List<ISkillCardFilter> applyCardFilterList)
|
|
{
|
|
for (int i = 0; i < applyCardFilterList.Count; i++)
|
|
{
|
|
if (!(applyCardFilterList[i] is SkillAllCardFilter))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void SettingRegisterTargetGroupAndInsert()
|
|
{
|
|
List<RegisterActionBase> registerDataList = (BattleManagerBase.GetIns() as NetworkBattleManagerBase).RegisterActionManager.RegisterDataList;
|
|
foreach (RegisterLotCardBase item in registerDataList.FindAll((RegisterActionBase x) => x is RegisterLotCardBase).ConvertAll((RegisterActionBase x) => x as RegisterLotCardBase))
|
|
{
|
|
RegisterActionBase registerActionBase = null;
|
|
int num = 0;
|
|
foreach (RegisterActionBase item2 in registerDataList)
|
|
{
|
|
if (item2 is RegisterLotCardBase || item2.PrivateGroupIndexMsg != "")
|
|
{
|
|
continue;
|
|
}
|
|
bool flag = false;
|
|
if (!item2.IsUseLotCard(item))
|
|
{
|
|
continue;
|
|
}
|
|
if (item2 is RegisterStateChangeCard)
|
|
{
|
|
if ((item2 as RegisterStateChangeCard).FromPlaceState == item.GetFromPlaceState())
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flag = true;
|
|
}
|
|
if (!flag)
|
|
{
|
|
continue;
|
|
}
|
|
if (item2 is RegisterCopyToken)
|
|
{
|
|
item.SettingGroupIndexMsg(item2, num);
|
|
if (item.GroupMsgList.Count > num + 1)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
item.SettingGroupIndexMsg(item2);
|
|
}
|
|
if (registerActionBase == null)
|
|
{
|
|
int num2 = registerDataList.IndexOf(item);
|
|
int num3 = registerDataList.IndexOf(item2);
|
|
if (num2 > num3)
|
|
{
|
|
registerActionBase = item2;
|
|
}
|
|
}
|
|
}
|
|
if (registerActionBase != null)
|
|
{
|
|
int index = registerDataList.IndexOf(registerActionBase);
|
|
registerDataList.Remove(item);
|
|
registerDataList.Insert(index, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static RegisterLotCardBase MakeRegisterLotAndRandomAdvance(SkillBase skillBase, IEnumerable<BattleCardBase> cards, SkillConditionCheckerOption checkerOption)
|
|
{
|
|
NetworkBattleManagerBase networkBattleManagerBase = BattleManagerBase.GetIns() as NetworkBattleManagerBase;
|
|
List<CardDataModel> unapprovedList = networkBattleManagerBase.networkBattleData.GetReceiveData().unapprovedList;
|
|
NetworkExecutionInfoCreator networkExec = skillBase._executionInfoCreator as NetworkExecutionInfoCreator;
|
|
int num = 0;
|
|
RegisterLotCardBase result = null;
|
|
List<RegisterLotCardBase> list = new List<RegisterLotCardBase>();
|
|
list = networkBattleManagerBase.RegisterActionManager.RegisterDataList.FindAll((RegisterActionBase x) => x is RegisterLotCardBase).ConvertAll((RegisterActionBase x) => x as RegisterLotCardBase);
|
|
for (int num2 = 0; num2 < cards.Count(); num2++)
|
|
{
|
|
CardDataModel unapprovedCard = GetCardDataModel(skillBase, cards.ElementAt(num2), unapprovedList, networkExec);
|
|
list = list.Where((RegisterLotCardBase data) => data.IsAlreadyAddedIndex(unapprovedCard.Index, unapprovedCard.fromState)).ToList();
|
|
if (list.Count == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (skillBase.ApplyAndFilter.Any((ApplySkillTargetFilterCollection f) => f.CardFilterList.Any((ISkillCardFilter cf) => cf is SkillLastTargetTribeFilter)))
|
|
{
|
|
networkBattleManagerBase.RegisterActionManager.Add(new RegisterExtract(isSelf: false, skillBase.SkillPrm.ownerCard.SelfBattlePlayer.GetLastTargetCardsList(0), RegisterActionBase.ActionBaseParameter.tribe.ToString(), isBase: false));
|
|
}
|
|
for (int num3 = 0; num3 < cards.Count(); num3++)
|
|
{
|
|
BattleCardBase battleCardBase = cards.ElementAt(num3);
|
|
CardDataModel cardDataModel = GetCardDataModel(skillBase, battleCardBase, unapprovedList, networkExec);
|
|
if (cardDataModel == null)
|
|
{
|
|
continue;
|
|
}
|
|
if (GetCardPlaceState(battleCardBase.SelfBattlePlayer, battleCardBase.Index) == NetworkBattleDefine.NetworkCardPlaceState.Deck)
|
|
{
|
|
networkBattleManagerBase.StableRandomDouble();
|
|
continue;
|
|
}
|
|
bool lotFirstSettingFlag = false;
|
|
RegisterLotCardBase registerLotCardBase = AddLotRegisterData(networkBattleManagerBase, networkBattleManagerBase.RegisterActionManager, battleCardBase, skillBase.SkillPrm.ownerCard, skillBase, cardDataModel.fromState, list, out lotFirstSettingFlag);
|
|
if (lotFirstSettingFlag)
|
|
{
|
|
registerLotCardBase.SettingTargetStatusToSearchSkill(networkBattleManagerBase, skillBase, num, cardDataModel, checkerOption);
|
|
}
|
|
if (RegisterTool.HasTargetOverCostFromFilter(skillBase))
|
|
{
|
|
num++;
|
|
}
|
|
result = registerLotCardBase;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static CardDataModel GetCardDataModel(SkillBase skillBase, BattleCardBase carddata, List<CardDataModel> unapprovedList, NetworkExecutionInfoCreator networkExec)
|
|
{
|
|
if (RegisterSkillConditionCheck.DoesSkillUsePrivateCount(skillBase) && skillBase is Skill_powerup)
|
|
{
|
|
int skillConditionCount = RegisterSkillConditionCheck.GetMovementCount(skillBase);
|
|
return unapprovedList.Find((CardDataModel x) => x.Index == carddata.Index && x.skillMovementNum / skillConditionCount == networkExec.GetSkillMovementNum() && x.publishedActiveSkillCount == skillBase.PublishedActiveSkillCount);
|
|
}
|
|
return unapprovedList.Find((CardDataModel x) => x.Index == carddata.Index && x.skillMovementNum == networkExec.GetSkillMovementNum() && x.publishedActiveSkillCount == skillBase.PublishedActiveSkillCount);
|
|
}
|
|
|
|
public static VfxBase Event_SetupPlayerUnapprovedAddEvent(SkillBase skillBase, IEnumerable<BattleCardBase> cards, SkillConditionCheckerOption checkerOption, SkillProcessor skillProcessor)
|
|
{
|
|
if (cards == null)
|
|
{
|
|
return NullVfx.GetInstance();
|
|
}
|
|
if (skillBase is Skill_summon_card { IsDeckSelfSummon: not false } && cards.Count() > 0 && !cards.ElementAt(0).IsInplay)
|
|
{
|
|
return NullVfx.GetInstance();
|
|
}
|
|
NetworkBattleManagerBase networkBattleManagerBase = BattleManagerBase.GetIns() as NetworkBattleManagerBase;
|
|
int skillMovementNum = GetSkillMovementNum(skillBase);
|
|
foreach (BattleCardBase card in cards)
|
|
{
|
|
bool isCardId = false;
|
|
NetworkBattleDefine.NetworkCardPlaceState to = GetCardPlaceState(skillBase.SkillPrm.ownerCard.SelfBattlePlayer, card.Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
if (skillBase.OnDisCardStart != 0)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
to = NetworkBattleDefine.NetworkCardPlaceState.Cemetery;
|
|
}
|
|
else if (skillBase.ApplyingTargetFilter is SkillTargetDeckFilter)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
}
|
|
else if (skillBase.ApplyingTargetFilter is SkillTargetHandFilter || skillBase.ApplyingTargetFilter is SkillTargetHandOtherSelfFilter)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
}
|
|
else if (skillBase.IsHaveApplicableTargetFilter<SkillTargetDiscardCardListFilter>() && (card.IsInCemetery || card.IsInNecromanceZone))
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Cemetery;
|
|
if (skillBase is Skill_token_draw { IsOpen: "true" } || skillBase is Skill_summon_token)
|
|
{
|
|
isCardId = true;
|
|
}
|
|
}
|
|
else if (skillBase.IsHaveApplicableTargetFilter<SkillTargetFusionIngredientCardsFilter>() && card.IsFusionIngredient)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.FusionIngredient;
|
|
}
|
|
else if (skillBase.ApplyingTargetFilter is SkillTargetSelfFilter && skillBase.ApplyAndFilter.Count > 0)
|
|
{
|
|
for (int i = 0; i < skillBase.ApplyAndFilter.Count; i++)
|
|
{
|
|
if (skillBase.ApplyAndFilter[i].TargetFilter is SkillTargetDeckFilter)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
}
|
|
else if (skillBase.ApplyAndFilter[i].TargetFilter is SkillTargetHandFilter || skillBase.ApplyAndFilter[i].TargetFilter is SkillTargetHandOtherSelfFilter)
|
|
{
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
}
|
|
else if (skillBase.ApplyAndFilter[i].TargetFilter is SkillTargetGameFusionIngredientedCards || skillBase.ApplyAndFilter[i].TargetFilter is SkillTargetDiscardCardListFilter)
|
|
{
|
|
networkCardPlaceState = (card.IsFusionIngredient ? NetworkBattleDefine.NetworkCardPlaceState.FusionIngredient : NetworkBattleDefine.NetworkCardPlaceState.Cemetery);
|
|
}
|
|
}
|
|
}
|
|
if ((skillBase is Skill_banish || skillBase is Skill_discard) && !RegisterValidate.IsDeckRandomEachSkill(skillBase))
|
|
{
|
|
isCardId = true;
|
|
}
|
|
networkBattleManagerBase.RegisterUnapprovedList.Add(new RegisterUnapproved(skillBase, card, networkCardPlaceState, to, skillMovementNum, isCardId));
|
|
}
|
|
return NullVfx.GetInstance();
|
|
}
|
|
|
|
public static RegisterLotCardBase AddLotRegisterData(NetworkBattleManagerBase battleMgr, RegisterActionManager registerCardList, BattleCardBase unapprovedCard, BattleCardBase skillCard, SkillBase skillBase, NetworkBattleDefine.NetworkCardPlaceState fromPlace, List<RegisterLotCardBase> sameTargetDataList, out bool lotFirstSettingFlag)
|
|
{
|
|
lotFirstSettingFlag = false;
|
|
RegisterLotCardBase registerLotCardBase = null;
|
|
if (!RegisterTool.HasTargetOverCostFromFilter(skillBase))
|
|
{
|
|
List<RegisterLotCardBase> list = new List<RegisterLotCardBase>();
|
|
list = registerCardList.RegisterDataList.FindAll((RegisterActionBase x) => x is RegisterLotCardBase).ConvertAll((RegisterActionBase x) => x as RegisterLotCardBase);
|
|
if (sameTargetDataList.Count > 0)
|
|
{
|
|
battleMgr.StableRandomDouble();
|
|
return sameTargetDataList[0];
|
|
}
|
|
int skillMovementNum = GetSkillMovementNum(skillBase);
|
|
RegisterLotCardBase registerLotCardBase2 = list.Find((RegisterLotCardBase x) => x.GetLotSkillBase() == skillBase && x.GetSkillMovementNum() == skillMovementNum);
|
|
if (registerLotCardBase2 != null && !skillBase.ApplyAndFilter.Any((ApplySkillTargetFilterCollection f) => !(f.SelectFilter is SkillSelectAllFilter) && (!(f.SelectFilter is SkillRandomSelectFilter) || f.SelectFilter.CalcCount(skillBase.OptionValue) <= 1)))
|
|
{
|
|
registerLotCardBase2.AddTargetIndexAndPlaceGroup(unapprovedCard.Index);
|
|
registerLotCardBase2.AddRandomList(battleMgr.StableRandomDouble());
|
|
return registerLotCardBase2;
|
|
}
|
|
}
|
|
registerLotCardBase = new RegisterLotCardBase(registerCardList, battleMgr, battleMgr.StableRandomDouble(), unapprovedCard.IsPlayer, fromPlace, unapprovedCard.Index, skillBase);
|
|
if (!RegisterValidate.IsDeckRandomEachSkill(skillBase))
|
|
{
|
|
registerCardList.Add(registerLotCardBase);
|
|
}
|
|
lotFirstSettingFlag = true;
|
|
return registerLotCardBase;
|
|
}
|
|
|
|
public static bool IsSendUnapprovedList(SkillBase skill)
|
|
{
|
|
if (IsNeedUnapprovedListSkill(skill) || IsTargetDeckSelf(skill))
|
|
{
|
|
return true;
|
|
}
|
|
if (RegisterFilter.IsFilterCardUnapproved(skill) && RegisterFilter.IsFilterCard(skill))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsTargetDeckSelf(SkillBase skill)
|
|
{
|
|
if (skill.ConditionTargetFilter is SkillTargetDeckSelfFilter)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static string FindDictionaryURI(Dictionary<string, object> data)
|
|
{
|
|
if (data.ContainsKey("uri"))
|
|
{
|
|
return data["uri"].ToString();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static void CreateLoadAndPlayEffectVfxLastTurnLog()
|
|
{
|
|
CreateLoadAndPlayEffectVfxCheckLog(isLastTurn: true);
|
|
}
|
|
|
|
public static void CreateLoadAndPlayEffectVfxClientInfoLog()
|
|
{
|
|
CreateLoadAndPlayEffectVfxCheckLog(isLastTurn: false);
|
|
}
|
|
|
|
private static void CreateLoadAndPlayEffectVfxCheckLog(bool isLastTurn)
|
|
{
|
|
try
|
|
{
|
|
BattleManagerBase ins = BattleManagerBase.GetIns();
|
|
if (ins == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (LoadAndPlayEffectVfx item in ins.VfxMgr.GetSequentialVfxQueues().ToList().FindAll((VfxBase x) => x is LoadAndPlayEffectVfx)
|
|
.ConvertAll((VfxBase x) => x as LoadAndPlayEffectVfx))
|
|
{
|
|
if (item.LoadingVfx != null && item.LoadingVfx is SkillBase.WaitEffectLoadVfx)
|
|
{
|
|
SkillBase.WaitEffectLoadVfx waitEffectLoadVfx = item.LoadingVfx as SkillBase.WaitEffectLoadVfx;
|
|
if (waitEffectLoadVfx.LoadVfx != null)
|
|
{
|
|
string log = "LoadVfxIsEnd=" + waitEffectLoadVfx.LoadVfx.IsEnd;
|
|
if (isLastTurn)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog(log);
|
|
}
|
|
else
|
|
{
|
|
LocalLog.AccumulateTraceLog(log);
|
|
}
|
|
}
|
|
}
|
|
string log2 = "loadEffect.LoadFileName=" + item.LoadFileName;
|
|
if (isLastTurn)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog(log2);
|
|
}
|
|
else
|
|
{
|
|
LocalLog.AccumulateTraceLog(log2);
|
|
}
|
|
if (item.WaitLoadEffectAndSetSeVfxData != null)
|
|
{
|
|
string log3 = "WaitLoadEffectAndSetSeVfxData Step" + item.WaitLoadEffectAndSetSeVfxData.NowStep;
|
|
if (isLastTurn)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog(log3);
|
|
}
|
|
else
|
|
{
|
|
LocalLog.AccumulateTraceLog(log3);
|
|
}
|
|
}
|
|
if (item.PlayEffectAndSeVfxData != null)
|
|
{
|
|
string log4 = "PlayEffectAndSeVfxData Step" + item.PlayEffectAndSeVfxData.NowStep;
|
|
if (isLastTurn)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog(log4);
|
|
}
|
|
else
|
|
{
|
|
LocalLog.AccumulateTraceLog(log4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("VfxCheckLog Error");
|
|
}
|
|
}
|
|
}
|