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.
517 lines
22 KiB
C#
517 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using Wizard;
|
|
using Wizard.Battle.Card;
|
|
using Wizard.Battle.Resource;
|
|
using Wizard.Battle.UI;
|
|
using Wizard.Battle.View;
|
|
using Wizard.Battle.View.Vfx;
|
|
|
|
public class UnitBattleCard : BattleCardBase
|
|
{
|
|
public const string DRAIN_EFFECT = "btl_magic_cure_1";
|
|
|
|
public const string DRAIN_SE = "se_btl_magic_cure_1";
|
|
|
|
public const float DRAIN_WAIT_TIME = 0.3f;
|
|
|
|
private bool _isEvolution;
|
|
|
|
public bool _isEvolvedOnWhenLeave;
|
|
|
|
public override bool IsUnit => true;
|
|
|
|
public override bool IsEvolution => _isEvolution;
|
|
|
|
public override bool IsEvolvedOnWhenLeave => _isEvolvedOnWhenLeave;
|
|
|
|
public override bool BaseMovable => base.Movable();
|
|
|
|
public override bool IsCantActivateFanfare => base.SelfBattlePlayer.Class.SkillApplyInformation.IsCantActivateFanfareUnit;
|
|
|
|
public event Func<VfxBase> OnAfterAttack;
|
|
|
|
public void Evolution(bool isEvolution = true)
|
|
{
|
|
_isEvolution = isEvolution;
|
|
}
|
|
|
|
public override bool Movable(bool isCheckOnDraw = true, bool isSkipSelecting = false, CHECK_CONDITION_MUTATIONSKILL_TYPE type = CHECK_CONDITION_MUTATIONSKILL_TYPE.NONE, bool isRecording = false)
|
|
{
|
|
type = IsCheckActiveMutationSkill;
|
|
if (!base.Movable(isCheckOnDraw, isSkipSelecting, type, isRecording))
|
|
{
|
|
return false;
|
|
}
|
|
return IsMutationMovable(type);
|
|
}
|
|
|
|
public UnitBattleCard(BuildInfo buildInfo)
|
|
: base(buildInfo)
|
|
{
|
|
}
|
|
|
|
public override void Setup(bool createNullView = false, bool isRecreate = false)
|
|
{
|
|
base.Setup(createNullView, isRecreate);
|
|
base.BattleCardView.SetupIconAnimations(this, base.Skills);
|
|
}
|
|
|
|
public override VfxBase TurnStart(SkillProcessor skillProcessor)
|
|
{
|
|
VfxBase vfxBase = base.TurnStart(skillProcessor);
|
|
if (Attackable)
|
|
{
|
|
return SequentialVfxPlayer.Create(vfxBase, InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect();
|
|
}));
|
|
}
|
|
return vfxBase;
|
|
}
|
|
|
|
public override VfxBase TurnEndPostProcess()
|
|
{
|
|
base.TurnEndPostProcess();
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
if (Attackable)
|
|
{
|
|
parallelVfxPlayer.Register(InstantVfx.Create(base.BattleCardView._inPlayFrameEffect.HideFrameEffect));
|
|
}
|
|
if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle)
|
|
{
|
|
parallelVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView.HideAttackFinished();
|
|
}));
|
|
}
|
|
base.AttackableCount = 0;
|
|
return parallelVfxPlayer;
|
|
}
|
|
|
|
public override VfxBase Evolution(bool isSkill, SkillProcessor skillProcessor, SkillConditionCheckerOption option, Func<BattleCardBase, IBattleResourceMgr, EvolveVfxBase> getEvolveVfxFunc = null)
|
|
{
|
|
BattlePlayerPair playerInfoPair = new BattlePlayerPair(base.SelfBattlePlayer, base.OpponentBattlePlayer);
|
|
if (!CanEvolution(isSkill, isSelfBattlePlayer: true) || !IsInplay)
|
|
{
|
|
return NullVfx.GetInstance();
|
|
}
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView._inPlayFrameEffect.SetIsSelectingAttackTarget(enable: true);
|
|
}));
|
|
sequentialVfxPlayer.Register(OnBeforeEvolveEvent(skillProcessor));
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView._inPlayFrameEffect.SetIsSelectingAttackTarget(enable: false);
|
|
}));
|
|
base.SelfBattlePlayer.EvolvedCards.Add(this);
|
|
base.SelfBattlePlayer.AddCurrentEvolvePlayCount(1);
|
|
int attackableCount = base.AttackableCount;
|
|
sequentialVfxPlayer.Register(base.SkillApplyInformation.AllSkillEffectStop(isEvolve: true));
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(base.BattleCardView._inPlayFrameEffect.HideFrameEffect));
|
|
EpSetModifier modifier = new EpSetModifier(0);
|
|
if (isSkill)
|
|
{
|
|
base.SkillApplyInformation.AddEpModifier(modifier);
|
|
}
|
|
OnEvolve(isSkill);
|
|
if (!isSkill)
|
|
{
|
|
base.SelfBattlePlayer.NowTurnEvol = false;
|
|
base.SelfBattlePlayer.IsEpEvolveThisTurn = true;
|
|
}
|
|
_isEvolution = true;
|
|
base.AttackableCount = attackableCount;
|
|
if (BattleManagerBase.GetIns().IsRecovery)
|
|
{
|
|
sequentialVfxPlayer.Register(new RecoveryEvolveVfx(this, _buildInfo.ResourceMgr));
|
|
}
|
|
else if (getEvolveVfxFunc == null)
|
|
{
|
|
if (base.IsPlayer && GameMgr.GetIns().GetDataMgr().Is3DSkin(isPlayer: true))
|
|
{
|
|
sequentialVfxPlayer.Register(new Class3dEvolveVfx(this, _buildInfo.ResourceMgr));
|
|
}
|
|
else if (base.IsPlayer && GameMgr.GetIns().GetDataMgr().IsHighRankSkinPlayer())
|
|
{
|
|
sequentialVfxPlayer.Register(new HighRankEvolveVfx(this, _buildInfo.ResourceMgr));
|
|
}
|
|
else
|
|
{
|
|
sequentialVfxPlayer.Register(new EvolveVfx(this, _buildInfo.ResourceMgr));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sequentialVfxPlayer.Register(getEvolveVfxFunc(this, _buildInfo.ResourceMgr));
|
|
}
|
|
if (_evolveSkillCollection.Count() > 0)
|
|
{
|
|
if (_evolveSkillCollection.Count((SkillBase s) => !s.IsAttachedSkill) == 0)
|
|
{
|
|
for (int num = 0; num < _evolveSkillCollection.Count(); num++)
|
|
{
|
|
base.Skills.Add(_evolveSkillCollection.ElementAt(num));
|
|
}
|
|
_evolveSkillCollection.Clear();
|
|
}
|
|
else
|
|
{
|
|
base.Skills = _evolveSkillCollection;
|
|
}
|
|
base.Skills.Complete();
|
|
if (!isSkill)
|
|
{
|
|
skillProcessor.Register(base.Skills.CreateWhenEvolveInfo(skillProcessor, playerInfoPair, option));
|
|
}
|
|
sequentialVfxPlayer.Register(base.Skills.RegisterAndProcessWhenChangeInplayImmediateInfo(playerInfoPair));
|
|
base.Skills.CreateAndRegisterWhenChangeInplayInfo(new List<BattleCardBase> { this }, skillProcessor, playerInfoPair);
|
|
foreach (SkillBase attachedSkill in base.SkillApplyInformation.AttachedSkillsInfo.AttachedSkills)
|
|
{
|
|
if (!base.Skills.Contains(attachedSkill))
|
|
{
|
|
base.Skills.Add(attachedSkill);
|
|
}
|
|
}
|
|
base.Skills.Complete();
|
|
if (_evolveSkillCollection._skillTimingInfo.IsWhenDestroy)
|
|
{
|
|
base.BuffInfoList.RemoveAll((BuffInfo b) => b.SkillFrom is Skill_rob_skill && b.SkillFrom.SkillPrm.ownerCard != this);
|
|
}
|
|
}
|
|
if (base.IsSelfTurn)
|
|
{
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect();
|
|
}));
|
|
}
|
|
sequentialVfxPlayer.Register(base.SkillApplyInformation.AllSkillEffectRestart());
|
|
if (isSkill)
|
|
{
|
|
base.SkillApplyInformation.RemoveEpModifier(modifier);
|
|
}
|
|
sequentialVfxPlayer.Register(base.BattleCardView.InitializeBattleCardIcon(this, base.Skills));
|
|
if (!isSkill)
|
|
{
|
|
List<BattleCardBase> list = base.SelfBattlePlayer.HandCardList.Where((BattleCardBase c) => c.Skills.Any((SkillBase s) => s.OnWhenEvolveOtherStart != 0 || s.OnWhenEvolveSelfAndOtherStart != 0 || s.OnWhenUseEpSelfAndOtherStart != 0)).ToList();
|
|
list.AddRange(base.OpponentBattlePlayer.HandCardList.Where((BattleCardBase c) => c.Skills.Any((SkillBase s) => s.OnWhenEvolveOtherStart != 0 || s.OnWhenEvolveSelfAndOtherStart != 0 || s.OnWhenUseEpSelfAndOtherStart != 0)));
|
|
list.AddRange(base.SelfBattlePlayer.ClassAndInPlayCardList.Where((BattleCardBase c) => c.Skills.Any((SkillBase s) => s.OnWhenEvolveOtherStart != 0 || s.OnWhenEvolveSelfAndOtherStart != 0 || s.OnWhenUseEpSelfAndOtherStart != 0)));
|
|
list.AddRange(base.OpponentBattlePlayer.ClassAndInPlayCardList.Where((BattleCardBase c) => c.Skills.Any((SkillBase s) => s.OnWhenEvolveOtherStart != 0 || s.OnWhenEvolveSelfAndOtherStart != 0 || s.OnWhenUseEpSelfAndOtherStart != 0)));
|
|
List<BattleCardBase> list2 = new List<BattleCardBase>();
|
|
list2.Add(this);
|
|
for (int num2 = 0; num2 < list.Count; num2++)
|
|
{
|
|
if (list[num2] != this && list[num2].Skills.Any((SkillBase s) => s.OnWhenEvolveOtherStart != 0))
|
|
{
|
|
skillProcessor.Register(list[num2].Skills.CreateWhenEvolveOtherInfo(list2, skillProcessor, new BattlePlayerReadOnlyInfoPair(list[num2].SelfBattlePlayer, list[num2].OpponentBattlePlayer)));
|
|
}
|
|
if (list[num2] != this && list[num2].Skills.Any((SkillBase s) => s.OnWhenUseEpSelfAndOtherStart != 0))
|
|
{
|
|
if (base.SelfBattlePlayer.CheckNotConsumeEpCard(this))
|
|
{
|
|
continue;
|
|
}
|
|
skillProcessor.Register(list[num2].Skills.CreateWhenUseEpSelfAndOtherInfo(skillProcessor, new BattlePlayerReadOnlyInfoPair(list[num2].SelfBattlePlayer, list[num2].OpponentBattlePlayer)));
|
|
}
|
|
if (list[num2].Skills.Any((SkillBase s) => s.OnWhenEvolveSelfAndOtherStart != 0))
|
|
{
|
|
skillProcessor.Register(list[num2].Skills.CreateWhenEvolveSelfAndOtherInfo(list2, skillProcessor, new BattlePlayerReadOnlyInfoPair(list[num2].SelfBattlePlayer, list[num2].OpponentBattlePlayer)));
|
|
}
|
|
}
|
|
}
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override VfxBase SetUpInplay()
|
|
{
|
|
_isEvolution = false;
|
|
_isEvolvedOnWhenLeave = false;
|
|
return base.SetUpInplay();
|
|
}
|
|
|
|
public override VfxBase Banish(SkillProcessor skillProcessor, bool isReturn = false)
|
|
{
|
|
if (isReturn)
|
|
{
|
|
_isEvolvedOnWhenLeave = _isEvolution;
|
|
_isEvolution = false;
|
|
}
|
|
return base.Banish(skillProcessor, isReturn);
|
|
}
|
|
|
|
public override VfxBase ReturnCard(SkillProcessor skillProcessor)
|
|
{
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
if (Attackable)
|
|
{
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(base.BattleCardView._inPlayFrameEffect.HideFrameEffect));
|
|
}
|
|
sequentialVfxPlayer.Register(base.SkillApplyInformation.AllSkillEffectStop(isEvolve: false, isReturn: true));
|
|
InitializeParameterOnWhenReturn();
|
|
VfxBase vfx = base.ReturnCard(skillProcessor);
|
|
sequentialVfxPlayer.Register(vfx);
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override void InitializeParameterOnWhenReturn()
|
|
{
|
|
base.IsFirstTurn = false;
|
|
base.IsSummonDrunkenness = true;
|
|
base.AttackableCount = 0;
|
|
_isEvolvedOnWhenLeave = _isEvolution;
|
|
_isEvolution = false;
|
|
base.InitializeParameterOnWhenReturn();
|
|
}
|
|
|
|
protected override VfxBase StartPlayCard()
|
|
{
|
|
base.StartPlayCard();
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
base.SelfBattlePlayer.HandCardToField(this);
|
|
base.BattleCardView.ResetTemplate();
|
|
sequentialVfxPlayer.Register(base.VfxCreator.CreatePick());
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override VfxBase StartAttack(BattleCardBase underAttackCard, BattlePlayerPair battlePlayerPair)
|
|
{
|
|
return ExecuteAttackSequence(underAttackCard, battlePlayerPair);
|
|
}
|
|
|
|
private VfxBase ExecuteAttackSequence(BattleCardBase targetCard, BattlePlayerPair battlePlayerPair)
|
|
{
|
|
SkillProcessor skillProcessor = new SkillProcessor();
|
|
DamageParam damageCalculationAtkTypeAttack = base.DamageCalculationAtkTypeAttack;
|
|
DamageParam damageCalculationAtkTypeBeAttacked = targetCard.DamageCalculationAtkTypeBeAttacked;
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create();
|
|
AttackOpponentResult attackOpponentResult = AttackOpponent(targetCard, damageCalculationAtkTypeAttack, skillProcessor, IsChallenge: true);
|
|
if (base.SkillApplyInformation.IsDrain)
|
|
{
|
|
sequentialVfxPlayer2.Register(WaitVfx.Create(0.3f));
|
|
sequentialVfxPlayer2.Register(ApplyDrain(damageCalculationAtkTypeAttack, skillProcessor, attackOpponentResult.damageResult));
|
|
}
|
|
AttackOpponentResult attackOpponentResult2 = targetCard.AttackOpponent(this, damageCalculationAtkTypeBeAttacked, skillProcessor, IsChallenge: false);
|
|
SequentialVfxPlayer sequentialVfxPlayer3 = SequentialVfxPlayer.Create(attackOpponentResult.attackVfx, attackOpponentResult.damageVfx);
|
|
SequentialVfxPlayer sequentialVfxPlayer4 = SequentialVfxPlayer.Create(WaitVfx.Create(0.4f), attackOpponentResult2.attackVfx);
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(attackOpponentResult2.damageVfx);
|
|
if (base.SkillApplyInformation.IsDrain)
|
|
{
|
|
parallelVfxPlayer.Register(sequentialVfxPlayer2);
|
|
}
|
|
sequentialVfxPlayer4.Register(parallelVfxPlayer);
|
|
sequentialVfxPlayer.Register(ParallelVfxPlayer.Create(sequentialVfxPlayer3, sequentialVfxPlayer4));
|
|
ParallelVfxPlayer parallelVfxPlayer2 = ParallelVfxPlayer.Create();
|
|
ParallelVfxPlayer parallelVfxPlayer3 = ParallelVfxPlayer.Create();
|
|
AttackSelectControl attackSelectControl = base.SelfBattlePlayer.BattleView.AttackSelectControl;
|
|
if (IsDead)
|
|
{
|
|
parallelVfxPlayer3.Register(base.SelfBattlePlayer.CardManagement(this, skillProcessor, BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false));
|
|
if (!targetCard.IsDead)
|
|
{
|
|
base.BattleCardView.playVoiceOnDeath = true;
|
|
base.BattleCardView.VoiceInfo.SetDestroyCardId(targetCard.BaseParameter.BaseCardId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parallelVfxPlayer2.Register(attackSelectControl.ResetCardAfterAttack(base.BattleCardView));
|
|
}
|
|
if (targetCard.IsDead)
|
|
{
|
|
parallelVfxPlayer3.Register(targetCard.SelfBattlePlayer.CardManagement(targetCard, skillProcessor, BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false));
|
|
targetCard.BattleCardView.playVoiceOnDeath = true;
|
|
targetCard.BattleCardView.VoiceInfo.SetDestroyCardId(base.BaseParameter.BaseCardId);
|
|
}
|
|
else
|
|
{
|
|
parallelVfxPlayer2.Register(attackSelectControl.ResetCardAfterAttack(targetCard.BattleCardView));
|
|
}
|
|
SequentialVfxPlayer sequentialVfxPlayer5 = SequentialVfxPlayer.Create();
|
|
sequentialVfxPlayer5.Register(parallelVfxPlayer2);
|
|
sequentialVfxPlayer5.Register(parallelVfxPlayer3);
|
|
sequentialVfxPlayer.Register(sequentialVfxPlayer5);
|
|
if (!base.SelfBattlePlayer.BattleMgr.IsVirtualBattle)
|
|
{
|
|
BattleLogManager.GetInstance().AddLogWar(this, targetCard);
|
|
}
|
|
VfxBase vfx = skillProcessor.Process(new BattlePlayerPair(base.SelfBattlePlayer, base.OpponentBattlePlayer));
|
|
sequentialVfxPlayer.Register(vfx);
|
|
sequentialVfxPlayer.Register(this.OnAfterAttack.GetAllFuncVfxResults());
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override AttackOpponentResult AttackOpponent(BattleCardBase target, DamageParam damageParam, SkillProcessor skillProcessor, bool IsChallenge)
|
|
{
|
|
VfxBase vfx = base.VfxCreator.CreateAttack(base.BattleCardView, target.BattleCardView);
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
DamageResult damageResult = target.ApplyDamage(null, damageParam, base.SkillApplyInformation.IsKiller, isReflectedDamage: false, skillProcessor, null);
|
|
BattleManagerBase ins = BattleManagerBase.GetIns();
|
|
base.SelfBattlePlayer.Class.SkillApplyInformation.CausedDamageLife(damageResult.DamageApplied, ins.CurrentTurn, ins.BattlePlayer.IsSelfTurn);
|
|
sequentialVfxPlayer.Register(damageResult.Vfx);
|
|
SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create();
|
|
if (IsChallenge)
|
|
{
|
|
base.AttackableCount--;
|
|
if (base.SkillApplyInformation.IsSneak)
|
|
{
|
|
sequentialVfxPlayer2.Register(AfterAddDamage());
|
|
}
|
|
}
|
|
sequentialVfxPlayer2.Register(vfx);
|
|
return new AttackOpponentResult(sequentialVfxPlayer2, sequentialVfxPlayer, damageResult);
|
|
}
|
|
|
|
protected VfxBase ApplyDrain(DamageParam damageParam, SkillProcessor skillProcessor, DamageResult damageResult)
|
|
{
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
BattleCardBase beforeHealCard = base.SelfBattlePlayer.Class.VirtualClone(base.SelfBattlePlayer.Class.SelfBattlePlayer, base.SelfBattlePlayer.Class.OpponentBattlePlayer);
|
|
HealParam healParam = new HealParam(damageResult.GainLife, this, base.SelfBattlePlayer.Class);
|
|
HealResult healResult = base.SelfBattlePlayer.Class.ApplyHealing(healParam, skillProcessor);
|
|
SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create(healResult.HealVfx, healResult.PrehealVfxVfx, healResult.PosthealVfxVfx);
|
|
skillProcessor.Register(base.SelfBattlePlayer.Class.Skills.CreateWhenHealing(base.SelfBattlePlayer.Class, skillProcessor, new BattlePlayerReadOnlyInfoPair(base.SelfBattlePlayer, base.OpponentBattlePlayer), healResult.HealAmount));
|
|
sequentialVfxPlayer2.Register(base.SelfBattlePlayer.StartSkillWhenHealingSelfAndOther(new List<BattleCardBase> { base.SelfBattlePlayer.Class }, skillProcessor, new List<int> { healResult.HealAmount }));
|
|
base.SelfBattlePlayer.CallOnDrain(healResult.HealAmount);
|
|
if (base.SelfBattlePlayer.Class.BattleCardView.CardWrapObject != null)
|
|
{
|
|
EffectBattle effectBattle = null;
|
|
Vector3 effectPosition = base.SelfBattlePlayer.Class.BattleCardView.CardWrapObject.transform.position;
|
|
sequentialVfxPlayer.Register(new SkillBase.WaitEffectLoadVfx("btl_magic_cure_1", EffectMgr.EngineType.SHURIKEN, "se_btl_magic_cure_1", BattleManagerBase.GetIns().BattleResourceMgr, delegate(EffectBattle eb)
|
|
{
|
|
effectBattle = eb;
|
|
}));
|
|
DelaySetupVfx vfx = new DelaySetupVfx(() => new SkillEffectBattleVfx(effectBattle, base.SelfBattlePlayer.Class.BattleCardView, BattleManagerBase.GetIns().BattleResourceMgr, () => effectPosition, () => effectPosition, 0f, 0.2f, EffectMgr.MoveType.NONE, base.SelfBattlePlayer.Class.SelfBattlePlayer.IsPlayer, Color.clear));
|
|
sequentialVfxPlayer2.Register(vfx);
|
|
}
|
|
sequentialVfxPlayer.Register(sequentialVfxPlayer2);
|
|
if (!base.SelfBattlePlayer.BattleMgr.IsVirtualBattle)
|
|
{
|
|
BattleLogManager.GetInstance().AddLogHeal(beforeHealCard, healResult.HealAmount);
|
|
}
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override DamageResult ApplyDamage(SkillBase skill, DamageParam damageParam, bool doesAttackerPossessKiller, bool isReflectedDamage, SkillProcessor skillProcessor, BattleCardBase reflectCard)
|
|
{
|
|
int damage = damageParam.Damage;
|
|
bool isSkillDamage = skill != null;
|
|
bool isSpellDamage = skill?.SkillPrm.ownerCard.IsSpell ?? false;
|
|
BattleCardBase damageReflectionTarget = GetDamageReflectionTarget(isSkillDamage);
|
|
if (damageReflectionTarget != this)
|
|
{
|
|
return damageReflectionTarget.ApplyDamage(skill, damageParam, doesAttackerPossessKiller: false, isReflectedDamage: true, skillProcessor, this);
|
|
}
|
|
damageParam.Damage = CalculateFinalDamageAmount(damageParam.Damage, isSkillDamage, isSpellDamage);
|
|
new SkillConditionCheckerOption().DefaultDamage = new DamageInfo(skill, damage);
|
|
BattleManagerBase ins = BattleManagerBase.GetIns();
|
|
base.SkillApplyInformation.DamageLife(damageParam.Damage, ins.CurrentTurn, ins.BattlePlayer.IsSelfTurn);
|
|
if (doesAttackerPossessKiller && !base.SkillApplyInformation.IsIndependent && !base.SkillApplyInformation.IsIndestructible)
|
|
{
|
|
FlagCardAsDestroyedByKiller();
|
|
}
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
sequentialVfxPlayer.Register(base.VfxCreator.CreateDamage(damageParam.Damage, base.Life, base.MaxLife, BaseMaxLife, isReflectedDamage, isSkillDamage));
|
|
skillProcessor.Register(base.Skills.CreateWhenDamageInfo(skill, skillProcessor, new BattlePlayerReadOnlyInfoPair(base.SelfBattlePlayer, base.OpponentBattlePlayer), damage, damageParam.Damage));
|
|
sequentialVfxPlayer.Register(base.ApplyDamage(skill, damageParam, doesAttackerPossessKiller, isReflectedDamage, skillProcessor, reflectCard).Vfx);
|
|
return new DamageResult(sequentialVfxPlayer, damageParam.Damage, damageParam.Damage, null, null, isReflectedDamage);
|
|
}
|
|
|
|
public override HealResult ApplyHealing(HealParam healParam, SkillProcessor skillProcessor)
|
|
{
|
|
BattleManagerBase ins = BattleManagerBase.GetIns();
|
|
int num = HealLife(healParam.HealAmount, ins.CurrentTurn, ins.BattlePlayer.IsSelfTurn);
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
sequentialVfxPlayer.Register(base.VfxCreator.CreateHealing(num, base.Life, base.MaxLife, BaseMaxLife));
|
|
new SkillConditionCheckerOption().HealingCardAndValue = new List<BattlePlayerBase.CardAndValue>
|
|
{
|
|
new BattlePlayerBase.CardAndValue(this, num)
|
|
};
|
|
return new HealResult(num, sequentialVfxPlayer);
|
|
}
|
|
|
|
public override VfxBase RemoveFromInPlay()
|
|
{
|
|
VfxBase result = base.RemoveFromInPlay();
|
|
if (this != null && !IsDead)
|
|
{
|
|
base.SkillApplyInformation.ClearParameterModifier();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected override ICardVfxCreator CreateVfxCreator(bool isPlayer, IBattleCardView battleCardView, bool isNullView)
|
|
{
|
|
if (isNullView)
|
|
{
|
|
return NullCardVfxCreator.GetInstance();
|
|
}
|
|
return new UnitCardVfxCreator(isPlayer, this, battleCardView, _buildInfo.ResourceMgr);
|
|
}
|
|
|
|
protected override ISkillApplyInformation CreateSkillApplyInformation(BattleCardBase card, ICardVfxCreator vfxCreator)
|
|
{
|
|
return new UnitSkillApplyInformation(card, vfxCreator);
|
|
}
|
|
|
|
protected override IBattleCardView CreateView(BattleCardView.BuildInfo buildInfo, bool isNullView)
|
|
{
|
|
if (isNullView)
|
|
{
|
|
return new NullBattleCardView(buildInfo);
|
|
}
|
|
return new UnitBattleCardView(buildInfo);
|
|
}
|
|
|
|
public override string GetCardSkillDescription(BattlePlayerBase.SideLogInfo sideLogInfo, bool? isForceGetEvolveText = null)
|
|
{
|
|
bool flag = IsEvolution;
|
|
if (isForceGetEvolveText.HasValue)
|
|
{
|
|
flag = isForceGetEvolveText.Value;
|
|
}
|
|
if (!flag)
|
|
{
|
|
return SkillDescription(sideLogInfo);
|
|
}
|
|
return EvoSkillDescription(sideLogInfo);
|
|
}
|
|
|
|
public override VfxBase RecoveryInPlay(int inPlayIndex, bool newReplayMoveTurn = false)
|
|
{
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
sequentialVfxPlayer.Register(base.RecoveryInPlay(inPlayIndex, newReplayMoveTurn));
|
|
if (IsEvolution)
|
|
{
|
|
sequentialVfxPlayer.Register(new EvolveImageChangeVfx(this, _buildInfo.ResourceMgr));
|
|
if (base.IsChoiceEvolutionCard)
|
|
{
|
|
sequentialVfxPlayer.Register(new EvolveNameChangeVfx(this));
|
|
}
|
|
sequentialVfxPlayer.Register(new EvolveUnitMaskCardInPlayVfx(base.BattleCardView));
|
|
}
|
|
sequentialVfxPlayer.Register(new RefreshAttackVfx(base.BattleCardView, base.Atk, base.BaseAtk, forceUpdate: true, newReplayMoveTurn));
|
|
sequentialVfxPlayer.Register(new RefreshHealthVfx(base.BattleCardView, base.Life, base.MaxLife, BaseMaxLife, newReplayMoveTurn));
|
|
if (Attackable && base.IsSelfTurn)
|
|
{
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
base.BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect();
|
|
}));
|
|
}
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override BattleCardBase VirtualClone(BattlePlayerBase selfBattlePlayer, BattlePlayerBase opponentBattlePlayer)
|
|
{
|
|
VirtualUnitBattleCard virtualUnitBattleCard = new VirtualUnitBattleCard(_buildInfo.VirtualClone(selfBattlePlayer, opponentBattlePlayer));
|
|
virtualUnitBattleCard._isEvolution = IsEvolution;
|
|
CopyToVirtualCardBase(virtualUnitBattleCard);
|
|
return virtualUnitBattleCard;
|
|
}
|
|
}
|