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

engine cleanup passes 4-7 + multi-instancing ambient rip

Browse Source 
Squashes 146 commits from battle-engine-extraction. Net: 2,045 files changed,
+11,896 / -158,687 lines. Ships engine passes 4-7 (dead-code cull, view-layer
stub, receive-path shrink) plus the Phase-5 AsyncLocal ambient deletion that
turns concurrent battles into a type-system property rather than a scope
contract.

## What landed

**Passes 4-7 (chunks 1-34):** Extended the Phase-4 const-false collapse into a
cascading cull across the skill graph, view layer, and receive-path periphery.
Six mode flags (IsWatchBattle/IsReplayBattle/IsAdmin/IsAdminWatch/IsPuzzleQuest/
IsAINetwork) became `const false`, every guarded block deleted. Field*.cs
subclass ctors + BackGroundBase + ObjectChecker culled to no-ops. Mulligan
family reworked to take a mgr param through IMulliganMgr.InitMulligan.
Emotion/Recovery/Resource clusters null-stubbed. Prediction/OperationSimulator/
skill filters converted from static ambient reads to per-mgr reads via
SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr / ins.BattleMgr / this.BattleMgr.

**Phase-5 ambient rip (chunks 35-47):** Deleted BattleAmbient / BattleAmbient-
Context / TestBattleScope in full. Every per-battle mutable slot now lives on
the mgr instance itself:
  mgr.InstanceIsForecast / InstanceIsRandomDraw / InstanceRecoveryInfo /
  InstanceViewerId / InstanceNetworkAgent / GameMgr
BattleManagerBase.GetIns() returns null unconditionally; the residual static
flags + 3 façades (Certification.ViewerId, Data.BattleRecoveryInfo,
ToolboxGame.RealTimeNetworkAgent) are null-tolerant defaults kept for the
handful of engine-internal readers that still reference their types. Zero
BattleAmbient references anywhere in engine + node + tests.

Added pre-seeded GameMgr ctor overload threaded through the mgr chain
(BattleManagerBase → SingleBattleMgr / NetworkBattleManagerBase → NetworkStandard-
BattleMgr → HeadlessBattleMgr / HeadlessNetworkBattleMgr). Fixtures build a
GameMgr, seed it via HeadlessEngineEnv.SeedCharaIds/SeedNetUser, and pass it
to the mgr's ctor — no ambient reach.

Node side (SVSim.BattleNode/SessionBattleEngine): _ctx replaced with a plain
GameMgr field; 34 `using var _ambient = BattleAmbient.Enter(_ctx)` scope wraps
ripped from every accessor and mutator; EngineGlobalInit.WirePerSessionGameMgr
takes GameMgr as a param and runs from SessionBattleEngine.SetupInternal
BEFORE mgr construction.

Test side: TestBattleScope deleted; 18 fixture [SetUp]s migrated to
`HeadlessEngineEnv.EnsureProcessGlobals()`; MultiInstanceEngineTests rewritten
around per-mgr construction (GetIns() → null is the pinned invariant).

## Regression fixes

- **chunk-48** (MulliganCtrl): chunk-35's `= null` stubs on card lookups broke
  the live receive-driven Deal path (BattlePlayerBase.DrawCard NRE'd downstream
  of NetworkPlayerMulliganCtrl.StartMulliganVfx). Restored the three lookups
  via `_battlePlayer.BattleMgr.GetBattleCardIdx`. Engine tests were satisfied
  by the WireMulliganPhase seam; unit tests exposed the live-path gap.

## Ship state

- SVSim.BattleEngine.Tests: 56/56 pass, 2 skip
- SVSim.UnitTests: 1554/1554 pass (was 1523/31-fail before chunk 48)
- Solution build: 0 source warnings (40 pre-existing NU1902 MessagePack CVEs
  in SVSim.EmulatedEntrypoint, unrelated)
- Sequential PVP smoke: verified live (two back-to-back battles, no regression
  on cleanup/spinup)
- Concurrent PVP smoke: verified live

Adds tools/engine-port/ClosureAnalyzer/ — the Roslyn transitive-type-closure
analyzer needed to make future cascade cleanup safe (per feedback memory
"Engine cleanup needs closure tool" from the 2026-06-28 pass-3 failure).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
gamer147
2026-07-03 19:18:54 -04:00
parent 5c1db83967
commit 2d9a6eea4b
2045 changed files with 11704 additions and 158495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
SVSim.BattleEngine/Shim/Generated/AccountTransferHelper.g.cs
View File

@@ -7,32 +7,7 @@ namespace Wizard
{
public partial class AccountTransferHelper
{
public CuteNetworkDefine.ACCOUNT_TYPE PressedTransitongButton;
private string _appleTokenId;
public AccountBase.TransitionOriginalScreen TransitionFromScreen { get; set; }
public DialogBase CreateAccountTransferDialog(AccountBase.DisplayType type, AccountBase.TransitionOriginalScreen from, Action close_callback = null) => default!;
public void DataTransferByFaceBook() { }
private void startFacebookSign(NetworkTask.ResultCode resultCode) { }
public void DataTransfer(Action close_callback = null) { }
public void GetAppleData(string tokenId) { }
public void DisplayAppleError(AppleLogin.Error error) { }
private void DisplayCannotFindAccountError() { }
public void ShowAccountMagritionConfirmBySocialAccount(NetworkTask.ResultCode resultCode) { }
public void ShowAccountMagritionConfirmByTransferCode(NetworkTask.ResultCode resultCode) { }
private void AddAccountBySocialAccountConfirm() { }
private void DisconnectAccountBySocialAccountConfirm() { }
private void UpdateAccountBySocialAccountConfirm() { }
private void UpdateAccountBySocialAccountConfirmLast() { }
private void UpdateAccountByTransferCodeConfirm() { }
private void AddAccountBySocialAccountExecute() { }
private void CancelAccountBySocialAccount() { }
private void DisconnectAccountBySocialAccountExecute() { }
private void UpdateAccountBySocialAccountExecute() { }
private void UpdateAccountByTransitionCodeExecute() { }
private static void CheckTimeSlipRotationPeriod(Action onFinish) { }
public void ShowAccountDisconnectResult(NetworkTask.ResultCode resultCode) { }
public void ShowAccountChainResult(NetworkTask.ResultCode resultCode) { }
public static void ShowAccountMigrationResult(NetworkTask.ResultCode resultCode) { }
public static void AccountMigrationResultReset() { }
}
}

13
SVSim.BattleEngine/Shim/Generated/AddTokenDeckVfx.g.cs
View File

@@ -1,13 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\AddTokenDeckVfx.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class AddTokenDeckVfx
{
protected const float CARD_UN_SORT_TIME = 0.2f;
public AddTokenDeckVfx(List<BattleCardBase> drawList, VfxBase spawnEffectVfx, BattlePlayerBase selfBattlePlayer, VfxBase skillOrDestroyVfx, bool isVisible) { }
private VfxBase CreateUnSpreadOutVfx(List<BattleCardBase> drawList) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

9
SVSim.BattleEngine/Shim/Generated/ApplicationFinishManager.g.cs
View File

@@ -8,15 +8,6 @@ namespace Wizard
{
public partial class ApplicationFinishManager
{
private DialogBase _keyOpenMenuDialog;
private static bool _canQuit;
private DialogBase _quitDialog;
private const int QUIT_DIALOG_SORTING_ORDER = 3;
public DialogBase QuitDialog { get; set; }
public static bool CanQuit { get; set; }
public static void ApplicationQuit() { }
public bool WantsToQuit() => default!;
public bool IsQuitDialog() => default!;
public void HandleEscapeDialog() { }
}
}

21
SVSim.BattleEngine/Shim/Generated/AttackTargetSelectTouchProcessor.g.cs
View File

@@ -9,29 +9,8 @@ public partial class AttackTargetSelectTouchProcessor
{
private enum MouseState
{
Idle,
MoveHold,
MoveFree
}
private readonly AttackSelectControl _attackSelectControl;
private readonly IPlayerView _battlePlayerView;
private readonly Prediction _prediction;
public bool stopAttack;
private bool evolve;
private MouseState _mouseState;
private Vector2 _positionStart;
public EvolutionSimpleProcessor EvolutionProcessor { get; set; }
public AttackTargetSelectTouchProcessor(BattleManagerBase battleMgr, BattleCardBase touchCard, InputMgr inputMgr, Prediction prediction) : base(battleMgr, touchCard, inputMgr) { }
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public static bool CheckAttackToUnitNotHasGuardError(BattleCardBase attackCard, BattleCardBase targetCard) => default!;
private bool AttackTargetSelectable(BattleCardBase attackCard, BattleCardBase targetCard) => default!;
private bool HasGuardEnemy(BattleCardBase attackCard, BattlePlayerBase battleEnemy) => default!;
private bool DragToAttack(BattleCardBase targetCard) => default!;
protected void SetupTouchProcessorEvents() { }
public bool CheckIsEnd() => default!;
private bool IsShowAlert() => default!;
public VfxWith<ITouchProcessor> End() => default!;
private bool UseEvolutionShortcut() => default!;
private bool UseDetailShortcut() => default!;
}
}

21
SVSim.BattleEngine/Shim/Generated/AvatarBattleBonusItem.g.cs
View File

@@ -1,21 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\AvatarBattleBonusItem.cs
using UnityEngine;
namespace Wizard.Battle.UI
{
public partial class AvatarBattleBonusItem
{
private UILabel _desc;
private UILabel _costLabel;
private UILabel _signLabel;
private UIDragScrollView _dragScrollView;
private UISprite _separator;
private UISprite _dummyFrame;
public BattlePlayerBase.AvatarBattleDescInfo SkillDescInfo;
public UILabel DescLabel { get; set; }
public UILabel CostLabel { get; set; }
public float Height { get; set; }
public void Setup(BattlePlayerBase.AvatarBattleDescInfo skillDescInfo, UIScrollView scrollView, bool isNeedSeparator, BattleCardBase targetCard) { }
public void SetText(BattleCardBase targetCard, bool isNeedSeparator) { }
private void SetCost(string strCost) { }
}
}

16
SVSim.BattleEngine/Shim/Generated/AvatarBattlePassiveBonusItem.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\AvatarBattlePassiveBonusItem.cs
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.UI
{
public partial class AvatarBattlePassiveBonusItem
{
private UILabel _desc;
private UIDragScrollView _dragScrollView;
public BattlePlayerBase.AvatarBattleDescInfo SkillDescInfo;
public UILabel DescLabel { get; set; }
public void Setup(BattlePlayerBase.AvatarBattleDescInfo skillDescInfo, BattleCardBase targetCard, UIScrollView scrollView) { }
public void SetText(BattleCardBase targetCard) { }
private string GetCantChoiceBraveText() => default!;
}
}

14
SVSim.BattleEngine/Shim/Generated/AvatarBattleTitleItem.g.cs
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\AvatarBattleTitleItem.cs
using UnityEngine;
namespace Wizard.Battle.UI
{
public partial class AvatarBattleTitleItem
{
private UILabel _titleLabel;
private UIWidget _dummyFrame;
private UIDragScrollView _dragScrollView;
public string TitleText { get; set; }
public float Height { get; set; }
public void Setup(string titleText, UIScrollView scrollView) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/AwakeSkillActivationVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\AwakeSkillActivationVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class AwakeSkillActivationVfx
{
public const float WAIT_TIME = 0.2f;
public AwakeSkillActivationVfx(IBattleCardView cardView) : base("stt_act_awake_1", "se_stt_act_awake_1", cardView.Transform, 0.2f) { }
}
}

12
SVSim.BattleEngine/Shim/Generated/BanishDeckCardVfx.g.cs
View File

@@ -1,12 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\BanishDeckCardVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class BanishDeckCardVfx
{
private const float CARD_HIDDEN_TIME = 0.2f;
private const float BANISH_WAIT_TIME = 1.2f;
public BanishDeckCardVfx(IBattleCardView cardView) { }
private void RegisterOpenCardVfx() { }
protected VfxBase MoveCardAndBanish() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

3
SVSim.BattleEngine/Shim/Generated/BattleCardView_AttackTargetSelectInfo.g.cs
View File

@@ -2,7 +2,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using CriWare;
using Cute;
using UnityEngine;
using Wizard.Battle.Resource;
@@ -14,8 +13,6 @@ public partial class BattleCardView
public partial class AttackTargetSelectInfo
{
public readonly Queue<AttackSelectControl.AttackPair> _attackPairsCardIsInvolvedIn;
public bool _isBeingSelectedInAttack;
private int _uneffectedByAttackTargettingCount;
public AttackSelectControl.AttackPair CurrentAttackPairCardIsInvolvedIn { get; set; }
public bool IsCardInvolvedInAttack { get; set; }
public bool IsUneffectedByAttackTargetting { get; set; }

13
SVSim.BattleEngine/Shim/Generated/BattleCardView_BuildInfo.g.cs
View File

@@ -4,7 +4,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using CriWare;
using Cute;
using UnityEngine;
using Wizard.Battle.Resource;
@@ -17,18 +16,6 @@ public partial class BuildInfo
{
public IReadOnlyBattleCardInfo cardInfo;
public BattlePlayerReadOnlyInfoPair _playerInfoPair;
public GameObject gameObject;
public BattleCamera battleCamera;
public BackGroundBase backGround;
public IBattleResourceMgr resourceMgr;
public Func<bool> getIsTouchable;
public Func<bool> getIsMovable;
public Func<bool> getIsOnMove;
public Func<int, bool> getIsFixedUseEnable;
public Func<bool> getIsActionCard;
public Func<bool> _getIsAbleToAttack;
public Func<bool> _getIsUnableToAttackClass;
public Func<HandCardFrameEffectType> getHandCardFrameEffectType;
// HEADLESS-FIX (M-HC-4a): store cardInfo so the headless BattleCardView can expose CardInfo (the
// backing card) — the receive ATTACK path reads BattleCardView.CardInfo.IsClass via
// AttackSelectControl.IsCardTranslatable. (Generated stub body was empty; re-apply on regen.)

36
SVSim.BattleEngine/Shim/Generated/BattleEnemyView.g.cs
View File

@@ -8,42 +8,6 @@ namespace Wizard.Battle.View
{
public partial class BattleEnemyView
{
protected string HandDeckObjectName { get; set; }
protected string InPlayCardObjectName { get; set; }
protected string CemeteryObjectName { get; set; }
protected string BanishObjectName { get; set; }
public EnemyChoiceBraveButtonUI EnemyChoiceBraveButtonUI { get; set; }
public Transform ChoiceBraveButtonTransform { get; set; }
public bool IsShowCantChoiceBraveText { get; set; }
public BattleEnemyView(BattleEnemy battlePlayer) { }
public void Setup(GameObject statusPanel, GameObject uiContainer, GameObject btlContainer, GameObject battle3DContainer) { }
public VfxBase StartShowChoice(BattleCardBase actCard, SkillBase choiceSkill, List<BattleCardBase> choiceCards, bool isEvol, BattleCardBase accelerateCard, bool isChoiceBrave) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase StartShowSelect(BattleCardBase actCard, SkillBase skill, IEnumerable<BattleCardBase> selectableCards, bool isEvol) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void RegisterPlayCard(BattleCardBase actCard) { }
public void DisableSettingFlag() { }
public SideLogControl GetSideLogControl(bool isSkillTargetSelect) => default!;
public VfxBase RecoveryInHandCards() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase RecoveryTurnStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase PrepareCardsForAttackSequenceVfx(IBattleCardView attackInitiator, IBattleCardView attackTarget) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private void FloatCardUpwardsDuringAttack(IBattleCardView cardInvolvedInAttack, float timeToReachTopPosition) { }
public VfxBase UpdateHandsSelectState(bool isSelecting) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public bool IsTouchable() => default!;
public void SetTouchable(bool enable) { }
public void ClearPlayQueue() { }
public void ShowCommonPanel() { }
protected AttackSelectControl CreateAttackSelectControl() => default!;
protected HandViewBase CreateHandView(GameObject gameObject) => default!;
protected PlayQueueViewBase CreatePlayQueueView() => default!;
protected InPlayViewBase CreateInPlayView(GameObject gameObject) => default!;
public VfxBase HideCardAttackEffects(IList<BattleCardBase> _targetCards) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase ReturnActCardAfterFusion(IBattleCardView fusionCardView, bool isFusionMetamorphose = false) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateBeforeFusionVfx(BattleCardBase fusionCard, List<BattleCardBase> ingredientCards) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void ShowChoiceBraveButton(bool isNewReplay) { }
public void UpdateChoiceBraveActivatingEffect(bool isActivating) { }
public void HideChoiceBraveButton() { }
public void UpdateChoiceBraveButtonPulsateEffectAndSprite() { }
public void HideChoiceBraveButtonPulsateEffect() { }
public VfxBase SetBp(int num) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public Vector3 GetBPLabelPosition() => default!;
}
}

10
SVSim.BattleEngine/Shim/Generated/BattleLoadingEndVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\BattleLoadingEndVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class BattleLoadingEndVfx
{
private readonly BattleManagerBase _battleMgr;
public BattleLoadingEndVfx(BattleManagerBase battleMgr) { }
public void Play() { }
}
}

209
SVSim.BattleEngine/Shim/Generated/BattleLogItem.g.cs
View File

@@ -9,219 +9,16 @@ public partial class BattleLogItem
{
public enum CardTextureOption
{
Null,
ForceNormal,
ForceEvolution,
DestroyedFollower
}
Null}
private enum FrameType
{
Unit,
Field,
Spell,
Class
}
Spell }
private enum DescStyle
{
Normal,
TurnSelf,
TurnOpponent,
Max
}
Normal }
private delegate string FuncDescText();
private static readonly string[] FRAMESPRITE_SELF;
private static readonly string[] FRAMESPRITE_OPPONENT;
private static readonly string[] FRAMESPRITE_SELECT;
private static readonly Color[] DESC_COL;
private static readonly UIWidget.Pivot[] DESC_PIVOT;
public const string BATTLE_LOG_ICON_PLAY = "battle_log_icon_play";
public const string BATTLE_LOG_ICON_ENHANCE = "battle_log_icon_enhance";
public const string BATTLE_LOG_ICON_ACCELERATE = "battle_log_icon_accelerate";
public const string BATTLE_LOG_ICON_FIGHT = "battle_log_icon_fight";
public const string BATTLE_LOG_ICON_DESTROY = "battle_log_icon_destroy";
public const string BATTLE_LOG_ICON_NECROMANCE = "battle_log_icon_necromance";
public const string BATTLE_LOG_ICON_DRAW = "battle_log_icon_draw";
public const string BATTLE_LOG_ICON_OVERDRAW = "battle_log_icon_overdraw";
public const string BATTLE_LOG_ICON_SUMMON = "battle_log_icon_summon";
public const string BATTLE_LOG_ICON_BUFF = "battle_log_icon_buff";
public const string BATTLE_LOG_ICON_DEBUFF = "battle_log_icon_debuff";
public const string BATTLE_LOG_ICON_BANISH = "battle_log_icon_banish";
public static readonly Color DAMAGE_LABEL_COLOR;
public static readonly Color HEAL_LABEL_COLOR;
private static readonly Color32 CARD_COLOR_GREY;
public static readonly float LOG_ITEM_HEIGHT;
private const float FRAME_POS_X_LEFT = -30f;
private const float FRAME_POS_X_RIGHT = 30f;
private const float FRAME_POS_X_CENTER = 0f;
private const float NO_FRAME_TEXT_OFFSET = -8f;
private const float DESC_LABEL_CENTER_POSITION_X = 42f;
private UISprite _frame;
private UIButton _frameButton;
private UISprite _selectCursor;
private TweenAlpha _selectTween;
private UISprite _separator;
private UITexture _cardTexture;
private UILabel _desc;
private UILabel _num;
private Transform _locator;
private UILabel _rightText;
private UISprite _leftIcon;
private UISprite _rightIcon;
private Transform _fightIcon;
private GameObject _dammyFrame;
private bool isBuff;
private BattlePlayer _battlePlayer;
private BattleManagerBase _battleMgr;
private BattleLogManager _battleLogMgr;
private BattleCardBase _card;
private BattleCardBase _detailCard;
private int _buffMomentCardId;
private LogType _logType;
private bool _isOwner;
private SkillBase _logSkill;
private CardTextureOption _textureOption;
private bool _isCopiedBuff;
public BuffInfo Buff;
public int Turn { get; set; }
public bool IsPlayerSideTurn { get; set; }
public string DivergenceId { get; set; }
public BossRushSpecialSkill BossRushSpecialSkill { get; set; }
public bool IsPlayer { get; set; }
public void SetBuff(BuffInfo buff) { }
public bool IsCopiedBuff() => default!;
public static void ClearHeaderTextureCache() { }
public static int GetHeaderTextureCacheNum() => default!;
public CardTextureOption GetTextureOption() => default!;
private void Start() { }
public bool IsOwner() => default!;
public BattleCardBase GetCard() => default!;
public BattleCardBase GetDetailCard() => default!;
public int GetBuffMomentCardId() => default!;
public SkillBase GetLogSkill() => default!;
public void SetLogSkill(SkillBase skill) { }
public void SetDivergenceId(string divergenceId) { }
public Transform GetLocator() => default!;
public LogType GetLogType() => default!;
public float GetPosX() => default!;
public GameObject GetSeparator() => default!;
private int GetTextureId() => default!;
public void Setup(BattleCardBase card, BattlePlayer battlePlayer, BattleManagerBase battleMgr, BattleLogManager battleLogMng, bool isOwner, CardTextureOption textureOption = CardTextureOption.Null, BattleCardBase detailCard = null, bool? isPlayer = null, BuffInfo buff = null, int buffMomentCardId = -1, BossRushSpecialSkill specialSkillInfo = null, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo = null, bool isBattleInfo = false) { }
public void SetupOnReplay(bool isPlayerSideTurn, int turn) { }
public void ReplaceDeckSummonLogCard(BattleCardBase deckSummonCard) { }
public void ReplaceDeckSummonLogCard(List<BattleCardBase> deckSummonCards) { }
public void _SetupCardTexture(BattleCardBase card, CardTextureOption textureOption, int buffMomentCardId, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo) { }
private void _SetupFrame(BattleCardBase card, bool? isPlayer = null, bool isOpponentAllHandSpellCostChange = false, BossRushSpecialSkill specialSkillInfo = null) { }
private void _SetupFrameSelect(BattleCardBase card) { }
private string _GetFrameSpriteName(BattleCardBase card, string[] spriteNameList, bool isOpponentAllHandSpellCostChange = false, BossRushSpecialSkill specialSkillInfo = null) => default!;
private void _SetupDescStyle(DescStyle style) { }
private void _SetupDescColor(DescStyle style) { }
public void SetTurn(bool isSelfTurn, int turn = -1) { }
public void SetCost(int cost, bool isPlayer) { }
private void _SetInner(LogType logType, FuncDescText funcText, string rightValueText = "", int mulliganCount = -1) { }
private void _SetInnerOnSkillTiming(LogType logType, SkillBase skill) { }
private void SetInnerOnSkillTiming(LogType logType) { }
public void UpdateLogType(LogType logType) { }
public void AddNecromanceLog() { }
private void _SetInnerOnDamage(LogType logType, BattleCardBase afterCard, int damageNum, bool isDrainBattle = false) { }
private void SetInnerOnDamage(LogType logType) { }
private void _SetInnerOnHeal(LogType logType, int healNum = -1, bool isDrain = false) { }
private void SetInnerOnHeal(LogType logType) { }
private void _SetInnerOnSkillTarget(LogType logType, bool isMinus = false, string logText = null, string rightValueText = null, int cardWithCount = -1, int[] randomArray = null, bool isDeadInNewReplay = false, bool isNewReplay = false) { }
public void AddUpRightValue(int addValue, string zeroSign = null) { }
public void ChangeDamageLogToDestroy() { }
public void AddDamageAmount(int damage, bool isDamage) { }
public void AddSummonCount(int summonCount) { }
private void CallOnCreateBattleLog(string rightValueText, NewReplayBattleMgr.BattleLogItemType logItemType, bool isMinus = false, bool isNecromance = false, int cardWithCount = -1, int[] randomArray = null, bool isDrain = false, bool isDrainBattle = false, bool isDeadByDamage = false, int mulliganCount = -1) { }
private void _SetInnerCard(LogType logType) { }
private void _SetInnerCard(LogType logType, int num) { }
public void SetBattleLogCardList(int num = 1) { }
public void SetDeckSummonCardList(int num = 1) { }
public void SetFusionInfoList() { }
public void SetFusionIngredientInfoList() { }
public void UpdateBattleLogCardCount(int num) { }
public void SetMulliganChanged(int changedNum) { }
public void SetPlay(LogType logType = LogType.Play) { }
public void SetSummon(int count, SkillBase skill) { }
public void SetAttack(BattleCardBase attackerAfter, bool isDamageDraw, bool isDrainBattle) { }
public void SetAttackCounter(BattleCardBase attackerAfter, bool isDrainBattle) { }
public void SetDrawCard(List<BattleCardBase> drawCards, bool isOverDraw = false) { }
public void SetOverDraw(bool isTurnStartDraw) { }
public void SetOpenDrawCard(SkillBase skill) { }
public void SetOpenCard() { }
public void SetDrawToken(int count, bool isOverDraw = false) { }
public void SetReturnCard(SkillBase skill) { }
public void SetDiscardCardNum(List<BattleCardBase> discardCards, SkillBase skill) { }
public void SetDiscardCard(SkillBase skill) { }
public void SetBanishHandCardNum(List<BattleCardBase> discardCards, SkillBase skill) { }
public void SetBanishDeckCardNum(List<BattleCardBase> discardCards, SkillBase skill) { }
public void SetBanishDeckCard(SkillBase skill) { }
public void SetBanishHandCard(SkillBase skill) { }
public void SetChangeCemetery(int num, SkillBase skill) { }
public void SetClearDestroyedCardList(SkillBase skill) { }
public void SetClearSummonedCardList(SkillBase skill) { }
public void SetChangeChantCount(int num, SkillBase skill) { }
public void SetChangeWhiteRitualStack(int num, SkillBase skill, bool isDebuffSkill) { }
public void SetChangePP(int num, bool isTotal, SkillBase skill) { }
public void SetEP(int ep, SkillBase skill) { }
public void SetEvolution() { }
public void SetEvolutionBySkill(SkillBase skill) { }
public void SetFusion(int materialCount) { }
public void SetFusionIngredient() { }
public void SetGeton() { }
public void SetGetonIngredient() { }
public void SetGetoffIngredient() { }
public void SetCantAttack(CantAttackType type, SkillBase skill) { }
public void SetAttackCountRecovery(SkillBase skill) { }
public void SetChangeDeck(SkillBase skill) { }
public void SetAddDeck(int count, SkillBase skill) { }
public void SetBuffAdd(int addAttack, int addLife, bool isMinusZeroAttack, bool isMinusZeroLife, SkillBase skill, bool isDead, bool isMinus) { }
public void SetBuffAdd(int addAttack, int addLife, int gainAttack, int gainLife, SkillBase skill, bool isInHand) { }
public void SetBuffMultiply(int multiplyAttack, int multiplyLife, SkillBase skill) { }
public void SetBuffAddClass(SkillBase skill) { }
public void SetBuffSetLife(int setLife, bool isClass, SkillBase skill) { }
public void SetBuffAddMaxLife(int addMaxLife, SkillBase skill, bool isDead, bool isDebuffSkill) { }
public void SetBuffInHandAdd(int addAttack, int addLife, SkillBase skill = null, bool isTargetInOpponentHand = false) { }
public void SetBuffInDeckAdd(SkillBase skill, bool isPlayer, int addAttack, int addLife) { }
public void SetHeal(int healAmount) { }
public void SetHealSkill(SkillBase skill, int healAmount) { }
public void SetDamage(BattleCardBase damageAfter, SkillBase skill) { }
public void SetDestroy() { }
public void SetBanish() { }
public void SetMetamorphose(SkillBase skill = null) { }
public void SetUniteMaterial() { }
public void SetBerserkBySkill(SkillBase skill) { }
public void SetLose(SkillBase skill) { }
public void SetLoseCopiedSkill(SkillBase skill, bool isRemain) { }
public void SetChangeClan(CardBasePrm.ClanType newClan, SkillBase skill, bool isTargetInOpponentHand = false) { }
public void SetChangeTribe(List<CardBasePrm.TribeType> newTribe, SkillBase skill, bool isTargetInOpponentHand = false) { }
public void SetChangePlayCount(int num, SkillBase skill) { }
public void SetGain(SkillGainType type, BattleCardBase gainFrom, int val1 = 0, SkillBase skill = null) { }
public void SetAttachSkill(SkillBase attachedSkill, SkillBase skill, bool isTargetInOpponentHand = false) { }
public void SetShortageDeckWin(SkillBase skill) { }
public void SetTimingWhenPlay(LogType logType, SkillBase skill) { }
public void SetTimingWhenDestroy(SkillBase skill) { }
public void SetTimingWhenLeave(SkillBase skill) { }
public void SetTimingWhenAttackSelfAndOtherAfter(SkillBase skill) { }
public void SetTimingOther(SkillBase skill) { }
public void SetCostChangeCalculate(int num, SkillBase skill = null, bool isTargetInOpponentHand = false) { }
public void SetCostChange(SkillBase skill) { }
public void SetRandomArray(int[] randomArray) { }
public void SetCardTextureColorToGrey() { }
public void SetTokenDrawModifier() { }
public void SetUsePp(SkillBase skill, int usePp) { }
public void SetExclusionTargetList(SkillBase skill) { }
public void SetInnerInReplay(LogType type, string rightValueText, bool isNecromance, int mulliganCount) { }
public void SetInnerOnSkillTimingInReplay(LogType logType, bool isNecromance) { }
public void SetInnerOnDamageInReplay(LogType logType, BattleCardBase card, string rightValueText, bool isDead) { }
public void SetInnerOnHealInReplay(LogType logType, string rightValueText) { }
public void SetInnerOnSkillTargetInReplay(LogType type, bool isMinus, string logText, string rightValueText, bool isDead) { }
public void SetSummonCountInReplay(int summonCount) { }
public static bool IsSameSkillOwner(SkillBase skillA, SkillBase skillB) => default!;
public bool IsSameLog(BattleLogItem logItem) => default!;
public bool IsUseRightText() => default!;
public void SetActiveDammyFrame(bool active) { }
private void OnClickLog() { }
public void OnUnClickLog() { }
public void SetSelectSpriteActive(bool setActive) { }
}
}

135
SVSim.BattleEngine/Shim/Generated/BattleLogManager.g.cs
View File

@@ -1,4 +1,8 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\BattleLogManager.cs
// TODO(engine-cleanup-pass2): 145 of 159 methods unrun in baseline
// Type: Wizard.Battle.UI.BattleLogManager
// See data_dumps/reports/engine-cleanup/live-methods.baseline.txt
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
@@ -11,86 +15,16 @@ public partial class BattleLogManager
public partial class CostCardLogInfo { }
public partial class CardLogInfo { }
public delegate void FuncSetup(BattleLogItem logItem);
private const int BATTLELOG_BLOCK_MAX = 30;
private const int SOLOMON_ID = 112341030;
private bool _isBattleLogOpen;
private BattleManagerBase _battleMgr;
private BattlePlayer _battlePlayer;
private WarPair _warBefore;
public BattleLogWindow _logWindow;
private BattleLogButton _logButton;
private GameObject _battleLogRoot;
private GameObject _battleLogButtonRoot;
public BattleLogItem _clickLogItem;
public BattleLogItem _clickSubLogItem;
private List<BattleLogItem> _logItemList;
private List<BattleLogItemSet> _logItemSetList;
private List<BattleLogItem> _pDestLogItemList;
private List<BattleLogItem> _eDestLogItemList;
private List<BattleLogItem> _pPlayCardLogItemList;
private List<BattleLogItem> _ePlayCardLogItemList;
private List<List<BattleLogItem>> _pDestLogItemListList;
private List<List<BattleLogItem>> _eDestLogItemListList;
private List<List<BattleLogItem>> _pPlayCardLogItemListList;
private List<List<BattleLogItem>> _ePlayCardLogItemListList;
private List<BattleLogItem> _deckSummonCardObjectList;
private List<CostCardLogInfo> _pDestroyedLogInfoList;
private List<CostCardLogInfo> _eDestroyedLogInfoList;
private List<CostCardLogInfo> _pPlayCardLogInfoList;
private List<CostCardLogInfo> _ePlayCardLogInfoList;
private Dictionary<int, int> _deckSummonCardIdList;
public List<BattleCardBase> PlayerFusionCard;
public List<BattleCardBase> EnemyFusionCard;
private List<GameObject> _pDestroyedCostFrameList;
private List<GameObject> _eDestroyedCostFrameList;
private List<GameObject> _pPlayCardCostFrameList;
private List<GameObject> _ePlayCardCostFrameList;
public List<BattleCardBase> PlayerPlayedCard;
public List<BattleCardBase> EnemyPlayedCard;
public List<BattleCardBase> PlayerDestroyedCard;
public List<BattleCardBase> EnemyDestroyedCard;
private int _pDestroyedMinCost;
private int _eDestroyedMinCost;
private int _pPlayCardMinCost;
private int _ePlayCardMinCost;
// PlayerFusionCard / EnemyFusionCard hoisted to BattleManagerBase as instance fields
// (2026-07-02) so concurrent battles don't alias a process-wide list — see
// BattleManagerBase.EnemyFusionCard.
private static BattleLogManager _instance;
private int _keyboardSelectLogNumber;
private BattleLogItem _selectBattleLog;
private BattleLogItemSet _oldClickLogItemSet;
private int _oldLogItemSetCount;
private List<BattleLogItem> _logCardList;
private const float CARD_FRAME_HIGHT = 48f;
private const float UI_SCREEN_HIGHT_HALF = 320f;
private const int DEFAULT_DESTROYED_COST = 99;
public const int MAX_COST_NUM = 30;
private bool _alertLayerEnable;
private int _alerOriginalLayer;
private CanNotTouchCardVfx _canNotTouchCardVfx;
private const int ZEUS_SUPREME_ID = 113041020;
private bool _isPlayerSkinEvolved;
private bool _isEnemySkinEvolved;
public bool IsOpen { get; set; }
public static BattleLogItem CreateLogItem(bool isSmall = false) => default!;
public static BattleLogItem CreateBuffLogItem(BattleCardBase card, BattleCardBase detailCard, BuffInfo buff, bool? isPlayer, bool useSmall, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null, int buffMomentCardId = -1, BossRushSpecialSkill specialSkillInfo = null) => default!;
public static MyRotationBonusItem CreateMyRotationBonusItem(BattlePlayerBase.MyRotationBonusCondition myRotationBonusCondition, bool isPlayer, bool needSeparator) => default!;
public static AvatarBattleTitleItem CreateAvatarBattleBonusTitleItem(string titleText, UIScrollView scrollView) => default!;
public static AvatarBattleTitleItem CreateAvatarBattleBuffTitleItem(string titleText, UIScrollView scrollView) => default!;
public static AvatarBattleBonusItem CreateAvatarBattleBonusItem(BattlePlayerBase.AvatarBattleDescInfo skillDescInfo, UIScrollView scrollView, bool isNeedSeparator, BattleCardBase targetCard) => default!;
public static AvatarBattlePassiveBonusItem CreateAvatarBattlePassiveBonusItem(BattlePlayerBase.AvatarBattleDescInfo skillDescInfo, BattleCardBase targetCard, UIScrollView scrollView) => default!;
public static BattleLogItem CreateBossRushPlayerSpecialSkillLogItem(BattleCardBase card, BossRushSpecialSkill bossRushSpecialSkill) => default!;
public static BossRushEnemySpecialSkillItem CreateEnemyBossRushSpecialSkillLogItem(BattleCardBase card, BossRushSpecialSkill bossRushSpecialSkill) => default!;
public static void DestroyLogItem(BattleLogItem logItem) { }
public static BattleLogItemSet CreateLogItemSet() => default!;
public static void DestroyLogItemSet(BattleLogItemSet logItemSet) { }
public static BattleLogManager GetInstance() => _instance ??= new BattleLogManager(); // HEADLESS-FIX (M9): non-null singleton so the draw's unguarded BattleLog tail (UpdateFusionedCardSkillDrewCard, and the IsBattleLog AddLogSkillDrawCard calls) no-ops instead of NRE on a null instance
private BattleLogManager() { }
public void SetUp(Transform parent, BattleManagerBase battleMgr, OperateMgr operateMgr, BattlePlayer battlePlayer) { }
public void Clear() { }
public void ClearDestroyedCardList(bool isPlayer) { }
public void ClearPlayedCardList(bool isPlayer) { }
private void _SetActiveWindow(bool isActive, BattleLogWindow.BattleLogType logType = BattleLogWindow.BattleLogType.Battle, bool isPlayer = true) { }
public void SetActiveShowButton(bool isActive) { }
public void ShowLog(BattleLogWindow.BattleLogType logType, bool isPlayer = true) { }
public void HideLog() { }
public void BeginLogBlockEvolution(BattleCardBase card) { }
public VfxBase EndLogBlockEvolution() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
@@ -104,50 +38,14 @@ public partial class BattleLogManager
public VfxBase SetupWarActionLog() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase BeginLogBlockWar(BattleCardBase attackCard, BattleCardBase attackedCard) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase EndLogBlockWar(BattleCardBase attackCard, BattleCardBase attackedCard, bool needAttack) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private LogType GetTimingLogType(SkillBase skill) => default!;
private void _AddLogSkillTiming(SkillBase skill, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null) { }
private void _AddLogSkillTiming(BattleCardBase ownerCard, LogType logType, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null) { }
public void AddNecromanceIcon(SkillBase skill, BattleCardBase card, bool isSpell) { }
private BattleLogItem _AddLogCommonOne(BattleCardBase card, FuncSetup funcSetup, bool isOwner = false, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo = null) => default!;
private void _AddLogCommon(List<BattleCardBase> cards, FuncSetup funcSetup, bool isOwner = false, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null) { }
public BattleLogItem AddLogCommonOneAndSetInner(BattleCardBase card, FuncSetup funcSetup, BattleLogItem.CardTextureOption textureOption, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo) => default!;
public void RemoveAllBattleLogSet() { }
public void ParentLogItemToGrid() { }
private int _SetupLogItemSet() => default!;
private int GetMinCost(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private void SetMinCost(BattleLogWindow.BattleLogType type, bool isPlayer, int value) { }
private List<GameObject> GetCostFrameList(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private List<CostCardLogInfo> GetCostCardLogInfoList(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private List<List<BattleLogItem>> GetLogListList(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private List<BattleLogItem> GetLogList(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private GameObject GetLogObject(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
private UILabel GetEmptyTextLabel(BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
public static Dictionary<BattleCardBase, int> GetCardCountsByCardId(List<BattleCardBase> cards) => default!;
public static int CompareCardLogInfo(BattleCardBase cardA, BattleCardBase cardB) => default!;
public static int CompareCardLogInfo(CardLogInfo logInfoA, CardLogInfo logInfoB) => default!;
private string GetNameIndex(int cost, int index) => default!;
private void _AddDestLogCommonOne(BattleCardBase card, FuncSetup funcSetup, BattleLogWindow.BattleLogType type, bool isPlayer, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo) { }
private void _ParentDestLogItemToGrid(BattleLogWindow.BattleLogType type, bool isPlayer) { }
private void _SetupLogDestItemList(BattleLogWindow.BattleLogType type, bool isPlayer) { }
private void MakeAndHideCostFrameList(BattleLogWindow.BattleLogType type, bool isPlayer) { }
public void SetupCostFrame() { }
public void AddLogDestFollower(BattleLogWindow.BattleLogType type, BattleCardBase card, List<NewReplayBattleMgr.BattleLogTextureInfo> battleLogTextureInfo = null) { }
private int GetCardIndex(int cost, int id, BattleLogWindow.BattleLogType type, bool isPlayer) => default!;
public void AddLogCost(int cost, BattleLogWindow.BattleLogType type, bool isPlayer) { }
public void EnableButton() { }
public void DisableButton() { }
private bool _IsAddLogBerserk(BattleCardBase beforeDamage, BattleCardBase afterDamage) => default!;
private bool _IsAddLogAwake(BattleCardBase card, int ppTotalPrev) => default!;
private bool _IsAddLogWar(BattleCardBase attackCard, BattleCardBase attackedCard) => default!;
private BattleLogItem _CreateAttack(bool isCounter, BattleCardBase beforeAttackFrom, BattleCardBase afterAttackFrom, bool isDamageDraw, bool isDrainBattle) => default!;
public VfxBase AddLogWar(BattleCardBase attackCard, BattleCardBase attackedCard) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void AddLogEvolution(BattleCardBase card) { }
public void AddLogFusion(BattleCardBase card, List<BattleCardBase> ingrediens) { }
public void AddLogSkillGetOn(BattleCardBase card, List<BattleCardBase> ingrediens) { }
public void AddLogSkillGetOff(SkillBase skill, List<BattleCardBase> ingrediens) { }
public BattleLogItem AddLogTurn(bool isSelfTurn, int turn = -1) => default!;
public void AddLogMulliganChanged(BattlePlayerBase player, int changedNum) { }
private BattleLogItem GetSameTypeLogItem(BattleCardBase card, LogType logType) => default!;
public void AddLogSkillDrawCard(List<BattleCardBase> drawCards, SkillBase skill, bool isOpen, bool isPlayerDraw, bool isOverDraw) { }
public void AddLogSkillDrawToken(List<BattleCardBase> drawCards, SkillBase skill, bool isOpen, bool isOverDraw = false) { }
public void AddLogOverDrawCards(List<BattleCardBase> overDrawCards) { }
@@ -184,11 +82,9 @@ public partial class BattleLogManager
public void AddLogSkillHeal(List<BattleCardBase> beforeHealCards, List<BattleCardBase.HealResult> healResults) { }
public void AddLogHeal(BattleCardBase beforeHealCard, int healAmount) { }
public void AddLogSkillDamage(BattleCardBase beforeDamage, BattleCardBase afterDamage, BattleCardBase beforeRefrection, BattleCardBase afterRefrection, SkillBase skill) { }
private void _AddLogDamage(BattleCardBase beforeDamage, BattleCardBase afterDamage, SkillBase skill) { }
public void AddLogSkillDeath(List<BattleCardBase> deathCards, SkillBase skill) { }
public void AddLogSkillDeath(List<BattleCardBase> deathCards) { }
public void AddLogDeath(BattleCardBase deathCard) { }
private void _AddLogDeath(List<BattleCardBase> deathCards) { }
public void AddLogSkillEvolution(List<BattleCardBase> evolveCards, SkillBase skill) { }
public void AddLogSkillMetamorphose(List<Skill_metamorphose.MetamorphoseCardPair> pairList, SkillBase skill, bool isTargetInOpponentHand = false, bool isFusion = false) { }
public void AddLogSkillUnite(Skill_unite.UniteCardPair pair, SkillBase skill) { }
@@ -199,34 +95,17 @@ public partial class BattleLogManager
public void AddLogSkillChangeClan(List<BattleCardBase> cards, CardBasePrm.ClanType newClan, SkillBase skill, bool isTargetInOpponentHand = false) { }
public void AddLogSkillChangeTribe(List<BattleCardBase> cards, List<CardBasePrm.TribeType> newTribe, SkillBase skill, bool isTargetInOpponentHand = false) { }
public void AddTokenDrawModifier(List<BattleCardBase> targetCards, SkillBase skill) { }
public static string GetTargetCostConditionText(SkillBase skill) => default!;
public void AddLogSkillChangePlayCount(BattleCardBase card, int count, SkillBase skill) { }
public void AddLogSkillShortageDeckWin(List<BattleCardBase> cards, SkillBase skill) { }
public void AddLogCostChange(List<BattleCardBase> cards, SkillBase skill, int cost, bool isSetCost, bool isTargetInOpponentHand, List<int> setCostDifferenceList) { }
public void AddLogOpenCard(BattleCardBase card) { }
public void AddLogOpenDrawCard(BattleCardBase card, SkillBase skill) { }
public void AddLogExclusionTargetList(List<BattleCardBase> cards, SkillBase skill) { }
public void InsertExclusionTargetListLog(SkillBase skill) { }
private static bool IsSameSkillTiming(LogType logA, LogType logB, bool isSpell) => default!;
private bool _CheckLastAddedSkillOwner(BattleCardBase card, LogType timingLogType) => default!;
private bool ExistSameCardLog(BattleCardBase card, LogType timingLogType) => default!;
public void AddLogSkillUsePp(SkillBase skill, BattleCardBase card, int usePp) { }
public void AddLogGiveWhiteRitualStack(int num, BattleCardBase targetCard, SkillBase skill) { }
public void AddLogDepriveWhiteRitualStack(int num, BattleCardBase targetCard, SkillBase skill) { }
public void UpdateSkillTiming(BattleCardBase card, LogType oldType, LogType newType) { }
private bool UpdateDamageAmount(BattleCardBase card, int amount, SkillBase skill, LogType logType) => default!;
private bool UpdateSummonCount(BattleCardBase card, int summonCount, SkillBase skill, bool isPlayerSide) => default!;
public void KeyboardSelectNext(int number) { }
public void KeyboardSelectBack(int number) { }
public void KeyboardSelectNumber(int number) { }
public void KeyboardResetSelect() { }
public void KeyboardUpdateLogList() { }
public void KeyboardUpdateScrollView() { }
public static int ConvertPremiumIdToNormalId(int cardId) => default!;
public void AddFusionIngredients(BattleCardBase fusionCard, bool isCreateClone) { }
public void ResetFusionIngredients(bool isPlayer) { }
public int GetFusionOrder(BattleCardBase a, BattleCardBase b) => default!;
public void UpdateFusionedCardSkillDrewCard(BattleCardBase fusionCard) { }
private void ReplacePlayerBattleLog(bool isPlayer) { }
}
}

50
SVSim.BattleEngine/Shim/Generated/BattleLogUtility.g.cs
View File

@@ -7,56 +7,6 @@ namespace Wizard.Battle.UI
public partial class BattleLogUtility
{
private delegate string FuncGetGainText(BattleCardBase gainFrom, int val1, SkillBase skill);
private static bool _isInitializedStatic;
private static Dictionary<CantAttackType, FuncGetCantAttackText> _cantAttackTextFunc;
private static Dictionary<Type, BattleLogTextBuilderAttachSkill> _attachSkillTextFunc;
private const string NETWORK_SKILL_PREFIX = "Network";
public const char CARD_COUNT_CHAR = '×';
public static void SetupStatic() { }
public static string GetCardName(BattleCardBase card) => default!;
public static string GetCardWithCountText(BattleCardBase card, int num) => default!;
public static bool IsAddLogDeath(BattleCardBase card) => default!;
public static string GetSkillTargetPlayerText(SkillBase skill) => default!;
public static string BuildTextTurn(bool isSelfTurn, int turn) => default!;
public static string BuildTextCost(int cost) => default!;
public static string BuildTextMulliganChanged(int changedNum) => default!;
public static string BuildTextSummon(BattleCardBase card, int summonCount) => default!;
public static string BuildTextPlay(BattleCardBase card) => default!;
public static string BuildTextEvolve() => default!;
public static string BuildTextFusion() => default!;
public static string BuildTextGeton() => default!;
public static string BuildTextGetoff() => default!;
public static void GetBuffValueStringFormatted(int addAttack, int addLife, ref string retAttack, ref string retLife, bool isMinusZeroAttack = false, bool isMinusZeroLife = false) { }
public static string BuildTextBuffInHandAdd(int addAttack, int addLife, SkillBase skill, bool isTargetInOpponentHand = false) => default!;
public static string BuildTextBuffInDeckAdd(SkillBase skill, bool isSelf, int addAttack, int addLife) => default!;
public static string BuildTextBuffAdd(int addAttack, int addLife, bool isMinusZeroAttack = false, bool isMinusZeroLife = false) => default!;
public static string BuildTextBuffAdd(int addAttack, int addLife, int gainAttack, int gainLife) => default!;
public static string BuildTextBuffMultiply(int multiplyAttack, int multiplyLife) => default!;
public static string BuildTextDamageCut(int cutAmount) => default!;
public static string BuildTextHeal(BattleCardBase healBefore, int healAmount) => default!;
public static string BuildTextDamage(BattleCardBase damageBefore, BattleCardBase damageAfter) => default!;
public static string BuildTextDestroy(BattleCardBase destroyedCard) => default!;
public static string BuildTextBanish() => default!;
public static string BuildTextMetamorphose(BattleCardBase newCard, BattleCardBase oldCard, SkillBase skill = null, bool isTargetInOpponentHand = false, int metamorphoseCardID = 0) => default!;
public static string BuildTextUniteMaterial() => default!;
public static string BuildTextAwake() => default!;
public static string BuildTextBerserk() => default!;
public static string BuildTextNecromance() => default!;
public static string BuildTextLose() => default!;
public static string BuildTextLoseLastWords() => default!;
public static string BuildTextRobLastWords() => default!;
public static string BuildTextChangeClan(CardBasePrm.ClanType newClan, SkillBase skill, bool isTargetInOpponentHand = false) => default!;
public static string BuildTextChangeTribe(CardBasePrm.TribeType newTribe, SkillBase skill, bool isTargetInOpponentHand = false) => default!;
public static string BuildTextChangePlayCount(int cnt) => default!;
public static string BuildTextTimingCallSkill(BattleCardBase card) => default!;
public static string BuildTextTimingWhenPlay(BattleCardBase card) => default!;
public static string BuildTextTimingWhenDestroy(BattleCardBase card) => default!;
public static string BuildTextTimingOther(BattleCardBase card) => default!;
public static string BuildTextCantAttack(CantAttackType type) => default!;
public static string GetPlayerAndPlace(SkillBase skill, SkillFilterCreator.ContentKeyword place) => default!;
public static string BuildTextRandomArray(int[] randomArray) => default!;
public static string BuildTextAttachSkill(SkillBase attachedSkill, SkillBase skill, bool isBuffText, bool isKeyWordCodeDelete = true, bool isNow = true, bool isTargetInOpponentHand = false) => default!;
public static string BuildAttachSkillText(SkillBase attachedSkill, bool isBuffText, bool isKeyWordCodeDelete = true, bool isNow = true) => default!;
private static string DeleteKeywordCode(string battleLogText) => default!;
}
}

115
SVSim.BattleEngine/Shim/Generated/BattlePlayerView.g.cs
View File

@@ -12,127 +12,12 @@ namespace Wizard.Battle.View
{
public partial class BattlePlayerView
{
public Vector3 firstHitPoint;
public bool moveSeFirst;
public bool isDetailRotating;
public const int CLASS_EFFECT_DIALOG_DEPTH = 31;
public bool _isEvolutionCardLanding;
private int? _detailEffectSavedLayer;
private const int KEY_WORD_START = 0;
private const int KEY_WORD_END = 1;
private const int KEY_WORD_DIALOG_LINE_OBJECT = 0;
private const string KEY_WORD_PRESS_COLOR = "[00d2e4]";
public const string KEY_WORD_COLOR = "[ffcd45]";
protected string HandDeckObjectName { get; set; }
protected string InPlayCardObjectName { get; set; }
protected string CemeteryObjectName { get; set; }
protected string BanishObjectName { get; set; }
private ArrowControl ArrowCtrl { get; set; }
private SoundMgr SoundMgr { get; set; }
public BattleCardBase DetailOpenCard { get; set; }
public BattleCardBase SubDetailOpenCard { get; set; }
public GameObject CardMoveEffect { get; set; }
public bool IsMenuOpen { get; set; }
public bool IsMenuCloseEscape { get; set; }
public bool CanPlayerEndTurnImmediately { get; set; }
public bool IsShowTurnEndDialogOfNotAttackingOrPlaying { get; set; }
public bool IsShowTurnEndDialogOfNotUsingHeroSkill { get; set; }
public bool _isEvolutionSkillSelect { get; set; }
public IList<BattleDialog> GetPopupPanelList { get; set; }
public bool IsEvolutionStart { get; set; }
public bool IsEvolutionVfx { get; set; }
public PlayerChoiceBraveButtonUI PlayerChoiceBraveButtonUI { get; set; }
public Transform ChoiceBraveButtonTransform { get; set; }
public bool IsShowCantChoiceBraveText { get; set; }
public BattlePlayerView(BattlePlayer battlePlayer) { }
public void Setup(GameObject statusPanel, GameObject uiContainer, GameObject btlContainer, GameObject battle3DContainer) { }
public void ClearPlayQueue() { }
public void ShowCommonPanel() { }
public void RegisterPlayCard(BattleCardBase actCard) { }
public void DisableSettingFlag() { }
public SideLogControl GetSideLogControl(bool isSkillTargetSelect) => default!;
public VfxBase StartShowChoice(BattleCardBase actCard, SkillBase choiceSkill, List<BattleCardBase> choiceCards, bool isEvol, BattleCardBase accelerateCard, bool isChoiceBrave) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase StartShowSelect(BattleCardBase actCard, SkillBase skill, IEnumerable<BattleCardBase> selectableCards, bool isEvol) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase UpdateHandsSelectState(bool isSelecting) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void GetCardSelectedWithButton(Camera camera, ref UIButton button, ref BattleCardBase card, ref GameObject check) { }
public void ClearDifferentiatePopUp(List<BattleDialogItem> deselectionItem) { }
public void LockOnAttackTarget(BattleCardBase Attacker, BattleCardBase Target) { }
public void ReleaseLockOnTarget() { }
public void ReverseDetailCard() { }
public void DetailReverseOver() { }
public void ShowDetailPanel(BattleManagerBase battleMgrBase, OperateMgr operateMgr, BattleCardBase card, DetailPanelControl.ShowRequest showRequest, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null, BuffInfo buff = null, string divergenceId = "", int logTextureId = 0) { }
private void ShowDetailCommon(BattleManagerBase battleMgrBase, OperateMgr operateMgr, List<BattleCardBase> cards, DetailPanelControl.ShowRequest showRequest, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null, BuffInfo buff = null, string divergenceId = "", int logTextureId = 0) { }
public void ShowDetailPanelList(BattleManagerBase battleMgrBase, OperateMgr operateMgr, List<BattleCardBase> cards, DetailPanelControl.ShowRequest showRequest) { }
public void CallOnOpenEvolveDialoguePanel() { }
public static bool HasKeyword(CardParameter cardParameter) => default!;
public void HideDetailPanel() { }
public void HideSubDetailPanel() { }
public BattleCardBase GetDetailCard() => default!;
private void OpenCardDetailList(BattleManagerBase battleMgrBase, OperateMgr operateMgr, List<BattleCardBase> cards, DetailPanelControl.ShowRequest showRequest, BuffInfo buff, BattleLogItem.CardTextureOption textureOption = BattleLogItem.CardTextureOption.Null, string divergenceId = "", int logTextureId = 0, bool useSubDetailPanelControl = false) { }
public void SetDetailScreenPosition(bool right) { }
public void DragArrowStart(BattleManagerBase battleMgr, BattleCardBase attackCard, GameObject arrowHead) { }
public void DragArrowStart(BattleManagerBase battleMgr, GameObject startObject, GameObject arrowHead, bool isTargettingEnemy = true) { }
public void DragArrow(BattleManagerBase battleMgr, GameObject arrowHead, Vector3 pos) { }
public void MoveCardStart(BattleCardBase moveCard, bool isEffectAndSoundOn) { }
public void MoveCard(BattleCardBase hitCard, Vector3 pos) { }
public void MoveCardCancel(BattleCardBase hitCard, Vector3 position, Quaternion rotation, bool IsPress) { }
public void CancelCardDrag(BattleCardBase cardBeingDragged) { }
public void CardMoveEffectSwitch(bool on) { }
public void HideModeEffect(bool on) { }
public bool IsMoving() => default!;
public void OffNotHideAndNotCreate() { }
public void LockOnEffectOn(BattleCardBase SelectCard) { }
public Effect DetailPanelSelectEffectOn(BattleCardBase selectedCard, DetailPanelControl.ShowRequest request) => default!;
public void StopBattleLogSelectDetailPanelEffect() { }
public void DetailPanelSelectEffectOff() { }
public bool isDetailAble(BattleCardBase card, DetailPanelControl.ShowRequest showRequest) => default!;
public bool IsDetailOn() => default!;
public bool IsFieldDetailOn() => default!;
public void ShowTurnEndDialog(GameObject return_obj = null) { }
public void ShowPlayerTurnEnd(bool isAuto = false) { }
public virtual void ShowTurnEndPulseEffect() { }
public virtual VfxBase HideTurnEndPulseEffect() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual void ShowTurnEndButton(bool showEffect = true) { }
public void ForceShowTurnEndButton() { }
public void UpdateTurnEndPulseEffect() { }
public void ShowKeyPanel(int page) { }
public void HideKeyPanel() { }
public DialogBase CreateKeyPanel(BattleCardBase card, UILabel label, CardMaster.CardMasterId cardMasterId, CardParameter baseParameter) => default!;
public static DialogBase CreateKeyPanel(UILabel label, IList<string> keywordList, CardMaster.CardMasterId cardMasterId) => default!;
public static DialogBase CreateKeyPanel(string skillDescription, UILabel label, CardMaster.CardMasterId cardMasterId) => default!;
public static DialogBase CreateClassEffectPanel(List<string> keyWordList, CardMaster.CardMasterId cardMasterId) => default!;
private static DialogBase CreateKeywordsPanel_Inner(string titleTextID, Action<BattleKeywordInfoListMgr> funcSetup, UILabel label = null) => default!;
private static void SetKeyWordView(UILabel label, BattleKeywordInfoListMgr keywordInfo, out string keywordText, out int startIndex, out int endIndex) { keywordText = default!; startIndex = default!; endIndex = default!; }
private static List<int[]> GetKeyWordIndexList(string inText) => default!;
public static List<string> GetKeyWordList(string inText) => default!;
private static void ChangeKeyWordNewLineToSpace(ref string keyWordText) { }
public static bool IsKeyWordUnderLine() => default!;
public static void SetKeyWordColor(GameObject colliderObject, UILabel label, DetailPanelControl control = null) { }
public static void SetLabelColorEvent(UILabel label, GameObject inClickObject = null) { }
public static void PressKeyWordColorChange(UILabel label, bool press) { }
public static void SetKeyWordLabelColor(UILabel label, string colorCode = "[ffcd45]") { }
public DialogBase ShowRetireConfirmPanel() => default!;
public DialogBase CreateBattleSetting() => default!;
public bool IsTouchable() => default!;
public void SetTouchable(bool enable) { }
public void ResetTouchable() { }
public void AddPopUpPanel(DialogBase dia, BattleDialogItem diaItem) { }
public void AddPopUpPanel(NonDialogPopup popup, BattleDialogItem item) { }
public VfxBase Recovery(bool doseFirst, bool isFocusHand = true) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase HideCardAttackEffects(IList<BattleCardBase> _targetCards) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase RecoveryInHandCards() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase RecoveryMulligan() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase RecoveryTurnStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected HandViewBase CreateHandView(GameObject gameObject) => default!;
protected PlayQueueViewBase CreatePlayQueueView() => default!;
protected InPlayViewBase CreateInPlayView(GameObject gameObject) => default!;
public DialogBase ShowFusionCardPlayDialog(EventDelegate onClickOk, Action onClose) => default!;
public void ShowChoiceBraveButton(bool isNewReplay) { }
public void UpdateChoiceBraveActivatingEffect(bool isActivating) { }
public void HideChoiceBraveButton() { }
public void UpdateChoiceBraveButtonPulsateEffectAndSprite() { }
public void HideChoiceBraveButtonPulsateEffect() { }
public VfxBase SetBp(int num) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public Vector3 GetBPLabelPosition() => default!;
}
}

17
SVSim.BattleEngine/Shim/Generated/BattleStarter.g.cs
View File

@@ -1,17 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\BattleStarter.cs
using System.Collections;
using Cute;
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class BattleStarter
{
public void Execute(Parameter param) { }
private IEnumerator ExecuteCoroutine(Parameter param) => default!;
private static void RegisterSelectedStoryInfo(Parameter param) { }
private static void RegisterDeck(DeckData deckData) { }
private static void RegisterBattleData(StoryChapterData chapterData, int chapterCharaId, int chapterClassId) { }
private static IEnumerator StoryStartTaskCoroutine(SelectedStoryInfo storyInfo) => default!;
private static IEnumerator FadeoutCoroutine() => default!;
private static void GoToBattleScene() { }
}
}

8
SVSim.BattleEngine/Shim/Generated/BerserkSkillActivationVfx.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\BerserkSkillActivationVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class BerserkSkillActivationVfx
{
public BerserkSkillActivationVfx(IBattleCardView cardView) : base("stt_act_berserk_1", "se_stt_act_berserk_1", cardView.Transform, 0.3f) { }
}
}

44
SVSim.BattleEngine/Shim/Generated/BishopInfomationUI.g.cs
View File

@@ -1,44 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\BishopInfomationUI.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEngine;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.UI
{
public partial class BishopInfomationUI
{
private new BattlePlayerBase _player;
private IBattlePlayerView _opponentBattlePlayerView;
private readonly float HANDCARD_YPOSITION;
private readonly float INPLAYCARD_YPOSITION;
private readonly float HANDCARD_XPOSITION;
private readonly float INPLAYCARD_XPOSITION;
private readonly float INFORMATION_UI_HIGHT;
private readonly Vector3 BISHOP_INFORMATION_LOACL_POSITION;
private const string BISHOP_INFORMATION_PATH = "UI/Battle/ClassInfomation_7";
private const string BISHOP_INFORMATION_UI_PREFAB_PATH = "UI/Battle/BishopSummonInfomation";
private const string BISHOP_INFORMATION_UI_CHILD = "BishopSummonInfomation_";
private bool _isPressing;
private List<BishopSummonTokenInfomationUI> _loadingTokenInfoUIList;
public BishopInfomationUI(BattlePlayerBase battlePlayerBase, IBattlePlayerView battlePlayerView, IBattlePlayerView battleEnemyView, int orderCount, int totalInfoNum) : base(battlePlayerBase, battlePlayerView, orderCount, totalInfoNum) { }
public void ShowInfomation(bool playEffect) { }
public void HideInfomation() { }
public void HideOtherInfomation() { }
public void HideAllInfomation() { }
protected void ShowAlert() { }
protected void HideAlert() { }
public VfxBase LoadResources(Transform parent, bool isPlayer) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void SetUpEvent(BattlePlayerBase player) { }
public void Recovery() { }
private void ShowInfo() { }
private void SetTokenInfoUIPosition(GameObject tokenInfoUIObj, bool isInHand, int summonCardIndex) { }
private void HideInfo() { }
private void HideAllInfo() { }
private IEnumerable<BattleCardBase> SelectSummonChantField(IEnumerable<BattleCardBase> cardList) => default!;
private List<int> GetLastWordSummonCard(BattleCardBase ownerCard) => default!;
private void WaitUntilLoadTexture() { }
}
}

28
SVSim.BattleEngine/Shim/Generated/BishopSummonTokenInfomationUI.g.cs
View File

@@ -1,28 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\BishopSummonTokenInfomationUI.cs
using System;
using Cute;
using UnityEngine;
namespace Wizard.Battle.UI
{
public partial class BishopSummonTokenInfomationUI
{
private UILabel _costLabel;
private UILabel _attackLabel;
private UILabel _lifeLabel;
private UIPanel _panel;
private UITexture _texture;
private GameObject _attackLabelRoot;
private GameObject _lifeLabelRoot;
private BattleCardBase _chantCardToSummonToken;
public bool IsLoading { get; set; }
public void SetUnit(int cost, int attack, int life, int order, int id, BattleCardBase chantCardToSummonToken, Action onLoaded = null) { }
public void SetAmulet(int cost, int order, int id, BattleCardBase chantCardToSummonToken, Action onLoaded = null) { }
private void SetCost(int cost) { }
private void SetAttack(int attack) { }
private void SetLife(int life) { }
private void SetSortingOrder(int order) { }
private void SetTexture(int id, bool isUnit, Action onLoaded) { }
private void SetOnDrawEvent() { }
public void SetInfoUIObjectActive(bool isActive) { }
}
}

7
SVSim.BattleEngine/Shim/Generated/BossRushEnemySpecialSkillItem.g.cs
View File

@@ -2,11 +2,4 @@
using UnityEngine;
namespace Wizard.Battle.UI
{
public partial class BossRushEnemySpecialSkillItem
{
private UILabel _desc;
public UILabel DescLabel { get; set; }
public BossRushSpecialSkill BossRushSpecialSkill { get; set; }
public void Setup(BossRushSpecialSkill specialSkill) { }
}
}

16
SVSim.BattleEngine/Shim/Generated/CanNotTouchCardVfx.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\CanNotTouchCardVfx.cs
using System;
using System.Collections.Generic;
namespace Wizard.Battle.View.Vfx
{
public partial class CanNotTouchCardVfx
{
private bool _canTouchCard;
private bool _isUpdateHandCardsPlayability;
private bool _isEvolveTutorial;
public CanNotTouchCardVfx(bool isUpdateHandCardsPlayability = true, bool isEvolveTutorial = false) { }
public CanNotTouchCardVfx(Func<bool> onCheckEnd) { }
public void End(bool isEvolveTutorialEnd = false) { }
public override void Update(float dt, List<IEffectVfx> effectVfxList) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/CardTouchProcessorBase.g.cs
View File

@@ -9,20 +9,10 @@ namespace Wizard.Battle.Touch
{
public partial class CardTouchProcessorBase
{
protected readonly BattleManagerBase _battleMgr;
protected readonly BattlePlayer _battlePlayer;
protected readonly BattleCardBase _firstTouchCard;
protected IEnumerable<BattleCardBase> _targetCards;
protected GameObject _lastFocusedObject;
protected BattleCardBase _lastFocusedCard;
protected InputMgr _inputMgr;
public CardTouchProcessorBase(BattleManagerBase battleMgr, BattleCardBase touchCard, InputMgr inputMgr) { }
public virtual VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxWith<ITouchProcessor> End() => default!;
private BattleCardBase GetBattleCardFromObject(GameObject cardObject) => default!;
public virtual bool CheckIsEnd() => default!;
protected virtual void SetupTouchProcessorEvents() { }
protected VfxBase CreateOpenCardDetailVfx(BattleCardBase targetCard, bool isPlayer) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

60
SVSim.BattleEngine/Shim/Generated/CardVfxCreatorBase.g.cs
View File

@@ -1,60 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\CardVfxCreatorBase.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class CardVfxCreatorBase
{
protected readonly bool _isPlayer;
protected readonly BattleCardBase _card;
protected readonly IBattleCardView _battleCardView;
protected readonly IBattleResourceMgr _resourceMgr;
private const float REFRESH_CARD_PARAMETER_WAIT_TIME = 0.2f;
public CardVfxCreatorBase(bool isPlayer, BattleCardBase card, IBattleCardView battleCardView, IBattleResourceMgr resourceMgr) { }
public virtual VfxBase CreateDraw(Vector3 pos, bool isCardRare) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreatePick() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDestroy(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDestroyHand(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateBanish(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxWithLoading CreateBanishHand(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => default!;
public virtual VfxBase CreateGeton(Transform vehicleCardTrans, IBattleCardView vehicleCardView, BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxWithLoading CreateFusionHand(BattlePlayerBase battlePlayerBase, IBattleCardView fusionCardView, bool isFusionMetamorphose) => default!;
public virtual VfxBase CreateParameterChange(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool isDead, bool isEvolve, bool skipWait = false) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateBuffStart(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool useWait = true) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateBuffStop(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool useWait = true) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDebuffStart(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool useWait = true) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDebuffStop(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool useWait = true) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateBuffStartInHand(BattleCardBase.ParameterChangeInformation parameterChangeInfo, bool useWait = true, bool isDebuff = false) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private VfxBase CreateChangeBuffStatusVfx(VfxBase originalVfx, bool useWait) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateGuardStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateGuardStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateKillerStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateKillerStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateProtectionStart(ProtectionColorType type) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateProtectionStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateNotBeAttackedStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateNotBeAttackedStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateUntouchableStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateUntouchableStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateQuick(bool hasAttacksRemaining, bool isCardUnableToAttackClass) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateSneakStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateSneakStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateForceCantAttackStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateForceCantAttackStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDrainStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDrainStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateAttack(IBattleCardView attackCardView, IBattleCardView attackTargetCardView) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateAttackFloatUp() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateAttackFloatDown(bool isAttacker, bool isDead, int attackableCount) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateMoving(Vector3 pos) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateDamage(int damage, int currentHealth, int maxHealth, int baseHealth, bool isReflectedDamage, bool isSkillDamage) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected DamageVfx CreateDamageVfx(int damage, bool isReflectedDamage) => default!;
public virtual VfxBase CreateHealing(int healAmount, int currentHealth, int maxHealth, int baseHealth) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateMaskCardInPlay() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateReflectionStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateReflectionStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateHeavenlyAegisStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateHeavenlyAegisStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateChangeAffiliation(BattleCardBase card, CardBasePrm.ClanType clan, bool showEffect) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

10
SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs
View File

@@ -1,16 +1,14 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View\CardVoiceInfoCache.cs
// TODO(engine-cleanup-pass2): 4 of 5 methods unrun in baseline
// Type: Wizard.Battle.View.CardVoiceInfoCache
// See data_dumps/reports/engine-cleanup/live-methods.baseline.txt
using System.Collections.Generic;
namespace Wizard.Battle.View
{
public partial class CardVoiceInfoCache
{
private const int CAP_VOICE_DIC = 32;
private const int WARNING_SIZE = 100;
private static Dictionary<int, IReadOnlyVoiceInfo> _voiceInfoDic;
public static void ClearCardVoiceInfo() { }
public static void CacheCardVoiceInfoForBattle(IList<int> cardID) { }
public static void CacheCardVoiceInfo(IList<int> cardID, CardMaster.CardMasterId cardMasterId) { }
public static IReadOnlyVoiceInfo GetCardVoiceInfoForBattle(int cardID) => HeadlessVoiceInfo.Instance; // HEADLESS-FIX (M7): non-null voice info for the IsRecovery death-voice tail
public static IReadOnlyVoiceInfo GetCardVoiceInfo(int cardID, CardMaster.CardMasterId cardMasterId) => default!;
}
}

9
SVSim.BattleEngine/Shim/Generated/ChangeChantCountVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ChangeChantCountVfx.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ChangeChantCountVfx
{
public ChangeChantCountVfx(BattleCardBase card, int count, IBattleResourceMgr resourceMgr) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/ChangeInPlayViewVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ChangeInPlayViewVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class ChangeInPlayViewVfx
{
private readonly IBattleCardView _view;
public ChangeInPlayViewVfx(IBattleCardView view) { }
public void Play() { }
}
}

9
SVSim.BattleEngine/Shim/Generated/ChangeWhiteRitualCountVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ChangeWhiteRitualCountVfx.cs
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class ChangeWhiteRitualCountVfx
{
public ChangeWhiteRitualCountVfx(BattleCardBase card, int count) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/ChapterCharaDecider.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\ChapterCharaDecider.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class ChapterCharaDecider
{
public void Execute(Parameter param) { }
private static int GetChapterCharaId(Parameter param) => default!;
}
}

9
SVSim.BattleEngine/Shim/Generated/ChapterCharaDecider__Wizard.Story.ChapterSelection.SelectionProcessing.Main.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23/Wizard.Story.ChapterSelection.SelectionProcessing.Main/ChapterCharaDecider.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.Main
{
public partial class ChapterCharaDecider
{
public void Execute(Parameter param) { }
private static int? GetChapterCharaId(Parameter param) => default!;
}
}

3
SVSim.BattleEngine/Shim/Generated/ChoiceBraveTouchProcessor.g.cs
View File

@@ -7,9 +7,6 @@ namespace Wizard.Battle.Touch
{
public partial class ChoiceBraveTouchProcessor
{
public bool EnableCancel;
public ChoiceBraveTouchProcessor(BattleManagerBase battleMgr, BattleCardBase card, List<SkillBase> choiceSkills) : base(battleMgr, card, battleMgr.TouchControl.GetPrediction(), choiceSkills, isEvolve: false, isChoiceBrave: true) { }
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxWith<ITouchProcessor> End() => default!;
}
}

29
SVSim.BattleEngine/Shim/Generated/ChoiceTouchProcessor.g.cs
View File

@@ -10,39 +10,10 @@ namespace Wizard.Battle.Touch
{
public partial class ChoiceTouchProcessor
{
protected readonly BattleCardBase _actCard;
protected readonly InputMgr _inputMgr;
protected readonly OperateMgr _operateMgr;
protected readonly BattlePlayer _battlePlayer;
protected bool _isSelectNow;
private readonly Prediction _prediction;
private readonly BattleManagerBase _battleManager;
private bool _stopFlag;
protected BattleCardBase _chosenCard;
private List<SkillBase> _choiceSkills;
private SkillBase _choiceSkill;
private List<BattleCardBase> _choiceCards;
private List<BattleCardBase> _chosenCards;
private bool _choiceCompleteFlag;
private bool _isEvolve;
private BattleCardBase _accelerateCard;
private BattleUIContainer _battleUIContainer;
private int _choiceNumber;
private const float DETAIL_PANEL_SIZE_PERCENT = 90.5f;
private CanNotTouchCardVfx _canNotTouchCardVfx;
private Action _onCompleteChoice;
private bool _isChoiceBrave;
protected bool IsSelectNow { get; set; }
public ChoiceTouchProcessor(BattleManagerBase battleMgr, BattleCardBase actCard, Prediction prediction, List<SkillBase> choiceSkills, bool isEvolve, bool isChoiceBrave, BattleCardBase accelerateCard = null) { }
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxWith<ITouchProcessor> End() => default!;
protected ITouchProcessor CreateAfterSelectTouchProcessor(BattleCardBase hasSelectionSkillCard) => default!;
private void EnableButtons(bool isUpdateEffectAndSprite) { }
private BattleCardBase GetCardAtMousePosition(Camera camera) => default!;
private IEnumerable<GameObject> GetTargetCards() => default!;
public virtual bool CheckIsEnd() => default!;
protected void EnableTurnEndButton() { }
private bool UseDetailShortcut() => default!;
}
}

10
SVSim.BattleEngine/Shim/Generated/ChoiceUtility.g.cs
View File

@@ -7,23 +7,13 @@ namespace Wizard.Battle.Touch
{
public partial class ChoiceUtility
{
public const string SPRITE_UNSELECTED = "btn_common_02_m2_off";
public const string SPRITE_SELECTED_NORMAL = "btn_common_02_m2_on";
public const string SPRITE_SELECTED_PRESSED = "btn_common_02_m2_on";
private const float EVOLUTION_CANCEL_ROTATION_TIME = 0.2f;
private static readonly Vector3 EVOLUTION_CANCEL_ROTATION_ANGLE;
private static readonly Vector3 CARD_DEFAULT_SCALE;
private const float CHANGE_SCALE_TIME = 0.3f;
public static int GetNumberOfCardsToSelect(SkillBase choiceSkill) => default!;
public static int GetNumberOfCardsToSelect(BattleCardBase card, bool isEvolve) => default!;
public static void ToggleChoiceButtonSprite(UIButton choiceButton, GameObject check, bool setActive, int numberOfCardsToSelect, bool isFusion = false, bool isComplete = false) { }
public static void StopChoiceEffects(List<BattleCardBase> choiceCards) { }
public static void PlayCancelEvolveChoiceAnimation(List<BattleCardBase> choiceCards, BattleManagerBase battleMgr) { }
public static bool DoesDuplicateCardNotExistInHand(BattleCardBase actingCard) => default!;
public static bool DoesChoiceCardHaveSelectSkill(BattleCardBase choiceCard, SkillBase choiceSkill) => default!;
public static void SetupActingChoiceCardToBePlayedFromQueue(BattleCardBase actingCard, BattleCardBase choiceCard, BattlePlayerBase battlePlayer, bool isChoiceBrave) { }
public static void SetupChoiceCardForSkillTargetSelect(BattleCardBase choiceCard) { }
public static List<BattleCardBase> CreateChoiceTokenCards(BattleCardBase actingCard, IBattlePlayerView playerBattleView, SkillBase choiceSkill, BattleManagerBase battleMgr) => default!;
public static List<BattleCardBase> SortSelectedChoiceCards(List<BattleCardBase> allChoiceCards, List<BattleCardBase> selectedChoiceCards) => default!;
}
}

10
SVSim.BattleEngine/Shim/Generated/Class3dEvolveVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\Class3dEvolveVfx.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class Class3dEvolveVfx
{
public Class3dEvolveVfx(BattleCardBase card, IBattleResourceMgr resourceMgr) { }
protected bool IsCardFront(BattleCardBase card) => default!;
}
}

33
SVSim.BattleEngine/Shim/Generated/ClassCardVfxCreatorBase.g.cs
View File

@@ -1,33 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ClassCardVfxCreatorBase.cs
using System;
using System.Collections.Generic;
using UnityEngine;
using Wizard.Battle.Player.ClassCharacter;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ClassCardVfxCreatorBase
{
protected readonly ClassBattleCardViewBase _classBattleCardView;
protected readonly IBattlePlayerView _battleView;
private readonly System.Random _random;
private const int _maxRandValueS = 3;
private const int _maxRandValueL = 2;
private GameObject _leaderFrameMesh;
private const string _leaderFrameMeshName = "Class";
private IStatusPanelControl StatusPanelControl { get; set; }
private GameObject LeaderFrameMesh { get; set; }
protected ClassCardVfxCreatorBase(bool isPlayer, BattleCardBase card, ClassBattleCardViewBase battleCardView, IBattlePlayerView battleView, IBattleResourceMgr resourceMgr) : base(isPlayer, card, battleCardView, resourceMgr) { }
public VfxBase CreateDamage(int damage, int currentHealth, int maxHealth, int baseHealth, bool isReflectedDamage, bool isSkillDamage) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateHealing(int healAmount, int currentHealth, int maxHealth, int baseHealth) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateCharacterPanelShake() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxBase CreateRetire(BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateDestroy(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateReflectionStart() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateReflectionStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateProtectionStart(ProtectionColorType type) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateProtectionStop() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected virtual void SetupDamageVfxEvent(DamageVfx vfx) { }
private VfxBase DestroyClassAndClearAllEffectsVfx(BattlePlayerBase battlePlayerBase, bool isRetire) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

77
SVSim.BattleEngine/Shim/Generated/ClassInfomationUIBase.g.cs
View File

@@ -1,77 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\ClassInfomationUIBase.cs
using System.Collections.Generic;
using UnityEngine;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.UI
{
public partial class ClassInfomationUIBase
{
protected readonly Vector3 PLAYER_HANDCOUNT_POSITION;
protected readonly Vector3 PLAYER_CLASS_INFOMATION_POSITION_1;
protected readonly Vector3 PLAYER_CLASS_INFOMATION_POSITION_2;
protected readonly Vector3 PLAYER_CROSS_CLASS_INFORMATION_POSITION_1;
protected readonly Vector3 PLAYER_CROSS_CLASS_INFORMATION_POSITION_2;
private readonly Vector3 EVENT_PLAYER_CLASS_INFORMATION_POSITION_1;
private readonly Vector3 EVENT_PLAYER_CLASS_INFORMATION_POSITION_2;
private readonly Vector3 EVENT_PLAYER_CROSS_CLASS_INFORMATION_POSITION_1;
private readonly Vector3 EVENT_PLAYER_CROSS_CLASS_INFORMATION_POSITION_2;
private readonly Vector3 EVENT_ENEMY_CLASS_INFORMATION_POSITION;
private readonly Vector3 EVENT_ENEMY_CROSS_CLASS_INFORMATION_POSITION_1;
private readonly Vector3 EVENT_ENEMY_CROSS_CLASS_INFORMATION_POSITION_2;
protected readonly Vector3 ENEMY_HANDCOUNT_POSITION;
protected readonly Vector3 ENEMY_CLASS_INFORMATION_POSITION;
protected readonly Vector3 ENEMY_CROSS_CLASS_INFORMATION_POSITION_1;
protected readonly Vector3 ENEMY_CROSS_CLASS_INFORMATION_POSITION_2;
protected readonly int FIRST_HAND_COUNT;
protected readonly BattlePlayerBase _player;
protected IBattlePlayerView _selfBattlePlayerView;
protected readonly Vector3 PLAYER_ALERT_POSITION;
protected readonly Vector3 ENEMY_ALERT_POSITION;
protected readonly Vector3 PLAYER_ALERT_LABEL_POSITION;
protected readonly Vector3 ENEMY_ALERT_LABEL_POSITION;
protected readonly Vector2 ALERT_SIZE;
protected readonly Vector2 ALERT_LABEL_SIZE;
protected static readonly Color HAND_COUNT_S;
protected static readonly Color HAND_COUNT_M;
protected static readonly Color HAND_COUNT_L;
protected static readonly Vector3 DOUBLE_INFO_SCALE;
private const int HAND_CARD_WARNING_COLOR_BORDER = 7;
protected bool _isSelectNow;
protected bool _inCardFocus;
protected GameObject _infomationUI;
protected GameObject _alertObject;
protected UILabel _alertlabel;
protected UISprite _alertSprite;
protected GameObject _handCount;
protected UILabel _handCountLabel;
protected UISprite _handCountIcon;
protected WizardUIButton _informationButton;
protected int _orderNum;
protected int _totalInfoNum;
protected bool CanShowOtherInfo { get; set; }
public virtual GameObject GetInfomationUI() => default!;
public ClassInfomationUIBase(BattlePlayerBase battlePlayerBase, IBattlePlayerView battlePlayerView, int orderNum, int totalInfoNum) { }
public virtual void ShowInfomation(bool playEffect = true) { }
public virtual void HideInfomation() { }
public virtual void HideOtherInfomation() { }
public virtual void HideAllInfomation() { }
public virtual void UpdateInfomation() { }
public void UpdateStatusPanelOnBattle(bool isPlayer) { }
public void SetClassInformationUiPosition(bool isPlayer) { }
protected Vector3 GetClassInfomationPosition(bool isPlayer) => default!;
protected virtual void ShowAlert() { }
protected virtual void HideAlert() { }
protected void AlertReset(string text) { }
public virtual VfxBase LoadResources(Transform parent, bool isPlayer) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual void SetUpEvent(BattlePlayerBase player) { }
public virtual void Recovery() { }
public static Color GetHandCardCountColor(int handCardCount) => default!;
private void UpdateHandCardCount(BattlePlayerBase battlePlayer) { }
public void SetIsSelect(bool flg) { }
public void SetInCardFocus(bool flg) { }
public virtual void SetTouchable(bool flag) { }
protected List<BattleCardBase> SelectOtherInfoTarget(List<BattleCardBase> cards) => default!;
public virtual void NewReplayUpdateInfomation(NetworkBattleReceiver.ClassInfoUiInfo classInfo) { }
}
}

26
SVSim.BattleEngine/Shim/Generated/ClassPage.g.cs
View File

@@ -5,30 +5,4 @@ using Cute;
using UnityEngine;
namespace Wizard.UI.Profile
{
public partial class ClassPage
{
private UIPanel _panel;
private TweenAlpha _tweenAlpha;
private GameObject _obj_skinChangeBtn;
private UILabel _label_skinChangeBtn;
private UILabel _label_headline_nextExp;
private UILabel _label_nextExp;
private UIGauge _sprite_expGauge;
private UILabel _label_headline_winNum;
private UILabel _label_winNum;
private GameObject _obj_itemListRoot;
private GameObject _partsClassPageItem;
private ProfileUI _mainScript;
private Dictionary<int, ClassPageItem> _itemDict;
private bool _isDestory;
private void Awake() { }
public void Create(ProfileUI mainScript) { }
public void Init() { }
private void OnDestroy() { }
private void SetClassInfo(int classId) { }
public static string GetCharaTexName(int skinId) => default!;
public IEnumerator Final() => default!;
private void ResetImageSelection() { }
private bool IsDuringResetImageSelection() => default!;
}
}

9
SVSim.BattleEngine/Shim/Generated/CommonPrefabContainer.g.cs
View File

@@ -4,17 +4,8 @@ namespace Wizard.Story.ChapterSelection
{
public partial class CommonPrefabContainer
{
private CharaInfoPanel _charaInfoPanelPrefab;
private SectionInfoPanel _sectionInfoPanelPrefab;
private AreaSelInfo _chapterRewardPanelPrefab;
private StoryChapterSelectDialog _subChapterSelectionDialogPrefab;
private StorySummaryDialog _summaryDialogPrefab;
private StoryLeaderSelectSummaryDialog _summaryWithCharaSelectionDialogPrefab;
public CharaInfoPanel CharaInfoPanelPrefab { get; set; }
public SectionInfoPanel SectionInfoPanelPrefab { get; set; }
public AreaSelInfo ChapterRewardPanelPrefab { get; set; }
public StoryChapterSelectDialog SubChapterSelectionDialogPrefab { get; set; }
public StorySummaryDialog SummaryDialogPrefab { get; set; }
public StoryLeaderSelectSummaryDialog SummaryWithCharaSelectionDialogPrefab { get; set; }
}
}

16
SVSim.BattleEngine/Shim/Generated/CostChangeVfx.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\CostChangeVfx.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class CostChangeVfx
{
private const string COST_DOWN_EFFECT = "stt_act_costdown_1";
private const string COST_DOWN_EFFECT_SE = "se_stt_act_costdown_1";
private const string COST_UP_EFFECT = "stt_act_costup_1";
private const string COST_UP_EFFECT_SE = "se_stt_act_costup_1";
private const int LORD_ATOMY_ID = 101541020;
public CostChangeVfx(List<BattleCardBase> targetList, bool isSpellCharge, List<bool> isCostUpList, bool isStop) { }
}
}

17
SVSim.BattleEngine/Shim/Generated/DamageVfx.g.cs
View File

@@ -1,17 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DamageVfx.cs
using System.Collections;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DamageVfx
{
public const int STRONG_DAMAGE_VALUE = 7;
private const float KNOCKBACK_AMOUNT = 0.1f;
protected string _effectName { get; set; }
public DamageVfx(IBattleCardView targetCardView, int damage) : base(targetCardView) { }
protected Vector3 GetKnockbackDirection(IBattleCardView targetCardView) => default!;
protected void SetupNumberAnimation(int value) { }
private IEnumerator KnockbackByDamage(IBattleCardView cardView, float targetLocalY, float moveTime) => default!;
private float Interp(float[] pts, float t) => default!;
}
}

33
SVSim.BattleEngine/Shim/Generated/DamageVfxBase.g.cs
View File

@@ -1,33 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DamageVfxBase.cs
using System;
using System.Collections;
using System.Collections.Generic;
using Cute;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DamageVfxBase
{
private const float DAMAGE_ANIMATION_LENGTH = 2.5f;
private const float DAMAGE_TEXT_MARGIN = 0.26f;
private const int DAMAGE_MAX_VALUE = 9999;
private const int TEXTURE_SHEET_MAX = 16;
private const float PLAYER_CLASS_DAMAGE_EFFECT_POSITION = 0.4f;
private const float ENEMY_CLASS_DAMAGE_EFFECT_POSITION = 0.3f;
protected BattleManagerBase _battleMgr;
protected readonly IBattleCardView _targetCardView;
private GameObject _numberObject;
private GameObject _damageEffect;
private bool IsLoadEnd;
protected virtual Vector3 StartPosition { get; set; }
protected string _effectName { get; set; }
public bool IsEffectEnd { get; set; }
protected DamageVfxBase(IBattleCardView targetCardView) { }
protected IEnumerator StartShowValue(int value) => default!;
protected virtual void HideValue() { }
protected virtual void SetupNumberAnimation(int value) { }
public void UpdateEffect() { }
public void RemoveCheck() { }
public void DestroyEffect() { }
}
}

10
SVSim.BattleEngine/Shim/Generated/DeckChangeVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DeckChangeVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class DeckChangeVfx
{
private readonly BattlePlayerBase battlePlayerBase;
public DeckChangeVfx(BattlePlayerBase battlePlayerBase) { }
public void Play() { }
}
}

18
SVSim.BattleEngine/Shim/Generated/DeckOutWinVfx.g.cs
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DeckOutWinVfx.cs
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DeckOutWinVfx
{
public static readonly Vector3 CARD_EFFECT_POSITION;
private static readonly float MOVE_TIME;
private static readonly float EFFECT_TIME;
private static readonly float EFFECT_DELAY_TIME;
private static readonly float EFFECT_MOVE_TIME;
private static readonly string DECK_OUT_WIN_EFFECT;
private static readonly string DECK_OUT_EFFECT;
private static readonly string SE_DECK_OUT_WIN;
private static readonly Color CARD_COLOR;
public DeckOutWinVfx(BattlePlayerBase battlePlayer) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/DeckSelectionConfirmDialogDisplay.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\DeckSelectionConfirmDialogDisplay.cs
using Cute;
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class DeckSelectionConfirmDialogDisplay
{
public void Execute(Parameter param) { }
private void OnClickNextButton(Parameter param, bool? isPlayVoice) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/DeckSelectionConfirmDialogDisplay__Wizard.Story.ChapterSelection.SelectionProcessing.Main.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23/Wizard.Story.ChapterSelection.SelectionProcessing.Main/DeckSelectionConfirmDialogDisplay.cs
using Cute;
namespace Wizard.Story.ChapterSelection.SelectionProcessing.Main
{
public partial class DeckSelectionConfirmDialogDisplay
{
public void Execute(Parameter param) { }
private void OnClickNextButton(Parameter param) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/DeckSelectionDialogDisplay.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\DeckSelectionDialogDisplay.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class DeckSelectionDialogDisplay
{
public void Execute(Parameter param) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/DeckSelectionDialogDisplay__Wizard.Story.ChapterSelection.SelectionProcessing.Main.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23/Wizard.Story.ChapterSelection.SelectionProcessing.Main/DeckSelectionDialogDisplay.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.Main
{
public partial class DeckSelectionDialogDisplay
{
public void Execute(Parameter param) { }
}
}

15
SVSim.BattleEngine/Shim/Generated/DeckSelfSummonVfx.g.cs
View File

@@ -1,15 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DeckSelfSummonVfx.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class DeckSelfSummonVfx
{
private const float DECK_BRIGHT_TIME = 0.3f;
private static readonly string DECK_SUMMON_EFFECT_PATH;
private static readonly string DECK_BRIGHT_EFFECT_PATH;
private static readonly string DECK_SUMMON_SE_PATH;
private static readonly string DECK_BRIGHT_SE_PATH;
public DeckSelfSummonVfx(BattleCardBase card, IBattleResourceMgr resourceMgr) { }
}
}

3
SVSim.BattleEngine/Shim/Generated/DeckTouchProcessor.g.cs
View File

@@ -6,9 +6,6 @@ namespace Wizard.Battle.Touch
{
public partial class DeckTouchProcessor
{
private readonly IBattlePlayerView _battlePlayerView;
private readonly InputMgr _inputMgr;
private bool AlwaysShowStatusPanel { get; set; }
public DeckTouchProcessor(IBattlePlayerView battlePlayerView, InputMgr inputMgr) { }
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();

4
SVSim.BattleEngine/Shim/Generated/DeckUpdateTask.g.cs
View File

@@ -5,13 +5,9 @@ public partial class DeckUpdateTask
{
public partial class DeckUpdateTaskParam { }
public partial class DeckUpdateTaskParamWithSubClass { }
private const int IS_DECK_DELETE_OFF = 0;
private const int IS_DECK_DELETE_ON = 1;
private Format _updateDeckFormat;
public AchievedInfo AchievedInfo { get; set; }
public DeckUpdateTask() { }
public void SetParameter(int deck_no, int class_id, int leader_skin_id, bool isRandomLeaderSkin, int[] leaderSkinIdList, long sleeve_id, string deck_name, bool is_delete, int[] card_id_array, Format format, string myRotationId) { }
public void SetParameterWithSubClass(int deckNo, int classId, int subClassId, int leaderSkinId, bool isRandomLeaderSkin, int[] leaderSkinIdList, long sleeveId, string deckName, bool isDelete, int[] cardIdArray, Format format) { }
protected int Parse() => default!;
}
}

9
SVSim.BattleEngine/Shim/Generated/DefaultOpeningVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DefaultOpeningVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class DefaultOpeningVfx
{
public DefaultOpeningVfx(BackGroundBase backGround) : base(backGround) { }
public override void RegisterOpeningVfx(ClassBattleCardBase playerClass, ClassBattleCardBase enemyClass) { }
}
}

15
SVSim.BattleEngine/Shim/Generated/DelaySetupVfx.g.cs
View File

@@ -1,15 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DelaySetupVfx.cs
using System;
using System.Collections.Generic;
namespace Wizard.Battle.View.Vfx
{
public partial class DelaySetupVfx
{
private readonly Func<VfxBase> _createVfx;
private VfxBase _vfx;
public bool IsEnd { get; set; }
public DelaySetupVfx(Func<VfxBase> createVfx) { }
public void Update(float dt, List<IEffectVfx> effectVfxList) { }
public void Play() { }
}
}

18
SVSim.BattleEngine/Shim/Generated/DestroyVfx.g.cs
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DestroyVfx.cs
using System.Linq;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class DestroyVfx
{
public partial class FileNamePair { }
protected const float BANISH_WAIT_TIME = 0.4f;
protected readonly IBattleCardView _view;
protected readonly IBattleResourceMgr _resourceMgr;
public static FileNamePair CreateBanishFileNamePair(IBattleCardView battleCardView) => default!;
protected DestroyVfx(IBattleCardView view, IBattleResourceMgr resourceMgr) { }
protected VfxBase CreateUnloadResourceVfx() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected FileNamePair GetDestroyEffectFileNames(BattleCardBase.DeathTypeInformation deathTypes, IBattleCardView battleCardView) => default!;
protected void PlayDestroySE(BattleCardBase.DeathTypeInformation deathTypes) { }
}
}

16
SVSim.BattleEngine/Shim/Generated/DestroyVfx_FileNamePair.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DestroyVfx.cs
using System.Linq;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class DestroyVfx
{
public partial class FileNamePair
{
public string ObjectFileName { get; set; }
public string SeFileName { get; set; }
public FileNamePair(string baseName) { }
public FileNamePair(string objectFileName, string seFileName) { }
}
}
}

16
SVSim.BattleEngine/Shim/Generated/DialogContactMenu.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.UI.Dialog\DialogContactMenu.cs
using UnityEngine;
using Wizard.UI.ReportToManagement;
namespace Wizard.UI.Dialog
{
public partial class DialogContactMenu
{
private DialogBase _dialog;
private UIButton _deleteAccountButton;
private void Start() { }
public void SetDialog(DialogBase dialog) { }
public void OnBtnContact() { }
public void OnBtnReport() { }
private void OnClickDeleteAccountButton() { }
}
}

2
SVSim.BattleEngine/Shim/Generated/DialogSpeedChallenge.g.cs
View File

@@ -5,8 +5,6 @@ namespace Wizard.UI.Dialog
{
public partial class DialogSpeedChallenge
{
private UILabel _label;
private UITexture _texture;
public void SetText(string text) { }
public void SetTexture(string name) { }
}

5
SVSim.BattleEngine/Shim/Generated/DialogSpeedChallengeResult.g.cs
View File

@@ -5,14 +5,9 @@ namespace Wizard.UI.Dialog
{
public partial class DialogSpeedChallengeResult
{
private UILabel _rank;
private UILabel _text;
private string _url;
private const int RANK_TEXT_START_ID = 4;
public void SetRankText(string text) { }
public void SetRankWithNumber(int rank) { }
public void SetText(string text) { }
public void SetUrl(string url) { }
public void OpenBrowser() { }
}
}

8
SVSim.BattleEngine/Shim/Generated/Download.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\Download.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class Download
{
public void Execute(Parameter param) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/DownloadConfirmDialogDisplay.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.Main\DownloadConfirmDialogDisplay.cs
using Cute;
namespace Wizard.Story.ChapterSelection.SelectionProcessing.Main
{
public partial class DownloadConfirmDialogDisplay
{
public void Execute(Parameter param) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/DownloadInfoGetter.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult\DownloadInfoGetter.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
public partial class DownloadInfoGetter
{
public void Execute(Parameter param) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/DownloadInfoGetter__Wizard.Story.ChapterSelection.SelectionProcessing.Main.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23/Wizard.Story.ChapterSelection.SelectionProcessing.Main/DownloadInfoGetter.cs
namespace Wizard.Story.ChapterSelection.SelectionProcessing.Main
{
public partial class DownloadInfoGetter
{
public void Execute(Parameter param) { }
}
}

24
SVSim.BattleEngine/Shim/Generated/DragonInfomationUI.g.cs
View File

@@ -1,24 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\DragonInfomationUI.cs
using System.Collections.Generic;
using UnityEngine;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.UI
{
public partial class DragonInfomationUI
{
private UILabel _label1;
private UILabel _label2;
private GameObject _chainSprite;
public DragonInfomationUI(BattlePlayerBase battlePlayerBase, IBattlePlayerView battlePlayerView, int orderCount, int totalInfoNum) : base(battlePlayerBase, battlePlayerView, orderCount, totalInfoNum) { }
public void ShowInfomation(bool playEffect) { }
public void HideInfomation() { }
protected void ShowAlert() { }
protected void HideAlert() { }
public VfxBase LoadResources(Transform parent, bool isPlayer) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void SetUpEvent(BattlePlayerBase player) { }
public void Recovery() { }
private void UpdateAwakeCount() { }
public void NewReplayUpdateInfomation(NetworkBattleReceiver.ClassInfoUiInfo classInfo) { }
}
}

17
SVSim.BattleEngine/Shim/Generated/DrawSpecialTokenVfx.g.cs
View File

@@ -1,17 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DrawSpecialTokenVfx.cs
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DrawSpecialTokenVfx
{
private static readonly float TURN_TIME;
private static readonly float END_MOVE_TIME;
public static readonly Vector3 CARD_EFFECT_ROTATION;
private static readonly float CARD_ROTATE_Y;
public DrawSpecialTokenVfx(List<BattleCardBase> beforeTransformDrawList, List<BattleCardBase> afterTransformDrawList, VfxBase spawnEffectVfx, BattlePlayerBase selfBattlePlayer, SkillBase skill, float beforeTransformWaitTime = 0f, float afterTransformWaitTime = 0.2f, string effectPath = "cmn_token_draw_1") { }
public static VfxBase TokenTransform(List<BattleCardBase> beforeTransformDrawList, List<BattleCardBase> afterTransformDrawList, float beforeTransformWaitTime, float afterTransformWaitTime, string effectPath, SkillBase skill) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

14
SVSim.BattleEngine/Shim/Generated/DrawTokenVfx.g.cs
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DrawTokenVfx.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DrawTokenVfx
{
private const float HAND_REARRANGE_TIME = 0.3f;
protected float GetRotationYLastToken { get; set; }
public DrawTokenVfx(List<BattleCardBase> drawList, VfxBase spawnEffectVfx, BattlePlayerBase selfBattlePlayer, bool isVisible) { }
public static VfxBase CreateAddTokensToHandVfx(List<BattleCardBase> drawList, BattlePlayerBase selfBattlePlayer, VfxBase destroyVfx) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

14
SVSim.BattleEngine/Shim/Generated/DummyDeckChangeCardVfx.g.cs
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DummyDeckChangeCardVfx.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DummyDeckChangeCardVfx
{
private readonly bool m_isPlayer;
private readonly int _changeCount;
public DummyDeckChangeCardVfx(bool isPlayer, int changeCount) { }
public void Play() { }
}
}

13
SVSim.BattleEngine/Shim/Generated/DummyDeckRemoveCardVfx.g.cs
View File

@@ -1,13 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\DummyDeckRemoveCardVfx.cs
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class DummyDeckRemoveCardVfx
{
private readonly bool _isPlayer;
private readonly int m_num;
public DummyDeckRemoveCardVfx(bool isPlayer, int num) { }
public void Play() { }
}
}

20
SVSim.BattleEngine/Shim/Generated/EffectBattleVfxBase.g.cs
View File

@@ -1,20 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EffectBattleVfxBase.cs
using System;
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class EffectBattleVfxBase
{
protected readonly EffectBattle _effect;
protected readonly IBattleCardView _cardView;
protected readonly GameObject _effectObject;
protected readonly IBattleResourceMgr _resourceMgr;
protected readonly Func<Vector3> _getTargetPositionFunc;
protected Animation _animationObj;
protected EffectBattleVfxBase(EffectBattle effect, IBattleCardView cardView, IBattleResourceMgr resourceMgr, Func<Vector3> getTargetPositionFunc) { }
protected VfxBase CreateStartTweenVfx(EffectMgr.MoveType moveType, EffectMgr.TargetType targetType, Func<Vector3> startPosition, float animationTime, bool isPlayer, IBattleCardView targetCardView = null) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected VfxBase CreatePlayVfx() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
protected VfxBase CreateAnimationAfterVfx(EffectMgr.MoveType moveType) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

23
SVSim.BattleEngine/Shim/Generated/ElfInfomationUI.g.cs
View File

@@ -1,23 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.UI\ElfInfomationUI.cs
using System.Collections.Generic;
using UnityEngine;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.UI
{
public partial class ElfInfomationUI
{
private UILabel _playCountLabel;
public ElfInfomationUI(BattlePlayerBase battlePlayerBase, IBattlePlayerView battlePlayerView, int orderCount, int totalInfoNum) : base(battlePlayerBase, battlePlayerView, orderCount, totalInfoNum) { }
public void ShowInfomation(bool playEffect) { }
public void HideInfomation() { }
protected void ShowAlert() { }
protected void HideAlert() { }
public void UpdateInfomation() { }
public VfxBase LoadResources(Transform parent, bool isPlayer) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void SetUpEvent(BattlePlayerBase player) { }
public void Recovery() { }
private VfxBase UpdatePlayCount(BattlePlayerBase battlePlayer, bool isTurnEnd = false) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void NewReplayUpdateInfomation(NetworkBattleReceiver.ClassInfoUiInfo classInfo) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/EmotionHideMessageVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.Touch\EmotionHideMessageVfx.cs
using Wizard.Battle.Resource;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.Touch
{
public partial class EmotionHideMessageVfx
{
public EmotionHideMessageVfx(IBattleResourceMgr resourceMgr) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/EnemyClassBattleCardView.g.cs
View File

@@ -7,15 +7,7 @@ namespace Wizard.Battle.View
{
public partial class EnemyClassBattleCardView
{
private static readonly Vector3 ENEMY_FORECASTICON_POS;
private readonly PlayerClassCharacter _classCharacter;
public IClassCharacter ClassCharacter { get; set; }
public float OriginalRootYPosition { get; set; }
public EnemyClassBattleCardView(BuildInfo buildInfo) : base(buildInfo) { } // HEADLESS-FIX (M-HC-4a): chain BuildInfo so the leader view's CardInfo resolves (attack-on-leader targetting)
public void StartOutFrame() { }
public void StartIntoFrame() { }
public float GetCurrentClipTime() => default!;
public bool GetCurrentClipIsName(ClassCharaPrm.MotionType motionType) => default!;
public void ClearSpineObject() { }
}
}

10
SVSim.BattleEngine/Shim/Generated/EnemyClassCardVfxCreator.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EnemyClassCardVfxCreator.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class EnemyClassCardVfxCreator
{
public EnemyClassCardVfxCreator(ClassBattleCardViewBase battleCardView, BattleCardBase card, IBattlePlayerView battleView, IBattleResourceMgr resourceMgr) : base(isPlayer: false, card, battleCardView, battleView, resourceMgr) { }
protected void SetupDamageVfxEvent(DamageVfx vfx) { }
}
}

11
SVSim.BattleEngine/Shim/Generated/EnemyDeckOutVfx.g.cs
View File

@@ -1,11 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EnemyDeckOutVfx.cs
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class EnemyDeckOutVfx
{
private BattleEnemy _battleEnemy;
private BattleManagerBase _battleMgr;
public EnemyDeckOutVfx(BattleEnemy battleEnemy, BattleManagerBase battleMgr) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/EnemyMulliganDrawVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EnemyMulliganDrawVfx.cs
using System.Collections.Generic;
namespace Wizard.Battle.View.Vfx
{
public partial class EnemyMulliganDrawVfx
{
public EnemyMulliganDrawVfx(IEnumerable<BattleCardBase> drawCards, bool isHideCard) : base(drawCards) { }
}
}

25
SVSim.BattleEngine/Shim/Generated/EnemyMulliganSwapVfx.g.cs
View File

@@ -1,25 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EnemyMulliganSwapVfx.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class EnemyMulliganSwapVfx
{
private IList<BattleCardBase> m_changeList;
private IList<int> m_PosIndexList;
private const float SCREEN_WIDTH = 800f;
private IList<BattleCardBase> m_drawCards;
private const float CARD_SORT_OFFSET = 220f;
private const float FIRST_CARD_POSITION_X = 180f;
private const float CARD_POSITION_Y = 500f;
private const float CARD_POSITION_Z = -50f;
private static readonly Vector3 CARD_ROTATION;
public EnemyMulliganSwapVfx(IList<BattleCardBase> newCards, IList<int> posList, IList<BattleCardBase> oldCards) { }
private void PrepareBuryCard() { }
private void PrepareDrawCard() { }
private VfxBase BuryAndDrawVfx() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private VfxBase ReturnOldCardsVfx() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private VfxBase MoveCardBackToDeck(IBattleCardView view) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

8
SVSim.BattleEngine/Shim/Generated/EpChangeVfx.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EpChangeVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class EpChangeVfx
{
public EpChangeVfx(BattlePlayerBase battlePlayer, int oldUsableEpAmount, int newUsableEpAmount, int maxEp) { }
}
}

4
SVSim.BattleEngine/Shim/Generated/EvolutionConfirmation.g.cs
View File

@@ -5,11 +5,7 @@ namespace Wizard.Battle.UI
{
public partial class EvolutionConfirmation
{
private DialogBase _dialog;
public bool IsPossibleToClose { get; set; }
public GameObject ConfirmationButton { get; set; }
public EvolutionConfirmation(Transform parent) { }
public DialogBase Show(BattlePlayer battlePlayer) => default!;
private VfxBase Hide() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

10
SVSim.BattleEngine/Shim/Generated/EvolutionHideMessageVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.Touch\EvolutionHideMessageVfx.cs
using Wizard.Battle.Resource;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.Touch
{
public partial class EvolutionHideMessageVfx
{
public EvolutionHideMessageVfx(BattleManagerBase battleMgr, IBattleResourceMgr resourceMgr) { }
}
}

15
SVSim.BattleEngine/Shim/Generated/EvolutionTouchProcessor.g.cs
View File

@@ -11,26 +11,11 @@ namespace Wizard.Battle.Touch
{
public partial class EvolutionTouchProcessor
{
private readonly BattleManagerBase _battleMgr;
private readonly BattlePlayer _battlePlayer;
private readonly IEnumerable<BattleCardBase> _targetCards;
private GameObject _lastFocusedObject;
private BattleCardBase _lastFocusedCard;
private InputMgr _inputMgr;
private IBattleResourceMgr _resourceMgr;
private bool _isForceEnd;
private bool _isDetailPanelEvolution;
public Func<VfxBase> OnAfterEvolveDragSelect;
private bool _stopSelectFlag;
private List<SkillBase> _selectSkills;
private readonly Prediction _prediction;
private readonly Func<BattleCardBase, List<BattleCardBase>, List<SkillBase>, bool, SkillTargetSelectTouchProcessor> _getSkillTargetSelectTouchProcessorFunc;
public EvolutionTouchProcessor(BattleManagerBase battleMgr, InputMgr inputMgr, IBattleResourceMgr resourceMgr, bool inDetailPanelEvolution, Func<BattleCardBase, List<BattleCardBase>, List<SkillBase>, bool, SkillTargetSelectTouchProcessor> getSkillTargetSelectTouchProcessorFunc, Prediction prediction) { }
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxWith<ITouchProcessor> End() => default!;
protected VfxBase CreateEvolutionSelectEndVfx(BattleCardBase targetCard) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private BattleCardBase GetBattleCardFromObject(GameObject cardObject) => default!;
public virtual VfxBase ShowEvolutionMessage() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual bool CheckIsEnd() => default!;
public void SetStopSelectFlag() { }

10
SVSim.BattleEngine/Shim/Generated/EvolveImageChangeVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EvolveImageChangeVfx.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class EvolveImageChangeVfx
{
public EvolveImageChangeVfx(BattleCardBase card, IBattleResourceMgr resourceMgr) { }
}
}

8
SVSim.BattleEngine/Shim/Generated/EvolveNameChangeVfx.g.cs
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EvolveNameChangeVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class EvolveNameChangeVfx
{
public EvolveNameChangeVfx(BattleCardBase card) { }
}
}

12
SVSim.BattleEngine/Shim/Generated/EvolveUnitMaskCardInPlayVfx.g.cs
View File

@@ -1,12 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EvolveUnitMaskCardInPlayVfx.cs
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class EvolveUnitMaskCardInPlayVfx
{
private readonly IBattleCardView _cardView;
private readonly bool _setParticleShader;
public EvolveUnitMaskCardInPlayVfx(IBattleCardView cardView, bool setParticleShader = true) { }
public void Play() { }
}
}

17
SVSim.BattleEngine/Shim/Generated/EvolveVfx.g.cs
View File

@@ -1,17 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\EvolveVfx.cs
using Cute;
using UnityEngine;
using Wizard.Battle.Resource;
using Wizard.Battle.UI;
namespace Wizard.Battle.View.Vfx
{
public partial class EvolveVfx
{
private readonly float SHOW_EMOTION_TIME;
private CanNotTouchCardVfx _canNotTouchCardVfx;
private bool _isSelfTurn;
protected virtual bool IsCardFront(BattleCardBase card) => default!;
public EvolveVfx(BattleCardBase card, IBattleResourceMgr resourceMgr, bool isNotConsumeEp = false) { }
private void ToggleTouchable(bool on) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/FallToGroundVfx.g.cs
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\FallToGroundVfx.cs
using UnityEngine;
namespace Wizard.Battle.View.Vfx
{
public partial class FallToGroundVfx
{
public FallToGroundVfx(GameObject cardGameObject) { }
}
}

9
SVSim.BattleEngine/Shim/Generated/FieldBattleCardView.g.cs
View File

@@ -7,15 +7,6 @@ namespace Wizard.Battle.View
{
public partial class FieldBattleCardView
{
public GameObject ChantCountIcon { get; set; }
public FieldBattleCardView(BuildInfo buildInfo) : base(buildInfo) { }
public void InitializeVoiceInfo(int cardID) { }
public VfxBase LoadResource() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase GetResourcePathes(List<BattleManagerBase.ResourceInfo> resourceInfos) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void UpdateParameterView(int offence, int life, int cost, string name, bool isOnField, bool isRecovery = false, bool useNormalCost = false) { }
public void UpdateOffence(int offence) { }
public void UpdateLife(int life) { }
public VfxBase ResetCardView(CardParameter baseParameter) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public void SetTillingAndOffset(Vector2 tilling, Vector2 offset) { }
}
}

11
SVSim.BattleEngine/Shim/Generated/FieldCardVfxCreator.g.cs
View File

@@ -1,11 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\FieldCardVfxCreator.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class FieldCardVfxCreator
{
public FieldCardVfxCreator(bool isPlayer, BattleCardBase card, IBattleCardView battleCardView, IBattleResourceMgr resourceMgr) : base(isPlayer, card, battleCardView, resourceMgr) { }
public VfxBase CreateDestroy(BattleCardBase.DeathTypeInformation deathTypes, BattlePlayerBase battlePlayerBase) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase CreateMaskCardInPlay() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
}
}

10
SVSim.BattleEngine/Shim/Generated/FieldMaskCardInPlayVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\FieldMaskCardInPlayVfx.cs
namespace Wizard.Battle.View.Vfx
{
public partial class FieldMaskCardInPlayVfx
{
private readonly IBattleCardView _cardView;
public FieldMaskCardInPlayVfx(IBattleCardView cardView) { }
public void Play() { }
}
}

12
SVSim.BattleEngine/Shim/Generated/ForecastBanishIconAttachVfx.g.cs
View File

@@ -1,12 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastBanishIconAttachVfx.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastBanishIconAttachVfx
{
public const string ICON = "forecast_banish";
protected string ResourcePath { get; set; }
protected string FORECAST_ICON_NAME { get; set; }
public ForecastBanishIconAttachVfx(IBattleCardView view, IBattleResourceMgr resourceMgr) { }
}
}

15
SVSim.BattleEngine/Shim/Generated/ForecastDamageIconAttachVfx.g.cs
View File

@@ -1,15 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastDamageIconAttachVfx.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastDamageIconAttachVfx
{
public const string ICON = "forecast_damage";
private readonly int _damage;
protected string ResourcePath { get; set; }
protected string FORECAST_ICON_NAME { get; set; }
public ForecastDamageIconAttachVfx(int damage, IBattleCardView view, IBattleResourceMgr resourceMgr) { }
protected void Setup(GameObject iconObject) { }
}
}

13
SVSim.BattleEngine/Shim/Generated/ForecastDeathIconAttachVfx.g.cs
View File

@@ -1,13 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastDeathIconAttachVfx.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastDeathIconAttachVfx
{
public const string ICON = "forecast_death";
private const float FIELD_OFFSET = 5f;
protected string ResourcePath { get; set; }
protected string FORECAST_ICON_NAME { get; set; }
public ForecastDeathIconAttachVfx(IBattleCardView view, IBattleResourceMgr resourceMgr) { }
}
}

15
SVSim.BattleEngine/Shim/Generated/ForecastIconVfxBase.g.cs
View File

@@ -1,15 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastIconVfxBase.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastIconVfxBase
{
protected readonly IBattleCardView _view;
public const float OFFSET_Z = -0.1f;
protected string FORECAST_ICON_NAME { get; set; }
protected string ResourcePath { get; set; }
protected ForecastIconVfxBase(IBattleCardView view, IBattleResourceMgr resourceMgr) { }
protected virtual void Setup(GameObject iconObject) { }
}
}

16
SVSim.BattleEngine/Shim/Generated/ForecastRandomSkillUseCardVfx.g.cs
View File

@@ -1,16 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastRandomSkillUseCardVfx.cs
using UnityEngine;
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastRandomSkillUseCardVfx
{
public const string ICON = "forecast_random";
private const float FIELD_OFFSET = 35f;
protected string ResourcePath { get; set; }
protected string FORECAST_ICON_NAME { get; set; }
public ForecastRandomSkillUseCardVfx(IBattleCardView view, IBattleResourceMgr resourceMgr) { }
public static ForecastRandomSkillUseCardVfx Create(IBattleCardView view, IBattleResourceMgr resourceMgr) => default!;
protected void Setup(GameObject iconObject) { }
}
}

10
SVSim.BattleEngine/Shim/Generated/ForecastRandomSkillUseMessageVfx.g.cs
View File

@@ -1,10 +0,0 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\Wizard.Battle.View.Vfx\ForecastRandomSkillUseMessageVfx.cs
using Wizard.Battle.Resource;
namespace Wizard.Battle.View.Vfx
{
public partial class ForecastRandomSkillUseMessageVfx
{
public ForecastRandomSkillUseMessageVfx(IBattleResourceMgr resourceMgr) { }
public static ForecastRandomSkillUseMessageVfx Create(IBattleResourceMgr resourceMgr) => default!;
}
}

10
SVSim.BattleEngine/Shim/Generated/Friend_PlayerData.g.cs
View File

@@ -13,22 +13,12 @@ public partial class Friend
public partial class PlayerData
{
public int ViewerId;
public int ApplyId;
public string Name;
public long EmblemId;
public int DegreeId;
public int Rank;
public string Country;
public DateTime ApplyTime;
public DateTime ApplyReceivedTime;
public DateTime BattleTime;
public DateTime TaskTime;
public bool isFriend;
public bool isFriendApply;
public bool isFriendApplyRecived;
public BattleParameter BattleParameter;
public bool IsSameGuildMember { get; set; }
public int MissionType { get; set; }
public PlayerData(string in_Name, long in_EmblemId, int in_DegreeId, int in_Rank, string in_Country) { }
public void Copy(UserFriend src) { }
}

13
SVSim.BattleEngine/Shim/Generated/FusionSimpleProcessor.g.cs
View File

@@ -4,17 +4,4 @@ using Wizard.Battle.UI;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.Touch
{
public partial class FusionSimpleProcessor
{
private BattleManagerBase _battleMgr;
private BattleCardBase _card;
private SkillBase _selectSkill;
private Skill_fusion_metamorphose _fusionMetamorphoseSkill;
private ITouchProcessor _nextProcessor;
public FusionSimpleProcessor(BattleManagerBase battleMgr, BattleCardBase card, SkillBase fusionSkill, Skill_fusion_metamorphose fusionMetamorphoseSkill) { }
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxWith<ITouchProcessor> End() => default!;
public virtual bool CheckIsEnd() => default!;
}
}

37
SVSim.BattleEngine/Shim/Generated/FusionTargetSelectTouchProcessor.g.cs
View File

@@ -6,41 +6,4 @@ using Wizard.Battle.UI;
using Wizard.Battle.View.Vfx;
namespace Wizard.Battle.Touch
{
public partial class FusionTargetSelectTouchProcessor
{
protected readonly BattleCardBase _actCard;
protected readonly InputMgr _inputMgr;
protected readonly BattlePlayer _battlePlayer;
protected bool _isSelectNow;
private readonly BattleManagerBase _battleManager;
private IEnumerable<BattleCardBase> _targetCards;
private IEnumerable<GameObject> _targetCardObjects;
private bool _stopSelectFlag;
private SkillBase _fusionSkill;
private Skill_fusion_metamorphose _fusionMetamorphoseSkill;
private List<BattleCardBase> _selectedCards;
private bool _selectCompleteFlag;
private int _needSelectCount;
private int _maxSelectCount;
private List<BattleCardBase> _selectableCards;
private BattleUIContainer _battleUIContainer;
private const float CANCEL_TOUCHABLE_WAIT_TIME = 0.2f;
public static readonly Vector3 INIT_LOCAL_EULAR_ANGLE;
private CanNotTouchCardVfx _canNotTouchCardVfx;
private bool _isNoSelectFusion;
protected bool IsSelectNow { get; set; }
public FusionTargetSelectTouchProcessor(BattleManagerBase battleMgr, BattleCardBase actCard, SkillBase fusionSkill, Skill_fusion_metamorphose fusionMetamorphoseSkill) { }
public static FusionTargetSelectTouchProcessor Create(BattleManagerBase battleMgr, BattleCardBase actCard, SkillBase fusionSkill, Skill_fusion_metamorphose fusionMetamorphoseSkill) => default!;
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public VfxBase Update(float dt, Camera camera) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
private void ChangeSelectFusionIngredientCard(BattleCardBase selectedCard, bool isSelect) { }
private BattleCardBase GetCardAtMousePosition(Camera camera) => default!;
private bool IsSelect() => default!;
private VfxBase MakeTouchEffect(BattleCardBase targetCard) => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public virtual VfxWith<ITouchProcessor> End() => default!;
protected virtual void SetTouchable(bool enable) { }
public virtual bool CheckIsEnd() => default!;
private IEnumerable<GameObject> GetTargetCards() => default!;
protected void EnableTurnEndButton(bool showEffect) { }
}
}

7
SVSim.BattleEngine/Shim/Generated/FusionWaitProcessor.g.cs
View File

@@ -9,13 +9,6 @@ namespace Wizard.Battle.Touch
{
public partial class FusionWaitProcessor
{
private bool _isOpenDialog;
private bool _isOkClicked;
private CanNotTouchCardVfx _canNotTouchVfx;
private DialogBase _dialog;
public FusionWaitProcessor(BattleManagerBase battleMgr, BattleCardBase actCard, List<SkillBase> selectSkills, Prediction prediction, Func<BattleCardBase, List<BattleCardBase>, List<SkillBase>, bool, SkillTargetSelectTouchProcessor> getSkillTargetSelectTouchProcessorFunc) : base(battleMgr, actCard, selectSkills, prediction, getSkillTargetSelectTouchProcessorFunc) { }
public VfxBase Start() => global::Wizard.Battle.View.Vfx.NullVfx.GetInstance();
public bool CheckIsEnd() => default!;
public VfxWith<ITouchProcessor> End() => default!;
}
}

23
SVSim.BattleEngine/Shim/Generated/GameObjMgr.g.cs
View File

@@ -4,34 +4,11 @@ using UnityEngine;
using Wizard;
public partial class GameObjMgr
{
private GameObject m_GameObj;
private GameObject m_UIContainer;
private Camera m_UIContainerCamera;
private GameObject m_SubUIContainer;
private Camera m_SubUICam;
private GameObject m_CameraContainer;
private IList<GameObject> m_AddedUIGameObj;
public GameObjMgr(GameObject GameObj) { }
public void CreateUIContainer() { }
public void DisposeUIGameObj() { }
public GameObject AddBattleUIContainerChild(GameObject g) => default!;
public GameObject AddUIContainerChild(GameObject GameObj) => default!;
public GameObject AddUIContainerChildPrefab(string str) => default!;
public GameObject AddUIContainerChildPrefab(GameObject GameObj) => default!;
public GameObject AddSubUIContainerChild(GameObject GameObj) => default!;
public GameObject AddSubUIContainerChildPrefab(string str) => default!;
public GameObject AddSubUIContainerChildPrefab(GameObject GameObj) => default!;
public GameObject AddCameraContainerChild(GameObject GameObj) => default!;
public GameObject AddCameraContainerChildPrefab(string str) => default!;
public GameObject AddUIManagerChildPrefab(GameObject gobj) => default!;
public GameObject AddUIManagerChildPrefab(string str) => default!;
public NguiObjs AddUIManagerChildPrefab(NguiObjs gobj) => default!;
public GameObject AddUIManagerRootChildPrefab(GameObject gobj) => default!;
public GameObject AddUIManagerRootChildPrefab(string str) => default!;
public GameObject GetGameObj() => default!;
public GameObject GetUIContainer() => default!;
public Camera GetUIContainerCam() => default!;
public GameObject GetSubUIContainer() => default!;
public Camera GetSubUICamera() => default!;
public GameObject GetCameraContainer() => default!;
}

11
SVSim.BattleEngine/Shim/Generated/GameSetup.g.cs
View File

@@ -5,15 +5,4 @@ using System.Linq;
using UnityEngine;
namespace Wizard.Title
{
public partial class GameSetup
{
private TemporaryAssetDeleter _temporaryAssetDeleter;
private UserInfoRequest m_userInfoRequest;
private ResourceDownloader m_assetDownloader;
private readonly BattleRecovery _battleRecovery;
private MonoBehaviour m_coroutineObj;
public bool IsRunning { get; set; }
public GameSetup(MonoBehaviour coroutineObj) { }
public IEnumerator StartSetup() => default!;
}
}

8
SVSim.BattleEngine/Shim/Generated/GetDeckDataFromCode.g.cs
View File

@@ -1,12 +1,4 @@
// AUTO-GENERATED no-op stubs (m1_stub_gen) from Shadowverse_Code_2026-05-23\DeckBuilder\GetDeckDataFromCode.cs
namespace DeckBuilder
{
public partial class GetDeckDataFromCode
{
public int ClanId;
public int SubClanId;
public bool IsSubClanSet;
public int[] CardIds;
public string MyRotationId;
}
}

Some files were not shown because too many files have changed in this diff Show More