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.
906 lines
30 KiB
C#
906 lines
30 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cute;
|
|
using UnityEngine;
|
|
using Wizard;
|
|
using Wizard.ErrorDialog;
|
|
using Wizard.RoomMatch;
|
|
|
|
public class Matching : MatchingBase
|
|
{
|
|
public enum DoMatchingResult
|
|
{
|
|
NONE = 0,
|
|
RC_BATTLE_MATCHING_ILLEGAL = 3001,
|
|
RC_BATTLE_MATCHING_RETRY = 3002,
|
|
RC_BATTLE_MATCHING_WAITING = 3003,
|
|
RC_BATTLE_MATCHING_SUCCEEDED = 3004,
|
|
RC_BATTLE_MATCHING_RETRY_PERIOD_ERROR = 3005,
|
|
RC_BATTLE_MATCHING_INIT = 3006,
|
|
RC_BATTLE_MATCHING_SUCCEEDED_OWNER = 3007,
|
|
COLOSSEUM_BATTLE_MATCHING_RETRY = 3008,
|
|
RC_BATTLE_MATCHING_IN_BATTLE_PHASE = 3009,
|
|
AI_BATTLE_MATCHING_SUCCEEDED = 3011,
|
|
COMPETITION_BATTLE_MATCHING_RETRY = 3012,
|
|
RC_BATTLE_MATCHING_NOT_JOINED_GATHERING = 5304,
|
|
RC_BATTLE_MATCHING_GATHERING_BATTLE_END = 5311,
|
|
RC_BATTLE_MATCHING_NOT_ROOM_ID = 5316,
|
|
RC_BATTLE_MATCHING_DISABLE_ROOM_ID = 5315
|
|
}
|
|
|
|
public enum DO_MATCHING_LOG
|
|
{
|
|
TEST,
|
|
FIRST,
|
|
RETRY,
|
|
DEBUG
|
|
}
|
|
|
|
private bool _isStartBattleLoad;
|
|
|
|
protected bool _goTitleOnTimeout;
|
|
|
|
protected bool _receivedMatchingTimeout;
|
|
|
|
protected int selectDeckID;
|
|
|
|
private List<Coroutine> _doMatchingAPICoroutineList = new List<Coroutine>();
|
|
|
|
private const int GAMESTART_MATCHING = 30;
|
|
|
|
public const int CONNECT_TRY_COUNT = 4;
|
|
|
|
private const int WAIT_AI_BATTLE_START = 4;
|
|
|
|
private const int LOADED_TIMEOUT_TIMER = 25;
|
|
|
|
protected const int CONNECT_ERROR_CODE = 12;
|
|
|
|
public bool isDisplayCancelButton = true;
|
|
|
|
public bool isOffViewAllEnable = true;
|
|
|
|
private bool _isStopDoMatching;
|
|
|
|
private bool _isDisconnect;
|
|
|
|
private DialogBase _errorDialog;
|
|
|
|
protected bool isGoBattle;
|
|
|
|
private List<MatchingIntervalActionBase> _matchingIntervalActionBaseList = new List<MatchingIntervalActionBase>();
|
|
|
|
protected MatchingRetryDomatching _retryDomatching;
|
|
|
|
public MatchingNetworkConnectChecker _matchingNetworkConnectCheker;
|
|
|
|
protected MatchingTimeChecker _matchingTimeCheker;
|
|
|
|
protected MatchingRetryLoaded _matchingRetryLoaded;
|
|
|
|
protected DoMatchingResult _doMatchingResultKind;
|
|
|
|
private bool _isDomatchingReceiveFirstFlag;
|
|
|
|
private int _doMatchingTimeoutPeriod;
|
|
|
|
protected string errorDialogReturnText = Wizard.Data.SystemText.Get("Battle_0414");
|
|
|
|
private GameObject _coroutineObject;
|
|
|
|
private DateTime _battleStartDate;
|
|
|
|
protected bool isOwner;
|
|
|
|
private NetworkTask _connectAPITask;
|
|
|
|
public bool IsStopNetWorkWithErrorCode { get; private set; }
|
|
|
|
public MonoBehaviour CoroutineMonoBehaviour { get; private set; }
|
|
|
|
private bool _isRecovery
|
|
{
|
|
get
|
|
{
|
|
if (BattleManagerBase.GetIns() == null || !BattleManagerBase.GetIns().IsRecovery)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public Matching()
|
|
{
|
|
_coroutineObject = new GameObject("MatchingCoroutine");
|
|
_coroutineObject.AddComponent<MatchingCoroutine>();
|
|
CoroutineMonoBehaviour = _coroutineObject.GetComponent<MonoBehaviour>();
|
|
_matchingIntervalActionBaseList = new List<MatchingIntervalActionBase>();
|
|
_retryDomatching = new MatchingRetryDomatching(this);
|
|
MatchingRetryDomatching retryDomatching = _retryDomatching;
|
|
retryDomatching.OnDoMatchingSuccess = (Action)Delegate.Combine(retryDomatching.OnDoMatchingSuccess, new Action(OnFinishedDoMatching));
|
|
_matchingIntervalActionBaseList.Add(_retryDomatching);
|
|
_matchingNetworkConnectCheker = new MatchingNetworkConnectChecker(this);
|
|
_matchingIntervalActionBaseList.Add(_matchingNetworkConnectCheker);
|
|
_matchingTimeCheker = new MatchingTimeChecker(this);
|
|
_matchingIntervalActionBaseList.Add(_matchingTimeCheker);
|
|
_matchingRetryLoaded = new MatchingRetryLoaded(this);
|
|
_matchingIntervalActionBaseList.Add(_matchingRetryLoaded);
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
SettingRealTimeNetworkEvent();
|
|
ToolboxGame.RealTimeNetworkAgent.SettingMatchingClass(this);
|
|
}
|
|
}
|
|
|
|
public virtual void FirstSetting(int classId, int selDeck, bool isRecovery = false)
|
|
{
|
|
RealTimeNetworkAgent.FinishTaskBase = GetBattleFinishTask();
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.InitCurrentMatchingStatus();
|
|
}
|
|
if (isRecovery)
|
|
{
|
|
selectDeckID = selDeck;
|
|
StartBattleLoad();
|
|
_matchingTimeCheker.Stop();
|
|
return;
|
|
}
|
|
_isStartBattleLoad = false;
|
|
selectDeckID = selDeck;
|
|
isOwner = false;
|
|
_isDomatchingReceiveFirstFlag = true;
|
|
_isStopDoMatching = false;
|
|
_isDisconnect = false;
|
|
DoMatching(OnFinishedDoMatching, 1, DO_MATCHING_LOG.FIRST);
|
|
_matchingTimeCheker.Start();
|
|
_matchingTimeCheker.SetTimeLimitSecond(30, "do_matchingTimeOut");
|
|
}
|
|
|
|
public void UpdateOffLineMatching()
|
|
{
|
|
if (ToolboxGame.RealTimeNetworkAgent == null)
|
|
{
|
|
UpdateMatching();
|
|
}
|
|
}
|
|
|
|
public void UpdateMatching()
|
|
{
|
|
foreach (MatchingIntervalActionBase matchingIntervalActionBase in _matchingIntervalActionBaseList)
|
|
{
|
|
matchingIntervalActionBase.Update();
|
|
}
|
|
LocalLog.SubmitAccumulateLastTraceLog();
|
|
}
|
|
|
|
public void StopMatchingAction()
|
|
{
|
|
foreach (MatchingIntervalActionBase matchingIntervalActionBase in _matchingIntervalActionBaseList)
|
|
{
|
|
matchingIntervalActionBase.Stop();
|
|
}
|
|
}
|
|
|
|
public override void DoMatching(Action onFinished, int need_init, DO_MATCHING_LOG log)
|
|
{
|
|
}
|
|
|
|
protected void DoMatchingResultSetting()
|
|
{
|
|
_doMatchingResultKind = (DoMatchingResult)Wizard.Data.DoMatchingDetail.data.matchingState;
|
|
_doMatchingTimeoutPeriod = Wizard.Data.DoMatchingDetail.data.timeoutPeriod;
|
|
_retryDomatching.SettingRetryPeriod(Wizard.Data.DoMatchingDetail.data.retryPeriod);
|
|
CustomPreference.SetNodeServerURL(Wizard.Data.DoMatchingDetail.data.nodeServerUrl);
|
|
}
|
|
|
|
protected virtual void OnFinishedDoMatching()
|
|
{
|
|
if (_isStopDoMatching)
|
|
{
|
|
return;
|
|
}
|
|
if (_isDomatchingReceiveFirstFlag)
|
|
{
|
|
_matchingTimeCheker.Start();
|
|
_matchingTimeCheker.SetTimeLimitSecond(_doMatchingTimeoutPeriod, "do_matchingReceiveTimeOut");
|
|
_isDomatchingReceiveFirstFlag = false;
|
|
}
|
|
switch (_doMatchingResultKind)
|
|
{
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_ILLEGAL:
|
|
ErrorDialogWithReturn(Wizard.Data.SystemText.Get("Error_3001"), Wizard.Data.SystemText.Get("ErrorHeader_3001"), Wizard.Data.SystemText.Get("Common_0132"));
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_RETRY:
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_WAITING:
|
|
case DoMatchingResult.COLOSSEUM_BATTLE_MATCHING_RETRY:
|
|
case DoMatchingResult.COMPETITION_BATTLE_MATCHING_RETRY:
|
|
_retryDomatching.Start();
|
|
_retryDomatching.SetNeedInit(0);
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_SUCCEEDED:
|
|
StopDomatchingAPICoroutine();
|
|
_matchingNetworkConnectCheker.SetBattleId(Wizard.Data.DoMatchingDetail.data.battleId);
|
|
StartConnect();
|
|
isOwner = false;
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_RETRY_PERIOD_ERROR:
|
|
ErrorDialogWithReturn(Wizard.Data.SystemText.Get("Error_3005"), Wizard.Data.SystemText.Get("ErrorHeader_3005"), Wizard.Data.SystemText.Get("Common_0132"));
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_INIT:
|
|
_retryDomatching.Start();
|
|
_retryDomatching.SetNeedInit(1);
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_SUCCEEDED_OWNER:
|
|
StopDomatchingAPICoroutine();
|
|
_retryDomatching.SettingRetryPeriod(Wizard.Data.DoMatchingDetail.data.retryPeriod);
|
|
_matchingNetworkConnectCheker.SetBattleId(Wizard.Data.DoMatchingDetail.data.battleId);
|
|
StartConnect();
|
|
isOwner = true;
|
|
break;
|
|
case DoMatchingResult.AI_BATTLE_MATCHING_SUCCEEDED:
|
|
StopDomatchingAPICoroutine();
|
|
_matchingNetworkConnectCheker.SetBattleId(Wizard.Data.DoMatchingDetail.data.battleId);
|
|
isOwner = true;
|
|
GameMgr.GetIns().IsAINetwork = true;
|
|
SafeStartBattleCoroutine(CreateAIBattleStart());
|
|
break;
|
|
case DoMatchingResult.RC_BATTLE_MATCHING_IN_BATTLE_PHASE:
|
|
if (ToolboxGame.RealTimeNetworkAgent == null || ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus <= RealTimeNetworkAgent.MatchingStatus.StartLoad)
|
|
{
|
|
ErrorDialogWithReturn(Wizard.Data.SystemText.Get("Battle_0513"), Wizard.Data.SystemText.Get("Battle_0412"), Wizard.Data.SystemText.Get("Battle_0414"));
|
|
}
|
|
break;
|
|
case (DoMatchingResult)3010:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void StartConnect()
|
|
{
|
|
_matchingNetworkConnectCheker.Start();
|
|
_matchingNetworkConnectCheker.OnTimeoutInitNetwork = OnTimeoutInitNetworkToTimeOutAction;
|
|
_matchingNetworkConnectCheker.OnConnectError = ConnectError;
|
|
}
|
|
|
|
private void ConnectError()
|
|
{
|
|
TimeOutAction("MatchingNetworkConnectCheker ConnectFailed", MatchingNetworkConnectChecker.IsOpenIpv6Dialog());
|
|
}
|
|
|
|
private IEnumerator CreateAIBattleStart()
|
|
{
|
|
yield return new WaitForSeconds(4f);
|
|
AIBattleStartTask task = new AIBattleStartTask();
|
|
SafeStartBattleCoroutine(Toolbox.NetworkManager.Connect(task, delegate
|
|
{
|
|
if (CoroutineMonoBehaviour != null)
|
|
{
|
|
StartConnect();
|
|
}
|
|
}));
|
|
}
|
|
|
|
private void StopDomatchingAPICoroutine()
|
|
{
|
|
for (int i = 0; i < _doMatchingAPICoroutineList.Count; i++)
|
|
{
|
|
CoroutineMonoBehaviour.StopCoroutine(_doMatchingAPICoroutineList[i]);
|
|
_doMatchingAPICoroutineList[i] = null;
|
|
}
|
|
_doMatchingAPICoroutineList = new List<Coroutine>();
|
|
Toolbox.NetworkManager.StopConnectCoroutine();
|
|
}
|
|
|
|
public void MatchingInitBattle()
|
|
{
|
|
_matchingTimeCheker.Start();
|
|
_matchingTimeCheker.SetTimeLimitSecond(30, "matchedStart");
|
|
ToolboxGame.RealTimeNetworkAgent.SetCurrentMatchingStatus(RealTimeNetworkAgent.MatchingStatus.Connect);
|
|
ToolboxGame.RealTimeNetworkAgent.OnResultCodeError = ReceiveResultCodeError;
|
|
ToolboxGame.RealTimeNetworkAgent.EmitMsgPack(GetInitBattleUri());
|
|
if (GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.SetbattleId(Wizard.Data.DoMatchingDetail.data.battleId);
|
|
StartBattleLoad();
|
|
isGoBattle = true;
|
|
GotoBattle();
|
|
}
|
|
}
|
|
|
|
protected virtual NetworkBattleDefine.NetworkBattleURI GetInitBattleUri()
|
|
{
|
|
return NetworkBattleDefine.NetworkBattleURI.InitBattle;
|
|
}
|
|
|
|
protected override void SettingOwnerToMatchingState()
|
|
{
|
|
}
|
|
|
|
protected void StartBattleLoad()
|
|
{
|
|
ToolboxGame.UIManager.CloseInSceneLoadingMatching();
|
|
LoadingInScene loadingInScene = ToolboxGame.UIManager.createInSceneLoadingBattle();
|
|
if (!_isRecovery)
|
|
{
|
|
loadingInScene.ProgressObj.IsOpponentWait = true;
|
|
}
|
|
if (_isStartBattleLoad)
|
|
{
|
|
return;
|
|
}
|
|
DataMgr dataMgr = GameMgr.GetIns().GetDataMgr();
|
|
_isStartBattleLoad = true;
|
|
GameMgr.GetIns().IsNetworkBattle = true;
|
|
dataMgr.Load();
|
|
NetworkUserInfoData networkUserInfoData = GameMgr.GetIns().GetNetworkUserInfoData();
|
|
if (GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
if (!_isRecovery)
|
|
{
|
|
GameMgr.GetIns().GetNetworkUserInfoData().TurnState = Wizard.Data.AIBattleStartData.TurnState;
|
|
GameMgr.GetIns().SettingSelfInfo(Wizard.Data.AIBattleStartData.Data.SelfInfo.DataDictionary, isWatchReplayRecovery: false);
|
|
GameMgr.GetIns().SettingBattleStartSelfInfo(Wizard.Data.AIBattleStartData.Data.SelfInfo.DataDictionary);
|
|
GameMgr.GetIns().SettingOpponentInfo(Wizard.Data.AIBattleStartData.Data.OppoInfo.DataDictionary, isWatchReplayRecovery: false);
|
|
GameMgr.GetIns().SettingBattleStartOpponentInfo(Wizard.Data.AIBattleStartData.Data.OppoInfo.DataDictionary);
|
|
dataMgr.SetEnemySleeveId(Convert.ToInt64(Wizard.Data.AIBattleStartData.Data.OppoInfo.DataDictionary["sleeveId"]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
long opponentSleeveId = networkUserInfoData.GetOpponentSleeveId();
|
|
List<CardDataModel> opponentDeck = networkUserInfoData.GetOpponentDeck();
|
|
dataMgr.SetCurrentEnemyDeckData(opponentDeck.Select((CardDataModel x) => x.CardId).ToList());
|
|
dataMgr.SetEnemySleeveId(opponentSleeveId);
|
|
List<CardDataModel> selfDeck = networkUserInfoData.GetSelfDeck();
|
|
if (GameMgr.GetIns().IsWatchBattle)
|
|
{
|
|
ClassCharacterMasterData classCharacterMasterData = dataMgr.GetCharaPrmByCharaId(networkUserInfoData.GetSelfCharaId());
|
|
if (classCharacterMasterData == null)
|
|
{
|
|
classCharacterMasterData = dataMgr.GetCharaPrmByClassId(networkUserInfoData.GetSelfClassId(), isCurrentChara: false);
|
|
}
|
|
dataMgr.SetPlayerCharaId(classCharacterMasterData.chara_id);
|
|
dataMgr.SetPlayerSubClassID(networkUserInfoData.GetSelfSubClassId());
|
|
dataMgr.SetPlayerMyRotationInfo(networkUserInfoData.GetSelfMyRotationId());
|
|
dataMgr.SetPlayerSleeveId(networkUserInfoData.GetSelfSleeveId());
|
|
Wizard.Data.RoomTwoPickBeforeBattleInfo.SelfInfoDeckCopyTwoPickDraftData();
|
|
}
|
|
dataMgr.SetCurrentDeckData(selfDeck.Select((CardDataModel x) => x.CardId).ToList());
|
|
dataMgr.LoadEnemyClassData();
|
|
}
|
|
UIManager.ChangeViewSceneParam changeViewSceneParam = new UIManager.ChangeViewSceneParam();
|
|
changeViewSceneParam.NotWait();
|
|
if (!GameMgr.GetIns().IsReplayBattle)
|
|
{
|
|
changeViewSceneParam.IsInactive_AllView = false;
|
|
changeViewSceneParam.IsDestroy_AllDialog = false;
|
|
}
|
|
UIManager.GetInstance().ChangeViewScene(UIManager.ViewScene.Battle, changeViewSceneParam);
|
|
_matchingTimeCheker.Stop();
|
|
}
|
|
|
|
public virtual void SettingRealTimeNetworkEvent()
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.OnMatchingReceiveUri = null;
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnMatchingReceiveUri = (Action<NetworkBattleDefine.NetworkBattleURI, Dictionary<string, object>>)Delegate.Combine(realTimeNetworkAgent.OnMatchingReceiveUri, new Action<NetworkBattleDefine.NetworkBattleURI, Dictionary<string, object>>(ReactionReceiveUri));
|
|
ToolboxGame.RealTimeNetworkAgent.OnEmit = null;
|
|
RealTimeNetworkAgent realTimeNetworkAgent2 = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent2.OnEmit = (Action<NetworkBattleDefine.NetworkBattleURI>)Delegate.Combine(realTimeNetworkAgent2.OnEmit, new Action<NetworkBattleDefine.NetworkBattleURI>(SettingLoadedTimeOutCoroutine));
|
|
}
|
|
|
|
private void ReactionReceiveUri(NetworkBattleDefine.NetworkBattleURI uri, Dictionary<string, object> synchronizeData)
|
|
{
|
|
switch (uri)
|
|
{
|
|
case NetworkBattleDefine.NetworkBattleURI.Matched:
|
|
if (ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus == RealTimeNetworkAgent.MatchingStatus.Connect)
|
|
{
|
|
SettingOwnerToMatchingState();
|
|
ToolboxGame.RealTimeNetworkAgent.SetCurrentMatchingStatus(RealTimeNetworkAgent.MatchingStatus.StartLoad);
|
|
StartBattleLoad();
|
|
}
|
|
break;
|
|
case NetworkBattleDefine.NetworkBattleURI.Retry:
|
|
{
|
|
string value = synchronizeData[NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.targetUri]].ToString();
|
|
if (Enum.IsDefined(typeof(NetworkBattleDefine.NetworkBattleURI), value) && (NetworkBattleDefine.NetworkBattleURI)Enum.Parse(typeof(NetworkBattleDefine.NetworkBattleURI), value) == NetworkBattleDefine.NetworkBattleURI.Loaded)
|
|
{
|
|
_matchingRetryLoaded.Start();
|
|
}
|
|
break;
|
|
}
|
|
case NetworkBattleDefine.NetworkBattleURI.BattleStart:
|
|
if (synchronizeData.ContainsKey(NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.battleStartDate]))
|
|
{
|
|
_battleStartDate = TimeUtil.MicroTimeToFromUnixTime(long.Parse(synchronizeData[NetworkBattleDefine.NetworkParameterNames[NetworkBattleDefine.NetworkParameter.battleStartDate]].ToString()));
|
|
}
|
|
else
|
|
{
|
|
_battleStartDate = DateTime.Now;
|
|
}
|
|
ToolboxGame.RealTimeNetworkAgent.SetNetworkInfo(synchronizeData, ref uri);
|
|
ToolboxGame.RealTimeNetworkAgent.SetCurrentMatchingStatus(RealTimeNetworkAgent.MatchingStatus.Prepared);
|
|
SafeStartBattleCoroutine(CheckNetworkInfo(delegate
|
|
{
|
|
isGoBattle = true;
|
|
_matchingTimeCheker.Stop();
|
|
GotoBattle();
|
|
}));
|
|
break;
|
|
}
|
|
}
|
|
|
|
private IEnumerator CheckNetworkInfo(Action callback)
|
|
{
|
|
while (!BattleManagerBase.GetIns().BattleStartControl.IsReady)
|
|
{
|
|
yield return null;
|
|
}
|
|
callback.Call();
|
|
}
|
|
|
|
private void SettingLoadedTimeOutCoroutine(NetworkBattleDefine.NetworkBattleURI uri)
|
|
{
|
|
if (uri == NetworkBattleDefine.NetworkBattleURI.Loaded)
|
|
{
|
|
_goTitleOnTimeout = true;
|
|
_matchingTimeCheker.Start();
|
|
_matchingTimeCheker.SetTimeLimitSecond(25, "loadedTimeout");
|
|
RealTimeNetworkAgent realTimeNetworkAgent = ToolboxGame.RealTimeNetworkAgent;
|
|
realTimeNetworkAgent.OnEmit = (Action<NetworkBattleDefine.NetworkBattleURI>)Delegate.Remove(realTimeNetworkAgent.OnEmit, new Action<NetworkBattleDefine.NetworkBattleURI>(SettingLoadedTimeOutCoroutine));
|
|
}
|
|
}
|
|
|
|
private void RemoveRealTimeNetworkEvent()
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.OnMatchingReceiveUri = null;
|
|
ToolboxGame.RealTimeNetworkAgent.OnEmit = null;
|
|
_matchingNetworkConnectCheker.OnConnectError = null;
|
|
_matchingNetworkConnectCheker.OnTimeoutInitNetwork = null;
|
|
}
|
|
|
|
public virtual void GotoBattle()
|
|
{
|
|
SettingOpponentClassDataAndLoadObject();
|
|
RemoveRealTimeNetworkEvent();
|
|
if (!GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
BattleManagerBase.GetIns().SetupReplayBattleInfoFilter();
|
|
}
|
|
if ((bool)ToolboxGame.RealTimeNetworkAgent && ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus != RealTimeNetworkAgent.MatchingStatus.Prepared)
|
|
{
|
|
ToolboxGame.RealTimeNetworkAgent.SetCurrentMatchingStatus(RealTimeNetworkAgent.MatchingStatus.Prepared);
|
|
}
|
|
if (!GameMgr.GetIns().IsAINetwork)
|
|
{
|
|
if ((bool)ToolboxGame.RealTimeNetworkAgent)
|
|
{
|
|
NetworkBattleManagerBase networkBattleManagerBase = BattleManagerBase.GetIns() as NetworkBattleManagerBase;
|
|
networkBattleManagerBase.SettingOpponentAliveEvent();
|
|
if (!_isRecovery)
|
|
{
|
|
networkBattleManagerBase.IsStopIntervalCheck = false;
|
|
}
|
|
ToolboxGame.RealTimeNetworkAgent.StartPreparedStartTimer(_battleStartDate);
|
|
ToolboxGame.RealTimeNetworkAgent.StartRecoveryRecording();
|
|
}
|
|
UIManager.GetInstance().OffViewAllOutside(UIManager.ViewScene.Battle);
|
|
if (!_isRecovery)
|
|
{
|
|
ToolboxGame.UIManager.CloseInSceneLoadingBattle();
|
|
}
|
|
}
|
|
DestroyCoroutineObject();
|
|
}
|
|
|
|
protected void SettingOpponentClassDataAndLoadObject()
|
|
{
|
|
DataMgr dataMgr = GameMgr.GetIns().GetDataMgr();
|
|
NetworkUserInfoData networkUserInfoData = GameMgr.GetIns().GetNetworkUserInfoData();
|
|
ClassCharacterMasterData classCharacterMasterData = dataMgr.GetCharaPrmByCharaId(networkUserInfoData.GetOpponentCharaId());
|
|
bool flag = PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.SHOW_OPPONENT_DEFAULT_SKIN);
|
|
if (flag && networkUserInfoData.GetOpponentChaosId() != -1 && (GameMgr.GetIns().IsNetworkBattle || GameMgr.GetIns().IsReplayBattle) && !networkUserInfoData.GetOpponentChaosOverrideSkin())
|
|
{
|
|
flag = false;
|
|
}
|
|
if (classCharacterMasterData == null || flag)
|
|
{
|
|
classCharacterMasterData = dataMgr.GetCharaPrmByClassId(networkUserInfoData.GetOpponentClassId(), isCurrentChara: false);
|
|
}
|
|
dataMgr.SetEnemyCharaId(classCharacterMasterData.chara_id);
|
|
dataMgr.SetEnemySubClassID(networkUserInfoData.GetOpponentSubClassId());
|
|
dataMgr.SetEnemyMyRotationInfo(networkUserInfoData.GetOpponentMyRotationId());
|
|
dataMgr.SetEnemyAvatarBattleInfo(networkUserInfoData.GetOpponentAvatarBattleId());
|
|
}
|
|
|
|
public virtual FinishTaskBase GetBattleFinishTask()
|
|
{
|
|
return new FinishTaskBase();
|
|
}
|
|
|
|
public bool GetMatchingDataReady()
|
|
{
|
|
return _isStartBattleLoad;
|
|
}
|
|
|
|
public void DisConnect(Action onDisconnected)
|
|
{
|
|
if (!_isDisconnect)
|
|
{
|
|
_isDisconnect = true;
|
|
string text = "matchingDisconnect";
|
|
DestroyCoroutineObject();
|
|
if ((bool)ToolboxGame.RealTimeNetworkAgent)
|
|
{
|
|
text += ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus;
|
|
ToolboxGame.RealTimeNetworkAgent.DestroyObj(RealTimeNetworkAgent.DESTROY_OBJECT_LOG.MatchingDisconnect);
|
|
}
|
|
text += StackTraceUtility.ExtractStackTrace();
|
|
LocalLog.AccumulateLastTraceLog(text);
|
|
_isStopDoMatching = true;
|
|
onDisconnected.Call();
|
|
}
|
|
}
|
|
|
|
protected void DestroyCoroutineObject()
|
|
{
|
|
StopMatchingAction();
|
|
if (CoroutineMonoBehaviour != null)
|
|
{
|
|
CoroutineMonoBehaviour.StopAllCoroutines();
|
|
CoroutineMonoBehaviour = null;
|
|
}
|
|
if (_coroutineObject != null)
|
|
{
|
|
UnityEngine.Object.Destroy(_coroutineObject);
|
|
_coroutineObject = null;
|
|
}
|
|
}
|
|
|
|
public void ReturnScene()
|
|
{
|
|
if (!_isStartBattleLoad && isOffViewAllEnable)
|
|
{
|
|
UIManager.GetInstance().OffViewAll();
|
|
}
|
|
ToolboxGame.DestroyNetworkAgent();
|
|
GameMgr.GetIns().IsAINetwork = false;
|
|
if (GetMatchingDataReady() && GameMgr.GetIns().GetBattleCtrl() != null)
|
|
{
|
|
UIManager.GetInstance().StartCoroutine(BattleEndCoroutin(GotoHomeScene));
|
|
return;
|
|
}
|
|
UIManager.GetInstance().CloseInSceneLoadingMatching();
|
|
if (GetMatchingDataReady())
|
|
{
|
|
GotoHomeScene();
|
|
}
|
|
else
|
|
{
|
|
GotoDeckSelectScene();
|
|
}
|
|
}
|
|
|
|
protected virtual void GotoHomeScene()
|
|
{
|
|
UIManager.ChangeViewSceneParam changeViewSceneParam = new UIManager.ChangeViewSceneParam();
|
|
changeViewSceneParam.MyPageMenuIndex = 0;
|
|
changeViewSceneParam.IsCutCardMotion = true;
|
|
UIManager.GetInstance().CloseInSceneLoadingMatching();
|
|
UIManager.GetInstance().CloseInSceneLoadingBattle();
|
|
UIManager.GetInstance().ChangeViewScene(UIManager.ViewScene.MyPage, changeViewSceneParam);
|
|
}
|
|
|
|
protected override void GotoDeckSelectScene()
|
|
{
|
|
}
|
|
|
|
private void OnSelectDeck(DialogBase dialogDeckList, DeckData deck)
|
|
{
|
|
if (deck == null || GameMgr.GetIns().GetDataMgr().m_BattleType == DataMgr.BattleType.None)
|
|
{
|
|
return;
|
|
}
|
|
if (!deck.IsUsable())
|
|
{
|
|
InCompleteDeckDecideDialog.Create(dialogDeckList, deck);
|
|
return;
|
|
}
|
|
CompleteDeckDecideDialog completeDeckDecideDialog = CompleteDeckDecideDialog.CreateForSingleDeck(dialogDeckList, deck, showSimpleStageOption: false, null);
|
|
if (GameMgr.GetIns().GetDataMgr().m_BattleType == DataMgr.BattleType.RoomBattle || GameMgr.GetIns().GetDataMgr().m_BattleType == DataMgr.BattleType.RoomTwoPick)
|
|
{
|
|
RoomBase.DeckConfirmDialog = completeDeckDecideDialog.Dialog;
|
|
}
|
|
}
|
|
|
|
public void QuitMatching(bool isReturnScene = true)
|
|
{
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("Matching_QuitMatching" + ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus);
|
|
}
|
|
DisConnect(delegate
|
|
{
|
|
if (isReturnScene)
|
|
{
|
|
ReturnScene();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void ReceiveResultCodeError(int code)
|
|
{
|
|
if (!IsStopNetWorkWithErrorCode)
|
|
{
|
|
IsStopNetWorkWithErrorCode = true;
|
|
_matchingTimeCheker.Stop();
|
|
switch (code)
|
|
{
|
|
case 30201:
|
|
_receivedMatchingTimeout = true;
|
|
TimeOutAction("ReceiveResultCodeError");
|
|
break;
|
|
case 30212:
|
|
TimeOutAction("NodeErrorDisconnect");
|
|
break;
|
|
case 30001:
|
|
case 30002:
|
|
case 30213:
|
|
case 30302:
|
|
DisConnect(null);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnTimeoutInitNetworkToTimeOutAction()
|
|
{
|
|
_matchingNetworkConnectCheker.OnTimeoutInitNetwork = null;
|
|
TimeOutAction("OnTimeoutInitNetwork");
|
|
}
|
|
|
|
public virtual void TimeOutAction(string log, bool isIpv6Dialog = false)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("TimeOutAction " + log);
|
|
if (ToolboxGame.RealTimeNetworkAgent != null && ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus >= RealTimeNetworkAgent.MatchingStatus.Prepared && ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus != RealTimeNetworkAgent.MatchingStatus.RoomReady && ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus != RealTimeNetworkAgent.MatchingStatus.Room)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("Matching_TimeOutActionIgnore" + ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus);
|
|
}
|
|
else if (isIpv6Dialog)
|
|
{
|
|
ErrorDialogWithRetry("", Wizard.Data.SystemText.Get("ErrorHeader_0016"), isIpv6Dialog);
|
|
}
|
|
else if (_goTitleOnTimeout && !_receivedMatchingTimeout)
|
|
{
|
|
ErrorDialogGoToTitle(Wizard.Data.SystemText.Get("Battle_0508"), Wizard.Data.SystemText.Get("Battle_0412"));
|
|
}
|
|
else if (_isStartBattleLoad || _receivedMatchingTimeout)
|
|
{
|
|
ErrorDialogWithReturn(Wizard.Data.SystemText.Get("Battle_0404"), Wizard.Data.SystemText.Get("Battle_0412"), Wizard.Data.SystemText.Get("Common_0132"));
|
|
}
|
|
else
|
|
{
|
|
TimeOutMessageToRetry();
|
|
}
|
|
}
|
|
|
|
protected virtual void TimeOutMessageToRetry()
|
|
{
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("Matching_TimeOutMessageToRetry" + ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus);
|
|
}
|
|
ErrorDialogWithRetry(Wizard.Data.SystemText.Get("Battle_0405"), Wizard.Data.SystemText.Get("Battle_0412"));
|
|
}
|
|
|
|
protected int GetLastResultCode()
|
|
{
|
|
return _connectAPITask.GetResultCode();
|
|
}
|
|
|
|
protected void ConnectAPI(NetworkTask task, Action<NetworkTask.ResultCode> callbackOnSuccess = null)
|
|
{
|
|
string text = "Matching_ConnectAPI " + task;
|
|
if ((bool)ToolboxGame.RealTimeNetworkAgent)
|
|
{
|
|
text += ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus;
|
|
}
|
|
text += StackTraceUtility.ExtractStackTrace();
|
|
LocalLog.AccumulateLastTraceLog(text);
|
|
_connectAPITask = task;
|
|
task.SkipAllCuteResultCodeCheckErrorPopup();
|
|
task.SkipCuteTimeOutPopup();
|
|
task.SkipCuteHttpStatusErrorPopup();
|
|
_doMatchingAPICoroutineList.Add(SafeStartBattleCoroutine(Toolbox.NetworkManager.Connect(task, callbackOnSuccess, delegate(NetworkTask.ResultCode result)
|
|
{
|
|
if (task.GetResultCode() == 109)
|
|
{
|
|
LocalLog.AccumulateLastTraceLog("Matching_TimeSlipRotation SeasonChangeError");
|
|
Dialog.Create(task.GetResultCode());
|
|
}
|
|
else
|
|
{
|
|
OnFailed((int)result);
|
|
}
|
|
}, OnErrorAPI)));
|
|
}
|
|
|
|
protected virtual void OnFailed(int code)
|
|
{
|
|
string text = "Matching_ConnectAPIOnFailed";
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
text += ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus;
|
|
}
|
|
LocalLog.AccumulateLastTraceLog(text);
|
|
int num = code;
|
|
if (code == 4)
|
|
{
|
|
UIManager.GetInstance().closeInSceneLoading();
|
|
DisConnect(null);
|
|
}
|
|
else
|
|
{
|
|
num = 12;
|
|
OnErrorAPI(num);
|
|
}
|
|
}
|
|
|
|
private void OnErrorAPI(int code)
|
|
{
|
|
if (code == 9999)
|
|
{
|
|
DisConnect(delegate
|
|
{
|
|
Dialog.Create(code);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
if (_connectAPITask != null && _connectAPITask.GetResultCode() == 109)
|
|
{
|
|
return;
|
|
}
|
|
string text = "Matching_OnErrorAPI";
|
|
if (ToolboxGame.RealTimeNetworkAgent != null)
|
|
{
|
|
text += ToolboxGame.RealTimeNetworkAgent.CurrentMatchingStatus;
|
|
}
|
|
LocalLog.AccumulateLastTraceLog(text);
|
|
UIManager.GetInstance().closeInSceneLoading();
|
|
TaskManager.GetErrorMsgFromCode(code, out var msg, out var title);
|
|
if (code != 317)
|
|
{
|
|
bool num = code == 101 || (code >= 2000 && code <= 2999);
|
|
bool flag = code >= 2000 && code <= 2999;
|
|
if (num)
|
|
{
|
|
NetworkUI.GetInstance().OpenGoToTitleErrorPopUp(title, Wizard.Data.SystemText.Get("Battle_0409"), code.ToString());
|
|
}
|
|
else if (flag)
|
|
{
|
|
ErrorDialogWithReturn(msg, title, Wizard.Data.SystemText.Get("Common_0132"));
|
|
}
|
|
else if (code == 3010)
|
|
{
|
|
ErrorDialogGoToTitle(msg, title);
|
|
}
|
|
else
|
|
{
|
|
ErrorDialogWithRetry(msg, title);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected DialogBase CreateDialogBase()
|
|
{
|
|
DialogBase dialogBase = null;
|
|
return (_errorDialog != null) ? _errorDialog : (_errorDialog = UIManager.GetInstance().CreateDialogClose());
|
|
}
|
|
|
|
protected void ErrorDialogWithReturn(string text, string title, string buttonMsg)
|
|
{
|
|
DisConnect(delegate
|
|
{
|
|
DialogBase dialogBase = CreateDialogBase();
|
|
dialogBase.SetTitleLabel(title);
|
|
dialogBase.SetText(text);
|
|
dialogBase.SetButtonLayout(DialogBase.ButtonLayout.GrayBtn);
|
|
dialogBase.SetButtonText(buttonMsg);
|
|
dialogBase.SetFadeButtonEnabled(flag: false);
|
|
dialogBase.SetPanelDepth(5400);
|
|
dialogBase.OnClose = ReturnScene;
|
|
});
|
|
}
|
|
|
|
protected void ErrorDialogGoToTitle(string text, string title)
|
|
{
|
|
DisConnect(delegate
|
|
{
|
|
DialogBase dialogBase = CreateDialogBase();
|
|
dialogBase.SetTitleLabel(title);
|
|
dialogBase.SetText(text);
|
|
dialogBase.SetButtonLayout(DialogBase.ButtonLayout.BackToTitleBtn);
|
|
dialogBase.SetFadeButtonEnabled(flag: false);
|
|
dialogBase.SetPanelDepth(5400);
|
|
});
|
|
}
|
|
|
|
protected void ErrorDialogWithRetry(string text, string title, bool isIpv6Dialog = false)
|
|
{
|
|
DisConnect(delegate
|
|
{
|
|
ErrorDialog(text, title, isIpv6Dialog);
|
|
});
|
|
}
|
|
|
|
protected virtual void ErrorDialog(string text, string title, bool isIPv6Dialog)
|
|
{
|
|
DialogBase dialogBase = CreateDialogBase();
|
|
if (isIPv6Dialog)
|
|
{
|
|
MatchingIPv6Toggle.AddMatchingIPv6Toggle(dialogBase);
|
|
}
|
|
dialogBase.SetSize(DialogBase.Size.M);
|
|
dialogBase.SetTitleLabel(title);
|
|
dialogBase.SetText(text);
|
|
dialogBase.SetButtonLayout(DialogBase.ButtonLayout.BlueBtn_GrayBtn);
|
|
dialogBase.SetButtonText(Wizard.Data.SystemText.Get("System_0012"), errorDialogReturnText);
|
|
dialogBase.SetFadeButtonEnabled(flag: false);
|
|
dialogBase.SetPanelDepth(5400);
|
|
dialogBase.ClickSe_Btn2 = Se.TYPE.SYS_BTN_CANCEL_TRANS;
|
|
EventDelegate method_btn = new EventDelegate(delegate
|
|
{
|
|
ToolboxGame.DestroyNetworkAgent();
|
|
Action action = delegate
|
|
{
|
|
UIManager.ChangeViewSceneParam param = new UIManager.ChangeViewSceneParam
|
|
{
|
|
OnChange = delegate
|
|
{
|
|
UIManager.GetInstance().CloseInSceneLoadingBattle();
|
|
}
|
|
};
|
|
UIManager.GetInstance().ChangeViewScene(UIManager.ViewScene.RankMatch, param);
|
|
};
|
|
if (_isStartBattleLoad)
|
|
{
|
|
UIManager.GetInstance().StartCoroutine(BattleEndCoroutin(action));
|
|
}
|
|
else
|
|
{
|
|
action();
|
|
}
|
|
});
|
|
EventDelegate eventDelegate = new EventDelegate(ReturnScene);
|
|
dialogBase.SetButtonDelegate(method_btn, eventDelegate, eventDelegate, eventDelegate);
|
|
}
|
|
|
|
protected IEnumerator BattleEndCoroutin(Action callback)
|
|
{
|
|
yield return null;
|
|
SBattleLoad battleLoad = BattleManagerBase.GetIns().SBattleLoad;
|
|
while (!battleLoad.isLoadEnd)
|
|
{
|
|
yield return null;
|
|
}
|
|
yield return GameMgr.GetIns().GetBattleCtrl().BattleEnd();
|
|
callback();
|
|
}
|
|
|
|
public Coroutine SafeStartBattleCoroutine(IEnumerator routine)
|
|
{
|
|
if (CoroutineMonoBehaviour == null)
|
|
{
|
|
return null;
|
|
}
|
|
return CoroutineMonoBehaviour.StartCoroutine(routine);
|
|
}
|
|
}
|