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.
1168 lines
46 KiB
C#
1168 lines
46 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Cute;
|
|
using LitJson;
|
|
using UnityEngine;
|
|
using Wizard.Battle.Mulligan;
|
|
using Wizard.Battle.Operation;
|
|
using Wizard.Battle.Phase;
|
|
using Wizard.Battle.Touch;
|
|
using Wizard.Battle.View;
|
|
using Wizard.Battle.View.Vfx;
|
|
|
|
namespace Wizard.Battle.Recovery;
|
|
|
|
public class RecoveryDataHandler
|
|
{
|
|
protected bool isEmitEnterRoom;
|
|
|
|
protected NetworkBattleManagerBase _networkBattleMgr;
|
|
|
|
protected StockReceiveMgr stockReceiveMessageMgr = new StockReceiveMgr("seq");
|
|
|
|
protected Coroutine _coroutineInBattle;
|
|
|
|
protected const string DATA_PARAM_VID = "vid";
|
|
|
|
protected const string DATA_PARAM_URI = "uri";
|
|
|
|
protected const string DATA_PARAM_TIME = "time";
|
|
|
|
private readonly List<NetworkBattleDefine.NetworkBattleURI> RecoveryExceptUriList = new List<NetworkBattleDefine.NetworkBattleURI>
|
|
{
|
|
NetworkBattleDefine.NetworkBattleURI.ChatStamp,
|
|
NetworkBattleDefine.NetworkBattleURI.Touch,
|
|
NetworkBattleDefine.NetworkBattleURI.TurnEndReady,
|
|
NetworkBattleDefine.NetworkBattleURI.SelectSkill,
|
|
NetworkBattleDefine.NetworkBattleURI.SlideObject,
|
|
NetworkBattleDefine.NetworkBattleURI.SelectObject
|
|
};
|
|
|
|
private NetworkBattleDefine.NetworkBattleURI _hasSequenceUri;
|
|
|
|
private int _hasSequenceResult;
|
|
|
|
private bool _isPlayerSend;
|
|
|
|
private bool _isOpponentDisconnect;
|
|
|
|
private Coroutine _timeOutCoroutine;
|
|
|
|
private bool isFirstTimeSet;
|
|
|
|
private DateTime _firstTime;
|
|
|
|
private DateTime _lastTime;
|
|
|
|
private float _pastTime;
|
|
|
|
private DateTime _battleStartDate;
|
|
|
|
private const int TIMEOUT_TIME = 10;
|
|
|
|
private JsonData jsonObject;
|
|
|
|
private Action OnFinishRecoveryLogSync;
|
|
|
|
private bool isTurnStartWithNoAction;
|
|
|
|
private CanNotTouchCardVfx _canNotTouchCardVfx;
|
|
|
|
private const float FUSION_WAIT_TIME = 0.3f;
|
|
|
|
private const string RECOVERY_KEY = "operations";
|
|
|
|
private const string OPERATION_KEY = "operation";
|
|
|
|
private const string SEQ_KEY = "seq";
|
|
|
|
private const string PLAY_KEY = "play";
|
|
|
|
private const string BOOL_KEY = "bool";
|
|
|
|
private const string INDEX_KEY = "index";
|
|
|
|
private const string SKILL_TARGET_KEY = "skill_target";
|
|
|
|
private const string TARGET_KEY = "target";
|
|
|
|
private const string ATTACK_KEY = "attack";
|
|
|
|
private const string EVOLVE_KEY = "evolve";
|
|
|
|
private const string MULLIGAN_KEY = "mulligan";
|
|
|
|
private const string MULLIGAN_ABANDON = "abandoned_cards";
|
|
|
|
private const string TURN_END_KEY = "turn_end";
|
|
|
|
private const string IS_BURIAL_RITE_KEY = "is_burial_rite";
|
|
|
|
public const string IS_CHOICE_BRAVE_KEY = "is_choice_brave";
|
|
|
|
private const string START_CHOICE_KEY = "start_choice";
|
|
|
|
private const string START_SELECT_KEY = "start_select";
|
|
|
|
public const string START_FUSION_KEY = "start_fusion";
|
|
|
|
private const string SELECT_KEY = "select";
|
|
|
|
public const string SELECT_FUSION_KEY = "select_fusion";
|
|
|
|
private const string CANCEL_SELECT_KEY = "cancel_select";
|
|
|
|
private const string CANCEL_CHOICE_KEY = "cancel_choice";
|
|
|
|
public const string CANCEL_FUSION_KEY = "cancel_fusion";
|
|
|
|
private const string COMP_CHOICE_KEY = "comp_choice";
|
|
|
|
private const string COMP_SELECT_KEY = "comp_select";
|
|
|
|
public const string COMP_FUSION = "comp_fusion";
|
|
|
|
private List<object> _mulliganList = new List<object>();
|
|
|
|
private int playIndex;
|
|
|
|
public int receivedMaxSequenceNum { get; protected set; }
|
|
|
|
public event Action OnCompleteRecovery;
|
|
|
|
public RecoveryDataHandler(NetworkBattleManagerBase networkbattleManager, Action onFinishRecoveringData, Action onFinishRecoveryLogSync, RecoveryOperationInfo aiBattleRecoveryData = null)
|
|
{
|
|
OnFinishRecoveryLogSync = onFinishRecoveryLogSync;
|
|
if (GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
if (aiBattleRecoveryData != null)
|
|
{
|
|
AISetup(networkbattleManager, onFinishRecoveringData, aiBattleRecoveryData);
|
|
}
|
|
else
|
|
{
|
|
RecoveryManagerBase.OpenRecoveryFailedDialog();
|
|
}
|
|
return;
|
|
}
|
|
string text = OperationRecorderBase.RecordDirectoryPath + "recovery_network.json";
|
|
if (File.Exists(text))
|
|
{
|
|
jsonObject = RecoveryOperationInfo.ReadRecoveryFile(text);
|
|
Setup(networkbattleManager, onFinishRecoveringData);
|
|
}
|
|
else
|
|
{
|
|
RecoveryManagerBase.OpenRecoveryFailedDialog();
|
|
}
|
|
}
|
|
|
|
private void Setup(NetworkBattleManagerBase networkbattleManager, Action onFinishRecoveringData)
|
|
{
|
|
_networkBattleMgr = networkbattleManager;
|
|
_coroutineInBattle = BattleCoroutine.GetInstance().StartCoroutine(StockDataPlayer(onFinishRecoveringData));
|
|
}
|
|
|
|
private void AISetup(NetworkBattleManagerBase networkbattleManager, Action onFinishRecoveringData, RecoveryOperationInfo aiBattleRecoveryData)
|
|
{
|
|
_networkBattleMgr = networkbattleManager;
|
|
_coroutineInBattle = BattleCoroutine.GetInstance().StartCoroutine(AIStockDataPlayer(onFinishRecoveringData, aiBattleRecoveryData));
|
|
}
|
|
|
|
public virtual void Stop()
|
|
{
|
|
BattleCoroutine.GetInstance().StopCoroutine(_coroutineInBattle);
|
|
}
|
|
|
|
public void OnBattleReceived()
|
|
{
|
|
Dictionary<string, object> play_list = Data.BattleRecoveryInfo.play_list;
|
|
if (play_list != null && play_list.ContainsKey("uri"))
|
|
{
|
|
string text = play_list["uri"].ToString();
|
|
if (text != null && text == "Watch")
|
|
{
|
|
ParseBattleWatchData(play_list);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ParseBattleWatchData(Dictionary<string, object> received)
|
|
{
|
|
if (!received.TryGetValue("playlist", out var value) || !(value is List<object> list))
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
Dictionary<string, object> dictionary = list[i] as Dictionary<string, object>;
|
|
int num = int.Parse(dictionary["seq"].ToString());
|
|
if (receivedMaxSequenceNum < num)
|
|
{
|
|
receivedMaxSequenceNum = int.Parse(dictionary["seq"].ToString());
|
|
}
|
|
if (stockReceiveMessageMgr.CheckStockData(dictionary))
|
|
{
|
|
stockReceiveMessageMgr.StockData(dictionary);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int GetWatchSequenceNum()
|
|
{
|
|
return stockReceiveMessageMgr.GetMaxSequenceNumber();
|
|
}
|
|
|
|
public int GetCurrentSequenceNumber()
|
|
{
|
|
return stockReceiveMessageMgr.SequenceAlreadyNumber;
|
|
}
|
|
|
|
protected IEnumerator StockDataPlayer(Action onFinishRecoveringData)
|
|
{
|
|
while (true)
|
|
{
|
|
if ((bool)ToolboxGame.RealTimeNetworkAgent && !ToolboxGame.RealTimeNetworkAgent.IsPlayReceiveDataOk())
|
|
{
|
|
yield return null;
|
|
continue;
|
|
}
|
|
if (stockReceiveMessageMgr.SequenceAlreadyNumber == GetWatchSequenceNum())
|
|
{
|
|
_networkBattleMgr.GetNetworkBattleReceiver().CheckLatestReplayInfoInRecoveryExceptUriList();
|
|
CallRecoveryFinish(onFinishRecoveringData, waitForAck: true);
|
|
}
|
|
Dictionary<string, object> dictionary = stockReceiveMessageMgr.FindData(stockReceiveMessageMgr.SequenceAlreadyNumber + 1);
|
|
if (dictionary != null)
|
|
{
|
|
bool flag = isOwner(dictionary["vid"].ToString());
|
|
string value = dictionary["uri"].ToString();
|
|
if (!Enum.IsDefined(typeof(NetworkBattleDefine.NetworkBattleURI), value))
|
|
{
|
|
NextStockReceive(dictionary);
|
|
continue;
|
|
}
|
|
NetworkBattleDefine.NetworkBattleURI networkBattleURI = (NetworkBattleDefine.NetworkBattleURI)Enum.Parse(typeof(NetworkBattleDefine.NetworkBattleURI), value);
|
|
if (networkBattleURI == NetworkBattleDefine.NetworkBattleURI.PlayActions || networkBattleURI == NetworkBattleDefine.NetworkBattleURI.TurnStart || networkBattleURI == NetworkBattleDefine.NetworkBattleURI.TurnEndActions || networkBattleURI == NetworkBattleDefine.NetworkBattleURI.Echo)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.AddActionSequence();
|
|
LocalLog.AccumulateLastTraceLog("uri:" + networkBattleURI.ToString() + " ActionSeq:" + ToolboxGame.RealTimeNetworkAgent.GetActionSequenceCount() + " Recovery");
|
|
}
|
|
if (networkBattleURI == NetworkBattleDefine.NetworkBattleURI.BattleStart)
|
|
{
|
|
DateTime battleStartDate = ((!dictionary.ContainsKey(NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.battleStartDate])) ? GetCulculateWaitTime(double.Parse(dictionary["time"].ToString())) : new DateTime(long.Parse(dictionary[NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.battleStartDate]].ToString())));
|
|
_battleStartDate = battleStartDate;
|
|
ToolboxGame.RealTimeNetworkAgent.SetIsBattleStart(flag: true);
|
|
}
|
|
if (networkBattleURI == NetworkBattleDefine.NetworkBattleURI.JudgeResult)
|
|
{
|
|
_hasSequenceResult = int.Parse(dictionary[NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.result]].ToString());
|
|
}
|
|
RecordLogTime(dictionary, networkBattleURI);
|
|
CheckNoAction(flag, networkBattleURI);
|
|
if (!flag)
|
|
{
|
|
bool isOpponentDisconnected = ToolboxGame.RealTimeNetworkAgent.IsOpponentDisconnected;
|
|
bool flag2 = networkBattleURI == NetworkBattleDefine.NetworkBattleURI.OppoDisconnect;
|
|
_isOpponentDisconnect = isOpponentDisconnected || flag2;
|
|
}
|
|
if (!RecoveryExceptUriList.Contains(networkBattleURI))
|
|
{
|
|
if (networkBattleURI != NetworkBattleDefine.NetworkBattleURI.OppoDisconnect && networkBattleURI != NetworkBattleDefine.NetworkBattleURI.RecoveryStart && networkBattleURI != NetworkBattleDefine.NetworkBattleURI.RecoveryEnd && (networkBattleURI != NetworkBattleDefine.NetworkBattleURI.JudgeResult || _hasSequenceResult != 0))
|
|
{
|
|
_hasSequenceUri = networkBattleURI;
|
|
_isPlayerSend = flag;
|
|
}
|
|
if (networkBattleURI == NetworkBattleDefine.NetworkBattleURI.TurnStart && flag)
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerEmotion.ResetPlayCount();
|
|
}
|
|
_networkBattleMgr.GetNetworkBattleReceiver().ReceivedMessage(networkBattleURI, isHaveSequence: true, dictionary, flag, null, checkBreakData: false);
|
|
if (_hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.TurnEndFinal || _hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.BattleFinish || _hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.Retire)
|
|
{
|
|
CallRecoveryFinish(onFinishRecoveringData, waitForAck: false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_networkBattleMgr.GetNetworkBattleReceiver().RecordReplayInfoInRecoveryExceptUriList(networkBattleURI, isHaveSequence: true, dictionary, flag);
|
|
}
|
|
if (networkBattleURI == NetworkBattleDefine.NetworkBattleURI.ChatStamp && flag)
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerEmotion.AddPlayCount();
|
|
}
|
|
NextStockReceive(dictionary);
|
|
}
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
private void NextStockReceive(Dictionary<string, object> frontData)
|
|
{
|
|
stockReceiveMessageMgr.UpdateSequenceAlreadyNumber(frontData);
|
|
stockReceiveMessageMgr.RemoveSelectData(frontData);
|
|
}
|
|
|
|
protected IEnumerator AIStockDataPlayer(Action onFinishRecoveringData, RecoveryOperationInfo aiBattleRecoveryData)
|
|
{
|
|
if (!aiBattleRecoveryData.SetupInfo.HasMulliganInfo)
|
|
{
|
|
yield return null;
|
|
AICallRecoveryFinish(onFinishRecoveringData, waitForAck: true, aiBattleRecoveryData);
|
|
}
|
|
else
|
|
{
|
|
SingleMulliganMgr singleMulliganMgr = new SingleMulliganMgr();
|
|
MulliganInfoControl component = GameMgr.GetIns().GetGameObjMgr().AddUIContainerChildPrefab("Prefab/UI/MulliganInfo")
|
|
.GetComponent<MulliganInfoControl>();
|
|
singleMulliganMgr.InitMulligan(component, _networkBattleMgr.BattlePlayer.PlayerBattleView);
|
|
SkillProcessor skillProcessor = new SkillProcessor();
|
|
singleMulliganMgr.MulliganStartDraw(aiBattleRecoveryData.SetupInfo.DidPlayerGoFirst, skillProcessor);
|
|
foreach (int playerMulliganReplaceCard in aiBattleRecoveryData.SetupInfo.PlayerMulliganReplaceCards)
|
|
{
|
|
int cardIndex = playerMulliganReplaceCard;
|
|
BattleCardBase battleCardBase = _networkBattleMgr.BattlePlayer.HandCardList.SingleOrDefault((BattleCardBase c) => c.Index == cardIndex);
|
|
if (battleCardBase != null)
|
|
{
|
|
singleMulliganMgr.AbandonList.Add(battleCardBase);
|
|
}
|
|
}
|
|
singleMulliganMgr.Submit(BattleManagerBase.GetIns());
|
|
singleMulliganMgr.GetMulliganInfo().SetPlayerReady();
|
|
IEnumerable<IOperationCommand> _commands = aiBattleRecoveryData.ActionCommands;
|
|
EnemyAI ai = BattleManagerBase.GetIns().EnemyAI as EnemyAI;
|
|
while (_commands.Any())
|
|
{
|
|
IOperationCommand operationCommand = _commands.FirstOrDefault();
|
|
if (operationCommand != null)
|
|
{
|
|
bool isSelfTurn = _networkBattleMgr.BattlePlayer.IsSelfTurn;
|
|
operationCommand.Operation(_networkBattleMgr);
|
|
ai.UpdateAICurrentVirtualField();
|
|
if (operationCommand is TurnEndOperationCommand && !_networkBattleMgr.IsBattleEnd)
|
|
{
|
|
if (isSelfTurn)
|
|
{
|
|
_networkBattleMgr.ControlTurnStartOpponent();
|
|
}
|
|
else
|
|
{
|
|
_networkBattleMgr.ControlTurnStartPlayer();
|
|
}
|
|
ai.UpdateAICurrentVirtualField();
|
|
}
|
|
}
|
|
_commands = _commands.Skip(1);
|
|
yield return null;
|
|
}
|
|
if (_networkBattleMgr.BattlePlayer.IsSelfTurn)
|
|
{
|
|
_networkBattleMgr.BattlePlayer.TurnStartEffectEnd();
|
|
}
|
|
AICallRecoveryFinish(onFinishRecoveringData, waitForAck: true, aiBattleRecoveryData);
|
|
}
|
|
yield return null;
|
|
}
|
|
|
|
private void CheckNoAction(bool isPlayer, NetworkBattleDefine.NetworkBattleURI uri)
|
|
{
|
|
if (isPlayer)
|
|
{
|
|
switch (uri)
|
|
{
|
|
case NetworkBattleDefine.NetworkBattleURI.TurnStart:
|
|
isTurnStartWithNoAction = true;
|
|
break;
|
|
default:
|
|
isTurnStartWithNoAction = false;
|
|
break;
|
|
case NetworkBattleDefine.NetworkBattleURI.OppoDisconnect:
|
|
case NetworkBattleDefine.NetworkBattleURI.RecoveryStart:
|
|
case NetworkBattleDefine.NetworkBattleURI.RecoveryEnd:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RecordLogTime(Dictionary<string, object> frontData, NetworkBattleDefine.NetworkBattleURI uri)
|
|
{
|
|
if (!frontData.ContainsKey("time"))
|
|
{
|
|
return;
|
|
}
|
|
if (!_networkBattleMgr._recoveryController.IsMariganFinished)
|
|
{
|
|
if (!isFirstTimeSet)
|
|
{
|
|
isFirstTimeSet = true;
|
|
_firstTime = GetCulculateWaitTime(double.Parse(frontData["time"].ToString()));
|
|
}
|
|
}
|
|
else if (uri == NetworkBattleDefine.NetworkBattleURI.TurnStart || uri == NetworkBattleDefine.NetworkBattleURI.Ready)
|
|
{
|
|
isFirstTimeSet = true;
|
|
_firstTime = GetCulculateWaitTime(double.Parse(frontData["time"].ToString()));
|
|
}
|
|
_lastTime = GetCulculateWaitTime(double.Parse(frontData["time"].ToString()));
|
|
}
|
|
|
|
private void CallRecoveryFinish(Action onFinishRecoveringData, bool waitForAck)
|
|
{
|
|
onFinishRecoveringData.Call();
|
|
_networkBattleMgr.SetupFieldAndHandAfterRecovery(delegate
|
|
{
|
|
CompleteRecovery(waitForAck);
|
|
});
|
|
}
|
|
|
|
private void AICallRecoveryFinish(Action onFinishRecoveringData, bool waitForAck, RecoveryOperationInfo aiBattleRecoveryData)
|
|
{
|
|
onFinishRecoveringData.Call();
|
|
_networkBattleMgr._recoveryController = null;
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
if (!aiBattleRecoveryData.SetupInfo.HasMulliganInfo)
|
|
{
|
|
if (!aiBattleRecoveryData.SetupInfo.HasMulliganInfo)
|
|
{
|
|
sequentialVfxPlayer = SequentialVfxPlayer.Create(_networkBattleMgr.MulliganMgr.RecoverMulligan(didPlayerSubmitMulligan: false, _networkBattleMgr), InstantVfx.Create(delegate
|
|
{
|
|
if (_networkBattleMgr.GetCurrentPhase() is RecoveryNetworkBeforeSubmitMulliganPhase recoveryNetworkBeforeSubmitMulliganPhase)
|
|
{
|
|
recoveryNetworkBeforeSubmitMulliganPhase.RecoveryEnd();
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_networkBattleMgr.ReinitializeTurnPanelControl();
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.ClearPlayQueue();
|
|
if (_networkBattleMgr.BattlePlayer.IsSelfTurn)
|
|
{
|
|
_networkBattleMgr.BattlePlayer.TurnStartEffectEnd();
|
|
}
|
|
_networkBattleMgr.SetupFieldAndHandAfterRecovery(null, aiBattleRecoveryData);
|
|
ParallelVfxPlayer vfx = ParallelVfxPlayer.Create(InstantVfx.Create(delegate
|
|
{
|
|
GameMgr.GetIns().GetBattleCtrl().StartCoroutine(FontChanger.FontChange(null));
|
|
}), _networkBattleMgr.BattlePlayer.Recovery(), _networkBattleMgr.BattleEnemy.Recovery());
|
|
IBattlePlayerView battlePlayerView = (_networkBattleMgr.BattleEnemy.IsSelfTurn ? _networkBattleMgr.BattleEnemy.BattleView : _networkBattleMgr.BattlePlayer.BattleView);
|
|
sequentialVfxPlayer.Register(vfx);
|
|
sequentialVfxPlayer.Register(HandViewBase.CreateHideCardMeshesVfx(_networkBattleMgr.BattleEnemy.HandCardList));
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
_networkBattleMgr.BattlePlayer.UpdateHandCardsPlayability();
|
|
}));
|
|
sequentialVfxPlayer.Register(battlePlayerView.RecoveryTurnStart());
|
|
sequentialVfxPlayer.Register(_networkBattleMgr.GetCurrentPhase().Setup());
|
|
}
|
|
AIOpenRecovery(aiBattleRecoveryData);
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.ResetTouchable();
|
|
if (_canNotTouchCardVfx != null)
|
|
{
|
|
_canNotTouchCardVfx.End();
|
|
_canNotTouchCardVfx = null;
|
|
}
|
|
_networkBattleMgr.RecoveryEnd();
|
|
ToolboxGame.RealTimeNetworkAgent.EndRecovery();
|
|
ToolboxGame.UIManager.CloseInSceneLoadingBattle();
|
|
}));
|
|
sequentialVfxPlayer.Register(_networkBattleMgr.JudgeBattleResult());
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(sequentialVfxPlayer);
|
|
}
|
|
|
|
private void CompleteRecovery(bool waitForAck)
|
|
{
|
|
Stop();
|
|
_networkBattleMgr.RecoveryEnd();
|
|
StopTimeOut();
|
|
NetworkBattleReceiver.RESULT_CODE rESULT_CODE = _networkBattleMgr.JudgeCurrentFinishStatus();
|
|
SequentialVfxPlayer sequentialVfxPlayer = SequentialVfxPlayer.Create();
|
|
if (_networkBattleMgr.IsBattleEnd)
|
|
{
|
|
sequentialVfxPlayer.Register(InstantVfx.Create(delegate
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.HideTurnEndButton();
|
|
}));
|
|
}
|
|
bool flag = false;
|
|
bool isCheckTimeOutTurnEnd = true;
|
|
switch (rESULT_CODE)
|
|
{
|
|
case NetworkBattleReceiver.RESULT_CODE.DeckoutWin:
|
|
CheckDeckoutResult(sequentialVfxPlayer, isDeckoutWin: true);
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.DeckoutLose:
|
|
CheckDeckoutResult(sequentialVfxPlayer, isDeckoutWin: false);
|
|
break;
|
|
case NetworkBattleReceiver.RESULT_CODE.NotFinish:
|
|
if (_networkBattleMgr._specialWinVfx != null)
|
|
{
|
|
RegisterSpecialWin(sequentialVfxPlayer);
|
|
break;
|
|
}
|
|
switch (_hasSequenceUri)
|
|
{
|
|
case NetworkBattleDefine.NetworkBattleURI.TurnEndActions:
|
|
if (_isPlayerSend)
|
|
{
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = 0;
|
|
_networkBattleMgr.SendTurnEnd();
|
|
}
|
|
else
|
|
{
|
|
_networkBattleMgr.networkBattleData.isReceiveTurnEndAction = true;
|
|
_networkBattleMgr.SendEcho(_networkBattleMgr.networkBattleData.GetReceiveData().playCardIndex, _networkBattleMgr.networkBattleData.GetReceiveData().actionType, isNotActiveSeq: true);
|
|
}
|
|
break;
|
|
case NetworkBattleDefine.NetworkBattleURI.TurnEnd:
|
|
{
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = 0;
|
|
bool flag2 = false;
|
|
if (!_isPlayerSend)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
else if (_networkBattleMgr.BattlePlayer.IsExtraTurn && !_isOpponentDisconnect)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (flag2)
|
|
{
|
|
_networkBattleMgr.SendJudge();
|
|
flag = true;
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckTurnStartToRecoveryEnd));
|
|
}
|
|
break;
|
|
}
|
|
case NetworkBattleDefine.NetworkBattleURI.Ready:
|
|
sequentialVfxPlayer.Register(_networkBattleMgr.StartBattle());
|
|
break;
|
|
case NetworkBattleDefine.NetworkBattleURI.TurnStart:
|
|
if (_networkBattleMgr.BattlePlayer.IsShortageDeck)
|
|
{
|
|
sequentialVfxPlayer.Register(SendDeckShortage(_networkBattleMgr.BattlePlayer));
|
|
}
|
|
else if (_networkBattleMgr.BattleEnemy.IsShortageDeck)
|
|
{
|
|
sequentialVfxPlayer.Register(SendDeckShortage(_networkBattleMgr.BattleEnemy));
|
|
}
|
|
else if (!_isPlayerSend && _networkBattleMgr.BattlePlayer.IsExtraTurn)
|
|
{
|
|
_networkBattleMgr.SendEcho(_networkBattleMgr.networkBattleData.GetReceiveData().playCardIndex, _networkBattleMgr.networkBattleData.GetReceiveData().actionType);
|
|
}
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = ((!_networkBattleMgr.BattlePlayer.IsSelfTurn) ? 1 : 0);
|
|
break;
|
|
case NetworkBattleDefine.NetworkBattleURI.Judge:
|
|
if (_networkBattleMgr.BattlePlayer.IsExtraTurn)
|
|
{
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(_networkBattleMgr.ControlTurnStartOpponent());
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = 0;
|
|
isCheckTimeOutTurnEnd = false;
|
|
}
|
|
else if (_networkBattleMgr.IsBeforePlayerTurn)
|
|
{
|
|
sequentialVfxPlayer.Register(_networkBattleMgr.ControlTurnStartPlayer());
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = 0;
|
|
isCheckTimeOutTurnEnd = false;
|
|
}
|
|
else
|
|
{
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = 0;
|
|
}
|
|
break;
|
|
default:
|
|
if (_networkBattleMgr._recoveryController.IsMariganFinished)
|
|
{
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = ((!_networkBattleMgr.BattlePlayer.IsSelfTurn) ? 1 : 0);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (_networkBattleMgr.IsBattleEnd)
|
|
{
|
|
BattlePlayer battlePlayer = _networkBattleMgr.BattlePlayer;
|
|
BattleEnemy battleEnemy = _networkBattleMgr.BattleEnemy;
|
|
ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
|
|
if (battlePlayer.Class.IsDead)
|
|
{
|
|
parallelVfxPlayer.Register(battlePlayer.Class.DestroyInPlay(new SkillProcessor()));
|
|
}
|
|
if (battleEnemy.Class.IsDead)
|
|
{
|
|
parallelVfxPlayer.Register(battleEnemy.Class.DestroyInPlay(new SkillProcessor()));
|
|
}
|
|
sequentialVfxPlayer.Register(parallelVfxPlayer);
|
|
}
|
|
break;
|
|
}
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(SequentialVfxPlayer.Create(InstantVfx.Create(delegate
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.ResetTouchable();
|
|
ToolboxGame.RealTimeNetworkAgent.EndRecovery();
|
|
_networkBattleMgr._recoveryController = null;
|
|
if (_networkBattleMgr.BattlePlayer.IsSelfTurn || !Data.BattleRecoveryInfo.IsMulliganEnd)
|
|
{
|
|
RecoveryCreateRegisterAction(delegate
|
|
{
|
|
if (!_networkBattleMgr.IsBattleEnd)
|
|
{
|
|
IPlayerView playerBattleView = _networkBattleMgr.BattlePlayer.PlayerBattleView;
|
|
playerBattleView.TurnEndButtonUI._isButtonForcedOff = false;
|
|
_networkBattleMgr.BattlePlayer.TurnStartEffectEnd();
|
|
playerBattleView.ShowTurnEndButton();
|
|
}
|
|
if (!Data.BattleRecoveryInfo.IsReceivedDeal)
|
|
{
|
|
_networkBattleMgr.NetworkSender.SendDeal();
|
|
}
|
|
if (_canNotTouchCardVfx != null)
|
|
{
|
|
_canNotTouchCardVfx.End();
|
|
_canNotTouchCardVfx = null;
|
|
}
|
|
OpenRecovery(isCheckTimeOutTurnEnd);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
OpenRecovery(isCheckTimeOutTurnEnd);
|
|
}
|
|
if (Data.BattleRecoveryInfo.IsMulliganEnd)
|
|
{
|
|
_networkBattleMgr.BattleUIContainer.Battery.SetActive(value: true);
|
|
_networkBattleMgr.BattlePlayer.StatusPanelControl.ShowStatusPanelAlways();
|
|
_networkBattleMgr.BattleEnemy.StatusPanelControl.ShowStatusPanelAlways();
|
|
}
|
|
ToolboxGame.UIManager.CloseInSceneLoadingBattle();
|
|
}), sequentialVfxPlayer));
|
|
ToolboxGame.RealTimeNetworkAgent.IsNotPlayReceivingData = false;
|
|
if (_hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.TurnEndFinal && rESULT_CODE != NetworkBattleReceiver.RESULT_CODE.NotFinish)
|
|
{
|
|
_networkBattleMgr.SendJudge();
|
|
}
|
|
if ((_hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.JudgeResult && _hasSequenceResult != 0) || _hasSequenceUri == NetworkBattleDefine.NetworkBattleURI.BattleFinish)
|
|
{
|
|
if (!_isPlayerSend)
|
|
{
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(SequentialVfxPlayer.Create(InstantVfx.Create(delegate
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent5 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent5.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent5.OnAck, new Action<Dictionary<string, object>>(AckBattleFinish));
|
|
StartTimeOut(10, isBattleFinish: true);
|
|
_networkBattleMgr.BattleFinishToTurnEndFinal(isSelfTurn: false);
|
|
})));
|
|
}
|
|
_networkBattleMgr.NetworkSender.SendRecoveryEnd();
|
|
return;
|
|
}
|
|
if (isCheckTimeOutTurnEnd && _networkBattleMgr.BattlePlayer.IsSelfTurn && (float)TimeUtil.GetElapsedTime(_firstTime, _lastTime.AddSeconds(TimeNativePlugin.GetDeviceOperatingTime())) >= 80f)
|
|
{
|
|
if (rESULT_CODE != NetworkBattleReceiver.RESULT_CODE.NotFinish)
|
|
{
|
|
_networkBattleMgr.BattleFinishToTurnEndFinal(_networkBattleMgr.BattlePlayer.IsSelfTurn);
|
|
RealTimeNetworkAgent realTimeNetworkAgent2 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent2.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent2.OnAck, new Action<Dictionary<string, object>>(AckTurnEndFinalToRecoveryEnd));
|
|
}
|
|
else
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent3 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent3.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent3.OnAck, new Action<Dictionary<string, object>>(AckTurnEndToRecoveryEnd));
|
|
}
|
|
}
|
|
else if (!flag)
|
|
{
|
|
_networkBattleMgr.NetworkSender.SendRecoveryEnd();
|
|
}
|
|
if (waitForAck)
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent4 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent4.OnAck = (Action<Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent4.OnAck, new Action<Dictionary<string, object>>(AckToComplete));
|
|
StartTimeOut(10);
|
|
}
|
|
else
|
|
{
|
|
AckToComplete(null);
|
|
}
|
|
}
|
|
|
|
private void AckTurnEndToRecoveryEnd(Dictionary<string, object> objs)
|
|
{
|
|
if (NetworkBattleGenericTool.FindDictionaryURI(objs) == NetworkBattleDefine.NetworkURINames[NetworkBattleDefine.NetworkBattleURI.TurnEnd])
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckTurnEndToRecoveryEnd));
|
|
_networkBattleMgr.NetworkSender.SendRecoveryEnd();
|
|
}
|
|
}
|
|
|
|
private void AckTurnEndFinalToRecoveryEnd(Dictionary<string, object> objs)
|
|
{
|
|
if (NetworkBattleGenericTool.FindDictionaryURI(objs) == NetworkBattleDefine.NetworkURINames[NetworkBattleDefine.NetworkBattleURI.TurnEndFinal])
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckTurnEndFinalToRecoveryEnd));
|
|
_networkBattleMgr.NetworkSender.SendJudgeResult(NetworkBattleSender.JUDGE_RESULT_STATUS.RecoveryBattleFinishToJudge);
|
|
}
|
|
}
|
|
|
|
private void AckTurnStartToRecoveryEnd(Dictionary<string, object> objs)
|
|
{
|
|
if (_networkBattleMgr.BattleEnemy.IsExtraTurn && !_isOpponentDisconnect && NetworkBattleGenericTool.FindDictionaryURI(objs) == NetworkBattleDefine.NetworkURINames[NetworkBattleDefine.NetworkBattleURI.Judge])
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckTurnStartToRecoveryEnd));
|
|
_networkBattleMgr.NetworkSender.SendRecoveryEnd();
|
|
}
|
|
else if (NetworkBattleGenericTool.FindDictionaryURI(objs) == NetworkBattleDefine.NetworkURINames[NetworkBattleDefine.NetworkBattleURI.TurnStart])
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent2 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent2.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent2.OnAck, new Action<Dictionary<string, object>>(AckTurnStartToRecoveryEnd));
|
|
_networkBattleMgr.NetworkSender.SendRecoveryEnd();
|
|
}
|
|
}
|
|
|
|
private void AckToComplete(Dictionary<string, object> objs)
|
|
{
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckToComplete));
|
|
this.OnCompleteRecovery.Call();
|
|
}
|
|
|
|
private void CheckDeckoutResult(SequentialVfxPlayer afterRecoveryResultVfx, bool isDeckoutWin)
|
|
{
|
|
if (_networkBattleMgr._specialWinVfx != null)
|
|
{
|
|
RegisterSpecialWin(afterRecoveryResultVfx);
|
|
}
|
|
else if (_networkBattleMgr != null && _networkBattleMgr.BattleResultControl != null && !_networkBattleMgr.BattleResultControl.IsResultOn)
|
|
{
|
|
if (_networkBattleMgr.GetBattlePlayer(isDeckoutWin).IsShortageDeck && _networkBattleMgr.GetBattlePlayer(isDeckoutWin).Class.SkillApplyInformation.IsShortageDeckWin)
|
|
{
|
|
afterRecoveryResultVfx.Register(SendDeckShortage(_networkBattleMgr.GetBattlePlayer(isDeckoutWin)));
|
|
}
|
|
else
|
|
{
|
|
afterRecoveryResultVfx.Register(SendDeckShortage(_networkBattleMgr.GetBattlePlayer(!isDeckoutWin)));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RegisterSpecialWin(SequentialVfxPlayer afterRecoveryResultVfx)
|
|
{
|
|
afterRecoveryResultVfx.Register(SequentialVfxPlayer.Create(_networkBattleMgr._specialWinVfx, InstantVfx.Create(delegate
|
|
{
|
|
if (!_isPlayerSend)
|
|
{
|
|
_networkBattleMgr.SendEchoRecovery(_networkBattleMgr._lastReceivedData);
|
|
}
|
|
})));
|
|
}
|
|
|
|
private void AckBattleFinish(Dictionary<string, object> objs)
|
|
{
|
|
StopTimeOut();
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnAck = (Action<Dictionary<string, object>>)Delegate.Remove(realTimeNetworkAgent.OnAck, new Action<Dictionary<string, object>>(AckBattleFinish));
|
|
this.OnCompleteRecovery.Call();
|
|
}
|
|
|
|
private void OpenRecovery(bool isSetTurnTimeoutTimer)
|
|
{
|
|
OnFinishRecoveryLogSync.Call();
|
|
if (isFirstTimeSet)
|
|
{
|
|
_pastTime = TimeUtil.GetElapsedTime(_firstTime, _lastTime.AddSeconds(TimeNativePlugin.GetDeviceOperatingTime()));
|
|
}
|
|
if (isSetTurnTimeoutTimer)
|
|
{
|
|
_networkBattleMgr.RecoveryTimeOutSetting(0f - _pastTime, Data.BattleRecoveryInfo.IsMulliganEnd, -1L);
|
|
_networkBattleMgr.SetTimeDecrementFlag(isTurnStartWithNoAction);
|
|
}
|
|
ToolboxGame.RealTimeNetworkAgent.StartPreparedStartTimer(_battleStartDate);
|
|
}
|
|
|
|
private void AIOpenRecovery(RecoveryOperationInfo aiBattleRecoveryData)
|
|
{
|
|
OnFinishRecoveryLogSync.Call();
|
|
DateTimeOffset dateTimeOffset = new DateTimeOffset(DateTime.Now.Ticks, new TimeSpan(0, 0, 0));
|
|
long num = dateTimeOffset.ToUnixTimeSeconds();
|
|
long num2 = (aiBattleRecoveryData.SetupInfo.HasMulliganInfo ? aiBattleRecoveryData.TurnStartTime : aiBattleRecoveryData.MulliganStartTime);
|
|
if (num2 == 0L)
|
|
{
|
|
num2 = aiBattleRecoveryData.OpeningStartTime;
|
|
}
|
|
if (!_networkBattleMgr.IsBattleEnd)
|
|
{
|
|
_networkBattleMgr.RecoveryTimeOutSetting(-(num - num2), aiBattleRecoveryData.SetupInfo.HasMulliganInfo, num2);
|
|
_networkBattleMgr.SetTimeDecrementFlag(isTurnStartWithNoAction);
|
|
}
|
|
ToolboxGame.RealTimeNetworkAgent.StartPreparedStartTimer(DateTime.Now.AddSeconds(-(num - num2)));
|
|
}
|
|
|
|
private void RecoveryCreateRegisterAction(Action callback)
|
|
{
|
|
if (jsonObject == null)
|
|
{
|
|
OnFinishRecoveryLogSync.Call();
|
|
return;
|
|
}
|
|
if (!jsonObject.Keys.Contains("operations"))
|
|
{
|
|
RecoveryManagerBase.OpenRecoveryFailedDialog();
|
|
return;
|
|
}
|
|
JsonData jsonData = jsonObject["operations"];
|
|
List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
|
|
for (int i = 0; i < jsonData.Count; i++)
|
|
{
|
|
Dictionary<string, object> dictionary = new Dictionary<string, object>();
|
|
foreach (string key in jsonData[i].Keys)
|
|
{
|
|
if (key == "abandoned_cards")
|
|
{
|
|
JsonData jsonData2 = jsonData[i]["abandoned_cards"];
|
|
for (int j = 0; j < jsonData2.Count; j++)
|
|
{
|
|
_mulliganList.Add(jsonData2[j]);
|
|
}
|
|
}
|
|
dictionary.Add(key, jsonData[i][key]);
|
|
}
|
|
list.Add(dictionary);
|
|
}
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.TurnEndButtonUI._isButtonForcedOff = true;
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.TurnEndButtonUI.DisableButton();
|
|
if (_canNotTouchCardVfx == null)
|
|
{
|
|
_canNotTouchCardVfx = new CanNotTouchCardVfx();
|
|
_networkBattleMgr.VfxMgr.RegisterImmediateVfx(_canNotTouchCardVfx);
|
|
}
|
|
UIManager.GetInstance().StartCoroutine(StockRecoveryPlayer(list, callback));
|
|
}
|
|
|
|
private void AINetworkRecoveryCreateRegisterAction(Action callback)
|
|
{
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.TurnEndButtonUI._isButtonForcedOff = true;
|
|
_networkBattleMgr.BattlePlayer.PlayerBattleView.TurnEndButtonUI.DisableButton();
|
|
if (_canNotTouchCardVfx == null)
|
|
{
|
|
_canNotTouchCardVfx = new CanNotTouchCardVfx();
|
|
_networkBattleMgr.VfxMgr.RegisterImmediateVfx(_canNotTouchCardVfx);
|
|
}
|
|
callback.Call();
|
|
}
|
|
|
|
protected virtual IEnumerator StockRecoveryPlayer(List<Dictionary<string, object>> recoveryDictList, Action callback)
|
|
{
|
|
bool skipRecoveryData = true;
|
|
if (skipRecoveryData && recoveryDictList.Count > 0 && Convert.ToInt32(recoveryDictList.Last()["seq"].ToString()) <= Data.BattleRecoveryInfo.Pub_seq)
|
|
{
|
|
playIndex = recoveryDictList.Count;
|
|
}
|
|
while (playIndex < recoveryDictList.Count)
|
|
{
|
|
if (skipRecoveryData && (bool)ToolboxGame.RealTimeNetworkAgent && !ToolboxGame.RealTimeNetworkAgent.IsPlayReceiveDataOk())
|
|
{
|
|
yield return null;
|
|
continue;
|
|
}
|
|
try
|
|
{
|
|
Dictionary<string, object> dictionary = recoveryDictList[playIndex];
|
|
new List<BattleCardBase>();
|
|
object obj = null;
|
|
BattleCardBase selectPlayCard = null;
|
|
bool flag = false;
|
|
if (Convert.ToInt32(dictionary["seq"].ToString()) > Data.BattleRecoveryInfo.Pub_seq)
|
|
{
|
|
string text = dictionary["operation"].ToString();
|
|
switch (text)
|
|
{
|
|
case "play":
|
|
{
|
|
BattleCardBase cardBaseByPrefix5 = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
bool flag3 = int.Parse(dictionary["is_choice_brave"].ToString()) == 1;
|
|
if (dictionary.ContainsKey("skill_target"))
|
|
{
|
|
obj = dictionary["skill_target"];
|
|
}
|
|
bool isTargetSelectSkill = obj != null;
|
|
VfxBase vfxBase = ((!flag3) ? _networkBattleMgr.OperateMgr.InitSetCard(cardBaseByPrefix5, isPlayer: true, isTargetSelectSkill) : NullVfx.GetInstance());
|
|
List<BattleCardBase> list = CreateSkillTargetListFromJsonData(isTargetSelectSkill, obj);
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(SequentialVfxPlayer.Create(vfxBase, _networkBattleMgr.OperateMgr.PlayCard(cardBaseByPrefix5, isPlayer: true, list, isRecovery: true, null, flag3)));
|
|
break;
|
|
}
|
|
case "attack":
|
|
{
|
|
BattleCardBase cardBaseByPrefix3 = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
BattleCardBase cardBaseByPrefix4 = GetCardBaseByPrefix(dictionary["target"].ToString());
|
|
RegisterPairToAttackSelectControl(cardBaseByPrefix3, cardBaseByPrefix4);
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(_networkBattleMgr.OperateMgr.Attack(cardBaseByPrefix3, cardBaseByPrefix4, isPlayer: true));
|
|
break;
|
|
}
|
|
case "evolve":
|
|
{
|
|
BattleCardBase cardBaseByPrefix = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
if (dictionary.ContainsKey("skill_target"))
|
|
{
|
|
obj = dictionary["skill_target"];
|
|
}
|
|
bool isTargetSelectSkill = obj != null;
|
|
List<BattleCardBase> list = CreateSkillTargetListFromJsonData(isTargetSelectSkill, obj);
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(_networkBattleMgr.OperateMgr.EvolutionCard(cardBaseByPrefix, isPlayer: true, list));
|
|
break;
|
|
}
|
|
case "mulligan":
|
|
if (!_networkBattleMgr.networkBattleData.isPlayerMulliganEnd)
|
|
{
|
|
for (int num = 0; num < _mulliganList.Count; num++)
|
|
{
|
|
BattleCardBase cardBaseByPrefix2 = GetCardBaseByPrefix(_mulliganList[num].ToString());
|
|
_networkBattleMgr.MulliganMgr.PlayerMlgCtrl.RegisterAbandonCard(cardBaseByPrefix2);
|
|
}
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(_networkBattleMgr.MulliganMgr.Submit(_networkBattleMgr));
|
|
}
|
|
break;
|
|
case "start_select":
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.StartSelect, _networkBattleMgr, selectPlayCard, flag);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordSelectStart(selectPlayCard);
|
|
break;
|
|
case "select":
|
|
{
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
bool flag2 = int.Parse(dictionary["is_burial_rite"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.SelectCard, _networkBattleMgr, selectPlayCard, flag, null, null, flag2);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordSelectCard(selectPlayCard, flag2);
|
|
break;
|
|
}
|
|
case "comp_select":
|
|
{
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
bool flag2 = int.Parse(dictionary["is_burial_rite"].ToString()) == 1;
|
|
bool flag3 = int.Parse(dictionary["is_choice_brave"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CompleteSelect, _networkBattleMgr, selectPlayCard, flag, null, null, flag2, flag3);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordCompleteSelect(selectPlayCard, flag2, flag3);
|
|
break;
|
|
}
|
|
case "cancel_select":
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CancelSelect, _networkBattleMgr, null, flag);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordCancelSelect();
|
|
break;
|
|
case "start_choice":
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.StartChoiceSelect, _networkBattleMgr, selectPlayCard, flag);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordStartChoiceSelect(selectPlayCard);
|
|
break;
|
|
case "comp_choice":
|
|
{
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
if (dictionary.ContainsKey("skill_target"))
|
|
{
|
|
obj = dictionary["skill_target"];
|
|
}
|
|
bool isTargetSelectSkill = obj != null;
|
|
List<BattleCardBase> list = CreateSkillTargetListFromJsonData(isTargetSelectSkill, obj);
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CompleteChoiceSelect, _networkBattleMgr, selectPlayCard, flag, list);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordCompleteChoiceSelect(list.Select((BattleCardBase c) => c.CardId).ToList());
|
|
break;
|
|
}
|
|
case "cancel_choice":
|
|
flag = int.Parse(dictionary["bool"].ToString()) == 1;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CancelChoiceSelect, _networkBattleMgr, null, flag);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordCancelChoice();
|
|
break;
|
|
case "start_fusion":
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.StartFusionSelect, _networkBattleMgr, selectPlayCard, isEvolveSelect: false);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordStartFusion(selectPlayCard);
|
|
break;
|
|
case "select_fusion":
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.SelectFusionIngredient, _networkBattleMgr, selectPlayCard, flag);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordSelectFusion(selectPlayCard);
|
|
break;
|
|
case "cancel_fusion":
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CancelSelect, _networkBattleMgr, null, isEvolveSelect: false);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).RecordCancelSelect();
|
|
break;
|
|
case "comp_fusion":
|
|
{
|
|
selectPlayCard = GetCardBaseByPrefix(dictionary["index"].ToString());
|
|
if (dictionary.ContainsKey("skill_target"))
|
|
{
|
|
obj = dictionary["skill_target"];
|
|
}
|
|
bool isTargetSelectSkill = obj != null;
|
|
EmitHandUtility.SendSelectSkill(NetworkBattleSender.SELECT_SKILL_OPERATION.CompleteFusionSelect, _networkBattleMgr, selectPlayCard, isEvolveSelect: false);
|
|
List<BattleCardBase> list = CreateSkillTargetListFromJsonData(isTargetSelectSkill, obj);
|
|
SequentialVfxPlayer vfx = SequentialVfxPlayer.Create(InstantVfx.Create(delegate
|
|
{
|
|
selectPlayCard.BattleCardView.HideHandCardInfo();
|
|
selectPlayCard.BattleCardView.GameObject.transform.localEulerAngles = FusionTargetSelectTouchProcessor.INIT_LOCAL_EULAR_ANGLE;
|
|
}), selectPlayCard.SelfBattlePlayer.BattleView.PlayQueueView.AddCardToViewVfx(selectPlayCard.BattleCardView, forceCardIntoPlayQueue: true, isSelectTarget: false, isChoice: false), new SkillSelectHandCardsVfx(list), WaitVfx.Create(0.3f), _networkBattleMgr.OperateMgr.FusionCard(selectPlayCard, isPlayer: true, list));
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(vfx);
|
|
_networkBattleMgr.OperateReceive.GetPlayActionsReflection(flag).ClearData();
|
|
break;
|
|
}
|
|
case "turn_end":
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(InstantVfx.Create(delegate
|
|
{
|
|
}));
|
|
break;
|
|
default:
|
|
Debug.LogError("Auto test \"" + text + "\" is not supported.");
|
|
break;
|
|
}
|
|
}
|
|
playIndex++;
|
|
}
|
|
catch
|
|
{
|
|
LocalLog.AccumulateTraceLog("Recovery: Failed to recover actions during disconnection. Force quit recovery. actionName:" + recoveryDictList[playIndex]["operation"].ToString() + ", playIndex:" + playIndex);
|
|
callback.Call();
|
|
yield break;
|
|
}
|
|
yield return null;
|
|
}
|
|
callback.Call();
|
|
}
|
|
|
|
private List<BattleCardBase> CreateSkillTargetListFromJsonData(bool isTargetSelectSkill, object jsonDataObject)
|
|
{
|
|
if (!isTargetSelectSkill)
|
|
{
|
|
return null;
|
|
}
|
|
List<BattleCardBase> list = new List<BattleCardBase>();
|
|
if (jsonDataObject is IEnumerable enumerable)
|
|
{
|
|
foreach (object item in enumerable)
|
|
{
|
|
string text = item.ToString();
|
|
BattleCardBase battleCardBase = GetCardBaseByPrefix(text);
|
|
if (battleCardBase == null)
|
|
{
|
|
bool flag = (text.Contains("p") ? true : false);
|
|
int num = Convert.ToInt32(text.Replace(flag ? "p" : "e", ""));
|
|
if (!CardMaster.GetInstanceForBattle().CardExists(num))
|
|
{
|
|
continue;
|
|
}
|
|
battleCardBase = _networkBattleMgr.CreateTransformCardRegisterVfx(null, num, flag);
|
|
}
|
|
if (battleCardBase != null)
|
|
{
|
|
list.Add(battleCardBase);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private void RegisterTarget(Dictionary<string, object> jsonData, BattleCardBase actionCard)
|
|
{
|
|
if (jsonData.ContainsKey("skill_target"))
|
|
{
|
|
string idxString = jsonData["skill_target"].ToString();
|
|
BattleCardBase cardBaseByPrefix = GetCardBaseByPrefix(idxString);
|
|
if (cardBaseByPrefix != null)
|
|
{
|
|
_networkBattleMgr.VfxMgr.RegisterSequentialVfx(_networkBattleMgr.OperateMgr.BattleCardSelect(actionCard, cardBaseByPrefix, isPlayer: true));
|
|
}
|
|
}
|
|
}
|
|
|
|
private BattleCardBase GetCardBaseByPrefix(string idxString)
|
|
{
|
|
BattleCardBase result = null;
|
|
if (idxString.Contains("p"))
|
|
{
|
|
int index = Convert.ToInt32(idxString.Replace("p", ""));
|
|
result = NetworkBattleGenericTool.GetIndexToCardBase(_networkBattleMgr, _networkBattleMgr.BattlePlayer, index);
|
|
}
|
|
else if (idxString.Contains("e"))
|
|
{
|
|
int index2 = Convert.ToInt32(idxString.Replace("e", ""));
|
|
result = NetworkBattleGenericTool.GetIndexToCardBase(_networkBattleMgr, _networkBattleMgr.BattleEnemy, index2);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void RegisterPairToAttackSelectControl(BattleCardBase attackCard, BattleCardBase targetCard)
|
|
{
|
|
AttackSelectControl.AttackPair attackPair = new AttackSelectControl.AttackPair(attackCard.BattleCardView, targetCard.BattleCardView);
|
|
AttackSelectControl attackSelectControl = _networkBattleMgr.BattlePlayer.BattleView.AttackSelectControl;
|
|
attackPair._attackTarget._isReady = !attackSelectControl.IsCardTranslatable(targetCard.BattleCardView);
|
|
attackSelectControl.RegisterAttackPair(attackPair);
|
|
}
|
|
|
|
private VfxBase SendDeckShortage(BattlePlayerBase player)
|
|
{
|
|
VfxBase result = player.SendShortageDeck();
|
|
_networkBattleMgr.BattleFinishToTurnEndFinal(_networkBattleMgr.BattlePlayer.IsSelfTurn);
|
|
return result;
|
|
}
|
|
|
|
private void StartTimeOut(int timer, bool isBattleFinish = false)
|
|
{
|
|
StopTimeOut();
|
|
_timeOutCoroutine = UIManager.GetInstance().StartCoroutine(StartTimeOutCorutine(timer, isBattleFinish));
|
|
}
|
|
|
|
private IEnumerator StartTimeOutCorutine(int timer, bool isBattleFinish = false)
|
|
{
|
|
long oldTimer = TimeUtil.GetAbsoluteTime().Ticks;
|
|
while (timer - NetworkUtility.GetTimeSpanSecond(oldTimer) > 0)
|
|
{
|
|
yield return null;
|
|
}
|
|
StopTimeOut();
|
|
if (isBattleFinish)
|
|
{
|
|
AckBattleFinish(null);
|
|
}
|
|
else
|
|
{
|
|
AckToComplete(null);
|
|
}
|
|
}
|
|
|
|
private void StopTimeOut()
|
|
{
|
|
if (_timeOutCoroutine != null)
|
|
{
|
|
UIManager.GetInstance().StopCoroutine(_timeOutCoroutine);
|
|
_timeOutCoroutine = null;
|
|
}
|
|
}
|
|
|
|
protected DateTime GetCulculateWaitTime(double time)
|
|
{
|
|
return TimeUtil.MicroTimeToFromUnixTime((long)time);
|
|
}
|
|
|
|
public bool isOwner(string idStr)
|
|
{
|
|
if (Convert.ToInt32(idStr) == GameMgr.GetIns().GetNetworkUserInfoData().GetSelfViewerId())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|