SVSim/SVSimServer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(battle-engine): seed copy roots + UnityEngine primitive shim

Browse Source 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
gamer147
2026-06-05 16:45:12 -04:00
parent bb80815b01
commit 550cedbf1e
8 changed files with 14060 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
SVSim.BattleEngine/COPIED.manifest.tsv Normal file
View File

@@ -0,0 +1,6 @@
# engine-relpath source-relpath sha256 patched(0|1)
BattleCardBase.cs BattleCardBase.cs b105aec032149ab0a1730c6e06e25530699851707150ad4b72e24fe6d17fd50f 0
BattleManagerBase.cs BattleManagerBase.cs b4181eac7af0ed578835ea75b7003e1b3466331006a35cd84b40139825680eb7 0
BattlePlayerBase.cs BattlePlayerBase.cs 9d3a665158706460a52900008dcfcdf575dbe08cb6d3cc05e63e718b2885b51b 0
SkillCreator.cs SkillCreator.cs 6b90cd32dea619058e1cf942bdd288981495f7711a76bff8ccc9e2787e3f6439 0
Wizard.Battle/ActionProcessor.cs Wizard.Battle/ActionProcessor.cs 7c8b40454a4948dd48a58c0efc240703eab9a77aea0add64e542f6b06c7323af 0
1 # engine-relpath source-relpath sha256 patched(0|1)
2 BattleCardBase.cs BattleCardBase.cs b105aec032149ab0a1730c6e06e25530699851707150ad4b72e24fe6d17fd50f 0
3 BattleManagerBase.cs BattleManagerBase.cs b4181eac7af0ed578835ea75b7003e1b3466331006a35cd84b40139825680eb7 0
4 BattlePlayerBase.cs BattlePlayerBase.cs 9d3a665158706460a52900008dcfcdf575dbe08cb6d3cc05e63e718b2885b51b 0
5 SkillCreator.cs SkillCreator.cs 6b90cd32dea619058e1cf942bdd288981495f7711a76bff8ccc9e2787e3f6439 0
6 Wizard.Battle/ActionProcessor.cs Wizard.Battle/ActionProcessor.cs 7c8b40454a4948dd48a58c0efc240703eab9a77aea0add64e542f6b06c7323af 0

2
SVSim.BattleEngine/Engine/.gitattributes vendored Normal file
View File

@@ -0,0 +1,2 @@
# Verbatim engine copies: never normalize line endings (keeps sha256 manifest valid).
*.cs -text

3876
SVSim.BattleEngine/Engine/BattleCardBase.cs Normal file
View File

File diff suppressed because it is too large Load Diff

2443
SVSim.BattleEngine/Engine/BattleManagerBase.cs Normal file
View File

File diff suppressed because it is too large Load Diff

4574
SVSim.BattleEngine/Engine/BattlePlayerBase.cs Normal file
View File

File diff suppressed because it is too large Load Diff

2227
SVSim.BattleEngine/Engine/SkillCreator.cs Normal file
View File

File diff suppressed because it is too large Load Diff

897
SVSim.BattleEngine/Engine/Wizard.Battle/ActionProcessor.cs Normal file
View File

@@ -0,0 +1,897 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Cute;
using UnityEngine;
using Wizard.Battle.Resource;
using Wizard.Battle.UI;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle;
public class ActionProcessor
{
private readonly BattlePlayerPair _pair;
public Action OnPlayComplete;
public Action OnEvolutionComplete;
public Action OnAttackComplete;
public Action OnFusionComplete;
public Action<BattleCardBase, BattleCardBase, int, int> OnAttackDamageComplete;
public Action<BattleCardBase> OnAttackProcessComplete;
public Action<BattleCardBase, BattleCardBase> OnAttackStart;
private const float ADMIN_WATCH_CARD_ROTATION_Y = 180f;
public const float ACCELERATE_WAITTIME = 0.4f;
public const float CRYSTALLIZE_WAITTIME_BEFORE = 0.2f;
public const float CRYSTALLIZE_WAITTIME_AFTER = 0.3f;
public static readonly Vector3 ACCELERATE_POSITION_OFFSET = new Vector3(0f, 0f, -0.03f);
public event Action<BattleCardBase, BattleCardBase, IEnumerable<BattleCardBase>> OnBeforePlayCard;
public event Action<BattleCardBase, BattleCardBase, List<int>> OnBeforeChosenPlayCard;
public event Action<BattleCardBase, IEnumerable<BattleCardBase>, bool> OnBeforeBurialRitePlayCard;
public event Func<BattleCardBase, VfxBase> OnAfterPlayCard;
public event Func<VfxBase> OnBeforeAttack;
public event Func<VfxBase> OnBeforeAttackSkillComplete;
public event Func<BattleCardBase, BattleCardBase, bool, VfxBase> OnAfterAttack;
public event Action<BattleCardBase, BattleCardBase, IEnumerable<BattleCardBase>> OnBeforeEvolution;
public event Action<BattleCardBase, BattleCardBase, List<int>> OnBeforeChosenEvolution;
public event Action<BattleCardBase> OnJustBeforeEvolution;
public event Action<BattleCardBase> OnRightAfterEvolution;
public event Func<BattleCardBase, VfxBase> OnAfterEvolution;
public event Action<BattleCardBase, IEnumerable<BattleCardBase>> OnBeforeFusion;
public event Func<BattleCardBase, VfxBase> OnAfterFusion;
public event Action<BattleCardBase, int, bool> OnTransform;
public event Action<SkillBase> OnSpecialAccelerate;
public ActionProcessor(BattlePlayerPair pair)
{
_pair = pair;
}
private void GetSelectTargetBySelectList(SkillBase selectSkill, List<BattleCardBase> selectList, List<SkillConditionCheckerOption.SkillAndSelectTarget> selectTargets, ref int skillIndex)
{
BattlePlayerPair playerInfoPair = new BattlePlayerPair(selectSkill.SkillPrm.ownerCard.SelfBattlePlayer, selectSkill.SkillPrm.ownerCard.OpponentBattlePlayer);
SkillConditionCheckerOption option = new SkillConditionCheckerOption();
int skillSelectCount = selectSkill.GetSkillSelectCount();
int num = 1;
if (skillSelectCount >= 2)
{
NetworkBattleManagerBase networkBattleManagerBase = selectSkill.SkillPrm.selfBattlePlayer.BattleMgr as NetworkBattleManagerBase;
num = ((selectSkill.SkillPrm.selfBattlePlayer.IsPlayer || networkBattleManagerBase == null || GameMgr.GetIns().IsAdminWatch || !RegisterValidate.IsValidateCard(selectSkill)) ? Math.Min(skillSelectCount, selectSkill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: true).Count()) : (from n in networkBattleManagerBase.GetValidateTargetSkillIndexList()
where n == NetworkBattleGenericTool.GetSkillIndex(selectSkill)
select n).Count());
}
for (int num2 = 0; num2 < num; num2++)
{
if (skillIndex >= selectList.Count)
{
break;
}
selectTargets.Add(new SkillConditionCheckerOption.SkillAndSelectTarget(selectList[skillIndex], selectSkill));
skillIndex++;
}
}
private VfxBase SetSkillConditionCheckeroptionSelectCards(BattleCardBase card, SkillConditionCheckerOption option, IEnumerable<BattleCardBase> cards, bool isEvolve, List<int> selectChoiceCardIdList, bool isFusion = false, bool isChoiceBrave = false)
{
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
SkillCollectionBase skillCollectionBase = (isEvolve ? card.EvolutionSkills : card.Skills);
bool isChoiceTransform = false;
List<BattleCardBase> list = null;
if (cards != null)
{
list = cards.ToList();
}
if (!isFusion && skillCollectionBase.Any((SkillBase s) => s is Skill_transform))
{
BattlePlayerReadOnlyInfoPair playerInfoPair = new BattlePlayerReadOnlyInfoPair(card.SelfBattlePlayer, card.OpponentBattlePlayer);
CardMaster instanceForBattle = CardMaster.GetInstanceForBattle();
for (int num = 1; num < skillCollectionBase.Count(); num++)
{
if (skillCollectionBase.Get(num) is Skill_transform skill_transform)
{
Skill_pp_fixeduse skill_pp_fixeduse = skillCollectionBase.Get(num - 1) as Skill_pp_fixeduse;
if (false || (skill_transform.TransformId != -1 && skill_pp_fixeduse != null && skill_pp_fixeduse.IsMutationFixedUseCost && skill_pp_fixeduse.CheckCondition(playerInfoPair, option, isPrePlay: true) && card.GetAccelerateOrCrystallizeTransformSkill() != null))
{
BattleCardBase.TransformType transformType = ((skill_transform.OnWhenAccelerate != 0) ? BattleCardBase.TransformType.Accelerate : BattleCardBase.TransformType.Crystallize);
sequentialVfxPlayer.Register(SwapTransformCard(card, card.BaseParameter.IsFoil ? instanceForBattle.GetCardParameterFromId(skill_transform.TransformId).FoilCardId : skill_transform.TransformId, option, transformType, selectChoiceCardIdList, list));
this.OnSpecialAccelerate.Call(skill_pp_fixeduse);
this.OnSpecialAccelerate.Call(skill_transform);
}
if (skillCollectionBase.Get(num - 1) is Skill_choice skill_choice && skill_choice.CheckCondition(playerInfoPair, option, isPrePlay: true))
{
isChoiceTransform = true;
}
}
}
}
if (cards == null && selectChoiceCardIdList == null)
{
return sequentialVfxPlayer;
}
SkillBase skillBase = card.GetSelectTypeSkill(isEvolve, isFusion: false, isRegister: false, isEvolutionSimpleProcessor: false, isChoiceCheck: true).FirstOrDefault((SkillBase s) => s is Skill_choice);
int num2 = 1;
if (skillBase != null)
{
num2 = SetupChoiceCard(card, option, selectChoiceCardIdList, skillBase, list, isChoiceTransform, sequentialVfxPlayer, isChoiceBrave);
}
if (list != null && list.Count > 0)
{
BattleCardBase battleCardBase = card;
if (option.PlayedCard != null && card != option.PlayedCard)
{
battleCardBase = option.PlayedCard;
}
IEnumerable<SkillBase> selectTypeSkill = battleCardBase.GetSelectTypeSkill(isEvolve, isFusion: false, isRegister: true);
int num3 = selectTypeSkill.Where((SkillBase s) => s.IsBurialRite).Count();
List<SkillBase> list2 = selectTypeSkill.Where((SkillBase s) => !(s is Skill_none)).ToList();
int skillIndex = num3;
for (int num4 = 0; num4 < list2.Count; num4++)
{
if (list2[num4].IsChoiceType)
{
num4 += num2 - 1;
}
else if (list2[num4].IsBurialRite)
{
if (list2[num4].IsUserSelectType)
{
GetSelectTargetBySelectList(list2[num4], list, option.SelectedCards, ref skillIndex);
}
}
else
{
GetSelectTargetBySelectList(list2[num4], list, option.SelectedCards, ref skillIndex);
}
}
for (int num5 = 0; num5 < num3; num5++)
{
option.BurialRiteCards.Add(list[num5]);
}
if (num3 > 0)
{
card.SkillApplyInformation.ClearLastBurialRiteCardList();
card.SkillApplyInformation.AddLastBurialRiteCardList(list);
}
}
return sequentialVfxPlayer;
}
private int SetupChoiceCard(BattleCardBase card, SkillConditionCheckerOption option, List<int> selectChoiceCardIdList, SkillBase selectChoiceSkill, List<BattleCardBase> selectList, bool isChoiceTransform, SequentialVfxPlayer vfx, bool isChoiceBrave)
{
int num = 1;
if (option.PlayedCard == null)
{
option.PlayedCard = card;
}
int num2 = -1;
if (selectChoiceSkill.ApplySelectFilter is SkillChoiceSelectFilter)
{
num = ((SkillChoiceSelectFilter)selectChoiceSkill.ApplySelectFilter).CalcCount(selectChoiceSkill.OptionValue);
}
if (selectChoiceCardIdList != null && selectChoiceCardIdList.Count >= 1)
{
foreach (int selectChoiceCardId in selectChoiceCardIdList)
{
num2 = selectChoiceCardId;
option.ChosenCards.Add(num2);
}
}
else if (selectList != null && selectList.Count > 0)
{
for (int i = 0; i < num; i++)
{
BattleCardBase battleCardBase = selectList[i];
num2 = battleCardBase.BaseParameter.CardId;
option.ChosenCards.Add(num2);
if (isChoiceTransform || isChoiceBrave)
{
selectList.Remove(battleCardBase);
}
}
}
if (num2 >= 0 && isChoiceTransform)
{
vfx.Register(SwapTransformCard(card, num2, option, BattleCardBase.TransformType.Choice, selectChoiceCardIdList, selectList));
}
return num;
}
private VfxBase SwapTransformCard(BattleCardBase originalCard, int transformCardID, SkillConditionCheckerOption option, BattleCardBase.TransformType transformType, List<int> selectChoiceCardIdList, List<BattleCardBase> selectList)
{
bool isMutation = transformType == BattleCardBase.TransformType.Accelerate || transformType == BattleCardBase.TransformType.Crystallize;
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
SequentialVfxPlayer sequentialVfxPlayer2 = SequentialVfxPlayer.Create();
BattleCardBase transformCard = originalCard.SelfBattlePlayer.CreateCard(transformCardID, originalCard.Index);
transformCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate
{
transformCard.BattleCardView.GameObject.SetActive(value: false);
}));
sequentialVfxPlayer2.Register(InstantVfx.Create(delegate
{
if (!BattleManagerBase.GetIns().IsRecovery)
{
Transform transform = transformCard.BattleCardView.Transform;
Transform transform2 = originalCard.BattleCardView.Transform;
transform.position = transform2.position;
transform.rotation = transform2.rotation;
if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle)
{
transform.parent = originalCard.SelfBattlePlayer.BattleView.HandDeck.transform;
}
else
{
transform.parent = transform2.parent;
}
transform.localScale = transform2.localScale;
transform.SetSiblingIndex(transform2.GetSiblingIndex());
if (!isMutation)
{
transformCard.BattleCardView.CardTemplate.DynamicSetupMaterials(transformCard, BattleManagerBase.GetIns().BattleResourceMgr);
originalCard.BattleCardView.GameObject.SetActive(value: false);
transformCard.BattleCardView.GameObject.SetActive(value: true);
}
}
}));
if (isMutation)
{
sequentialVfxPlayer.Register(sequentialVfxPlayer2);
}
else
{
transformCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(sequentialVfxPlayer2);
}
transformCard.SetOnDraw(draw: false);
originalCard.MetamorphoseCard = transformCard;
transformCard.TransformInfo = new BattleCardBase.TransformInformation(transformType, originalCard);
option.PlayedCard = transformCard;
option.SummonedCard = transformCard;
SkillBase skillBase = transformCard.GetSelectTypeSkill().FirstOrDefault((SkillBase s) => s is Skill_choice);
if (skillBase != null)
{
SetupChoiceCard(transformCard, option, selectChoiceCardIdList, skillBase, selectList, isChoiceTransform: false, sequentialVfxPlayer, isChoiceBrave: false);
}
this.OnTransform.Call(originalCard, transformCardID, !isMutation);
return sequentialVfxPlayer;
}
private VfxBase SetupPlayCard(BattleCardBase originalCard, BattleCardBase playCard, SkillProcessor skillProcessor, bool isChoiceBrave)
{
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
bool isMutation = originalCard.CheckConditionFixedUseCost(isPrePlay: true) && originalCard.CalcFixedUseCost(originalCard.SelfBattlePlayer.Pp) < originalCard.Cost;
GameMgr gameMgr = GameMgr.GetIns();
bool isAdminWatch = gameMgr.IsAdminWatch;
BattleManagerBase battleMgr = BattleManagerBase.GetIns();
if (!isChoiceBrave)
{
sequentialVfxPlayer.Register(playCard.SelfBattlePlayer.ReplaceInHand(originalCard, playCard, skillProcessor));
}
if (isMutation)
{
sequentialVfxPlayer.Register(battleMgr.LoadCardResources(new List<BattleCardBase> { playCard }));
}
if (!battleMgr.IsRecovery)
{
playCard.SelfBattlePlayer.BattleMgr.VfxMgr.RegisterImmediateVfx(InstantVfx.Create(delegate
{
originalCard.SelfBattlePlayer.BattleView.HandView.RemoveCardFromView(originalCard.BattleCardView, 0.3f);
}));
}
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
if (!battleMgr.IsRecovery)
{
playCard.SelfBattlePlayer.BattleView.PlayQueueView.RemoveCardFromView(originalCard.BattleCardView, (isAdminWatch && isMutation) || isChoiceBrave);
if (isMutation)
{
playCard.BattleCardView.CardTemplate.DynamicSetupMaterials(playCard, battleMgr.BattleResourceMgr);
}
}
}));
if (!isMutation)
{
sequentialVfxPlayer.Register(battleMgr.OperateMgr.InitSetCard(playCard, playCard.SelfBattlePlayer.IsPlayer, isSelect: false, isRecovery: false, isChoiceSelect: true, isAccelerateSelect: false, registerDirectlyToVfxManager: true, isFusionWait: false, isChoiceBrave));
}
else
{
bool isChoice = playCard.GetSelectTypeSkill().Any((SkillBase s) => s is Skill_choice);
sequentialVfxPlayer.Register(playCard.SelfBattlePlayer.BattleView.PlayQueueView.InstantAddCardToViewVfx(playCard.BattleCardView, forceCardIntoPlayQueue: false, isChoice));
if (isMutation)
{
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
Vector3 position = originalCard.BattleCardView.GameObject.transform.position;
position += ACCELERATE_POSITION_OFFSET;
Quaternion rot = originalCard.BattleCardView.GameObject.transform.rotation;
if (!playCard.IsSpell && playCard.SelfBattlePlayer.BattleView.PlayQueueView.IsCardInQueue(playCard.BattleCardView))
{
Vector3 localEulerAngles = originalCard.BattleCardView.GameObject.transform.localEulerAngles;
rot = Quaternion.Euler(localEulerAngles.x, 0f, localEulerAngles.z);
}
gameMgr.GetEffectMgr().Start(playCard.IsSpell ? EffectMgr.EffectType.CMN_CARD_ACCELERATE_1 : EffectMgr.EffectType.CMN_CARD_CRYSTALLIZE_1, playCard.IsSpell ? position : originalCard.BattleCardView.GameObject.transform.position, rot, 31);
}));
sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0.2f));
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
CardTemplate cardTemplate = originalCard.BattleCardView.CardTemplate;
cardTemplate.SetEffectStyle(UILabel.Effect.None);
if (originalCard is UnitBattleCard)
{
cardTemplate.NormalAtkLabelTemp.effectStyle = UILabel.Effect.None;
cardTemplate.NormalLifeLabelTemp.effectStyle = UILabel.Effect.None;
}
}));
sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0f));
}
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
if (!battleMgr.IsRecovery && isMutation)
{
Transform transform = playCard.BattleCardView.Transform;
Transform transform2 = originalCard.BattleCardView.Transform;
if (playCard.IsSpell || playCard.SelfBattlePlayer.BattleView.PlayQueueView.IsCardInQueue(playCard.BattleCardView))
{
MotionUtils.SetLayerAll(playCard.BattleCardView.CardWrapObject, 31);
playCard.BattleCardView.Transform.SetParent(battleMgr.CutInContainer.transform, worldPositionStays: false);
}
if (playCard.IsSpell)
{
transform.position = transform2.position;
transform.localScale = transform2.localScale;
originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform);
originalCard.BattleCardView.GameObject.SetActive(value: false);
playCard.BattleCardView.GameObject.SetActive(value: true);
playCard.BattleCardView.ShowInHandFrameEffect(enable: true, HandCardFrameEffectType.LIGHT_BLUE);
originalCard.BattleCardView.CardTemplate.SetEffectStyle(UILabel.Effect.None);
}
else
{
transform.position = transform2.position;
transform.localScale = transform2.localScale;
originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform);
originalCard.BattleCardView.GameObject.SetActive(value: false);
playCard.BattleCardView.GameObject.SetActive(value: true);
originalCard.BattleCardView.Transform.SetParent(originalCard.SelfBattlePlayer.BattleView.BanishParent.transform);
}
}
}));
if (isMutation)
{
sequentialVfxPlayer.Register(WaitVfx.Create(playCard.IsSpell ? 0.2f : 0.3f));
if (!playCard.IsSpell)
{
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
originalCard.BattleCardView.GameObject.SetActive(value: false);
MotionUtils.SetLayerAll(playCard.BattleCardView.CardWrapObject, 10);
}));
}
}
}
return sequentialVfxPlayer;
}
public VfxBase PlayCard(BattleCardBase card, IEnumerable<BattleCardBase> selectedCards, List<int> selectChoiceId = null, bool isChoiceBrave = false)
{
if (selectedCards != null)
{
foreach (BattleCardBase selectedCard in selectedCards)
{
selectedCard.SelfBattlePlayer.AddLastTargetCardsList(selectedCard);
}
}
SetIndividualId(card.NormalSkills);
if (card.NormalSkills.Any((SkillBase s) => s.HasIndividualId))
{
card.SelfBattlePlayer.BattleMgr.IncrementIndividualId();
}
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
SkillProcessor skillProcessor = new SkillProcessor();
BattleCardBase battleCardBase = card;
SkillConditionCheckerOption skillConditionCheckerOption = new SkillConditionCheckerOption();
skillConditionCheckerOption.PlayedCard = card;
skillConditionCheckerOption.SummonedCard = card;
if (isChoiceBrave)
{
card.SelfBattlePlayer.IsAlreadyChoiceBraveInThisTurn = true;
card.SelfBattlePlayer.BattleView.UpdateChoiceBraveButtonPulsateEffectAndSprite();
card.SelfBattlePlayer.BattleView.UpdateChoiceBraveActivatingEffect(isActivating: false);
int cardId = ((selectChoiceId != null && selectChoiceId.Count > 0) ? selectChoiceId[0] : selectedCards.First().CardId);
BattleCardBase selectSkillCard = (CardMaster.IsChoiceBraveCardCheck(card.CardId) ? card : ((selectedCards != null && selectedCards.Count() > 1 && (card.IsPlayer || GameMgr.GetIns().IsAdminWatch)) ? selectedCards.First() : null));
skillConditionCheckerOption.PlayedCard = card.SelfBattlePlayer.BattleMgr.ReplaceChoiceBraveCard(card, cardId, selectSkillCard);
}
sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(card, skillConditionCheckerOption, selectedCards, isEvolve: false, selectChoiceId, isFusion: false, isChoiceBrave));
if (battleCardBase != skillConditionCheckerOption.PlayedCard)
{
if (battleCardBase.SkillApplyInformation.SkillRandomArray == null)
{
skillConditionCheckerOption.PlayedCard.SkillApplyInformation.GiveSkillRandomArray(battleCardBase.SkillApplyInformation.SkillRandomArray);
}
battleCardBase = skillConditionCheckerOption.PlayedCard;
sequentialVfxPlayer.Register(SetupPlayCard(card, battleCardBase, skillProcessor, isChoiceBrave));
BattleManagerBase.GetIns().PSideLogControl.RemoveAllLog();
}
battleCardBase.SetPlayedTurnNow();
int count = skillConditionCheckerOption.ChosenCards.Count;
int num = selectedCards?.Count() ?? 0;
if (count > 0 && num - count < 0)
{
List<BattleCardBase> list = ((selectedCards != null) ? selectedCards.ToList() : new List<BattleCardBase>());
foreach (int chosenCard in skillConditionCheckerOption.ChosenCards)
{
BattleCardBase item = BattleManagerBase.GetIns().CreateTransformCardRegisterVfx(skillConditionCheckerOption.PlayedCard, chosenCard, skillConditionCheckerOption.PlayedCard.IsPlayer);
list.Insert(0, item);
}
selectedCards = list;
}
this.OnBeforePlayCard.Call(card, battleCardBase, selectedCards);
this.OnBeforeChosenPlayCard.Call(card, battleCardBase, skillConditionCheckerOption.ChosenCards);
if (skillConditionCheckerOption.BurialRiteCards != null && skillConditionCheckerOption.BurialRiteCards.Count > 0)
{
this.OnBeforeBurialRitePlayCard.Call(battleCardBase, selectedCards, arg3: false);
}
bool isEnhance = battleCardBase.CheckConditionFixedUseCost(isPrePlay: true);
VfxWith<SkillProcessor.ProcessInfo> vfxWith = card.PlayChoiceCard(skillProcessor, skillConditionCheckerOption);
VfxWith<SkillProcessor.ProcessInfo> vfxWith2 = battleCardBase.PlayCard(skillProcessor, skillConditionCheckerOption, isInplayGeneration: false, card);
VfxBase vfx = battleCardBase.SelfBattlePlayer.StartSkillWhenChangeInplay(null, new List<BattleCardBase> { battleCardBase }, skillProcessor);
skillProcessor.Register(vfxWith.Value);
skillProcessor.Register(vfxWith2.Value);
VfxBase vfx2 = _pair.Self.StartSkillWhenPlayOtherEnhanceAndAccelerateAndCrystallize(battleCardBase, isEnhance, skillProcessor);
VfxBase vfx3 = _pair.Self.StartSkillWhenSummonOther(battleCardBase, skillProcessor);
VfxBase vfx4 = skillProcessor.Process(_pair);
if (card != battleCardBase && card.Skills.HaveBeforeChoiceSkill())
{
BattleLogManager.GetInstance().AddLogPlayAsChoiceTransform(battleCardBase);
}
VfxBase vfxBase = battleCardBase.FinishWhenPlaySkill();
VfxBase allFuncVfxResults = this.OnAfterPlayCard.GetAllFuncVfxResults(battleCardBase);
BattleUIContainer battleUIContainer = BattleManagerBase.GetIns().BattleUIContainer;
bool isSelfTurn = BattleManagerBase.GetIns().BattlePlayer.IsSelfTurn;
if (isSelfTurn)
{
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
battleUIContainer.PlayerCardPlaying = true;
if (battleUIContainer.IsEnableMenu())
{
battleUIContainer.DisableMenu();
}
}));
}
sequentialVfxPlayer.Register(vfxWith2.Vfx);
sequentialVfxPlayer.Register(vfx);
sequentialVfxPlayer.Register(battleCardBase.StopSpellCharge());
sequentialVfxPlayer.Register(vfx2);
sequentialVfxPlayer.Register(vfx3);
sequentialVfxPlayer.Register(vfx4);
if (vfxBase != null)
{
sequentialVfxPlayer.Register(vfxBase);
}
if (allFuncVfxResults.IsVfxNonEmpty())
{
sequentialVfxPlayer.Register(allFuncVfxResults);
}
Action handleBattleMenu = delegate
{
};
if (isSelfTurn)
{
handleBattleMenu = delegate
{
battleUIContainer.PlayerCardPlaying = false;
if (BattleManagerBase.GetIns().BattlePlayer.BattleView.PlayQueueView.QueueCount() == 0 && !battleUIContainer.IsEnableMenu())
{
battleUIContainer.RequestEnableMenuWhenTouchable();
}
};
}
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
BattlePlayer battlePlayer = BattleManagerBase.GetIns().BattlePlayer;
handleBattleMenu();
int num2 = battlePlayer.BattleView.PlayQueueView.QueueCount();
bool isSelecting = battlePlayer.BattleView.IsSelecting;
if (num2 == 0 && !isSelecting && !battlePlayer.IsDuringChoiceBrave)
{
battlePlayer.BattleView.ClearSelectCardList();
}
}));
OnPlayComplete.Call();
return sequentialVfxPlayer;
}
private void SetIndividualId(SkillCollectionBase skills)
{
for (int i = 0; i < skills.Count(); i++)
{
skills.ElementAt(i).InitSetIndividualId();
}
}
public VfxBase Attack(IBattleCardUniqueID attackCardId, IBattleCardUniqueID targetCardId)
{
BattleCardBase attackCard = _pair.Self.InPlayCards.SingleOrDefault((BattleCardBase c) => c.EquelsID(attackCardId));
IfNullCardThenException(attackCard, attackCardId, "場");
if (attackCard.SkillApplyInformation.IsQuick)
{
attackCard.SelfBattlePlayer.GameQuickAttackCards.Add(attackCard);
}
BattleCardBase battleCardBase = ((targetCardId.IsPlayer == _pair.Self.IsPlayer) ? _pair.Self.ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c.EquelsID(targetCardId)) : _pair.Opponent.ClassAndInPlayCardList.SingleOrDefault((BattleCardBase c) => c.EquelsID(targetCardId)));
IfNullCardThenException(battleCardBase, targetCardId, "場");
attackCard.BattleCardView._inPlayFrameEffect.HideFrameEffect();
OnAttackStart.Call(attackCard, battleCardBase);
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
SkillProcessor skillProcessor = new SkillProcessor();
SkillCollectionBase skills = attackCard.Skills;
foreach (SkillBase item in skills)
{
if (item.IsBeforAttackSkill)
{
VfxWith<SkillProcessor.ProcessInfo> vfxWith = skills.CreateBeforeAttackInfo(item, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer));
skillProcessor.Register(vfxWith.Value);
sequentialVfxPlayer.Register(vfxWith.Vfx);
if (vfxWith.Value != null)
{
attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard);
}
}
if (item.IsWhenFightSkill)
{
VfxWith<SkillProcessor.ProcessInfo> vfxWith2 = skills.CreateBeforeFightInfo(item, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer));
skillProcessor.Register(vfxWith2.Value);
sequentialVfxPlayer.Register(vfxWith2.Vfx);
if (vfxWith2.Value != null)
{
attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard);
}
}
}
SkillCollectionBase skills2 = battleCardBase.Skills;
foreach (SkillBase item2 in skills2)
{
if (item2.IsWhenFightSkill)
{
VfxWith<SkillProcessor.ProcessInfo> vfxWith3 = skills2.CreateBeforeFightInfo(item2, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer));
skillProcessor.Register(vfxWith3.Value);
sequentialVfxPlayer.Register(vfxWith3.Vfx);
if (vfxWith3.Value != null)
{
attackCard.SelfBattlePlayer.PredictionWarningCards.Add(attackCard);
}
}
}
foreach (BattleCardBase item3 in from c in _pair.Self.ClassAndInPlayCardList.Concat(_pair.Opponent.ClassAndInPlayCardList)
where c.Skills._skillTimingInfo.IsBeforeAttackSelfAndOther
select c)
{
SkillCollectionBase skills3 = item3.Skills;
foreach (SkillBase item4 in skills3)
{
if (item4.IsBeforeAttackSelfAndOtherSkill)
{
VfxWith<SkillProcessor.ProcessInfo> vfxWith4 = skills3.CreateBeforeAttackSelfAndOtherInfo(item4, attackCard, battleCardBase, skillProcessor, new BattlePlayerPair(item3.SelfBattlePlayer, item3.OpponentBattlePlayer));
skillProcessor.Register(vfxWith4.Value);
sequentialVfxPlayer.Register(vfxWith4.Vfx);
if (vfxWith4.Value != null)
{
item3.SelfBattlePlayer.PredictionWarningCards.Add(item3);
}
}
}
}
VfxBase allFuncVfxResults = this.OnBeforeAttack.GetAllFuncVfxResults();
sequentialVfxPlayer.Register(allFuncVfxResults);
sequentialVfxPlayer.Register(attackCard.SelfBattlePlayer.BattleView.PrepareCardsForAttackSequenceVfx(attackCard.BattleCardView, battleCardBase.BattleCardView));
VfxBase vfx = skillProcessor.Process(_pair);
sequentialVfxPlayer.Register(vfx);
VfxBase allFuncVfxResults2 = this.OnBeforeAttackSkillComplete.GetAllFuncVfxResults();
sequentialVfxPlayer.Register(allFuncVfxResults2);
BattleCardBase battleCardBase2 = (attackCard.IsDead ? null : attackCard.GetDamageReflectionTarget(isSkillDamage: false));
int damage = battleCardBase.DamageCalculationAtkTypeBeAttacked.Damage;
int num = attackCard.CalculateFinalDamageAmount(damage);
BattleCardBase battleCardBase3 = (battleCardBase.IsDead ? null : battleCardBase.GetDamageReflectionTarget(isSkillDamage: false));
int damage2 = attackCard.DamageCalculationAtkTypeAttack.Damage;
int num2 = battleCardBase.CalculateFinalDamageAmount(damage2);
OnAttackDamageComplete.Call(attackCard, battleCardBase, num2, num);
bool flag = !attackCard.IsDead && !battleCardBase.IsDead && !attackCard.SelfBattlePlayer.Class.IsDead && !battleCardBase.SelfBattlePlayer.Class.IsDead && attackCard.IsInplay && battleCardBase.IsInplay;
if (flag)
{
VfxBase vfx2 = attackCard.StartAttack(battleCardBase, _pair);
sequentialVfxPlayer.Register(vfx2);
}
else
{
if (attackCard.SkillApplyInformation.IsSneak)
{
sequentialVfxPlayer.Register(attackCard.SkillApplyInformation.FourceDepriveSneak());
}
attackCard.AttackableCount--;
if (!attackCard.Attackable)
{
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
attackCard.BattleCardView._inPlayFrameEffect.HideFrameEffect();
}));
}
AttackSelectControl attackSelectControl = attackCard.SelfBattlePlayer.BattleView.AttackSelectControl;
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
if (!attackCard.IsDead && attackCard.IsInplay)
{
IBattleCardView battleCardView = attackCard.BattleCardView;
parallelVfxPlayer.Register(attackSelectControl.ResetCardAfterAttack(battleCardView));
}
if (!battleCardBase.IsDead && battleCardBase.IsInplay)
{
IBattleCardView battleCardView2 = battleCardBase.BattleCardView;
parallelVfxPlayer.Register(attackSelectControl.ResetCardAfterAttack(battleCardView2));
}
sequentialVfxPlayer.Register(parallelVfxPlayer);
}
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
{
attackCard.BattleCardView._inPlayFrameEffect.UpdateCanAttackEffect();
}));
if (GameMgr.GetIns().IsWatchBattle || GameMgr.GetIns().IsReplayBattle)
{
bool num3 = attackCard.SelfBattlePlayer.BattleMgr.DetailMgr.DetailPanelControl.IsShow && attackCard.SelfBattlePlayer.BattleMgr.DetailMgr.DetailPanelControl._card == attackCard;
bool flag2 = attackCard.SelfBattlePlayer.IsSelfTurn && attackCard.IsPlayer && attackCard.IsInplay && attackCard.AttackableCount <= 0;
if (num3 && flag2)
{
sequentialVfxPlayer.Register(attackCard.BattleCardView.ShowAttackFinished());
}
}
OnAttackProcessComplete.Call(attackCard);
if (flag)
{
SkillProcessor skillProcessor2 = new SkillProcessor();
attackCard.SelfBattlePlayer.StartSkillWhenDamageSelfAndOther(null, (battleCardBase3 != null) ? new List<BattleCardBase> { battleCardBase3 } : null, skillProcessor2, damage2, num2);
if (battleCardBase is UnitBattleCard)
{
attackCard.SelfBattlePlayer.StartSkillWhenDamageSelfAndOther(null, (battleCardBase2 != null) ? new List<BattleCardBase> { battleCardBase2 } : null, skillProcessor2, damage, num);
}
for (int num4 = 0; num4 < attackCard.Skills.Count(); num4++)
{
SkillBase skillBase = attackCard.Skills.ElementAt(num4);
if (skillBase.OnAfterAttackStart != 0)
{
SkillProcessor.ProcessInfo info = attackCard.Skills.CreateAfterAttackInfo(skillBase, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer));
skillProcessor2.Register(info);
}
if (skillBase.OnAfterFightStart != 0)
{
SkillProcessor.ProcessInfo info2 = attackCard.Skills.CreateAfterFightInfo(skillBase, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(attackCard.SelfBattlePlayer, attackCard.OpponentBattlePlayer));
skillProcessor2.Register(info2);
}
}
for (int num5 = 0; num5 < battleCardBase.Skills.Count(); num5++)
{
SkillBase skillBase2 = battleCardBase.Skills.ElementAt(num5);
if (skillBase2.OnAfterFightStart != 0)
{
SkillProcessor.ProcessInfo info3 = battleCardBase.Skills.CreateAfterFightInfo(skillBase2, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer));
skillProcessor2.Register(info3);
}
}
foreach (BattleCardBase item5 in from c in _pair.Self.ClassAndInPlayCardList.Concat(_pair.Opponent.ClassAndInPlayCardList)
where c.Skills._skillTimingInfo.IsAfterAttackSelfAndOther
select c)
{
SkillCollectionBase skills4 = item5.Skills;
foreach (SkillBase item6 in skills4)
{
if (item6.IsAfterAttackSelfAndOtherSkill)
{
VfxWith<SkillProcessor.ProcessInfo> vfxWith5 = skills4.CreateAfterAttackSelfAndOtherInfo(item6, attackCard, battleCardBase, skillProcessor2, new BattlePlayerPair(item5.SelfBattlePlayer, item5.OpponentBattlePlayer));
skillProcessor2.Register(vfxWith5.Value);
sequentialVfxPlayer.Register(vfxWith5.Vfx);
if (vfxWith5.Value != null)
{
item5.SelfBattlePlayer.PredictionWarningCards.Add(item5);
}
}
}
}
VfxBase vfx3 = skillProcessor2.Process(_pair);
sequentialVfxPlayer.Register(vfx3);
}
VfxBase allFuncVfxResults3 = this.OnAfterAttack.GetAllFuncVfxResults(attackCard, battleCardBase, flag);
sequentialVfxPlayer.Register(allFuncVfxResults3);
OnAttackComplete.Call();
return sequentialVfxPlayer;
}
public VfxBase Evolve(IBattleCardUniqueID cardId, Func<IEnumerable<BattleCardBase>, SkillBase, Func<IEnumerable<BattleCardBase>, VfxBase>, VfxBase> selectSkillTargetCards)
{
BattleCardBase card = _pair.Self.InPlayCards.SingleOrDefault((BattleCardBase c) => c.EquelsID(cardId));
IfNullCardThenException(card, cardId, "場");
return CallCardSkill(card.EvolutionSkills, (IEnumerable<BattleCardBase> selectedCards) => Evolution(card, selectedCards), selectSkillTargetCards);
}
public VfxBase Evolution(BattleCardBase card, IEnumerable<BattleCardBase> selectedCards, List<int> selectChoiceId = null)
{
BattleCardBase battleCardBase = card;
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
if (BattleManagerBase.GetIns().BattlePlayer.Class.IsDead || BattleManagerBase.GetIns().BattleEnemy.Class.IsDead || card.IsEvolution || !card.SelfBattlePlayer.IsSelfTurn)
{
return NullVfx.GetInstance();
}
SkillConditionCheckerOption option = new SkillConditionCheckerOption();
sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(card, option, selectedCards, isEvolve: true, selectChoiceId));
SkillProcessor skillProcessor = new SkillProcessor();
if (option.PlayedCard != null && card.EvolutionSkills.Any((SkillBase s) => s is Skill_transform))
{
battleCardBase = option.PlayedCard;
sequentialVfxPlayer.Register(battleCardBase.SelfBattlePlayer.ReplaceInPlay(card, battleCardBase, skillProcessor));
sequentialVfxPlayer.Register(battleCardBase.SetUpInplay());
BattlePlayerPair playerInfoPair = new BattlePlayerPair(battleCardBase.SelfBattlePlayer, battleCardBase.OpponentBattlePlayer);
sequentialVfxPlayer.Register(battleCardBase.Skills.RegisterAndProcessWhenChangeInplayImmediateInfo(playerInfoPair));
battleCardBase.Skills.CreateAndRegisterWhenChangeInplayInfo(new List<BattleCardBase> { battleCardBase }, skillProcessor, playerInfoPair);
sequentialVfxPlayer.Register(card.RemoveFromInPlay());
}
BattlePlayerReadOnlyInfoPair pair = new BattlePlayerReadOnlyInfoPair(card.SelfBattlePlayer, card.OpponentBattlePlayer);
SkillBase skillBase = card.EvolutionSkills.FirstOrDefault((SkillBase s) => s.OnWhenEvolveBeforeStart != 0 && s is Skill_evolve_to_other && s.CheckCondition(pair, option, isPrePlay: true));
if (skillBase != null)
{
IBattleResourceMgr battleResourceMgr = card.SelfBattlePlayer.BattleMgr.BattleResourceMgr;
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
UnitBattleCardView unitBattleCardView = card.BattleCardView as UnitBattleCardView;
parallelVfxPlayer.Register(battleResourceMgr.DecrementEffectBattleRefCount(card.BaseParameter.AtkEffectParameter.GetEffectPath(isEvolve: false)));
parallelVfxPlayer.Register(battleResourceMgr.DecrementEffectBattleRefCount(card.BaseParameter.AtkEffectParameter.GetEffectPath(isEvolve: true)));
if (option.ChosenCards.Count > 0)
{
card.UpdateBuildInfoAndSkillCollection(option.ChosenCards[0], isFoil: false);
}
else
{
card.UpdateBuildInfoAndSkillCollection(skillBase.OptionValue.GetInt(SkillFilterCreator.ContentKeyword.card_id, -1), card.BaseParameter.IsFoil);
}
card.BattleCardView.InitializeVoiceInfo(card.CardId);
for (int num = 0; num < card.NormalSkills.Count(); num++)
{
card.NormalSkills.ElementAt(num).SetInductionVoiceIndex();
}
for (int num2 = 0; num2 < card.EvolutionSkills.Count(); num2++)
{
card.EvolutionSkills.ElementAt(num2).SetInductionVoiceIndex();
}
if (unitBattleCardView != null)
{
parallelVfxPlayer.Register(unitBattleCardView.LoadAttackEffect(card.BaseParameter.AtkEffectParameter, isEvolve: false));
parallelVfxPlayer.Register(unitBattleCardView.LoadAttackEffect(card.BaseParameter.AtkEffectParameter, isEvolve: true));
}
sequentialVfxPlayer.Register(parallelVfxPlayer);
}
if (option.ChosenCards.Count > 0 && selectedCards.Count() <= 0)
{
List<BattleCardBase> list = selectedCards.ToList();
foreach (int chosenCard in option.ChosenCards)
{
BattleCardBase item = BattleManagerBase.GetIns().CreateTransformCardRegisterVfx(card, chosenCard, option.PlayedCard.IsPlayer);
list.Add(item);
}
selectedCards = list;
}
SetIndividualId(card.EvolutionSkills);
if (card.EvolutionSkills.Any((SkillBase s) => s.HasIndividualId))
{
card.SelfBattlePlayer.BattleMgr.IncrementIndividualId();
}
this.OnBeforeEvolution.Call(card, battleCardBase, selectedCards);
this.OnBeforeChosenEvolution.Call(card, battleCardBase, option.ChosenCards);
if (option.BurialRiteCards != null && option.BurialRiteCards.Count > 0)
{
this.OnBeforeBurialRitePlayCard.Call(battleCardBase, selectedCards, arg3: true);
}
this.OnJustBeforeEvolution.Call(battleCardBase);
VfxBase vfx = battleCardBase.Evolution(isSkill: false, skillProcessor, option);
sequentialVfxPlayer.Register(vfx);
this.OnRightAfterEvolution.Call(battleCardBase);
VfxBase vfx2 = skillProcessor.Process(_pair);
sequentialVfxPlayer.Register(vfx2);
VfxBase allFuncVfxResults = this.OnAfterEvolution.GetAllFuncVfxResults(battleCardBase);
sequentialVfxPlayer.Register(allFuncVfxResults);
OnEvolutionComplete.Call();
return sequentialVfxPlayer;
}
public VfxBase Fusion(BattleCardBase fusionCard, List<BattleCardBase> selectedCards)
{
BattleManagerBase ins = BattleManagerBase.GetIns();
if (ins.BattlePlayer.Class.IsDead || ins.BattleEnemy.Class.IsDead || fusionCard.IsEvolution || !fusionCard.SelfBattlePlayer.IsSelfTurn)
{
return NullVfx.GetInstance();
}
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
SkillConditionCheckerOption option = new SkillConditionCheckerOption();
this.OnBeforeFusion.Call(fusionCard, selectedCards);
sequentialVfxPlayer.Register(SetSkillConditionCheckeroptionSelectCards(fusionCard, option, selectedCards, isEvolve: false, new List<int>(), isFusion: true));
sequentialVfxPlayer.Register(fusionCard.SelfBattlePlayer.CardManagement(fusionCard, new SkillProcessor(), BattlePlayerBase.CARD_MANAGEMENT.FUSION_MATERIAL, isRandom: false, selectedCards));
VfxBase allFuncVfxResults = this.OnAfterFusion.GetAllFuncVfxResults(fusionCard);
sequentialVfxPlayer.Register(allFuncVfxResults);
OnFusionComplete.Call();
return sequentialVfxPlayer;
}
private VfxBase CallCardSkill(SkillCollectionBase skills, Func<IEnumerable<BattleCardBase>, VfxBase> standardCall, Func<IEnumerable<BattleCardBase>, SkillBase, Func<IEnumerable<BattleCardBase>, VfxBase>, VfxBase> selectSkillTargetCards, bool isNotSelect = false)
{
SkillBase actSkill = null;
IEnumerable<BattleCardBase> skillUserSelectableTargets = GetSkillUserSelectableTargets(skills, _pair, ref actSkill);
if (isNotSelect || skillUserSelectableTargets == null)
{
return standardCall(null);
}
return selectSkillTargetCards(skillUserSelectableTargets, actSkill, standardCall);
}
private static void IfNullCardThenException(BattleCardBase card, IBattleCardUniqueID cardId, string positionName)
{
if (card == null)
{
throw new ArgumentException("カード " + cardId.GetName() + " は" + positionName + "に見つかりませんでした");
}
}
public static IEnumerable<BattleCardBase> GetSkillUserSelectableTargets(SkillBase skill, BattlePlayerReadOnlyInfoPair playerInfoPair, SkillConditionCheckerOption option = null, List<BattleCardBase> selectedCards = null)
{
if (skill == null || !skill.DoesSkillFulfillActivationConditions(playerInfoPair, ignoreHandSkill: true, isPrePlay: true))
{
return null;
}
if (option == null)
{
option = new SkillConditionCheckerOption();
}
IEnumerable<BattleCardBase> selectableCards = skill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: false, selectedCards);
if (!selectableCards.Any())
{
selectableCards = skill.GetSelectableCards(playerInfoPair, option, isSkipForceSelect: true, selectedCards);
}
if (!selectableCards.Any())
{
return null;
}
return selectableCards;
}
public static IEnumerable<BattleCardBase> GetSkillUserSelectableTargets(SkillCollectionBase skills, BattlePlayerReadOnlyInfoPair playerInfoPair, ref SkillBase actSkill)
{
IEnumerable<SkillBase> source = skills.Where(delegate(SkillBase s)
{
BattlePlayerReadOnlyInfoPair playerInfoPair2 = new BattlePlayerReadOnlyInfoPair(s.SkillPrm.ownerCard.SelfBattlePlayer, s.SkillPrm.ownerCard.OpponentBattlePlayer);
return s.IsUserSelectType && s.CheckCondition(playerInfoPair2, new SkillConditionCheckerOption(), isPrePlay: true);
});
if (source.Count() > 0)
{
actSkill = ((source.Count() > 1) ? source.ToList().Last() : source.ToList().First());
}
return GetSkillUserSelectableTargets(actSkill, playerInfoPair);
}
}

35
SVSim.BattleEngine/Shim/UnityEngine/Primitives.cs Normal file
View File

@@ -0,0 +1,35 @@
// AUTHORED SHIM (not copied). Minimal no-op UnityEngine surface. Grows via the
// Task 4 compile loop -- add only members the compiler actually demands.
namespace UnityEngine
{
public struct Vector2 { public float x, y; public Vector2(float x, float y){ this.x=x; this.y=y; } }
public struct Vector3
{
public float x, y, z;
public Vector3(float x, float y, float z){ this.x=x; this.y=y; this.z=z; }
public static Vector3 zero => new Vector3(0,0,0);
public static Vector3 operator +(Vector3 a, Vector3 b) => new Vector3(a.x+b.x, a.y+b.y, a.z+b.z);
}
public struct Quaternion
{
public float x, y, z, w;
public static Quaternion identity => new Quaternion();
public static Quaternion Euler(float x, float y, float z) => new Quaternion();
}
public struct Color { public float r, g, b, a; public Color(float r,float g,float b,float a){ this.r=r; this.g=g; this.b=b; this.a=a; } }
public static class Mathf
{
public const float PI = 3.14159265f;
public static float Floor(float f) => (float)System.Math.Floor(f);
public static int FloorToInt(float f) => (int)System.Math.Floor(f);
public static float Max(float a, float b) => System.Math.Max(a, b);
public static float Min(float a, float b) => System.Math.Min(a, b);
public static float Clamp(float v, float lo, float hi) => System.Math.Max(lo, System.Math.Min(hi, v));
}
public static class Debug
{
public static void Log(object m) { }
public static void LogWarning(object m) { }
public static void LogError(object m) { }
}
}