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.
610 lines
23 KiB
C#
610 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cute;
|
|
using Wizard;
|
|
using Wizard.Battle;
|
|
using Wizard.Battle.UI;
|
|
using Wizard.Battle.View;
|
|
using Wizard.Battle.View.Vfx;
|
|
|
|
public class Skill_attach_skill : SkillBase
|
|
{
|
|
public class AttachOptionInfo
|
|
{
|
|
protected string _info;
|
|
|
|
private static readonly string[] INFO_MAKER_TEXT_LIST = new string[15]
|
|
{
|
|
"skill", "timing", "condition", "target", "option", "preprocess", "effect_condition", "icon", "effect_path", "se_path",
|
|
"effect_move_type", "engine_type", "effect_time", "effect_target_type", "skill_voice"
|
|
};
|
|
|
|
public string Skill { get; private set; }
|
|
|
|
public string Timing { get; private set; }
|
|
|
|
public string Condition { get; private set; }
|
|
|
|
public string Target { get; private set; }
|
|
|
|
public string Option { get; private set; }
|
|
|
|
public string Preprocess { get; private set; }
|
|
|
|
public HandCardFrameEffectType EffectCondition { get; private set; }
|
|
|
|
public string Icon { get; private set; }
|
|
|
|
public string EffectPath { get; private set; }
|
|
|
|
public string SEPath { get; private set; }
|
|
|
|
public string EffectMoveType { get; private set; }
|
|
|
|
public string EngineType { get; private set; }
|
|
|
|
public string EffectTime { get; private set; }
|
|
|
|
public string EffectTargetType { get; private set; }
|
|
|
|
public string Voice { get; private set; }
|
|
|
|
public AttachOptionInfo(string info)
|
|
{
|
|
_info = info;
|
|
Skill = "none";
|
|
Timing = "none";
|
|
Condition = "none";
|
|
Target = "none";
|
|
Option = "none";
|
|
Preprocess = "none";
|
|
EffectCondition = HandCardFrameEffectType.NONE;
|
|
Icon = string.Empty;
|
|
EffectPath = string.Empty;
|
|
SEPath = string.Empty;
|
|
EffectMoveType = "SKIP";
|
|
EngineType = "SHURIKEN";
|
|
EffectTime = "1";
|
|
EffectTargetType = "none";
|
|
Voice = "none";
|
|
SetupSkillInfo(_info);
|
|
}
|
|
|
|
protected void SetupSkillInfo(string info)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
for (int i = 0; i < info.Length; i++)
|
|
{
|
|
if (info[i] == '(')
|
|
{
|
|
if (num == 0)
|
|
{
|
|
num2 = i;
|
|
}
|
|
num++;
|
|
}
|
|
if (info[i] == ')')
|
|
{
|
|
num--;
|
|
if (num == 0)
|
|
{
|
|
string value = info.Substring(num2, i - (num2 - 1));
|
|
KeyIsSetting(value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void KeyIsSetting(string value)
|
|
{
|
|
int num = -1;
|
|
string text = string.Empty;
|
|
for (int i = 0; i < INFO_MAKER_TEXT_LIST.Length; i++)
|
|
{
|
|
int num2 = value.IndexOf(INFO_MAKER_TEXT_LIST[i] + ":");
|
|
if (num2 != -1 && (num == -1 || num > num2))
|
|
{
|
|
num = num2;
|
|
text = INFO_MAKER_TEXT_LIST[i];
|
|
}
|
|
}
|
|
if (text != string.Empty)
|
|
{
|
|
value = value.Remove(value.Count() - 1, 1).Remove(0, 1);
|
|
}
|
|
if (text != null)
|
|
{
|
|
switch (text)
|
|
{
|
|
case "skill":
|
|
value = value.Remove(0, "skill:".Count());
|
|
Skill = value;
|
|
break;
|
|
case "timing":
|
|
value = value.Remove(0, "timing:".Count());
|
|
Timing = value;
|
|
break;
|
|
case "condition":
|
|
value = value.Remove(0, "condition:".Count());
|
|
Condition = value;
|
|
break;
|
|
case "target":
|
|
value = value.Remove(0, "target:".Count());
|
|
Target = value;
|
|
break;
|
|
case "option":
|
|
value = value.Remove(0, "option:".Count());
|
|
Option = value;
|
|
break;
|
|
case "preprocess":
|
|
value = value.Remove(0, "preprocess:".Count());
|
|
Preprocess = value;
|
|
break;
|
|
case "effect_condition":
|
|
value = value.Remove(0, "effect_condition:".Count());
|
|
EffectCondition = HandCardFrameEffectControl.ToStrFrameEffect(value)[0];
|
|
break;
|
|
case "icon":
|
|
value = value.Remove(0, "icon:".Count());
|
|
Icon = value;
|
|
break;
|
|
case "effect_path":
|
|
value = value.Remove(0, "effect_path:".Count());
|
|
EffectPath = value;
|
|
break;
|
|
case "se_path":
|
|
value = value.Remove(0, "se_path:".Count());
|
|
SEPath = value;
|
|
break;
|
|
case "effect_move_type":
|
|
value = value.Remove(0, "effect_move_type:".Count());
|
|
EffectMoveType = value;
|
|
break;
|
|
case "engine_type":
|
|
value = value.Remove(0, "engine_type:".Count());
|
|
EngineType = value;
|
|
break;
|
|
case "effect_time":
|
|
value = value.Remove(0, "effect_time:".Count());
|
|
EffectTime = value;
|
|
break;
|
|
case "effect_target_type":
|
|
value = value.Remove(0, "effect_target_type:".Count());
|
|
EffectTargetType = value;
|
|
break;
|
|
case "skill_voice":
|
|
value = value.Remove(0, "skill_voice:".Count());
|
|
Voice = value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected List<SkillBase> _attachSkills = new List<SkillBase>();
|
|
|
|
public Action OnIndividualIdSkillStop;
|
|
|
|
protected List<BattleCardBase> _effectTargets;
|
|
|
|
public SkillCreator.SkillBuildInfo BuildInfo { get; protected set; }
|
|
|
|
public string SaveTurnSkillId { get; private set; } = string.Empty;
|
|
|
|
public int AttachedTurn { get; private set; } = -1;
|
|
|
|
public bool IsEvolutionEndStop { get; set; }
|
|
|
|
public override bool IsTargetIndicate => false;
|
|
|
|
protected virtual bool IsTargetSelectedCard
|
|
{
|
|
get
|
|
{
|
|
if (!base.IsUserSelectType)
|
|
{
|
|
return base.ApplyingTargetFilter is SkillTargetLastTargetFilter;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool AttachWhenDestroy => BuildInfo._timing == "when_destroy";
|
|
|
|
public List<SkillBase> GetAttachSkills()
|
|
{
|
|
return _attachSkills;
|
|
}
|
|
|
|
public Skill_attach_skill(SkillParameter skillPrm, string option)
|
|
: base(skillPrm, option)
|
|
{
|
|
string option2 = base.OptionValue.GetOption(SkillFilterCreator.ContentKeyword.skill);
|
|
SkillCreator.SkillBuildInfo skillBuildInfo = skillPrm.ownerCard.SelfBattlePlayer.BattleMgr.BattleLifeTimeSharedObject.GetSkillBuildInfo(option2);
|
|
if (skillBuildInfo == null)
|
|
{
|
|
BuildInfo = CreateAttachSkillBuildInfo(option2);
|
|
skillPrm.ownerCard.SelfBattlePlayer.BattleMgr.BattleLifeTimeSharedObject.SetSkillBuildInfo(option2, BuildInfo);
|
|
}
|
|
else
|
|
{
|
|
BuildInfo = skillBuildInfo;
|
|
}
|
|
SetDuplicateBanSkillNum();
|
|
}
|
|
|
|
public override VfxWithLoading Start(CallParameter parameter)
|
|
{
|
|
_attachSkills = new List<SkillBase>();
|
|
long banNum = base.OptionValue.GetLong(SkillFilterCreator.ContentKeyword.duplicate_ban_id, 0);
|
|
bool isAttachEvolveSkill = base.OptionValue.GetOption(SkillFilterCreator.ContentKeyword.is_evolve, "false") == "true";
|
|
string[] array = base.OptionValue.GetString(SkillFilterCreator.ContentKeyword.save_turn_skill_id).Split(':');
|
|
SaveTurnSkillId = array[0];
|
|
if (array.Count() > 1 && array[1] == SkillFilterCreator.ContentKeyword.is_individual.ToString())
|
|
{
|
|
SaveTurnSkillId += base.IndividualId;
|
|
}
|
|
int voiceIndex = AddSkillVoice(this, BuildInfo);
|
|
ParallelVfxPlayer parallelVfx = ParallelVfxPlayer.Create();
|
|
SequentialVfxPlayer iconVfx = SequentialVfxPlayer.Create();
|
|
List<BattleCardBase> list = parameter.targetCards.Where((BattleCardBase s) => s.IsInDeck || s.IsInHand || s.IsInplay).ToList();
|
|
if (base.DuplicateBanSkillNum != string.Empty)
|
|
{
|
|
List<BattleCardBase> list2 = new List<BattleCardBase>();
|
|
for (int num = 0; num < list.Count; num++)
|
|
{
|
|
IEnumerable<Skill_attach_skill> enumerable = from s in list[num].Skills
|
|
where s.IsAttachedSkill && s.GetAttachSkill != null
|
|
select s.GetAttachSkill as Skill_attach_skill;
|
|
if (enumerable != null && enumerable.Count() > 0)
|
|
{
|
|
if (!enumerable.Any((Skill_attach_skill s) => (!base.IsDuplicateBanSelfSkill || s.SkillPrm.ownerCard == base.SkillPrm.ownerCard) && s.DuplicateBanSkillNum == base.DuplicateBanSkillNum))
|
|
{
|
|
list2.Add(list[num]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
list2.Add(list[num]);
|
|
}
|
|
}
|
|
list = list2;
|
|
}
|
|
CallOnAttachSkill(list.Where((BattleCardBase c) => IsEffectTarget(c)).ToList());
|
|
if (GiveSkill(list, BuildInfo, parameter, banNum, voiceIndex, isAttachEvolveSkill, ref parallelVfx, ref iconVfx))
|
|
{
|
|
AttachedTurn = base.SkillPrm.ownerCard.SelfBattlePlayer.Turn;
|
|
}
|
|
if (IsBattleLog && IsTargetInOpponentHand() && !IsTargetSelectedCard)
|
|
{
|
|
LoggingOpponentPrivateCard(list.ToList(), BuildInfo);
|
|
}
|
|
_effectTargets = new List<BattleCardBase>();
|
|
if (list.Count() == 0)
|
|
{
|
|
return NullVfxWithLoading.GetInstance();
|
|
}
|
|
if (GameMgr.GetIns().IsAdminWatch)
|
|
{
|
|
_effectTargets = list;
|
|
}
|
|
else
|
|
{
|
|
_effectTargets = list.Where((BattleCardBase c) => IsEffectTarget(c)).ToList();
|
|
}
|
|
bool flag = (base.SkillPrm.ownerCard.IsPlayer && base.ApplyBattlePlayerFilter is SelfBattlePlayerFilter) || (!base.SkillPrm.ownerCard.IsPlayer && base.ApplyBattlePlayerFilter is OpponentBattlePlayerFilter);
|
|
bool isFollowInHand = parameter.targetCards.Count() > 0 && flag && IsTargetInHand();
|
|
VfxWithLoading vfxWithLoading = CreateSkillEffect(base.SkillPrm.resourceMgr, _effectTargets, isFollowInHand, addToLastOperation: true);
|
|
VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create(vfxWithLoading.MainVfx, parallelVfx, iconVfx);
|
|
vfxWithLoadingSequential.RegisterToLoadingVfx(vfxWithLoading.LoadingVfx);
|
|
return vfxWithLoadingSequential;
|
|
}
|
|
|
|
public virtual bool GiveSkill(List<BattleCardBase> targets, SkillCreator.SkillBuildInfo buildInfo, CallParameter parameter, long banNum, int voiceIndex, bool isAttachEvolveSkill, ref ParallelVfxPlayer parallelVfx, ref SequentialVfxPlayer iconVfx)
|
|
{
|
|
bool flag = base.OptionValue.GetOption(SkillFilterCreator.ContentKeyword.show_battle_log, "true") == "true";
|
|
bool result = false;
|
|
foreach (BattleCardBase target in targets)
|
|
{
|
|
if (target.SkillApplyInformation.AttachedSkillsInfo.DuplicateBanNum.Any((long c) => c != 0L && c == banNum))
|
|
{
|
|
continue;
|
|
}
|
|
BattleCardBase battleCardBase = target;
|
|
SkillBase skill = target.SkillApplyInformation.AttachSkill(BuildInfo, base.SkillPrm.resourceMgr, base.SkillPrm.ownerCard.GetName(), base.SkillPrm.ownerCard.CardId, banNum, this, isAttachEvolveSkill);
|
|
if (skill == null)
|
|
{
|
|
continue;
|
|
}
|
|
result = true;
|
|
_attachSkills.Add(skill);
|
|
if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessInPlayPeriodOfTime))
|
|
{
|
|
skill.OnSkillStopStart += delegate(SkillBase _skill, List<BattleCardBase> cards, SkillProcessor skillProcessorOneTime)
|
|
{
|
|
Stop(skillProcessorOneTime);
|
|
};
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessRemoveAfterAction))
|
|
{
|
|
skill.ChacheIsMakeFoil();
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessDamageAfterStop))
|
|
{
|
|
skill.OnSkillStart += delegate
|
|
{
|
|
BattleCardBase card = skill.SkillPrm.ownerCard;
|
|
card.OnDamageAfter += (SkillProcessor skillProcessorOneTime) => StopSpecificCard(card);
|
|
};
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessReflectionAfterStop))
|
|
{
|
|
skill.OnSkillStart += delegate
|
|
{
|
|
BattleCardBase card = skill.SkillPrm.ownerCard;
|
|
card.OnReflectionAfter += (SkillProcessor skillProcessorOneTime) => StopSpecificCard(card);
|
|
};
|
|
}
|
|
BuffInfo buffInfo = (IsBattleLog ? AddBuffInfoIfNeeded(target) : null);
|
|
if (base.HasIndividualId && (battleCardBase.IsPlayer || GameMgr.GetIns().IsAdminWatch))
|
|
{
|
|
skill.AddIndividualIdSkillBuffLog(this, battleCardBase);
|
|
}
|
|
if (target.IsClass)
|
|
{
|
|
UpdateClassBuffIfActive(target);
|
|
}
|
|
BuffInfoContainer buffInfoContainer = new BuffInfoContainer(target, buffInfo, base.SkillPrm.ownerCard.Skills.IndexOf(this), "", skill, banNum);
|
|
SetOnLoseEvent(battleCardBase, buffInfo, buffInfoContainer);
|
|
parallelVfx.Register(CheckResidentAndImmediateAttachSkillCondition(parameter.skillProcessor, targets.ToList(), skill));
|
|
if (!target.IsInHand)
|
|
{
|
|
iconVfx.Register(target.BattleCardView.InitializeBattleCardIcon(target, target.Skills));
|
|
}
|
|
base.buffInfoContainer.Add(buffInfoContainer);
|
|
parallelVfx.Register(InstantVfx.Create(delegate
|
|
{
|
|
}));
|
|
if (IsBattleLog && IsEffectTarget(target) && flag)
|
|
{
|
|
BattleLogManager.GetInstance().AddLogSkillAttachSkill(target, skill, this);
|
|
}
|
|
base.IsActivity = true;
|
|
skill.SetSkillVoiceIndex(voiceIndex);
|
|
string assetTypePath = Toolbox.ResourcesManager.GetAssetTypePath(skill.SkillPrm.buildInfo._effectPath, ResourcesManager.AssetLoadPathType.Effect2D, isfetch: true);
|
|
VfxBase vfx = base.SkillPrm.resourceMgr.LoadEffectBattle(assetTypePath, skill.SkillPrm.buildInfo._effectPath, skill.SkillPrm.buildInfo._sePath);
|
|
parallelVfx.Register(vfx);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public override VfxWithLoading Stop(SkillProcessor skillProcessor)
|
|
{
|
|
base.Stop(skillProcessor);
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
if (!IsEvolutionEndStop)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
foreach (BuffInfoContainer item in buffInfoContainer)
|
|
{
|
|
item._targetCard.SkillApplyInformation.RemoveSkill(item._attachSkill, base.SkillPrm.ownerCard, item._duplicateBanNum, this, item._intValue);
|
|
list.Add(item._targetCard);
|
|
item._targetCard.RemoveBuffInfo(item._buffInfo);
|
|
if (item._targetCard.IsClass)
|
|
{
|
|
UpdateClassBuffIfActive(item._targetCard);
|
|
}
|
|
if (!item._targetCard.IsClass && !item._targetCard.IsInHand)
|
|
{
|
|
parallelVfxPlayer.Register(item._targetCard.BattleCardView.InitializeBattleCardIcon(item._targetCard, item._targetCard.Skills));
|
|
}
|
|
}
|
|
CallOnUpdateSkillEffect(list);
|
|
buffInfoContainer.Clear();
|
|
}
|
|
OnIndividualIdSkillStop.Call();
|
|
StopEnd(skillProcessor);
|
|
return VfxWithLoading.Create(parallelVfxPlayer);
|
|
}
|
|
|
|
public VfxWithLoading StopSpecificCard(BattleCardBase card)
|
|
{
|
|
BuffInfoContainer buffInfoContainer = base.buffInfoContainer.FirstOrDefault((BuffInfoContainer b) => b._targetCard == card);
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
if (buffInfoContainer != null)
|
|
{
|
|
buffInfoContainer._targetCard.SkillApplyInformation.RemoveSkill(buffInfoContainer._attachSkill, base.SkillPrm.ownerCard, buffInfoContainer._duplicateBanNum, this, buffInfoContainer._intValue);
|
|
buffInfoContainer._targetCard.RemoveBuffInfo(buffInfoContainer._buffInfo);
|
|
if (buffInfoContainer._targetCard.IsClass)
|
|
{
|
|
UpdateClassBuffIfActive(buffInfoContainer._targetCard);
|
|
}
|
|
if (!buffInfoContainer._targetCard.IsClass && !buffInfoContainer._targetCard.IsInHand)
|
|
{
|
|
parallelVfxPlayer.Register(buffInfoContainer._targetCard.BattleCardView.InitializeBattleCardIcon(buffInfoContainer._targetCard, buffInfoContainer._targetCard.Skills));
|
|
}
|
|
base.buffInfoContainer.Remove(buffInfoContainer);
|
|
}
|
|
return VfxWithLoading.Create(parallelVfxPlayer);
|
|
}
|
|
|
|
public override VfxWithLoading RemoveAfter()
|
|
{
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
foreach (BuffInfoContainer item in buffInfoContainer)
|
|
{
|
|
item._targetCard.SkillApplyInformation.RemoveSkill(item._attachSkill, base.SkillPrm.ownerCard, item._duplicateBanNum, this, item._intValue);
|
|
item._targetCard.RemoveBuffInfo(item._buffInfo);
|
|
if (!item._targetCard.IsClass && !item._targetCard.IsInHand)
|
|
{
|
|
parallelVfxPlayer.Register(item._targetCard.BattleCardView.InitializeBattleCardIcon(item._targetCard, item._targetCard.Skills));
|
|
}
|
|
}
|
|
buffInfoContainer.Clear();
|
|
OnIndividualIdSkillStop.Call();
|
|
return VfxWithLoading.Create(parallelVfxPlayer);
|
|
}
|
|
|
|
private bool IsEffectTarget(BattleCardBase target)
|
|
{
|
|
if (!target.IsPlayer && !target.IsInplay)
|
|
{
|
|
return GameMgr.GetIns().IsAdminWatch;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static SkillCreator.SkillBuildInfo CreateAttachSkillBuildInfo(string option)
|
|
{
|
|
if (string.IsNullOrEmpty(option))
|
|
{
|
|
return null;
|
|
}
|
|
AttachOptionInfo attachOptionInfo = new AttachOptionInfo(option);
|
|
return new SkillCreator.SkillBuildInfo(attachOptionInfo.Skill, attachOptionInfo.Timing, attachOptionInfo.Condition, attachOptionInfo.Target, attachOptionInfo.Option, attachOptionInfo.Preprocess, attachOptionInfo.EffectCondition, attachOptionInfo.Icon, null, attachOptionInfo.EffectPath, sePath: attachOptionInfo.SEPath, effectMoveType: EffectMgr.ToStrMoveType(attachOptionInfo.EffectMoveType), engineType: EffectMgr.ToStrEngineType(attachOptionInfo.EngineType), effectTime: float.Parse(attachOptionInfo.EffectTime), effectTargetType: EffectMgr.ToStrTargetType(attachOptionInfo.EffectTargetType), voice: attachOptionInfo.Voice);
|
|
}
|
|
|
|
public static SkillBase CreateAndAttachSkill(BattleCardBase targetCard, SkillBase originalSkill, SkillCreator.SkillBuildInfo buildInfo)
|
|
{
|
|
SkillBase skill = targetCard.SkillApplyInformation.AttachSkill(buildInfo, originalSkill.SkillPrm.resourceMgr, originalSkill.SkillPrm.ownerCard.GetName(), originalSkill.SkillPrm.ownerCard.CardId, originalSkill.OptionValue.GetLong(SkillFilterCreator.ContentKeyword.duplicate_ban_id, 0), originalSkill);
|
|
if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessInPlayPeriodOfTime))
|
|
{
|
|
skill.OnSkillStopStart += delegate(SkillBase _skill, List<BattleCardBase> cards, SkillProcessor skillProcessorOneTime)
|
|
{
|
|
originalSkill.Stop(skillProcessorOneTime);
|
|
};
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessRemoveAfterAction))
|
|
{
|
|
skill.OnSkillEnd += (SkillBase _skill, List<BattleCardBase> cards, SkillConditionCheckerOption checkerOption, SkillProcessor skillProcessorOneTime) => skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessRemoveAfterAction && (s as SkillPreprocessRemoveAfterAction).IsEnd()) ? ((VfxBase)originalSkill.Stop(skillProcessorOneTime)) : ((VfxBase)NullVfx.GetInstance());
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessDamageAfterStop))
|
|
{
|
|
skill.OnSkillStart += delegate
|
|
{
|
|
skill.SkillPrm.ownerCard.OnDamageAfter += (SkillProcessor skillProcessorOneTime) => originalSkill.Stop(skillProcessorOneTime);
|
|
};
|
|
}
|
|
else if (skill.PreprocessList.Any((SkillPreprocessBase s) => s is SkillPreprocessReflectionAfterStop))
|
|
{
|
|
skill.OnSkillStart += delegate
|
|
{
|
|
skill.SkillPrm.ownerCard.OnReflectionAfter += (SkillProcessor skillProcessorOneTime) => originalSkill.Stop(skillProcessorOneTime);
|
|
};
|
|
}
|
|
int skillVoiceIndex = AddSkillVoice(skill, buildInfo);
|
|
skill.SetSkillVoiceIndex(skillVoiceIndex);
|
|
return skill;
|
|
}
|
|
|
|
private static int AddSkillVoice(SkillBase skill, SkillCreator.SkillBuildInfo buildInfo)
|
|
{
|
|
if (buildInfo._voice != string.Empty && skill.SkillPrm.ownerCard.BattleCardView != null)
|
|
{
|
|
return skill.SkillPrm.ownerCard.BattleCardView.VoiceInfo.AddAttachSkillVoice(buildInfo._voice);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private VfxBase CheckResidentAndImmediateAttachSkillCondition(SkillProcessor skillProcessor, List<BattleCardBase> targets, SkillBase skill)
|
|
{
|
|
BattlePlayerBase turnPlayer = (base.SkillPrm.selfBattlePlayer.IsSelfTurn ? base.SkillPrm.selfBattlePlayer : base.SkillPrm.opponentBattlePlayer);
|
|
BattlePlayerBase notTurnPlayer = (base.SkillPrm.selfBattlePlayer.IsSelfTurn ? base.SkillPrm.opponentBattlePlayer : base.SkillPrm.selfBattlePlayer);
|
|
BattlePlayerPair onTurnPlayerPair = new BattlePlayerPair(turnPlayer, notTurnPlayer);
|
|
BattlePlayerPair notTurnPlayerPair = new BattlePlayerPair(notTurnPlayer, turnPlayer);
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
List<BattleCardBase> list2 = new List<BattleCardBase>();
|
|
list = targets.Where((BattleCardBase c) => c.IsInplay && c.IsPlayer == turnPlayer.IsPlayer).ToList();
|
|
list2 = targets.Where((BattleCardBase c) => c.IsInplay && c.IsPlayer == notTurnPlayer.IsPlayer).ToList();
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
parallelVfxPlayer.Register(ProcessWhenChangeImmediate(list, onTurnPlayerPair, notTurnPlayerPair));
|
|
parallelVfxPlayer.Register(ProcessWhenChangeImmediate(list2, onTurnPlayerPair, notTurnPlayerPair));
|
|
parallelVfxPlayer.Register(RegisterInPlaySkill(list, skillProcessor, onTurnPlayerPair, notTurnPlayerPair));
|
|
parallelVfxPlayer.Register(RegisterInPlaySkill(list2, skillProcessor, onTurnPlayerPair, notTurnPlayerPair));
|
|
return parallelVfxPlayer;
|
|
}
|
|
|
|
private VfxBase ProcessWhenChangeImmediate(List<BattleCardBase> inPlayCards, BattlePlayerPair onTurnPlayerPair, BattlePlayerPair notTurnPlayerPair)
|
|
{
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
for (int i = 0; i < inPlayCards.Count; i++)
|
|
{
|
|
sequentialVfxPlayer.Register(inPlayCards[i].Skills.RegisterAndProcessWhenChangeInplayImmediateInfo(inPlayCards[i].IsSelfTurn ? onTurnPlayerPair : notTurnPlayerPair));
|
|
}
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
private VfxBase RegisterInPlaySkill(List<BattleCardBase> inPlayCards, SkillProcessor skillProcessor, BattlePlayerPair onTurnPlayerPair, BattlePlayerPair notTurnPlayerPair)
|
|
{
|
|
SequentialVfxPlayer result = SequentialVfxPlayer.Create();
|
|
for (int i = 0; i < inPlayCards.Count; i++)
|
|
{
|
|
inPlayCards[i].Skills.CreateAndRegisterWhenChangeInplayInfo(inPlayCards, skillProcessor, inPlayCards[i].IsSelfTurn ? onTurnPlayerPair : notTurnPlayerPair, isSummonCheck: false);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected void LoggingOpponentPrivateCard(List<BattleCardBase> targets, SkillCreator.SkillBuildInfo buildInfo)
|
|
{
|
|
if (!IsBattleLog || BattleManagerBase.GetIns().BattleEnemy.HandCardList.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
BattleLogManager instance = BattleLogManager.GetInstance();
|
|
SkillBase attachedSkill = base.SkillPrm.ownerCard.CreateSkillCreator(base.SkillPrm.ownerCard.SelfBattlePlayer, base.SkillPrm.ownerCard.OpponentBattlePlayer, base.SkillPrm.resourceMgr).Create(buildInfo, null, isAttachSkill: true, this);
|
|
if (GameMgr.GetIns().IsAdminWatch)
|
|
{
|
|
for (int i = 0; i < targets.Count; i++)
|
|
{
|
|
instance.AddLogSkillAttachSkill(targets[i], attachedSkill, this);
|
|
}
|
|
}
|
|
else if (!(base.ApplyingTargetFilter is SkillTargetSkillDrewCardFilter) || targets.Count != 0)
|
|
{
|
|
instance.AddLogSkillAttachSkill(BattleManagerBase.GetIns().BattleEnemy.Class, attachedSkill, this, isTargetInOpponentHand: true);
|
|
}
|
|
}
|
|
|
|
public static void GiveIndividualId(SkillBase attachSkill, SkillBase createdSkill)
|
|
{
|
|
BattleCardBase ownerCard = attachSkill.SkillPrm.ownerCard;
|
|
bool flag = ownerCard.NormalSkills.Any((SkillBase s) => s == attachSkill);
|
|
int num = (flag ? ownerCard.NormalIndividualId : ownerCard.EvolutionIndividualId);
|
|
if (num != -1)
|
|
{
|
|
createdSkill.SetIndividualId(num);
|
|
return;
|
|
}
|
|
createdSkill.InitSetIndividualId();
|
|
if (createdSkill.IndividualId != -1)
|
|
{
|
|
if (flag)
|
|
{
|
|
ownerCard.NormalIndividualId = createdSkill.IndividualId;
|
|
}
|
|
else
|
|
{
|
|
ownerCard.EvolutionIndividualId = createdSkill.IndividualId;
|
|
}
|
|
ownerCard.SelfBattlePlayer.BattleMgr.IncrementIndividualId();
|
|
}
|
|
}
|
|
|
|
public override void SetOnLoseEvent(BattleCardBase targetCard, BuffInfo buff, BuffInfoContainer container)
|
|
{
|
|
targetCard.OnLoseSkillOneTime += delegate(SkillBase loseSkill, SkillProcessor skillProcessor, BattleCardBase card)
|
|
{
|
|
card.RemoveBuffInfo(buff);
|
|
buffInfoContainer.Remove(container);
|
|
OnIndividualIdSkillStop.Call();
|
|
return NullVfx.GetInstance();
|
|
};
|
|
}
|
|
|
|
public virtual void CallOnAttachSkill(List<BattleCardBase> targetCards)
|
|
{
|
|
}
|
|
}
|