0d9d8acae0
Compile-driven bulk-copy loop (tools/engine-port/m1_copy_loop.py) pulled the precise reference closure of the battle-core roots, stopping at the classify god-object/View-VFX-UI boundary. 782 files; no re-explosion (M0 had estimated ~order 1000). Residual frontier = 52 shim-classified + 80 external (Unity/BCL) types to author next.
2159 lines
75 KiB
C#
2159 lines
75 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cute;
|
|
using UnityEngine;
|
|
using Wizard;
|
|
using Wizard.Battle;
|
|
using Wizard.Battle.Phase;
|
|
using Wizard.Battle.Player.ClassCharacter;
|
|
using Wizard.Battle.Recovery;
|
|
using Wizard.Battle.View;
|
|
using Wizard.Battle.View.Vfx;
|
|
using Wizard.BattleMgr;
|
|
|
|
public class NetworkBattleManagerBase : BattleManagerBase
|
|
{
|
|
public class ValidateSkillData
|
|
{
|
|
public int CardIndex;
|
|
|
|
public bool isPlayer;
|
|
|
|
public int SkillIndex;
|
|
|
|
public ValidateSkillData(int card, bool player, int skill)
|
|
{
|
|
CardIndex = card;
|
|
isPlayer = player;
|
|
SkillIndex = skill;
|
|
}
|
|
}
|
|
|
|
public RegisterActionManager RegisterActionManager;
|
|
|
|
protected SendKeyActionDataManager sendKeyActionDataManager;
|
|
|
|
public NetworkBattleReceiver.ReceiveData _lastReceivedData;
|
|
|
|
public VfxBase _specialWinVfx;
|
|
|
|
protected NetworkBattleReceiver networkReceiver;
|
|
|
|
protected NetworkConsistency networkConsistency;
|
|
|
|
private BattleCardBase _operatePlayCard;
|
|
|
|
private List<BattleCardBase> _operatePlaySelectCard;
|
|
|
|
protected bool _isSendSpecialWin;
|
|
|
|
private bool _isSpecialWin;
|
|
|
|
public OperateReceive OperateReceive;
|
|
|
|
protected OperateReceiveChecker operateReceiveChecker;
|
|
|
|
public TurnEndTimeController turnEndTimeController;
|
|
|
|
protected NetworkTouchControl networkTouchControl;
|
|
|
|
public NetworkBattleSetupCardEvent _networkBattleSetupCardEventBase;
|
|
|
|
protected List<NetworkBattleIntervalCheckerBase> _intervalCheckList;
|
|
|
|
protected OperateMgr operateEvent_OperateMgr;
|
|
|
|
protected bool isStopOperateFlag;
|
|
|
|
public bool IsSendSwap;
|
|
|
|
private Func<CardCreateInfo, IndexInfo, int, bool, bool, BattleCardBase> CreateBattleCardFunc;
|
|
|
|
private bool _isJudgeResultReceive;
|
|
|
|
private Coroutine _checkJudgeResultToDisconnectCoroutine;
|
|
|
|
private Coroutine _resultRetryCoroutine;
|
|
|
|
private BATTLE_RESULT_TYPE _finishEffectType;
|
|
|
|
private int judgeResult_NotFinishNum;
|
|
|
|
private const int NOTFINISH_RETRYNUM = 5;
|
|
|
|
public NetworkBattleReceiver.RESULT_CODE JudgeResultReceiveCode;
|
|
|
|
protected ReceiveIntervalTrigger receiveIntervalTrigger;
|
|
|
|
public SendIntervalTrigger SendIntervalTriggerMain;
|
|
|
|
public bool IsStopIntervalCheck;
|
|
|
|
protected bool IsShowDisconnectPanel;
|
|
|
|
protected bool IsShowOpponentDisconnectPanel;
|
|
|
|
public RecoveryController _recoveryController;
|
|
|
|
private bool _isNoLimitJudgeResult;
|
|
|
|
private bool _isNodeErrorToNocontest;
|
|
|
|
public BATTLE_RESULT_TYPE BattleResultType;
|
|
|
|
protected List<ReplaceReceivedCard.CardIdAndIndex> NotReplaceCardList;
|
|
|
|
private Coroutine _waitToReconnectSocketCoroutine;
|
|
|
|
private bool _isBattleEndLog;
|
|
|
|
public List<RegisterUnapproved> RegisterUnapprovedList { get; protected set; }
|
|
|
|
public NetworkBattleSender NetworkSender { get; protected set; }
|
|
|
|
public BattleCardBase NowPlayCard { get; private set; }
|
|
|
|
public bool IsCardPlayToTurnEndTimeoutStop { get; private set; }
|
|
|
|
public NetworkBattleData networkBattleData { get; protected set; }
|
|
|
|
public bool IsNetworkBattleEnd { get; private set; }
|
|
|
|
public OpponentRecoveryToDispChecker opponentRecoveryToDispChecker { get; protected set; }
|
|
|
|
public DisconnectToDispChecker disconnectToDispChecker { get; protected set; }
|
|
|
|
public RecoveryToDispChecker recoveryToDispChecker { get; protected set; }
|
|
|
|
public DisconnectToLoseChecker disconnectToLoseChecker { get; protected set; }
|
|
|
|
public NotMulliganEndToJudgeChecker notMulliganEndToJudgeChecker { get; protected set; }
|
|
|
|
public OpponentNotTurnStartToWinChecker opponentNotTurnStartToWinChecker { get; private set; }
|
|
|
|
public OpponentNotTurnEndToWinChecker opponentNotTurnEndToWinChecker { get; private set; }
|
|
|
|
public NotTurnEndToLoseChecker notTurnEndToLoseChecker { get; protected set; }
|
|
|
|
public NotTurnStartToLoseChecker notTurnStartToLoseChecker { get; protected set; }
|
|
|
|
public ReceiveTurnEndToJudgeResult receiveTurnEndToJudgeResult { get; protected set; }
|
|
|
|
public JudgeResultFailedToRetryChecker judgeResultFailedToRetryChecker { get; private set; }
|
|
|
|
public override bool IsStopOperate => isStopOperateFlag;
|
|
|
|
public bool IsBeforePlayerTurn { get; private set; }
|
|
|
|
public SlideObjectReceiveControl SlideObjectReceiveCtrl { get; private set; }
|
|
|
|
protected List<ValidateSkillData> validateSkillIndexList { get; set; }
|
|
|
|
protected List<int> registerSelectTypeSkillIndexList { get; set; }
|
|
|
|
public bool IsValidateSkillIndexListEmpty
|
|
{
|
|
get
|
|
{
|
|
if (validateSkillIndexList != null)
|
|
{
|
|
return !validateSkillIndexList.Any();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool IsSkillSelectTiming { get; private set; }
|
|
|
|
private List<int> LastCheckInplayWhiteRitualStackPair { get; set; } = new List<int> { 0, 0 };
|
|
|
|
public void SetIsSkillSelectTiming(bool val)
|
|
{
|
|
IsSkillSelectTiming = val;
|
|
}
|
|
|
|
public override void Update(float dt)
|
|
{
|
|
base.Update(dt);
|
|
if (IsBattleEnd && turnEndTimeController != null)
|
|
{
|
|
if (!_isBattleEndLog)
|
|
{
|
|
turnEndTimeController.EndCountDown("BattleEnd");
|
|
_isBattleEndLog = true;
|
|
}
|
|
}
|
|
else if (turnEndTimeController != null)
|
|
{
|
|
turnEndTimeController.UpdateTimerCountDown();
|
|
turnEndTimeController.UpdateTimeoutTurnEnd();
|
|
}
|
|
}
|
|
|
|
public bool IsNotReplaceCardListAny(int index, bool isPlayer)
|
|
{
|
|
for (int i = 0; i < NotReplaceCardList.Count; i++)
|
|
{
|
|
if (NotReplaceCardList[i].CardIndex == index && NotReplaceCardList[i].IsPlayer == isPlayer)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void AddNotReplaceCardList(ReplaceReceivedCard.CardIdAndIndex cardInfo)
|
|
{
|
|
NotReplaceCardList.Add(cardInfo);
|
|
}
|
|
|
|
public ReplaceReceivedCard.CardIdAndIndex GetAndRemoveNotReplaceCard(int index, bool isPlayer)
|
|
{
|
|
ReplaceReceivedCard.CardIdAndIndex cardIdAndIndex = null;
|
|
for (int i = 0; i < NotReplaceCardList.Count; i++)
|
|
{
|
|
if (NotReplaceCardList[i].CardIndex == index && NotReplaceCardList[i].IsPlayer == isPlayer)
|
|
{
|
|
cardIdAndIndex = NotReplaceCardList[i];
|
|
}
|
|
}
|
|
NotReplaceCardList.Remove(cardIdAndIndex);
|
|
return cardIdAndIndex;
|
|
}
|
|
|
|
public override int GetMaxDeckCount(bool isSelf)
|
|
{
|
|
return GameMgr.GetIns().GetDataMgr().GetDeckMaxCount(isSelf);
|
|
}
|
|
|
|
public NetworkBattleManagerBase(IBattleMgrContentsCreator contentsCreator)
|
|
: base(contentsCreator)
|
|
{
|
|
NetworkBattleManagerSetup();
|
|
}
|
|
|
|
protected override void FirstRecoverySetting()
|
|
{
|
|
}
|
|
|
|
protected virtual void NetworkBattleManagerSetup()
|
|
{
|
|
IsShowDisconnectPanel = false;
|
|
IsShowOpponentDisconnectPanel = false;
|
|
NotReplaceCardList = new List<ReplaceReceivedCard.CardIdAndIndex>();
|
|
validateSkillIndexList = new List<ValidateSkillData>();
|
|
RegisterActionManager = new RegisterActionManager(this);
|
|
registerSelectTypeSkillIndexList = new List<int>();
|
|
sendKeyActionDataManager = new SendKeyActionDataManager();
|
|
TouchControl = new NetworkTouchControl(this, _battleCamera, _backGround);
|
|
networkTouchControl = TouchControl as NetworkTouchControl;
|
|
JudgeResultReceiveCode = NetworkBattleReceiver.RESULT_CODE.NotFinish;
|
|
if (base.IsRecovery || GameMgr.GetIns().IsReplayBattle)
|
|
{
|
|
networkTouchControl.SetDisableTouch();
|
|
networkBattleData = new NetworkRecoveryBattleData(this);
|
|
networkReceiver = new NetworkReplayBattleReceiver(this);
|
|
OperateReceive = new RecoveryOperateReceive(this, RegisterActionManager, OperateMgr, networkBattleData);
|
|
int selfIdxSeed = (base.IsRecovery ? _contentsCreator.RecoveryManager.IdxChangeSeed : Data.ReplayBattleInfo.IdxChangeSeed);
|
|
int oppIdxSeed = (GameMgr.GetIns().IsReplayBattle ? Data.ReplayBattleInfo.OppoIdxChangeSeed : (-1));
|
|
CreateXorShift(selfIdxSeed, oppIdxSeed);
|
|
}
|
|
else
|
|
{
|
|
networkBattleData = new NetworkBattleData(this);
|
|
networkReceiver = new NetworkBattleReceiver(this);
|
|
OperateReceive = new OperateReceive(this, RegisterActionManager, OperateMgr, networkBattleData);
|
|
}
|
|
SetupCreateBattleCardFunc(base.IsRecovery);
|
|
OperateMgr.SetTouchControl(TouchControl);
|
|
RegisterUnapprovedList = new List<RegisterUnapproved>();
|
|
networkConsistency = new NetworkConsistency(this);
|
|
_networkBattleSetupCardEventBase = new NetworkBattleSetupCardEvent(this, RegisterActionManager, networkBattleData);
|
|
operateReceiveChecker = new OperateReceiveChecker(this, networkBattleData);
|
|
_intervalCheckList = new List<NetworkBattleIntervalCheckerBase>();
|
|
opponentRecoveryToDispChecker = new OpponentRecoveryToDispChecker();
|
|
disconnectToDispChecker = new DisconnectToDispChecker();
|
|
_intervalCheckList.Add(disconnectToDispChecker);
|
|
disconnectToLoseChecker = new DisconnectToLoseChecker();
|
|
_intervalCheckList.Add(disconnectToLoseChecker);
|
|
opponentNotTurnStartToWinChecker = new OpponentNotTurnStartToWinChecker(this);
|
|
_intervalCheckList.Add(opponentNotTurnStartToWinChecker);
|
|
opponentNotTurnEndToWinChecker = new OpponentNotTurnEndToWinChecker(this);
|
|
_intervalCheckList.Add(opponentNotTurnEndToWinChecker);
|
|
notMulliganEndToJudgeChecker = new NotMulliganEndToJudgeChecker();
|
|
_intervalCheckList.Add(notMulliganEndToJudgeChecker);
|
|
notTurnEndToLoseChecker = new NotTurnEndToLoseChecker(this);
|
|
_intervalCheckList.Add(notTurnEndToLoseChecker);
|
|
notTurnStartToLoseChecker = new NotTurnStartToLoseChecker();
|
|
_intervalCheckList.Add(notTurnStartToLoseChecker);
|
|
receiveTurnEndToJudgeResult = new ReceiveTurnEndToJudgeResult();
|
|
_intervalCheckList.Add(receiveTurnEndToJudgeResult);
|
|
judgeResultFailedToRetryChecker = new JudgeResultFailedToRetryChecker();
|
|
_intervalCheckList.Add(judgeResultFailedToRetryChecker);
|
|
receiveIntervalTrigger = new ReceiveIntervalTrigger();
|
|
SendIntervalTriggerMain = new SendIntervalTrigger();
|
|
SlideObjectReceiveCtrl = new SlideObjectReceiveControl(this);
|
|
}
|
|
|
|
protected virtual void OpponentAliveCallback()
|
|
{
|
|
DispOpponentDisconnect(flag: false);
|
|
}
|
|
|
|
protected virtual void OpponentDisconnectCallback()
|
|
{
|
|
DispOpponentDisconnect(flag: true);
|
|
}
|
|
|
|
public override void SetupActionProcessorEvent(ActionProcessor processor, bool isPlayer)
|
|
{
|
|
base.SetupActionProcessorEvent(processor, isPlayer);
|
|
SetupNetworkActionProcessorEvent(processor, isPlayer);
|
|
}
|
|
|
|
protected virtual void SetupNetworkActionProcessorEvent(ActionProcessor processor, bool isPlayer)
|
|
{
|
|
processor.OnTransform += delegate(BattleCardBase card, int id, bool isChoice)
|
|
{
|
|
if (card.IsPlayer)
|
|
{
|
|
RegisterActionManager.Add(new RegisterMetamorphoseData(id, card.Index, card.IsPlayer, null, isChoice));
|
|
}
|
|
};
|
|
processor.OnSpecialAccelerate += delegate(SkillBase skill)
|
|
{
|
|
if (skill.SkillPrm.ownerCard.IsPlayer && RegisterSkillConditionCheck.IsSkillConditionCheck(skill))
|
|
{
|
|
_networkBattleSetupCardEventBase.Event_SkillConditionCheck(skill, new List<BattleCardBase>());
|
|
}
|
|
};
|
|
processor.OnBeforeChosenPlayCard += delegate(BattleCardBase originalCard, BattleCardBase playCard, List<int> chosenIndexs)
|
|
{
|
|
if (originalCard.IsPlayer || NetworkBattleGenericTool.IsAcceleratedCard(originalCard) || NetworkBattleGenericTool.IsCrystallizeCard(originalCard) || playCard.IsChoiceBraveSkillCard)
|
|
{
|
|
sendKeyActionDataManager.SettingKeyActionData(originalCard, playCard, chosenIndexs);
|
|
}
|
|
};
|
|
processor.OnBeforeBurialRitePlayCard += delegate(BattleCardBase originalCard, IEnumerable<BattleCardBase> selectedCards, bool isEvolve)
|
|
{
|
|
sendKeyActionDataManager.SettingBurialRiteKeyActionData(originalCard, selectedCards, isEvolve);
|
|
};
|
|
processor.OnBeforeChosenEvolution += delegate(BattleCardBase originalCard, BattleCardBase evolCard, List<int> chosenIndexs)
|
|
{
|
|
if (originalCard.IsPlayer)
|
|
{
|
|
sendKeyActionDataManager.SettingKeyActionData(originalCard, evolCard, chosenIndexs, isEvol: true);
|
|
}
|
|
};
|
|
processor.OnBeforeFusion += delegate(BattleCardBase originalCard, IEnumerable<BattleCardBase> selectedCards)
|
|
{
|
|
if (originalCard.IsPlayer)
|
|
{
|
|
sendKeyActionDataManager.SettingFusionKeyActionData(originalCard, selectedCards);
|
|
}
|
|
};
|
|
}
|
|
|
|
public void SetPublishedActiveSkillCount(SkillCollectionBase skills)
|
|
{
|
|
for (int i = 0; i < skills.Count(); i++)
|
|
{
|
|
if (!skills.Get(i).SkillPrm.selfBattlePlayer.BattleMgr.IsVirtualBattle && !(skills.Get(i) is Skill_none))
|
|
{
|
|
skills.Get(i).SetPublishedActiveSkillCount(skills.Get(i).SkillPrm.selfBattlePlayer.BattleMgr.AllPublishedActiveSkillCount + base.TemporaryPublishedAddCount);
|
|
base.TemporaryPublishedAddCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void SetupCreateBattleCardFunc(bool createCardWithoutGameObject)
|
|
{
|
|
if (createCardWithoutGameObject)
|
|
{
|
|
CreateBattleCardFunc = delegate(CardCreateInfo info, IndexInfo indexInfo, int repeat, bool isVirtual, bool isActualCard)
|
|
{
|
|
CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(info.Id);
|
|
BattlePlayerBase battlePlayer = GetBattlePlayer(info.IsPlayer);
|
|
return CreateBattleCard(info.Id, info.IsPlayer, null, cardParameterFromId, battlePlayer, SetupCardIndex(battlePlayer, (info.IndexInfo == null) ? indexInfo.AddIndex : info.IndexInfo.AddIndex));
|
|
};
|
|
}
|
|
else
|
|
{
|
|
CreateBattleCardFunc = base.CreateBattleCardWithGameObject;
|
|
}
|
|
}
|
|
|
|
public virtual void RecoveryEnd()
|
|
{
|
|
base.IsRecovery = false;
|
|
networkTouchControl.SetEnableTouch();
|
|
NetworkBattleData networkBattleData = this.networkBattleData;
|
|
this.networkBattleData = new NetworkBattleData(this);
|
|
this.networkBattleData.isPlayerMulliganEnd = networkBattleData.isPlayerMulliganEnd;
|
|
this.networkBattleData.isOppoMulliganEnd = networkBattleData.isOppoMulliganEnd;
|
|
this.networkBattleData.SetReceiveData(networkBattleData.GetReceiveData());
|
|
this.networkBattleData.isEnemyFirstTurn = networkBattleData.isEnemyFirstTurn;
|
|
_networkBattleSetupCardEventBase.OverwriteNetworkBattleData(this.networkBattleData);
|
|
SetupCreateBattleCardFunc(createCardWithoutGameObject: false);
|
|
OperateMgr operateMgr = OperateMgr;
|
|
OperateMgr = CreateOperateMgr();
|
|
OperateMgr.SetUpRecoveryEvent(operateMgr);
|
|
operateMgr = null;
|
|
OperateReceive = new OperateReceive(this, RegisterActionManager, OperateMgr, this.networkBattleData);
|
|
if (_phase is NetworkMulliganPhase)
|
|
{
|
|
(_phase as NetworkMulliganPhase).MulliganEventSetting();
|
|
}
|
|
operateReceiveChecker = new OperateReceiveChecker(this, this.networkBattleData);
|
|
networkReceiver = new NetworkBattleReceiver(this);
|
|
SetupNetworkEvent(isRecovery: true);
|
|
SetupReplayRecordingEvent();
|
|
if (_specialWinVfx == null)
|
|
{
|
|
ClearRegisterCardList();
|
|
}
|
|
}
|
|
|
|
private void SetupReplayRecordingEvent()
|
|
{
|
|
_contentsCreator.ReplayRecordManager.SetupOperateMgrEvents(this);
|
|
}
|
|
|
|
public virtual void RecoveryTimeOutSetting(float extendTime, bool isMulliganEnd, long startTime = -1L)
|
|
{
|
|
if (!isMulliganEnd)
|
|
{
|
|
if (MulliganMgr != null)
|
|
{
|
|
MulliganMgr.GetMulliganInfo().SetExtendTime(extendTime);
|
|
}
|
|
return;
|
|
}
|
|
if (!BattlePlayer.IsSelfTurn)
|
|
{
|
|
opponentNotTurnEndToWinChecker.StartChecker();
|
|
return;
|
|
}
|
|
if (turnEndTimeController == null)
|
|
{
|
|
TurnEndButtonUI component = SBattleLoad.m_TurnEndBtnUI.GetComponent<TurnEndButtonUI>();
|
|
turnEndTimeController = new TurnEndTimeController(this, BattlePlayer, component);
|
|
}
|
|
if (!turnEndTimeController.IsCountdownRunning())
|
|
{
|
|
turnEndTimeController.StartCountDown("SetTimeoutSetting");
|
|
}
|
|
turnEndTimeController.SetExtendTime(extendTime);
|
|
}
|
|
|
|
public void SetTimeDecrementFlag(bool isDecrement)
|
|
{
|
|
if (turnEndTimeController != null)
|
|
{
|
|
turnEndTimeController.SetDecrementFlag(isDecrement);
|
|
}
|
|
}
|
|
|
|
public virtual void SetupFieldAndHandAfterRecovery(Action onEndRecoveryCallback, RecoveryOperationInfo aiBattleRecoveryData = null)
|
|
{
|
|
if (!Data.BattleRecoveryInfo.IsMulliganEnd)
|
|
{
|
|
SequentialVfxPlayer vfx = SequentialVfxPlayer.Create(MulliganMgr.RecoverMulligan(networkBattleData.isPlayerMulliganEnd, this), InstantVfx.Create(onEndRecoveryCallback));
|
|
base.VfxMgr.RegisterSequentialVfx(vfx);
|
|
return;
|
|
}
|
|
BattlePlayer.PlayerBattleView.ClearPlayQueue();
|
|
BattleEnemy.BattleEnemyView.ClearPlayQueue();
|
|
RecreateCardViews(BattlePlayer.InPlayCards);
|
|
RecreateCardViews(BattlePlayer.HandCardList);
|
|
RecreateCardViews(BattlePlayer.DeckCardList);
|
|
RecreateCardViews(BattlePlayer.ReservedCardList);
|
|
RecreateCardViews(BattleEnemy.InPlayCards);
|
|
RecreateCardViews(BattleEnemy.HandCardList);
|
|
RecreateCardViews(BattleEnemy.DeckCardList);
|
|
RecreateCardViews(BattleEnemy.ReservedCardList);
|
|
RefreshHealthVfx refreshHealthVfx = new RefreshHealthVfx(BattlePlayer);
|
|
RefreshHealthVfx refreshHealthVfx2 = new RefreshHealthVfx(BattleEnemy);
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create(BattlePlayer.BattleView.RecoveryInPlayCards(), BattlePlayer.BattleView.RecoveryInHandCards(), BattlePlayer.BattleView.RecoveryClassAndInPlayCardAttachSkillEffect(), BattleEnemy.BattleView.RecoveryInPlayCards(), BattleEnemy.BattleView.RecoveryInHandCards(), BattleEnemy.BattleView.RecoveryClassAndInPlayCardAttachSkillEffect(), refreshHealthVfx, refreshHealthVfx2);
|
|
ReinitializeTurnPanelControl();
|
|
VfxBase vfxBase = (BattlePlayer.IsSelfTurn ? BattlePlayer.BattleView.RecoveryTurnStart() : BattleEnemy.BattleEnemyView.RecoveryTurnStart());
|
|
ParallelVfxPlayer parallelVfxPlayer2 = ParallelVfxPlayer.Create(BattlePlayer.BattleView.RecoveryBattleUI(), BattleEnemy.BattleView.RecoveryBattleUI(), InstantVfx.Create(delegate
|
|
{
|
|
BattlePlayer.PlayerBattleView.ForceShowTurnEndButton();
|
|
}), vfxBase, RecoveryAfterMulliganPhase.RestoreUI(this));
|
|
VfxBase vfxBase2 = (BattleEnemy.IsSelfTurn ? BattleEnemy.CreateThinkingVfx(this) : NullVfx.GetInstance());
|
|
SequentialVfxPlayer vfx2 = SequentialVfxPlayer.Create(parallelVfxPlayer2, parallelVfxPlayer, HandViewBase.CreateHideCardMeshesVfx(BattleEnemy.HandCardList), vfxBase2, InstantVfx.Create(onEndRecoveryCallback), InstantVfx.Create(delegate
|
|
{
|
|
ResetLeaderAnimation(BattlePlayer, BattleEnemy);
|
|
}));
|
|
base.VfxMgr.RegisterSequentialVfx(vfx2);
|
|
}
|
|
|
|
protected void ResetLeaderAnimation(BattlePlayer battlePlayer, BattleEnemy battleEnemy)
|
|
{
|
|
PlayerClassBattleCardView playerClassBattleCardView = battlePlayer.Class.BattleCardView as PlayerClassBattleCardView;
|
|
playerClassBattleCardView.ClassCharacter.SetAnimationEnable(PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SHOW_LEADER_ANIMATION));
|
|
if (battlePlayer.IsSkinEvolved)
|
|
{
|
|
playerClassBattleCardView.ClassCharacter.PlayMotion(ClassCharaPrm.MotionType.z_idle);
|
|
}
|
|
EnemyClassBattleCardView enemyClassBattleCardView = battleEnemy.Class.BattleCardView as EnemyClassBattleCardView;
|
|
enemyClassBattleCardView.ClassCharacter.SetAnimationEnable(PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SHOW_LEADER_ANIMATION));
|
|
if (battleEnemy.IsSkinEvolved)
|
|
{
|
|
enemyClassBattleCardView.ClassCharacter.PlayMotion(ClassCharaPrm.MotionType.z_idle);
|
|
}
|
|
}
|
|
|
|
public void SendEchoRecovery(NetworkBattleReceiver.ReceiveData receiveData)
|
|
{
|
|
NetworkSender.SendEcho(-1, receiveData.actionType, sendKeyActionDataManager);
|
|
}
|
|
|
|
protected void RecreateCardViews(IEnumerable<BattleCardBase> cardList)
|
|
{
|
|
foreach (BattleCardBase card in cardList)
|
|
{
|
|
if (card.BattleCardView.IsNullView)
|
|
{
|
|
CardParameter cardParameterFromId = CardMaster.GetInstanceForBattle().GetCardParameterFromId(card.CardId);
|
|
GameObject cardGameObject = CreateBaseCardGameObject(cardParameterFromId, card.IsPlayer, card.Index);
|
|
SetupCardObjectMaterials(cardGameObject, card);
|
|
card.RecreateView(cardGameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override int CreateBackgroundId()
|
|
{
|
|
if (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SIMPLE_STAGE))
|
|
{
|
|
return 9;
|
|
}
|
|
int backGroundId = _contentsCreator.RecoveryManager.BackGroundId;
|
|
if (backGroundId >= 0)
|
|
{
|
|
return backGroundId;
|
|
}
|
|
return GameMgr.GetIns().GetNetworkUserInfoData().GetFieldId();
|
|
}
|
|
|
|
protected override OperateMgr CreateOperateMgr()
|
|
{
|
|
if (base.IsRecovery)
|
|
{
|
|
return new RecoveryOperateMgr(this, TouchControl);
|
|
}
|
|
return base.CreateOperateMgr();
|
|
}
|
|
|
|
public override IInnerOptionsBuilder CreateEnemyInnerOptionsBuilder()
|
|
{
|
|
return new NetworkOpponentInnerOptionsBuilder();
|
|
}
|
|
|
|
public override void StartOpening(int FirstAttack)
|
|
{
|
|
base.StartOpening(FirstAttack);
|
|
TurnEndButtonUI component = SBattleLoad.m_TurnEndBtnUI.GetComponent<TurnEndButtonUI>();
|
|
if (!GameMgr.GetIns().IsAINetwork || turnEndTimeController == null)
|
|
{
|
|
turnEndTimeController = new TurnEndTimeController(this, BattlePlayer, component);
|
|
}
|
|
}
|
|
|
|
protected override void SetupEvent()
|
|
{
|
|
base.SetupEvent();
|
|
SetupBattlePlayerRegisterEvents(BattlePlayer);
|
|
SetupBattlePlayerRegisterEvents(BattleEnemy);
|
|
if (base.IsRecovery)
|
|
{
|
|
StartRecoveryRecording();
|
|
}
|
|
else
|
|
{
|
|
SetupNetworkEvent(isRecovery: false);
|
|
}
|
|
}
|
|
|
|
protected virtual void SendTurnStart()
|
|
{
|
|
}
|
|
|
|
protected virtual void SendTurnEndAction()
|
|
{
|
|
}
|
|
|
|
public virtual void SendTurnEnd()
|
|
{
|
|
}
|
|
|
|
protected virtual void SendChatStamp(ClassCharaPrm.EmotionType emoteType)
|
|
{
|
|
}
|
|
|
|
protected virtual void SendPlayCard(BattleCardBase playCard, List<BattleCardBase> playSelectCard, SendKeyActionDataManager sendKeyActionDataManager)
|
|
{
|
|
}
|
|
|
|
protected virtual void SendAttackData(BattleCardBase attackCard, BattleCardBase targetCard)
|
|
{
|
|
}
|
|
|
|
protected virtual void SendEvolveData(BattleCardBase playCard, List<BattleCardBase> playSelectCard, SendKeyActionDataManager sendKeyActionDataManager)
|
|
{
|
|
}
|
|
|
|
protected virtual void SendFusionData(BattleCardBase playCard, List<BattleCardBase> playSelectCard, SendKeyActionDataManager sendKeyActionDataManager)
|
|
{
|
|
}
|
|
|
|
protected virtual void SendJudgement()
|
|
{
|
|
}
|
|
|
|
public virtual void SendEcho(int playIndex, NetworkBattleDefine.PlayActionType actionType, bool isNotActiveSeq = false, bool isTurnStart = false)
|
|
{
|
|
}
|
|
|
|
protected virtual void SetupNetworkEvent(bool isRecovery)
|
|
{
|
|
BattlePlayer battlePlayer = BattlePlayer;
|
|
battlePlayer.OnTurnStartComplete = (Action)Delegate.Combine(battlePlayer.OnTurnStartComplete, (Action)delegate
|
|
{
|
|
notTurnStartToLoseChecker.StopChecker();
|
|
_isNoLimitJudgeResult = false;
|
|
SendTurnStart();
|
|
notTurnEndToLoseChecker.StartChecker();
|
|
});
|
|
BattleEnemy battleEnemy = BattleEnemy;
|
|
battleEnemy.OnTurnStartComplete = (Action)Delegate.Combine(battleEnemy.OnTurnStartComplete, (Action)delegate
|
|
{
|
|
notTurnStartToLoseChecker.StopChecker();
|
|
_isNoLimitJudgeResult = false;
|
|
});
|
|
BattlePlayer.OnShortageDeck += delegate
|
|
{
|
|
RegisterActionManager.Add(new RegisterDeckOut(isSelf: true));
|
|
return OnShortageDeck(BattlePlayer);
|
|
};
|
|
BattleEnemy.OnShortageDeck += delegate
|
|
{
|
|
RegisterActionManager.Add(new RegisterDeckOut(isSelf: false));
|
|
return OnShortageDeck(BattleEnemy);
|
|
};
|
|
BattlePlayer.OnTurnEndStart += delegate
|
|
{
|
|
_isNoLimitJudgeResult = true;
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.ResetDisconnectLogNum();
|
|
}
|
|
};
|
|
BattleEnemy.OnTurnEndStart += delegate
|
|
{
|
|
notTurnStartToLoseChecker.StartChecker();
|
|
_isNoLimitJudgeResult = true;
|
|
};
|
|
if (isRecovery)
|
|
{
|
|
FirstSettingRealTimeNetworkBattle();
|
|
}
|
|
else
|
|
{
|
|
BattleCoroutine.GetInstance().StartCoroutine(WaitNetworkBattleLoading());
|
|
}
|
|
}
|
|
|
|
public void SettingTurnEndRestore(BattlePlayerBase player)
|
|
{
|
|
RegisterEnhanceTrigger registerEnhanceTrigger = new RegisterEnhanceTrigger(player);
|
|
registerEnhanceTrigger.SettingTurnEndRestore(new List<BattleCardBase>(player.HandCardList));
|
|
if (player.EvolveWaitTurnCount <= 0)
|
|
{
|
|
registerEnhanceTrigger.SettingCanEvolve();
|
|
}
|
|
if (Data.CurrentFormat == Format.Unlimited)
|
|
{
|
|
registerEnhanceTrigger.SettingIsUnlimited();
|
|
}
|
|
RegisterActionManager.Add(registerEnhanceTrigger);
|
|
}
|
|
|
|
public void SettingTurnStartRestore(BattlePlayerBase player)
|
|
{
|
|
RegisterEnhanceTrigger registerEnhanceTrigger = new RegisterEnhanceTrigger(player);
|
|
registerEnhanceTrigger.SettingTurnStartRestore();
|
|
if (player.EvolveWaitTurnCount <= 0)
|
|
{
|
|
registerEnhanceTrigger.SettingCanEvolve();
|
|
}
|
|
if (Data.CurrentFormat == Format.Unlimited)
|
|
{
|
|
registerEnhanceTrigger.SettingIsUnlimited();
|
|
}
|
|
RegisterActionManager.Add(registerEnhanceTrigger);
|
|
}
|
|
|
|
public void RegisterInplayWhiteRitualStack(BattlePlayerBase player)
|
|
{
|
|
int num = player.InPlayCards.Where((BattleCardBase c) => c.IsTribe(CardBasePrm.TribeType.WHITE_RITUAL) && (c.IsField || c.IsChantField)).Sum((BattleCardBase c) => c.SkillApplyInformation.WhiteRitualCount);
|
|
if (LastCheckInplayWhiteRitualStackPair[(!player.IsPlayer) ? 1 : 0] != num)
|
|
{
|
|
RegisterPlayerParameter data = new RegisterPlayerParameter(RegisterActionBase.ActionBaseParameter.stack, num, player.IsPlayer);
|
|
RegisterActionManager.Add(data);
|
|
LastCheckInplayWhiteRitualStackPair[(!player.IsPlayer) ? 1 : 0] = num;
|
|
}
|
|
}
|
|
|
|
protected virtual void SetupBattlePlayerRegisterEvents(BattlePlayerBase battlePlayer)
|
|
{
|
|
battlePlayer.OnAddHandCardEvent += delegate(BattleCardBase card, NetworkBattleDefine.NetworkCardPlaceState fromState, bool isOpen, SkillBase skill)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
AddRegisterMoveCard(card, fromState, to, skill, isNotCheck: false, isOpen, isFlood: false, card.Skills.Any((SkillBase s) => s.OnWhenDraw != 0));
|
|
};
|
|
battlePlayer.OnAfterReturnCardEvent += delegate(BattleCardBase card)
|
|
{
|
|
_networkBattleSetupCardEventBase.SetupCardSkillEvent(card);
|
|
};
|
|
battlePlayer.OnAddCemeteryEvent += delegate(BattleCardBase card, BattlePlayerBase.CEMETERY_TYPE cemeteryType, bool isOpen, SkillBase skill)
|
|
{
|
|
if (!card.IsClass && card.Index != -1)
|
|
{
|
|
bool flag = false;
|
|
if (cemeteryType != BattlePlayerBase.CEMETERY_TYPE.NORMAL)
|
|
{
|
|
foreach (RegisterActionBase item in RegisterActionManager.RegisterDataList.FindAll((RegisterActionBase x) => x is RegisterToken))
|
|
{
|
|
RegisterChoiceAdd registerChoiceAdd = item as RegisterChoiceAdd;
|
|
RegisterToken registerToken = item as RegisterToken;
|
|
if (registerChoiceAdd != null && card.IsPlayer == registerChoiceAdd.IsSelf && registerChoiceAdd.IndexList.Any((int s) => s == card.Index))
|
|
{
|
|
registerChoiceAdd.SetToPlace(NetworkBattleDefine.NetworkCardPlaceState.Cemetery);
|
|
flag = true;
|
|
}
|
|
else if (registerToken != null && registerToken.CardObj == card && registerToken.ToPlaceState != NetworkBattleDefine.NetworkCardPlaceState.Deck)
|
|
{
|
|
registerToken.SetToPlace(NetworkBattleDefine.NetworkCardPlaceState.Cemetery);
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.None;
|
|
switch (cemeteryType)
|
|
{
|
|
case BattlePlayerBase.CEMETERY_TYPE.NORMAL:
|
|
networkCardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index);
|
|
if (networkCardPlaceState == NetworkBattleDefine.NetworkCardPlaceState.Hand && card.Skills.Any((SkillBase s) => s.OnDisCardStart != 0))
|
|
{
|
|
isOpen = true;
|
|
}
|
|
break;
|
|
case BattlePlayerBase.CEMETERY_TYPE.FIELD_RETURN_HAND_OVER:
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Field;
|
|
break;
|
|
case BattlePlayerBase.CEMETERY_TYPE.DECK_DRAW_HAND_OVER:
|
|
networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
break;
|
|
}
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Cemetery;
|
|
AddRegisterMoveCard(card, networkCardPlaceState, to, skill, isNotCheck: true, isOpen, (cemeteryType != BattlePlayerBase.CEMETERY_TYPE.NORMAL) ? true : false, isWhenDraw: false, card.SkillApplyInformation.IsGuard);
|
|
}
|
|
}
|
|
};
|
|
battlePlayer.OnSummonAfterEvent += delegate(BattleCardBase card)
|
|
{
|
|
RegisterInplayWhiteRitualStack(card.SelfBattlePlayer);
|
|
};
|
|
battlePlayer.OnLeaveAfterEvent += delegate(BattleCardBase card)
|
|
{
|
|
RegisterInplayWhiteRitualStack(card.SelfBattlePlayer);
|
|
};
|
|
battlePlayer.OnMetamorphoseAfterEvent += delegate(BattleCardBase originalCard, BattleCardBase newCard)
|
|
{
|
|
RegisterInplayWhiteRitualStack(newCard.SelfBattlePlayer);
|
|
};
|
|
battlePlayer.OnSpellPlayEvent += delegate(BattleCardBase card)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState networkCardPlaceState = NetworkBattleDefine.NetworkCardPlaceState.Hand;
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Cemetery;
|
|
AddRegisterMoveCard(card, networkCardPlaceState, to, null);
|
|
};
|
|
battlePlayer.OnAddPlayCardEvent += delegate(BattleCardBase card, bool isGetoff, SkillBase skill)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState networkCardPlaceState = ((!isGetoff) ? NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index) : NetworkBattleDefine.NetworkCardPlaceState.Riding);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Field;
|
|
AddRegisterMoveCard(card, networkCardPlaceState, to, skill);
|
|
List<RegisterMetamorphoseData> list = RegisterActionManager.RegisterDataList.FindAll((RegisterActionBase x) => x is RegisterMetamorphoseData).ConvertAll((RegisterActionBase x) => x as RegisterMetamorphoseData);
|
|
if (list != null)
|
|
{
|
|
RegisterMetamorphoseData registerMetamorphoseData = list.Find((RegisterMetamorphoseData x) => x.IsChoice);
|
|
if (registerMetamorphoseData != null)
|
|
{
|
|
RegisterActionManager.Remove(registerMetamorphoseData);
|
|
RegisterActionManager.Add(registerMetamorphoseData);
|
|
}
|
|
}
|
|
};
|
|
battlePlayer.OnAddDeckEvent += delegate(BattleCardBase card, SkillBase skill)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState cardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Deck;
|
|
AddRegisterMoveCard(card, cardPlaceState, to, skill);
|
|
};
|
|
battlePlayer.OnAddBanishEvent += delegate(BattleCardBase card, SkillBase skill, bool isOpen)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState cardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Banish;
|
|
AddRegisterMoveCard(card, cardPlaceState, to, skill, isNotCheck: false, isOpen);
|
|
};
|
|
battlePlayer.OnGeton += delegate(BattleCardBase card, SkillBase skill)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState cardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Riding;
|
|
AddRegisterMoveCard(card, cardPlaceState, to, skill);
|
|
};
|
|
battlePlayer.OnAddBlackHole += delegate(List<BattleCardBase> cards, SkillBase skill)
|
|
{
|
|
for (int i = 0; i < cards.Count; i++)
|
|
{
|
|
if (!(cards[i] is NullBattleCard))
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState cardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, cards[i].Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.BlackHole;
|
|
AddRegisterMoveCard(cards[i], cardPlaceState, to, skill);
|
|
}
|
|
}
|
|
RegisterInplayWhiteRitualStack(battlePlayer);
|
|
};
|
|
battlePlayer.OnAddUniteEvent += delegate(BattleCardBase card, SkillBase skill)
|
|
{
|
|
NetworkBattleDefine.NetworkCardPlaceState cardPlaceState = NetworkBattleGenericTool.GetCardPlaceState(battlePlayer, card.Index);
|
|
NetworkBattleDefine.NetworkCardPlaceState to = NetworkBattleDefine.NetworkCardPlaceState.Unite;
|
|
AddRegisterMoveCard(card, cardPlaceState, to, skill);
|
|
};
|
|
battlePlayer.OnChangePP += delegate(int changePpCount)
|
|
{
|
|
if (changePpCount != 0)
|
|
{
|
|
RegisterActionManager.Add(new RegisterPlayerParameter(RegisterActionBase.ActionBaseParameter.maxPP, changePpCount, battlePlayer.IsPlayer));
|
|
}
|
|
};
|
|
battlePlayer.OnTurnEndFinish += delegate
|
|
{
|
|
if (battlePlayer.IsPlayer)
|
|
{
|
|
IsBeforePlayerTurn = battlePlayer.IsExtraTurn;
|
|
}
|
|
else
|
|
{
|
|
IsBeforePlayerTurn = !battlePlayer.IsExtraTurn;
|
|
}
|
|
return NullVfx.GetInstance();
|
|
};
|
|
}
|
|
|
|
protected virtual bool isNetworkOepn()
|
|
{
|
|
return ToolboxGame.RealTimeNetworkAgent.IsOpen();
|
|
}
|
|
|
|
private IEnumerator WaitNetworkBattleLoading()
|
|
{
|
|
while (ToolboxGame.RealTimeNetworkAgent == null)
|
|
{
|
|
yield return null;
|
|
}
|
|
while (!isNetworkOepn())
|
|
{
|
|
yield return null;
|
|
}
|
|
FirstSettingRealTimeNetworkBattle();
|
|
int randomSeed = GameMgr.GetIns().GetNetworkUserInfoData().GetRandomSeed();
|
|
LocalLog.AccumulateLastTraceLog("657699SetSeed " + randomSeed);
|
|
_stableRandom = new System.Random(randomSeed);
|
|
_stableRandomOnlySelf = new System.Random(randomSeed);
|
|
}
|
|
|
|
protected void FirstSettingRealTimeNetworkBattle()
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.SetNetworkBattleMgr(this);
|
|
}
|
|
|
|
public virtual void SettingOpponentAliveEvent()
|
|
{
|
|
NetworkStatus playerNetworkStatus = ToolboxGame.RealTimeNetworkAgent.PlayerNetworkStatus;
|
|
playerNetworkStatus.OnAlive = (Action)Delegate.Combine(playerNetworkStatus.OnAlive, new Action(OnPlayerAlive));
|
|
NetworkStatus opponentNetworkStatus = ToolboxGame.RealTimeNetworkAgent.OpponentNetworkStatus;
|
|
opponentNetworkStatus.OnAlive = (Action)Delegate.Combine(opponentNetworkStatus.OnAlive, new Action(OpponentAliveCallback));
|
|
NetworkStatus opponentNetworkStatus2 = ToolboxGame.RealTimeNetworkAgent.OpponentNetworkStatus;
|
|
opponentNetworkStatus2.OnDisconnect = (Action)Delegate.Combine(opponentNetworkStatus2.OnDisconnect, new Action(OpponentDisconnectCallback));
|
|
}
|
|
|
|
public override void SetupBattlePlayersEvent()
|
|
{
|
|
base.SetupBattlePlayersEvent();
|
|
BattlePlayer.Emotion.OnPlay += (ClassCharaPrm.EmotionType emoteType) => (emoteType == ClassCharaPrm.EmotionType.LOSE || emoteType == ClassCharaPrm.EmotionType.SURRENDER_LOSE || ClassCharaPrm.IsEvolutionEmotionType(emoteType)) ? ((VfxBase)NullVfx.GetInstance()) : ((VfxBase)InstantVfx.Create(delegate
|
|
{
|
|
SendChatStamp(emoteType);
|
|
}));
|
|
}
|
|
|
|
public override void SetUpOperateEvent(OperateMgr operateMgr)
|
|
{
|
|
base.SetUpOperateEvent(operateMgr);
|
|
operateEvent_OperateMgr = operateMgr;
|
|
SetUpNetworkOperateEvent();
|
|
}
|
|
|
|
private void SetUpNetworkOperateEvent()
|
|
{
|
|
OperateMgr operateMgr = operateEvent_OperateMgr;
|
|
operateMgr.OnBeforeSetCard += delegate
|
|
{
|
|
IsCardPlayToTurnEndTimeoutStop = true;
|
|
};
|
|
operateMgr.OnSetCard += delegate(BattleCardBase card)
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnSetCard \n";
|
|
NowPlayCard = card;
|
|
};
|
|
if (base.IsRecovery)
|
|
{
|
|
return;
|
|
}
|
|
operateMgr.OnSetCardSuccess += delegate(BattleCardBase originalCard, BattleCardBase card, IEnumerable<BattleCardBase> selectedCard)
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnSetCardSuccess \n";
|
|
SettingPlaySelectCard(card.IsChoiceBraveSkillCard ? originalCard : card, selectedCard);
|
|
};
|
|
operateMgr.OnSetCardComplete += delegate
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnSetCardComplete \n";
|
|
if (_operatePlayCard != null && _operatePlayCard.IsPlayer)
|
|
{
|
|
SendPlayCard(_operatePlayCard, _operatePlaySelectCard, sendKeyActionDataManager);
|
|
initSelectData();
|
|
NetworkBattleSender.PlayActionLogMsg = "";
|
|
}
|
|
IsCardPlayToTurnEndTimeoutStop = false;
|
|
return NullVfx.GetInstance();
|
|
};
|
|
operateMgr.OnEvolveSuccess += delegate(BattleCardBase originalCard, BattleCardBase card, IEnumerable<BattleCardBase> selectedCard)
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnEvolveSuccess \n";
|
|
SettingPlaySelectCard(card, selectedCard);
|
|
};
|
|
operateMgr.OnEvoleComplete += delegate
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnEvoleComplete \n";
|
|
if (_operatePlayCard != null && _operatePlayCard.IsPlayer)
|
|
{
|
|
SendEvolveData(_operatePlayCard, _operatePlaySelectCard, sendKeyActionDataManager);
|
|
initSelectData();
|
|
NetworkBattleSender.PlayActionLogMsg = "";
|
|
}
|
|
return NullVfx.GetInstance();
|
|
};
|
|
operateMgr.OnPlayerAttack += delegate(BattleCardBase attackCard, BattleCardBase targetCard)
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnPlayerAttack \n";
|
|
SendAttackData(attackCard, targetCard);
|
|
NetworkBattleSender.PlayActionLogMsg = "";
|
|
return NullVfx.GetInstance();
|
|
};
|
|
operateMgr.OnBeforeFusion += delegate(BattleCardBase card, IEnumerable<BattleCardBase> selectedCard)
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnFusionSuccess \n";
|
|
SettingPlaySelectCard(card, selectedCard);
|
|
};
|
|
operateMgr.OnAfterFusion += delegate
|
|
{
|
|
NetworkBattleSender.PlayActionLogMsg += "OnFusionComplete \n";
|
|
if (_operatePlayCard != null && _operatePlayCard.IsPlayer)
|
|
{
|
|
SendFusionData(_operatePlayCard, _operatePlaySelectCard, sendKeyActionDataManager);
|
|
initSelectData();
|
|
NetworkBattleSender.PlayActionLogMsg = "";
|
|
}
|
|
return NullVfx.GetInstance();
|
|
};
|
|
}
|
|
|
|
private void SettingPlaySelectCard(BattleCardBase card, IEnumerable<BattleCardBase> selectedCards)
|
|
{
|
|
if (!card.IsPlayer)
|
|
{
|
|
return;
|
|
}
|
|
_operatePlayCard = card;
|
|
if (selectedCards != null)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
List<BattleCardBase> list2 = selectedCards.ToList();
|
|
foreach (BattleCardBase item in list2)
|
|
{
|
|
if (NetworkBattleGenericTool.GetCardPlaceState(item.SelfBattlePlayer, item.Index) == NetworkBattleDefine.NetworkCardPlaceState.None)
|
|
{
|
|
list.Add(item);
|
|
}
|
|
}
|
|
foreach (BattleCardBase item2 in list)
|
|
{
|
|
list2.Remove(item2);
|
|
}
|
|
_operatePlaySelectCard = list2.ToList();
|
|
}
|
|
else
|
|
{
|
|
_operatePlaySelectCard = null;
|
|
}
|
|
}
|
|
|
|
private void initSelectData()
|
|
{
|
|
_operatePlayCard = null;
|
|
_operatePlaySelectCard = null;
|
|
}
|
|
|
|
public NetworkBattleReceiver GetNetworkBattleReceiver()
|
|
{
|
|
return networkReceiver;
|
|
}
|
|
|
|
public override void DisposeBattleGameObj()
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("DisposeBattleGameObj");
|
|
base.DisposeBattleGameObj();
|
|
BattleFinishToEffectClear();
|
|
BattleFinishToStopIntervalChecker();
|
|
ToolboxGame.DestroyNetworkAgent();
|
|
StopJudgeResultCoroutine();
|
|
StopReconnectCorutine();
|
|
GameMgr.GetIns().IsNetworkBattle = false;
|
|
GameMgr.GetIns().IsWatchBattle = false;
|
|
GameMgr.GetIns().IsReplayBattle = false;
|
|
GameMgr.GetIns().IsNewReplayBattle = false;
|
|
SettingNetworkBattleEnd();
|
|
}
|
|
|
|
public void SettingNetworkBattleEnd()
|
|
{
|
|
IsNetworkBattleEnd = true;
|
|
}
|
|
|
|
protected override int GetFirstAttack(int FirstAttack)
|
|
{
|
|
return FirstAttack;
|
|
}
|
|
|
|
public override void SetupCardEvent(BattleCardBase card)
|
|
{
|
|
base.SetupCardEvent(card);
|
|
_networkBattleSetupCardEventBase.SetupCardEvent(this, RegisterActionManager, card, RegisterUnapprovedList);
|
|
}
|
|
|
|
public virtual bool IsSkillConditionCheckSkill(int cardIdx)
|
|
{
|
|
if (networkBattleData.GetReceiveData() == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (networkBattleData.GetReceiveData().SkillConditionCheckList.Find((CardDataModel x) => x.Index == cardIdx) == null)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override BattleCardBase MetamorphoseCard(int metemprphoseID, bool isPlayer, int index, SkillBase skill, bool isFusion = false)
|
|
{
|
|
bool flag = false;
|
|
BattleCardBase battleCardBase = null;
|
|
if (!isPlayer && NetworkBattleGenericTool.GetCardPlaceState(BattleEnemy, index) == NetworkBattleDefine.NetworkCardPlaceState.Hand && !GameMgr.GetIns().IsAdmin)
|
|
{
|
|
flag = true;
|
|
battleCardBase = NetworkBattleGenericTool.GetIndexToCardBase(this, BattleEnemy, index);
|
|
}
|
|
BattleCardBase battleCardBase2 = base.MetamorphoseCard(metemprphoseID, isPlayer, index, skill);
|
|
RegisterActionManager.Add(new RegisterMetamorphoseData(battleCardBase2.CardId, index, isPlayer, skill, isChoice: false, isFirstOnly: false, isFusion));
|
|
if (flag && !isFusion)
|
|
{
|
|
battleCardBase2 = base.MetamorphoseCard(battleCardBase.BaseParameter.BaseCardId, isPlayer, index, skill);
|
|
}
|
|
return battleCardBase2;
|
|
}
|
|
|
|
public override BattleCardBase CreateBattleCardWithGameObject(CardCreateInfo info, IndexInfo infoIndex, int repeatCount = -1, bool isVirtual = false, bool isActualCard = false)
|
|
{
|
|
if (!isActualCard && infoIndex.AddIndex == -1 && IsNotReplaceCardListAny(GetBattlePlayer(info.IsPlayer).cardTotalNum, info.IsPlayer))
|
|
{
|
|
ReplaceReceivedCard.CardIdAndIndex andRemoveNotReplaceCard = GetAndRemoveNotReplaceCard(GetBattlePlayer(info.IsPlayer).cardTotalNum, info.IsPlayer);
|
|
info.SetId(andRemoveNotReplaceCard.CardId);
|
|
info.SetCost(andRemoveNotReplaceCard.Cost);
|
|
}
|
|
BattleCardBase battleCardBase = CreateBattleCardFunc(info, infoIndex, repeatCount, isVirtual, isActualCard);
|
|
if (infoIndex.IsSkillCopy)
|
|
{
|
|
RegisterActionManager.Add(new RegisterCopyToken(battleCardBase, info.IsChoice, info.PlaceStatus, infoIndex.CopySkillSelectIndex, info.Skill));
|
|
}
|
|
else if ((info.PlaceStatus == NetworkBattleDefine.NetworkCardPlaceState.Hand || info.PlaceStatus == NetworkBattleDefine.NetworkCardPlaceState.Deck) && infoIndex.TargetIndex != -1 && !info.IsReferenceOpponenCard)
|
|
{
|
|
RegisterActionManager.Add(new RegisterCopyToken(battleCardBase, info.IsChoice, info.PlaceStatus, infoIndex.TargetIndex, info.Skill));
|
|
}
|
|
else if (info.PlaceStatus != NetworkBattleDefine.NetworkCardPlaceState.None)
|
|
{
|
|
RegisterActionManager.Add(new RegisterToken(battleCardBase, info.IsChoice, info.PlaceStatus, info.Skill, repeatCount));
|
|
}
|
|
else
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("NonRegisterToken addIndex " + infoIndex.AddIndex);
|
|
}
|
|
return battleCardBase;
|
|
}
|
|
|
|
public override VfxBase PlaySpecialWin(BattlePlayerBase winPlayer)
|
|
{
|
|
RegisterActionManager.Add(new RegisterSpecialWin(winPlayer.IsPlayer));
|
|
BattleFinishToEffectClear();
|
|
base.VfxMgr.RegisterImmediateVfx(new CanNotTouchCardVfx());
|
|
_isSendSpecialWin = true;
|
|
bool playerDead = !winPlayer.IsPlayer;
|
|
_isSpecialWin = winPlayer.IsPlayer;
|
|
return SequentialVfxPlayer.Create(DeadClass(playerDead, FINISH_TYPE.SPECIAL_WIN));
|
|
}
|
|
|
|
protected override SequentialVfxPlayer OnShortageDeck(BattlePlayerBase battlePlayer)
|
|
{
|
|
if (battlePlayer.IsShortageDeckWin)
|
|
{
|
|
BattleFinishToEffectClear();
|
|
base.VfxMgr.RegisterImmediateVfx(new CanNotTouchCardVfx());
|
|
_isSendSpecialWin = true;
|
|
_isSpecialWin = battlePlayer.IsPlayer;
|
|
}
|
|
return base.OnShortageDeck(battlePlayer);
|
|
}
|
|
|
|
public void SendJudge()
|
|
{
|
|
SendJudgement();
|
|
}
|
|
|
|
public virtual void ReceiveRetire(bool isWin)
|
|
{
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.ReceiveRetire);
|
|
}
|
|
|
|
public void ReceiveConsistencyLose()
|
|
{
|
|
JudgeResultReceiveCode = NetworkBattleReceiver.RESULT_CODE.NoContest;
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.ReceiveConsistencyLose);
|
|
}
|
|
|
|
public void ReceiveInvalidLose()
|
|
{
|
|
JudgeResultReceiveCode = NetworkBattleReceiver.RESULT_CODE.NoContest;
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.Invalid);
|
|
}
|
|
|
|
public void OppoDisconnectVictory()
|
|
{
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.OppoDisconnectVictory);
|
|
}
|
|
|
|
protected void OpponentNotMulliganEndVictory()
|
|
{
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.OppoNotMulliganVictory);
|
|
}
|
|
|
|
protected void OpponentNotTurnStartVictory()
|
|
{
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.OpponentNotTurnStartVictory);
|
|
}
|
|
|
|
protected void OpponentNotTurnEndVictory()
|
|
{
|
|
FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS.OpponentNotTurnEndVictory);
|
|
}
|
|
|
|
protected void DispOpponentDisconnect(bool flag)
|
|
{
|
|
try
|
|
{
|
|
if (IsBattleEnd)
|
|
{
|
|
return;
|
|
}
|
|
IClassCharacter classCharacter = ((IClassBattleCardView)BattleEnemy.Class.BattleCardView).ClassCharacter;
|
|
if (flag)
|
|
{
|
|
if (!IsShowDisconnectPanel)
|
|
{
|
|
VfxBase vfx = classCharacter.SetWaiting(flag: true);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx);
|
|
}
|
|
IsShowOpponentDisconnectPanel = true;
|
|
}
|
|
else
|
|
{
|
|
VfxBase vfx2 = classCharacter.SetWaiting(flag: false);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx2);
|
|
IsShowOpponentDisconnectPanel = false;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
protected void DispOpponentRecovery(bool flag)
|
|
{
|
|
IClassCharacter classCharacter = ((IClassBattleCardView)BattleEnemy.Class.BattleCardView).ClassCharacter;
|
|
if (flag)
|
|
{
|
|
VfxBase vfx = classCharacter.SetRecovery(flag: true);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx);
|
|
}
|
|
else
|
|
{
|
|
VfxBase vfx2 = classCharacter.SetRecovery(flag: false);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx2);
|
|
}
|
|
}
|
|
|
|
protected virtual void ControlDisconnectOffTouchAndView(bool flag)
|
|
{
|
|
try
|
|
{
|
|
if (flag)
|
|
{
|
|
RealTimeNetworkAgent.ReconnectSocketAndLogFlagOn();
|
|
_waitToReconnectSocketCoroutine = BattleCoroutine.GetInstance().StartCoroutine(WaitToReconnectSocket());
|
|
if (IsShowOpponentDisconnectPanel)
|
|
{
|
|
VfxBase vfx = ((IClassBattleCardView)BattleEnemy.Class.BattleCardView).ClassCharacter.SetWaiting(flag: false);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx);
|
|
}
|
|
SelfDisconnectOffTouch();
|
|
BattlePlayer.PlayerBattleView.ShowAlert(PanelMgr.BattleAlertType.DisconnectInfomation, isClass: false);
|
|
IsShowDisconnectPanel = true;
|
|
}
|
|
else
|
|
{
|
|
StopReconnectCorutine();
|
|
if (IsShowOpponentDisconnectPanel)
|
|
{
|
|
VfxBase vfx2 = ((IClassBattleCardView)BattleEnemy.Class.BattleCardView).ClassCharacter.SetWaiting(flag: true);
|
|
base.VfxMgr.RegisterImmediateVfx(vfx2);
|
|
}
|
|
SelfDisconnectOffTouchRelease();
|
|
BattleManagerBase.GetIns().BattlePlayer.PlayerBattleView.OffNotHideAndNotCreate();
|
|
BattleManagerBase.GetIns().BattlePlayer.PlayerBattleView.HideAlertDialogue();
|
|
IsShowDisconnectPanel = false;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public virtual void FinishBattleEffect(bool classDead)
|
|
{
|
|
BATTLE_RESULT_TYPE bATTLE_RESULT_TYPE = _finishEffectType;
|
|
if (_isNodeErrorToNocontest)
|
|
{
|
|
switch (BattleResultType)
|
|
{
|
|
case BATTLE_RESULT_TYPE.CONSISTENCY:
|
|
BattleResultControl.SetSpecialResultTypeText(Data.SystemText.Get("Battle_0481"));
|
|
break;
|
|
case BATTLE_RESULT_TYPE.WIN:
|
|
bATTLE_RESULT_TYPE = BATTLE_RESULT_TYPE.LOSE;
|
|
SettingResultUI_SpecialResultTypeText(bATTLE_RESULT_TYPE);
|
|
break;
|
|
case BATTLE_RESULT_TYPE.LOSE:
|
|
bATTLE_RESULT_TYPE = BATTLE_RESULT_TYPE.WIN;
|
|
SettingResultUI_SpecialResultTypeText(bATTLE_RESULT_TYPE);
|
|
break;
|
|
}
|
|
_isNodeErrorToNocontest = false;
|
|
}
|
|
bool isPlayer = false;
|
|
switch (bATTLE_RESULT_TYPE)
|
|
{
|
|
case BATTLE_RESULT_TYPE.WIN:
|
|
isPlayer = true;
|
|
break;
|
|
case BATTLE_RESULT_TYPE.LOSE:
|
|
isPlayer = false;
|
|
break;
|
|
case BATTLE_RESULT_TYPE.CONSISTENCY:
|
|
BattleResultControl.SetBattleFinishConsistency();
|
|
isPlayer = true;
|
|
classDead = false;
|
|
break;
|
|
}
|
|
if (classDead)
|
|
{
|
|
BattleCardBase battleCardBase = GetBattlePlayer(isPlayer).Class;
|
|
if (battleCardBase.Life >= 1 && !battleCardBase.IsDead)
|
|
{
|
|
battleCardBase.FlagCardAsDestroyedByKiller();
|
|
FINISH_TYPE finishTypeByStatus = GetFinishTypeByStatus();
|
|
base.VfxMgr.RegisterSequentialVfx(DeadClass(isPlayer, finishTypeByStatus));
|
|
}
|
|
}
|
|
base.VfxMgr.RegisterSequentialVfx(InstantVfx.Create(delegate
|
|
{
|
|
InitiateGameEndSequence(!isPlayer);
|
|
}));
|
|
}
|
|
|
|
public FINISH_TYPE GetFinishTypeByStatus()
|
|
{
|
|
FINISH_TYPE fINISH_TYPE = FINISH_TYPE.NORMAL;
|
|
switch (JudgeResultReceiveCode)
|
|
{
|
|
case NetworkBattleReceiver.RESULT_CODE.RetireWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.RetireLose:
|
|
return FINISH_TYPE.RETIRE;
|
|
case NetworkBattleReceiver.RESULT_CODE.SpecialWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.SpecialLose:
|
|
return FINISH_TYPE.SPECIAL_WIN;
|
|
default:
|
|
return FINISH_TYPE.NORMAL;
|
|
}
|
|
}
|
|
|
|
public void DebugFinishSend()
|
|
{
|
|
}
|
|
|
|
protected virtual void FinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS judgeResultStatus, bool isWin = false, bool isNotRetry = false)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("FinishSend " + judgeResultStatus);
|
|
judgeResult_NotFinishNum = 0;
|
|
SendJudgeResultToFinishBattleTask(judgeResultStatus, isNotRetry);
|
|
}
|
|
|
|
private void SendJudgeResultToFinishBattleTask(NetworkBattleSender.JUDGE_RESULT_STATUS judgeResultStatus, bool isNotRetry)
|
|
{
|
|
if (!IsNetworkBattleEnd)
|
|
{
|
|
NetworkSender.SendJudgeResult(judgeResultStatus);
|
|
if (!isNotRetry)
|
|
{
|
|
StopJudgeResultCoroutine();
|
|
_checkJudgeResultToDisconnectCoroutine = BattleCoroutine.GetInstance().StartCoroutine(CheckJudgeResultToDisconnect());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DebugJudgeResult()
|
|
{
|
|
}
|
|
|
|
private IEnumerator WaitToReconnectSocket()
|
|
{
|
|
WaitForSeconds wait = new WaitForSeconds(16f);
|
|
while (true)
|
|
{
|
|
yield return wait;
|
|
RealTimeNetworkAgent.ReconnectSocketAndLogFlagOn();
|
|
}
|
|
}
|
|
|
|
private void StopReconnectCorutine()
|
|
{
|
|
if (_waitToReconnectSocketCoroutine != null)
|
|
{
|
|
BattleCoroutine.GetInstance().StopCoroutine(_waitToReconnectSocketCoroutine);
|
|
}
|
|
}
|
|
|
|
protected IEnumerator CheckJudgeResultToDisconnect()
|
|
{
|
|
while (!_isJudgeResultReceive)
|
|
{
|
|
yield return null;
|
|
if (IsBackTitleOnDisconnect())
|
|
{
|
|
JudgeErrorDialog(isError: false);
|
|
break;
|
|
}
|
|
}
|
|
_checkJudgeResultToDisconnectCoroutine = null;
|
|
}
|
|
|
|
public virtual void SendFinishBattleTask()
|
|
{
|
|
BattlePlayer.BattleView.HideTurnEndButton();
|
|
ToolboxGame.RealTimeNetworkAgent.FinishBattleTask();
|
|
}
|
|
|
|
private IEnumerator SendJudgeResultRetry()
|
|
{
|
|
long matchedTimer = TimeUtil.GetAbsoluteTime().Ticks;
|
|
do
|
|
{
|
|
yield return null;
|
|
}
|
|
while (!((float)NetworkUtility.GetTimeSpanSecond(matchedTimer) >= 5f));
|
|
SendJudgeResultToFinishBattleTask(NetworkBattleSender.JUDGE_RESULT_STATUS.RetrySend, isNotRetry: false);
|
|
}
|
|
|
|
public void JudgeResultReceive(NetworkBattleReceiver.RESULT_CODE result, bool isNotStopCoroutine = false)
|
|
{
|
|
if (_isJudgeResultReceive)
|
|
{
|
|
return;
|
|
}
|
|
JudgeResultReceiveCode = result;
|
|
switch (result)
|
|
{
|
|
case NetworkBattleReceiver.RESULT_CODE.NotFinish:
|
|
judgeResult_NotFinishNum++;
|
|
if (!_isNoLimitJudgeResult && judgeResult_NotFinishNum >= 5)
|
|
{
|
|
judgeResult_NotFinishNum = 0;
|
|
StopJudgeResultCoroutine();
|
|
judgeResultFailedToRetryChecker.StartChecker();
|
|
}
|
|
else if (!judgeResultFailedToRetryChecker.IsStarted())
|
|
{
|
|
if (_resultRetryCoroutine != null)
|
|
{
|
|
BattleCoroutine.GetInstance().StopCoroutine(_resultRetryCoroutine);
|
|
_resultRetryCoroutine = null;
|
|
}
|
|
_resultRetryCoroutine = BattleCoroutine.GetInstance().StartCoroutine(SendJudgeResultRetry());
|
|
}
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.LifeWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.DeckoutWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.RetireWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.SpecialWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.DisconnectWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.FirstcardWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.TurnendWin:
|
|
case NetworkBattleReceiver.RESULT_CODE.TurnstartWin:
|
|
_isJudgeResultReceive = true;
|
|
SettingResultUI_SpecialResultTypeText(BATTLE_RESULT_TYPE.LOSE);
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.LifeLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.DeckoutLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.RetireLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.SpecialLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.DisconnectLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.FirstcardLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.TurnendLose:
|
|
case NetworkBattleReceiver.RESULT_CODE.TurnstartLose:
|
|
_isJudgeResultReceive = true;
|
|
SettingResultUI_SpecialResultTypeText(BATTLE_RESULT_TYPE.WIN);
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.MaxTurnLose:
|
|
{
|
|
_isJudgeResultReceive = true;
|
|
SettingResultUI_SpecialResultTypeText(BATTLE_RESULT_TYPE.WIN);
|
|
BattlePlayer.Class.FlagCardAsDestroyedBySkill();
|
|
BattleEnemy.Class.FlagCardAsDestroyedBySkill();
|
|
VfxBase vfxBase = BattlePlayer.CardManagement(BattlePlayer.Class, null, BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false);
|
|
VfxBase vfxBase2 = BattleEnemy.CardManagement(BattleEnemy.Class, null, BattlePlayerBase.CARD_MANAGEMENT.DESTROY, isRandom: false);
|
|
base.VfxMgr.RegisterSequentialVfx(ParallelVfxPlayer.Create(vfxBase, vfxBase2));
|
|
break;
|
|
}
|
|
case NetworkBattleReceiver.RESULT_CODE.NoContest:
|
|
case NetworkBattleReceiver.RESULT_CODE.Invalid:
|
|
_isJudgeResultReceive = true;
|
|
SettingResultUI_SpecialResultTypeText(BATTLE_RESULT_TYPE.CONSISTENCY);
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.Error:
|
|
JudgeErrorDialog(isError: true);
|
|
break;
|
|
}
|
|
if (_isJudgeResultReceive && !isNotStopCoroutine)
|
|
{
|
|
StopJudgeResultCoroutine();
|
|
SendFinishBattleTask();
|
|
ReceiveStop();
|
|
Screen.sleepTimeout = -2;
|
|
}
|
|
}
|
|
|
|
public void NodeErrorToNocontest()
|
|
{
|
|
_isNodeErrorToNocontest = true;
|
|
_finishEffectType = BATTLE_RESULT_TYPE.CONSISTENCY;
|
|
ToolboxGame.RealTimeNetworkAgent.FinishBattleTask();
|
|
}
|
|
|
|
private void StopJudgeResultCoroutine()
|
|
{
|
|
if (_checkJudgeResultToDisconnectCoroutine != null)
|
|
{
|
|
BattleCoroutine.GetInstance().StopCoroutine(_checkJudgeResultToDisconnectCoroutine);
|
|
_checkJudgeResultToDisconnectCoroutine = null;
|
|
}
|
|
if (_resultRetryCoroutine != null)
|
|
{
|
|
BattleCoroutine.GetInstance().StopCoroutine(_resultRetryCoroutine);
|
|
_resultRetryCoroutine = null;
|
|
}
|
|
}
|
|
|
|
protected void JudgeErrorDialog(bool isError)
|
|
{
|
|
if (!IsNetworkBattleEnd)
|
|
{
|
|
UIManager instance = UIManager.GetInstance();
|
|
instance.dialogAllClear();
|
|
SettingNetworkBattleEnd();
|
|
ToolboxGame.DestroyNetworkAgent();
|
|
DialogBase dialogBase = instance.CreateDialogClose(isSystem: true);
|
|
dialogBase.SetSize(DialogBase.Size.M);
|
|
if (isError)
|
|
{
|
|
dialogBase.SetTitleLabel(Data.SystemText.Get("ErrorHeader_0015"));
|
|
dialogBase.SetText(Data.SystemText.Get("Error_0015"));
|
|
}
|
|
else
|
|
{
|
|
dialogBase.SetTitleLabel(Data.SystemText.Get("ErrorHeader_0014"));
|
|
dialogBase.SetText(Data.SystemText.Get("Error_0014"));
|
|
}
|
|
dialogBase.AddButton(DialogBase.ButtonType.BackToTitle);
|
|
dialogBase.SetPanelDepth(5000);
|
|
dialogBase.SetFadeButtonEnabled(flag: false);
|
|
BattleFinishToStopIntervalChecker();
|
|
instance.closeInSceneCenterLoading();
|
|
BattleManagerBase.GetIns().BattlePlayer.PlayerBattleView.OffNotHideAndNotCreate();
|
|
BattleManagerBase.GetIns().BattlePlayer.PlayerBattleView.HideAlertDialogue();
|
|
}
|
|
}
|
|
|
|
protected void BeforeDisconnectLose()
|
|
{
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.ReconnectSocket();
|
|
}
|
|
}
|
|
|
|
protected virtual void DisconnectLose()
|
|
{
|
|
}
|
|
|
|
public void BattleFinishReceiveAfterFinishBattleSend(NetworkBattleSender.JUDGE_RESULT_STATUS log, bool isWin = false)
|
|
{
|
|
FinishBattleSend(log, isWin);
|
|
}
|
|
|
|
public NetworkBattleReceiver.RESULT_CODE JudgeCurrentFinishStatus()
|
|
{
|
|
if (BattlePlayer.Class.IsDead && BattleEnemy.Class.IsDead)
|
|
{
|
|
if ((BattlePlayer.Class.IsDead && BattlePlayer.DeckCardList.Count == 0) || (BattleEnemy.Class.IsDead && BattleEnemy.DeckCardList.Count == 0))
|
|
{
|
|
if (BattlePlayer.IsSelfTurn)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutLose;
|
|
}
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutWin;
|
|
}
|
|
if (BattlePlayer.Class.Life <= 0 || BattleEnemy.Class.Life <= 0)
|
|
{
|
|
if (BattlePlayer.IsSelfTurn)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.LifeLose;
|
|
}
|
|
return NetworkBattleReceiver.RESULT_CODE.LifeWin;
|
|
}
|
|
}
|
|
if (BattlePlayer.Class.Life <= 0)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.LifeLose;
|
|
}
|
|
if (BattleEnemy.Class.Life <= 0)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.LifeWin;
|
|
}
|
|
if (BattlePlayer.Class.IsDead && BattlePlayer.DeckCardList.Count == 0)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutLose;
|
|
}
|
|
if (BattleEnemy.Class.IsDead && BattleEnemy.DeckCardList.Count == 0)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutWin;
|
|
}
|
|
if (BattlePlayer.IsShortageDeck && BattlePlayer.IsShortageDeckWin && BattleEnemy.IsShortageDeck && BattleEnemy.IsShortageDeckWin)
|
|
{
|
|
if (BattlePlayer.IsSelfTurn)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.SpecialLose;
|
|
}
|
|
return NetworkBattleReceiver.RESULT_CODE.SpecialWin;
|
|
}
|
|
if (BattlePlayer.IsShortageDeck && BattlePlayer.IsShortageDeckWin)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutWin;
|
|
}
|
|
if (BattleEnemy.IsShortageDeck && BattleEnemy.IsShortageDeckWin)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.DeckoutLose;
|
|
}
|
|
if (_isSendSpecialWin)
|
|
{
|
|
if (_isSpecialWin)
|
|
{
|
|
return NetworkBattleReceiver.RESULT_CODE.SpecialWin;
|
|
}
|
|
return NetworkBattleReceiver.RESULT_CODE.SpecialLose;
|
|
}
|
|
return NetworkBattleReceiver.RESULT_CODE.NotFinish;
|
|
}
|
|
|
|
private bool IsDisconnectLose()
|
|
{
|
|
if (disconnectToLoseChecker.IsSelfDisconnectLose())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool IsBackTitleOnDisconnect()
|
|
{
|
|
if (disconnectToLoseChecker.IsSelfDisConnectOnTimeout())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override VfxBase JudgeBattleResult()
|
|
{
|
|
if (BattlePlayer.IsSelfTurn)
|
|
{
|
|
if (base.IsRecovery && (JudgeCurrentFinishStatus() == NetworkBattleReceiver.RESULT_CODE.DeckoutLose || JudgeCurrentFinishStatus() == NetworkBattleReceiver.RESULT_CODE.DeckoutWin))
|
|
{
|
|
return NullVfx.GetInstance();
|
|
}
|
|
if (JudgeCurrentFinishStatus() != NetworkBattleReceiver.RESULT_CODE.NotFinish)
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckEmitBattleFinish));
|
|
}
|
|
}
|
|
else if (JudgeCurrentFinishStatus() != NetworkBattleReceiver.RESULT_CODE.NotFinish)
|
|
{
|
|
BattleFinishToTurnEndFinal(isSelfTurn: false);
|
|
}
|
|
if (IsBattleGameFinishStatus())
|
|
{
|
|
notTurnStartToLoseChecker.EndTimer();
|
|
notTurnEndToLoseChecker.EndTimer();
|
|
}
|
|
return NullVfx.GetInstance();
|
|
}
|
|
|
|
protected virtual void AckEmitBattleFinish(Dictionary<string, object> objs)
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckEmitBattleFinish));
|
|
BattleFinishToTurnEndFinal(isSelfTurn: true);
|
|
}
|
|
|
|
private void AddRegisterMoveCard(BattleCardBase card, NetworkBattleDefine.NetworkCardPlaceState from, NetworkBattleDefine.NetworkCardPlaceState to, SkillBase skill, bool isNotCheck = false, bool isOpen = false, bool isFlood = false, bool isWhenDraw = false, bool hasGuard = false)
|
|
{
|
|
bool flag = false;
|
|
if (isNotCheck)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (from != NetworkBattleDefine.NetworkCardPlaceState.None && from != NetworkBattleDefine.NetworkCardPlaceState.Banish && from != NetworkBattleDefine.NetworkCardPlaceState.FusionIngredient && from != NetworkBattleDefine.NetworkCardPlaceState.Unite)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
RegisterActionManager.Add(new RegisterStateChangeCard(card, from, to, skill, isOpen, isFlood, isWhenDraw, hasGuard));
|
|
}
|
|
}
|
|
|
|
public virtual void BattleFinishToTurnEndFinal(bool isSelfTurn)
|
|
{
|
|
BattleFinishToEffectClear();
|
|
foreach (NetworkBattleIntervalCheckerBase intervalCheck in _intervalCheckList)
|
|
{
|
|
if (!(intervalCheck is OpponentNotTurnEndToWinChecker) && !(intervalCheck is OpponentNotTurnStartToWinChecker) && !(intervalCheck is BattleFinishToOpponentDisConnectChecker) && !(intervalCheck is DisconnectToLoseChecker))
|
|
{
|
|
intervalCheck.StopChecker();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void SettingResultUI_SpecialResultTypeText(BATTLE_RESULT_TYPE battleResult)
|
|
{
|
|
string text = "";
|
|
NetworkBattleReceiver.RESULT_CODE judgeResultReceiveCode = JudgeResultReceiveCode;
|
|
if (battleResult == BATTLE_RESULT_TYPE.LOSE)
|
|
{
|
|
if (judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.RetireWin)
|
|
{
|
|
text = Data.SystemText.Get("Battle_0418");
|
|
}
|
|
else if (judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.DisconnectWin || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.FirstcardWin || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.TurnendWin || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.TurnstartWin || (_isNodeErrorToNocontest && judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.NotFinish))
|
|
{
|
|
text = Data.SystemText.Get("Battle_0420");
|
|
}
|
|
}
|
|
else if (judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.DisconnectLose || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.FirstcardLose || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.TurnendLose || judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.TurnstartLose || (_isNodeErrorToNocontest && judgeResultReceiveCode == NetworkBattleReceiver.RESULT_CODE.NotFinish))
|
|
{
|
|
text = Data.SystemText.Get("Battle_0421");
|
|
}
|
|
else
|
|
{
|
|
switch (judgeResultReceiveCode)
|
|
{
|
|
case NetworkBattleReceiver.RESULT_CODE.MaxTurnLose:
|
|
text = Data.SystemText.Get("Battle_0498");
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.NoContest:
|
|
case NetworkBattleReceiver.RESULT_CODE.Invalid:
|
|
text = Data.SystemText.Get("Battle_0419");
|
|
break;
|
|
}
|
|
}
|
|
if (text != "")
|
|
{
|
|
BattleResultControl.SetSpecialResultTypeText(text);
|
|
}
|
|
_finishEffectType = battleResult;
|
|
}
|
|
|
|
public void ReceiveStop()
|
|
{
|
|
networkReceiver.ReceiveStop();
|
|
}
|
|
|
|
public void ConductReceiveData(NetworkBattleReceiver.ReceiveData receiveData, bool isPlayer = false)
|
|
{
|
|
bool isExtraTurn = BattlePlayer.IsExtraTurn;
|
|
networkBattleData.SetReceiveData(receiveData);
|
|
networkBattleData.BeforeSettingReceiveData();
|
|
if (base.CurrentTurn <= 1 && !isPlayer && (receiveData.dataUri == NetworkBattleDefine.NetworkBattleURI.TurnStart || receiveData.dataUri == NetworkBattleDefine.NetworkBattleURI.PlayActions))
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("Conduct " + receiveData.dataUri.ToString() + " " + Convert.ToInt32(_isJudgeResultReceive));
|
|
}
|
|
if (!_isJudgeResultReceive)
|
|
{
|
|
NetworkOperationCollectionBase networkOperationCollection = CreateNetworkOperationCollection(receiveData, isPlayer);
|
|
OperateReceive.StartOperate(networkOperationCollection, receiveData);
|
|
}
|
|
receiveIntervalTrigger.ReceiveDataCheck(this, networkBattleData, isPlayer, isExtraTurn);
|
|
networkBattleData.AfterSettingReceiveData();
|
|
}
|
|
|
|
public void ConductReplayReceiveData(NetworkBattleReceiver.ReplayReceiveData receiveData)
|
|
{
|
|
networkBattleData.SetReceiveData(receiveData);
|
|
if (!_isJudgeResultReceive)
|
|
{
|
|
NewReplayOperationCollection networkOperationCollection = new NewReplayOperationCollection(this as NetworkReplayBattleMgr, receiveData, networkBattleData);
|
|
(OperateReceive as NewReplayOperateReceive).StartReplayOperate(networkOperationCollection, receiveData);
|
|
}
|
|
}
|
|
|
|
protected virtual NetworkOperationCollectionBase CreateNetworkOperationCollection(NetworkBattleReceiver.ReceiveData receivedData, bool isPlayer)
|
|
{
|
|
if (base.IsRecovery)
|
|
{
|
|
return new RecoveryOperationCollection(this, OperateMgr, receivedData, networkBattleData, isPlayer);
|
|
}
|
|
if (!IsOperateReceiveCheck())
|
|
{
|
|
LocalLog.AccumulateTraceLog("ConductError");
|
|
return new NullOperationCollection();
|
|
}
|
|
return new NetworkOperationCollection(this, OperateMgr, receivedData, networkBattleData, isPlayer);
|
|
}
|
|
|
|
protected virtual bool IsOperateReceiveCheck()
|
|
{
|
|
return operateReceiveChecker.IsOperateReceive();
|
|
}
|
|
|
|
public void ConductReceiveData_NotHaveSequence(NetworkBattleReceiver.ReceiveData receiveData, bool isPlayer)
|
|
{
|
|
networkBattleData.SetReceiveData(receiveData);
|
|
NetworkOperationCollectionBase networkOperationCollection = CreateNetworkOperationCollection(receiveData, isPlayer);
|
|
OperateReceive.StartOperate(networkOperationCollection, receiveData);
|
|
receiveIntervalTrigger.ReceiveDataCheck(this, networkBattleData, isPlayer, isExTurn: false);
|
|
}
|
|
|
|
public List<BattleCardBase> GetUnapprovedCardObj(BattlePlayerBase player, int skillCardIndex, int publishedActiveCount, int movement, SkillBase skill)
|
|
{
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
List<CardDataModel> unapprovedList = networkBattleData.GetReceiveData().unapprovedList;
|
|
if (unapprovedList == null)
|
|
{
|
|
return list;
|
|
}
|
|
int num = -1;
|
|
if (skill.ApplySelectFilter is SkillRandomSelectFilter skillRandomSelectFilter && !skill.IsOnceCallTiming)
|
|
{
|
|
num = skillRandomSelectFilter.CalcCount(skill.OptionValue);
|
|
}
|
|
foreach (CardDataModel item in unapprovedList)
|
|
{
|
|
if (item.Index == -99)
|
|
{
|
|
continue;
|
|
}
|
|
if (RegisterSkillConditionCheck.DoesSkillUsePrivateCount(skill) && skill is Skill_powerup)
|
|
{
|
|
int movementCount = RegisterSkillConditionCheck.GetMovementCount(skill);
|
|
if (item.skillMovementNum / movementCount != movement)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if (item.skillMovementNum != movement)
|
|
{
|
|
continue;
|
|
}
|
|
if (item.skillCardIndex != skillCardIndex || item.publishedActiveSkillCount != publishedActiveCount || item.IsInvoked != skill.IsInvoked || item.IsGotUnapproved)
|
|
{
|
|
continue;
|
|
}
|
|
BattleCardBase indexToCardBase = NetworkBattleGenericTool.GetIndexToCardBase(this, player, item.Index);
|
|
if (skill is NetworkSkill_metamorphose && skill.OnWhenAddToHand != 0 && item.ToStateList.Any((NetworkBattleDefine.NetworkCardPlaceState s) => s == NetworkBattleDefine.NetworkCardPlaceState.Hand) && (indexToCardBase == null || !indexToCardBase.IsInHand))
|
|
{
|
|
item.skillMovementNum++;
|
|
continue;
|
|
}
|
|
if (indexToCardBase != null)
|
|
{
|
|
if (skill.OnWhenDrawOtherStart != 0 && item.ToStateList.Any((NetworkBattleDefine.NetworkCardPlaceState s) => s == NetworkBattleDefine.NetworkCardPlaceState.Hand) && !indexToCardBase.IsInHand)
|
|
{
|
|
continue;
|
|
}
|
|
list.Add(indexToCardBase);
|
|
if (!skill.IsOnceCallTiming)
|
|
{
|
|
item.IsGotUnapproved = true;
|
|
}
|
|
}
|
|
if (num != -1 && list.Count >= num)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public bool IsContainUnapprovedSkill(SkillBase skill, int skillCardIndex, int publishedActiveCount, int movement)
|
|
{
|
|
List<CardDataModel> unapprovedList = networkBattleData.GetReceiveData().unapprovedList;
|
|
if (unapprovedList == null)
|
|
{
|
|
return false;
|
|
}
|
|
foreach (CardDataModel item in unapprovedList)
|
|
{
|
|
if (item.Index == -99)
|
|
{
|
|
continue;
|
|
}
|
|
if (RegisterSkillConditionCheck.DoesSkillUsePrivateCount(skill) && skill is Skill_powerup)
|
|
{
|
|
int movementCount = RegisterSkillConditionCheck.GetMovementCount(skill);
|
|
if (item.skillMovementNum / movementCount != movement)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if (item.skillMovementNum != movement)
|
|
{
|
|
continue;
|
|
}
|
|
if (item.skillCardIndex == skillCardIndex && item.publishedActiveSkillCount == publishedActiveCount && item.IsInvoked == skill.IsInvoked)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public List<int> GetValidateTargetSkillIndexList()
|
|
{
|
|
return networkBattleData.GetReceiveData().validateSkillIndexList;
|
|
}
|
|
|
|
public virtual bool IsReceivedSkillConditionCheck(int movement, SkillBase skill)
|
|
{
|
|
bool isPlayer = skill.SkillPrm.ownerCard.IsPlayer;
|
|
int index = skill.SkillPrm.ownerCard.Index;
|
|
int num = skill.SkillPrm.ownerCard.Skills.IndexOf(skill);
|
|
int publishSkillCount = NetworkBattleGenericTool.GetPublishSkillCount(skill);
|
|
int movementCount = RegisterSkillConditionCheck.GetMovementCount(skill);
|
|
foreach (CardDataModel skillConditionCheck in networkBattleData.GetReceiveData().SkillConditionCheckList)
|
|
{
|
|
bool flag = false;
|
|
if (skillConditionCheck.publishedActiveSkillCount == publishSkillCount)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (skillConditionCheck.publishedActiveSkillCount != publishSkillCount && skillConditionCheck.SkillIndex == num)
|
|
{
|
|
flag = true;
|
|
}
|
|
bool flag2 = skillConditionCheck.skillMovementNum / movementCount == movement;
|
|
bool flag3 = skillConditionCheck.IsInvoked == skill.IsInvoked;
|
|
if (flag && skillConditionCheck.Index == index && flag2 && flag3)
|
|
{
|
|
if (GameMgr.GetIns().IsWatchBattle && skillConditionCheck.isOpponent == isPlayer)
|
|
{
|
|
return false;
|
|
}
|
|
return skillConditionCheck.activate == 1;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public List<CardDataModel> SearchSkillConditionCheckDataList(int cardIdx, int publishSkillCount, int skillMovement, int skillConditionCount)
|
|
{
|
|
if (networkBattleData.GetReceiveData() == null)
|
|
{
|
|
return null;
|
|
}
|
|
List<CardDataModel> list = new List<CardDataModel>();
|
|
foreach (CardDataModel skillConditionCheck in networkBattleData.GetReceiveData().SkillConditionCheckList)
|
|
{
|
|
if (skillConditionCheck.Index == cardIdx && skillConditionCheck.publishedActiveSkillCount == publishSkillCount && skillConditionCheck.skillMovementNum / skillConditionCount == skillMovement)
|
|
{
|
|
list.Add(skillConditionCheck);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public void ClearRegisterCardList()
|
|
{
|
|
if (base.CurrentTurn <= 1 && !BattlePlayer.IsSelfTurn)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("ClearRegister" + RegisterActionManager.RegisterDataList.Count);
|
|
}
|
|
validateSkillIndexList.Clear();
|
|
RegisterActionManager.Clear();
|
|
RegisterUnapprovedList.Clear();
|
|
registerSelectTypeSkillIndexList.Clear();
|
|
_networkBattleSetupCardEventBase.ClearSkillMovement();
|
|
base.TemporaryPublishedAddCount = 0;
|
|
sendKeyActionDataManager.Clear();
|
|
}
|
|
|
|
public void AddValidateSkillIndexList(int validateCardIndex, bool isPlayer, int validateSkillIndex)
|
|
{
|
|
validateSkillIndexList.Add(new ValidateSkillData(validateCardIndex, isPlayer, validateSkillIndex));
|
|
}
|
|
|
|
public void AddRegisterSelectTypeSkillIndexList(int index)
|
|
{
|
|
registerSelectTypeSkillIndexList.Add(index);
|
|
}
|
|
|
|
private void SelfDisconnectOffTouch()
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("SelfDisconnectOffTouch time " + disconnectToLoseChecker.GetDisconnectTime());
|
|
LocalLog._isSendGungnirLog = true;
|
|
networkTouchControl.IsDisconnect = true;
|
|
networkTouchControl.notDragPlayCardFlag = true;
|
|
networkTouchControl.notAttackFlag = true;
|
|
networkTouchControl.notEmoteFlag = true;
|
|
networkTouchControl.notEvolCardFlag = true;
|
|
isStopOperateFlag = true;
|
|
BattlePlayer.PlayerBattleView.TurnEndButtonUI.HideBtn();
|
|
if (!GameMgr.GetIns().IsWatchBattle)
|
|
{
|
|
MenuButtonObject.SetActive(value: false);
|
|
}
|
|
BattlePlayer.PlayerBattleView.AllClear(popUpClose: true);
|
|
BattleCardBase hitCard = networkTouchControl._hitCard;
|
|
if (hitCard != null && hitCard.IsOnMove)
|
|
{
|
|
networkTouchControl.StopMovingHandCard(hitCard);
|
|
networkTouchControl.Exit();
|
|
}
|
|
if (networkTouchControl._touchProcessor != null)
|
|
{
|
|
base.VfxMgr.RegisterImmediateVfx(networkTouchControl._touchProcessor.End().Vfx);
|
|
}
|
|
}
|
|
|
|
private void SelfDisconnectOffTouchRelease()
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("SelfDisconnectOffTouchRelease");
|
|
networkTouchControl.IsDisconnect = false;
|
|
networkTouchControl.notDragPlayCardFlag = false;
|
|
networkTouchControl.notAttackFlag = false;
|
|
networkTouchControl.notEmoteFlag = false;
|
|
networkTouchControl.notEvolCardFlag = false;
|
|
BattlePlayer.PlayerBattleView.ShowTurnEndButton();
|
|
isStopOperateFlag = false;
|
|
if (!(_phase is NetworkMulliganPhase))
|
|
{
|
|
MenuButtonObject.SetActive(value: true);
|
|
}
|
|
NetworkSender.SendChatStamp("-1");
|
|
}
|
|
|
|
public void BattleFinishToEffectClear()
|
|
{
|
|
if (turnEndTimeController != null)
|
|
{
|
|
turnEndTimeController.BattleEndToTraceLog();
|
|
turnEndTimeController.EndCountDown("BattleFinishToEffectClear");
|
|
}
|
|
}
|
|
|
|
public void BattleFinishToStopIntervalChecker()
|
|
{
|
|
foreach (NetworkBattleIntervalCheckerBase intervalCheck in _intervalCheckList)
|
|
{
|
|
intervalCheck.FinishChecker();
|
|
}
|
|
}
|
|
|
|
public bool IsEchoWait()
|
|
{
|
|
return networkBattleData.isEchoWait;
|
|
}
|
|
|
|
private void OnPlayerAlive()
|
|
{
|
|
ConnectionReportTrigger.ConnectionReport(this);
|
|
}
|
|
|
|
public virtual void RecoveryRecordSkillTarget(IEnumerable<BattleCardBase> targetCards)
|
|
{
|
|
_contentsCreator.RecoveryRecordManager.RecordSkillTarget(targetCards);
|
|
}
|
|
|
|
public IEnumerable<BattleCardBase> RecoverySkillTarget(IEnumerable<BattleCardBase> skillTargets, int targetCount)
|
|
{
|
|
if (GameMgr.GetIns().IsNetworkBattle)
|
|
{
|
|
return skillTargets;
|
|
}
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
for (int i = 0; i < targetCount; i++)
|
|
{
|
|
string cardName = _contentsCreator.RecoveryManager.RecoveryPopSkillTargetCardName();
|
|
BattleCardBase item = BattleEnemy.AllCards.FirstOrDefault((BattleCardBase c) => c.GetName() == cardName);
|
|
list.Add(item);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public override VfxBase StartBattle()
|
|
{
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
LocalLog.SetLastTraceLogTurn(1);
|
|
sequentialVfxPlayer.Register(ChangePhase(base.PhaseCreator.CreateMainPhase()));
|
|
if (base.IsRecovery)
|
|
{
|
|
return sequentialVfxPlayer;
|
|
}
|
|
if (IsFirst)
|
|
{
|
|
sequentialVfxPlayer.Register(BattlePlayer.StartTurnControl("First"));
|
|
}
|
|
return sequentialVfxPlayer;
|
|
}
|
|
|
|
public override VfxBase ChangePhase(IPhase phase)
|
|
{
|
|
if (phase is NetworkMulliganPhase)
|
|
{
|
|
notMulliganEndToJudgeChecker.StartChecker();
|
|
}
|
|
return base.ChangePhase(phase);
|
|
}
|
|
|
|
protected bool IsBattleGameFinishStatus()
|
|
{
|
|
NetworkBattleReceiver.RESULT_CODE rESULT_CODE = JudgeCurrentFinishStatus();
|
|
if (rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.LifeWin || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.LifeLose || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.DeckoutWin || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.DeckoutLose || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.SpecialWin || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.SpecialLose || rESULT_CODE == NetworkBattleReceiver.RESULT_CODE.MaxTurnLose)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int GetExpectCount(int publishedActiveSkillCount)
|
|
{
|
|
CardDataModel cardDataModel = networkBattleData.GetReceiveData().SkillConditionCheckList.FirstOrDefault((CardDataModel s) => s.publishedActiveSkillCount == publishedActiveSkillCount);
|
|
if (cardDataModel != null)
|
|
{
|
|
networkBattleData.GetReceiveData().SkillConditionCheckList.Remove(cardDataModel);
|
|
if (cardDataModel.SkillCallCount != -1)
|
|
{
|
|
return cardDataModel.SkillCallCount;
|
|
}
|
|
if (cardDataModel.SkillValueCount != -1)
|
|
{
|
|
return cardDataModel.SkillValueCount;
|
|
}
|
|
if (cardDataModel.SkillValueParameter.HasValue)
|
|
{
|
|
return cardDataModel.SkillValueParameter.Value;
|
|
}
|
|
if (cardDataModel.IsHighlander)
|
|
{
|
|
return 1;
|
|
}
|
|
if (cardDataModel.activate != -1)
|
|
{
|
|
return cardDataModel.activate;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public void ReplaceDeckCardOnWatch(bool isPlayer, int idx, int id)
|
|
{
|
|
BattlePlayerBase battlePlayer = GetBattlePlayer(isPlayer);
|
|
BattleCardBase battleCardBase = battlePlayer.DeckCardList.FirstOrDefault((BattleCardBase c) => c.Index == idx);
|
|
if (CardMaster.GetInstanceForBattle().GetCardParameterFromId(id).CharType != CardBasePrm.CharaType.NORMAL)
|
|
{
|
|
int index = battlePlayer.DeckCardList.IndexOf(battleCardBase);
|
|
battleCardBase.GetBuildInfo.CardId = id;
|
|
battleCardBase = (battlePlayer.DeckCardList[index] = CardCreatorBase.CreateToken(battleCardBase.GetBuildInfo, createNullView: true));
|
|
}
|
|
battleCardBase.ReplaceParameterAndSkillOnDeck(id);
|
|
if (battleCardBase.HasDeckSelfSkill)
|
|
{
|
|
battlePlayer.AddDeckSkillCard(battleCardBase);
|
|
}
|
|
}
|
|
|
|
public void RecordSelectSkillInRecovery(NetworkBattleReceiver.ReceiveData receiveData)
|
|
{
|
|
OperateReceive.RecordSelectSkillInRecovery(receiveData);
|
|
}
|
|
|
|
public void CheckLatestReplayInfoInRecovery()
|
|
{
|
|
OperateReceive.CheckLatestReplayInfoInRecovery();
|
|
}
|
|
}
|