feat(battle-engine): M1 auto-copy closure (782 battle-logic files)

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.

SVSim.BattleEngine/Engine/Cute/AssetErrorState.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+
+namespace Cute;
+
+public class AssetErrorState
+{
+	public enum Code
+	{
+		NONE = 0,
+		SERVER_TIMEOUT = 1,
+		SERVER_UNDEFINED_ERROR = 2,
+		LOCAL_CAPACITY_OVER = 4,
+		CANCELED = 8,
+		FILE_READ_ERROR = 0x10,
+		SERVER_NOT_FOUND_ERROR = 0x20
+	}
+
+	public enum DialogDecision
+	{
+		UNDECIDED,
+		RETRY,
+		TERMINATE
+	}
+
+	private Dictionary<string, Code> errors = new Dictionary<string, Code>();
+
+	public DialogDecision lastDialogDecision;
+
+	public int errorFlag { get; private set; }
+
+	public bool canceled { get; private set; }
+
+	public bool HasError()
+	{
+		return errorFlag != 0;
+	}
+
+	public bool HasError(Code code)
+	{
+		return ((uint)errorFlag & (uint)code) != 0;
+	}
+
+	public void SetCanceled()
+	{
+		canceled = true;
+	}
+
+	public int ErrorCount()
+	{
+		return errors.Count;
+	}
+
+	public AssetErrorState()
+	{
+		Reset();
+	}
+
+	public void Report(string filename, Code errorCode)
+	{
+		if (errorCode != Code.NONE)
+		{
+			errorFlag |= (int)errorCode;
+			errors[filename] = errorCode;
+		}
+	}
+
+	public Code Query(string filename)
+	{
+		if (!errors.TryGetValue(filename, out var value))
+		{
+			return Code.NONE;
+		}
+		return value;
+	}
+
+	public void Reset()
+	{
+		errorFlag = 0;
+		lastDialogDecision = DialogDecision.UNDECIDED;
+		errors.Clear();
+		canceled = false;
+	}
+
+	public List<string> GatherErrorFilenames()
+	{
+		List<string> list = new List<string>();
+		foreach (KeyValuePair<string, Code> error in errors)
+		{
+			list.Add(error.Key);
+		}
+		return list;
+	}
+}

SVSim.BattleEngine/Engine/Cute/AssetRequestContext.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace Cute;
+
+public class AssetRequestContext
+{
+	public Action<AssetHandle> callback { get; set; }
+
+	public AssetErrorState errorState { get; set; }
+
+	public Utility.LeanSemaphore semaphore { get; set; }
+
+	public bool preferSynchronousLoad { get; set; }
+
+	public AssetRequestContext(Action<AssetHandle> callback = null, Utility.LeanSemaphore semaphore = null, AssetErrorState errorState = null, bool preferSynchronousLoad = false)
+	{
+		this.callback = callback;
+		this.semaphore = semaphore;
+		this.errorState = errorState;
+		this.preferSynchronousLoad = preferSynchronousLoad;
+	}
+}

SVSim.BattleEngine/Engine/Cute/Certification.cs

@@ -0,0 +1,375 @@
+using System;
+using System.Collections;
+using System.Text;
+using Steamworks;
+using UnityEngine;
+using Wizard;
+using Wizard.Title;
+
+namespace Cute;
+
+public class Certification : MonoBehaviour
+{
+	public static bool CheckUrlScheme;
+
+	private const int ERROR_CODE_ACCOUNT_REMOVED = 5607;
+
+	private static string udid;
+
+	private static int viewer_id;
+
+	private static int short_udid;
+
+	private static string sessionId;
+
+	private const float DELAY_TIME = 0.02f;
+
+	protected Callback<GetAuthSessionTicketResponse_t> m_GetAuthSessionTicketResponse;
+
+	public static string Udid
+	{
+		get
+		{
+			if (string.IsNullOrEmpty(udid))
+			{
+				udid = Cryptographer.decode(Toolbox.SavedataManager.GetString("UDID"));
+			}
+			return udid;
+		}
+	}
+
+	public static int ViewerId
+	{
+		get
+		{
+			if (viewer_id == 0)
+			{
+				viewer_id = Toolbox.SavedataManager.GetInt("VIEWER_ID");
+			}
+			return viewer_id;
+		}
+		set
+		{
+			Toolbox.SavedataManager.SetInt("VIEWER_ID", value);
+			Toolbox.SavedataManager.Save();
+			viewer_id = value;
+		}
+	}
+
+	public static int ShortUdid
+	{
+		get
+		{
+			if (short_udid == 0)
+			{
+				short_udid = Toolbox.SavedataManager.GetInt("SHORT_UDID");
+			}
+			return short_udid;
+		}
+		set
+		{
+			Toolbox.SavedataManager.SetInt("SHORT_UDID", value);
+			short_udid = value;
+		}
+	}
+
+	public static string SessionId
+	{
+		get
+		{
+			if (string.IsNullOrEmpty(sessionId))
+			{
+				sessionId = ViewerId + Udid;
+			}
+			return Cryptographer.MakeMd5(sessionId);
+		}
+		set
+		{
+			sessionId = value;
+		}
+	}
+
+	public static string dmmViewerId { get; private set; }
+
+	public static string dmmOnetimeToken { get; private set; }
+
+	public static ulong SteamID { get; private set; }
+
+	public static string SteamSessionTicket { get; private set; }
+
+	public static bool IsExistsViewerId()
+	{
+		if (ViewerId != 0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	public static string GetEncodedViewerId()
+	{
+		string s = CryptAES.encrypt(ViewerId.ToString());
+		return Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
+	}
+
+	public static string GetEncodedSessionId()
+	{
+		return Convert.ToBase64String(Encoding.UTF8.GetBytes(SessionId));
+	}
+
+	public static string GetEncodedShortUdid()
+	{
+		return Convert.ToBase64String(Encoding.UTF8.GetBytes(ShortUdid.ToString()));
+	}
+
+	public static string GetKeyChainViewerId()
+	{
+		return "";
+	}
+
+	public static string GetIDFA()
+	{
+		return "";
+	}
+
+	public static void SetKeyChainViewerId(string viewerId)
+	{
+	}
+
+	public static void DeleteKeyChainViewerId()
+	{
+	}
+
+	public static void InitializeFileds()
+	{
+		sessionId = null;
+		udid = null;
+		viewer_id = 0;
+		short_udid = 0;
+		Toolbox.SavedataManager.SetInt("VIEWER_ID", 0);
+		Toolbox.SavedataManager.SetInt("SHORT_UDID", 0);
+		Toolbox.SavedataManager.SetString("UDID", "");
+	}
+
+	public IEnumerator Login()
+	{
+		if (ViewerId == 0)
+		{
+			GenerateUdid();
+			SignUpTask signUpTask = new SignUpTask();
+			signUpTask.SetParameter();
+			yield return StartCoroutine(Toolbox.NetworkManager.Connect(signUpTask, delegate
+			{
+				StartCoroutine(GameStartCheckTaskExec());
+			}, delegate
+			{
+				if (Toolbox.BootNetwork != null)
+				{
+					Toolbox.BootNetwork.IsDoneGameStartCheck = false;
+				}
+				OutOfService.ShowServiceEndedDialogIfNeeded();
+			}, delegate
+			{
+				if (Toolbox.BootNetwork != null)
+				{
+					Toolbox.BootNetwork.IsDoneGameStartCheck = false;
+				}
+			}));
+		}
+		else
+		{
+			yield return StartCoroutine(GameStartCheckTaskExec());
+		}
+	}
+
+	public static bool IsiCloudAvailable()
+	{
+		return false;
+	}
+
+	public static void SetiCloudUser()
+	{
+	}
+
+	public static void EraseiCloudUser()
+	{
+	}
+
+	public static string GetiCloudUser()
+	{
+		return "";
+	}
+
+	public void CheckiCloudUserData(Action<NetworkTask.ResultCode> callback)
+	{
+		GetiCloudUserDataTask.VerifiediCloudUserData.Reset();
+		string text = GetiCloudUser();
+		if (string.IsNullOrEmpty(text))
+		{
+			callback(NetworkTask.ResultCode.Success);
+			return;
+		}
+		GenerateUdid();
+		GetiCloudUserDataTask getiCloudUserDataTask = new GetiCloudUserDataTask();
+		getiCloudUserDataTask.SetParameter(text);
+		StartCoroutine(Toolbox.NetworkManager.Connect(getiCloudUserDataTask, callback));
+	}
+
+	public void MigrateiCloudUserData(Action<NetworkTask.ResultCode> callback)
+	{
+		string parameter = GetiCloudUser();
+		UpdateiCloudUserDataTask updateiCloudUserDataTask = new UpdateiCloudUserDataTask();
+		updateiCloudUserDataTask.SetParameter(parameter);
+		StartCoroutine(Toolbox.NetworkManager.Connect(updateiCloudUserDataTask, callback));
+	}
+
+	public void FirstTimeSaveiCloudUserData()
+	{
+		if (IsiCloudAvailable() && string.IsNullOrEmpty(GetiCloudUser()))
+		{
+			SetiCloudUser();
+		}
+	}
+
+	public IEnumerator GameStartCheckTaskExec()
+	{
+		GameStartCheckTask gameStartCheckTask = new GameStartCheckTask();
+		gameStartCheckTask.AddSkipCuteCheckResultCode(5607);
+		gameStartCheckTask.SetParameter();
+		bool isRemoveAccount = false;
+		yield return StartCoroutine(Toolbox.NetworkManager.Connect(gameStartCheckTask, delegate
+		{
+			if (Toolbox.BootNetwork != null)
+			{
+				Toolbox.BootNetwork.IsDoneGameStartCheck = true;
+			}
+			URLScheme.ClearCampaignData();
+		}, delegate
+		{
+			if (Toolbox.BootNetwork != null)
+			{
+				Toolbox.BootNetwork.IsDoneGameStartCheck = false;
+			}
+			OutOfService.ShowServiceEndedDialogIfNeeded();
+		}, delegate(int resultCode)
+		{
+			if (Toolbox.BootNetwork != null)
+			{
+				Toolbox.BootNetwork.IsDoneGameStartCheck = false;
+			}
+			URLScheme.ClearCampaignData();
+			if (resultCode == 5607)
+			{
+				isRemoveAccount = true;
+				OnRemoveAccount();
+			}
+		}));
+		if (isRemoveAccount)
+		{
+			while (true)
+			{
+				yield return null;
+			}
+		}
+	}
+
+	private void OnRemoveAccount()
+	{
+		DialogBase dialogBase = UIManager.GetInstance().CreateConfirmationDialog(Data.SystemText.Get("MyPage_0097"));
+		dialogBase.SetTitleLabel(Data.SystemText.Get("ErrorHeader_0001"));
+		dialogBase.SetSize(DialogBase.Size.M);
+		dialogBase.OnClose = delegate
+		{
+			UserInfoRequest.DeleteUserData();
+		};
+	}
+
+	public void GenerateUdid()
+	{
+		udid = Cryptographer.decode(Toolbox.SavedataManager.GetString("UDID"));
+		if (string.IsNullOrEmpty(udid))
+		{
+			Toolbox.SavedataManager.SetString("UDID", Cryptographer.encode(Guid.NewGuid().ToString()));
+			Toolbox.SavedataManager.Save();
+		}
+	}
+
+	public static bool IsLogined()
+	{
+		return !string.IsNullOrEmpty(sessionId);
+	}
+
+	private IEnumerator Start()
+	{
+		while (Toolbox.BootSystem == null)
+		{
+			yield return 0;
+		}
+		SessionId = "";
+		setDmmPlatformData();
+		setSTEAMPlatformData();
+		URLSchemeStart();
+	}
+
+	private void OnApplicationFocus(bool focus)
+	{
+		if (focus)
+		{
+			URLSchemeStart();
+		}
+	}
+
+	private void URLSchemeStart()
+	{
+		if (CheckUrlScheme)
+		{
+			StartCoroutine(Delay(0.02f, delegate
+			{
+			}));
+		}
+	}
+
+	private IEnumerator Delay(float waitTime, Action action)
+	{
+		yield return new WaitForSeconds(waitTime);
+		action();
+	}
+
+	private void setSTEAMPlatformData()
+	{
+		try
+		{
+			SteamID = SteamUser.GetSteamID().m_SteamID;
+			m_GetAuthSessionTicketResponse = Callback<GetAuthSessionTicketResponse_t>.Create(OnGetAuthSessionTicketResponse);
+			byte[] array = new byte[1024];
+			SteamNetworkingIdentity pSteamNetworkingIdentity = default(SteamNetworkingIdentity);
+			SteamUser.GetAuthSessionTicket(array, array.Length, out var pcbTicket, ref pSteamNetworkingIdentity);
+			Array.Resize(ref array, (int)pcbTicket);
+			StringBuilder stringBuilder = new StringBuilder();
+			for (int i = 0; i < pcbTicket; i++)
+			{
+				stringBuilder.AppendFormat("{0:x2}", array[i]);
+			}
+			SteamSessionTicket = stringBuilder.ToString();
+		}
+		catch (Exception ex)
+		{
+			Debug.LogError("<color=aqua>steam client が起動していない。steamの機能を使えません。</color>");
+			Debug.LogError(ex.Message);
+			Debug.LogError(ex.StackTrace);
+		}
+	}
+
+	private void OnGetAuthSessionTicketResponse(GetAuthSessionTicketResponse_t pCallback)
+	{
+	}
+
+	private void setDmmPlatformData()
+	{
+	}
+
+	public void URLSchemeStartiOS(string message)
+	{
+		URLScheme.URLSchemeStartiOS(message);
+	}
+}

SVSim.BattleEngine/Engine/Cute/INetworkUI.cs

@@ -0,0 +1,54 @@
+namespace Cute;
+
+public interface INetworkUI
+{
+	string GetText(string code);
+
+	void StartLoading(bool notEditor = false);
+
+	void StopLoading();
+
+	void GoToMypage();
+
+	void SoftwareRest();
+
+	bool IsKeepLastRequest();
+
+	void SetKeepLastRequest(bool flag);
+
+	void OpenRetryAndToTitleErrorPopUp(string title, string message, string code);
+
+	void OpenGoToMypageErrorPopUp(string title, string message, string code);
+
+	void OpenGoToTitleErrorPopUp(string title, string message, string code);
+
+	void OpenGotoStoreErrorPopup();
+
+	void OpenRetryFailErrorPopup();
+
+	void OpenTimeOutErrorPopUp();
+
+	void OpenHttpStatusErrorPopUp();
+
+	void OpenResourceVersionUpPopUp();
+
+	void OpenSessionErrorPopUp();
+
+	bool isCloseDialogGroupError(int resultCode);
+
+	void OpenCloseOnlyErrorPopUp(int resultCode);
+
+	void OpenStrictServerErrorPopUp(int resultCode);
+
+	void OpenAccountBlockErrorPopUp(int resultCode);
+
+	void OpenAccountLimitedBlockErrorPopUp(int resultCode, string endTimeText);
+
+	void OpenAllMaintenancePopUp(int resultCode, string endTime);
+
+	void OpenEachFunctionMaintenancePopUp(int resultCode);
+
+	void OpenOtherServerErrorPopUp(int resultCode);
+
+	void OpenSocialServiceNoResponseErrorPopup();
+}

SVSim.BattleEngine/Engine/Cute/NetworkManager.cs

@@ -0,0 +1,406 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using LitJson;
+using MessagePack;
+using UnityEngine;
+using UnityEngine.Networking;
+using Wizard;
+using Wizard.Battle.Phase;
+using Wizard.Bingo;
+using Wizard.Scripts.Network.Data.TaskData.BuildDeckPurchase;
+using Wizard.Scripts.Network.Data.TaskData.ItemPurchase;
+using Wizard.Scripts.Network.Data.TaskData.SkinPurchase;
+using Wizard.Scripts.Network.Data.TaskData.SpotCardExchange;
+
+namespace Cute;
+
+public class NetworkManager : MonoBehaviour, IManager
+{
+	public const float TimeOut = 30f;
+
+	public const float TimeOutShort = 2f;
+
+	protected NetworkTask lastRequestTask;
+
+	public bool isConnect;
+
+	public bool isTimeOut;
+
+	public bool isError;
+
+	private bool isEncrypt = true;
+
+	private bool isUseJson;
+
+	private bool _showLoadingIcon = true;
+
+	private IEnumerator connectCoroutine;
+
+	[SerializeField]
+	public Certification _certification;
+
+	public INetworkUI NetworkUI { get; set; }
+
+	private void Start()
+	{
+		Toolbox.NetworkManager = this;
+	}
+
+	public bool IsReachability()
+	{
+		if (Application.internetReachability != NetworkReachability.NotReachable)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	public IEnumerator Connect(NetworkTask task, Action<NetworkTask.ResultCode> callbackOnSuccess = null, Action<NetworkTask.ResultCode> callbackOnFailure = null, Action<int> callbackOnResultCodeError = null, bool encrypt = true, bool useJson = false, bool showLoadingIcon = true, bool showErrorDialog = true)
+	{
+		while (isConnect)
+		{
+			yield return 0;
+		}
+		isEncrypt = encrypt;
+		isUseJson = useJson;
+		_showLoadingIcon = showLoadingIcon;
+		if (true)
+		{
+			if (IsBattle())
+			{
+				LocalLog.AccumulateLastTraceLog("taskStart " + task);
+			}
+			lastRequestTask = task;
+			lastRequestTask.Initialize();
+			lastRequestTask.CallbackOnSuccess = callbackOnSuccess;
+			lastRequestTask.CallbackOnFailure = callbackOnFailure;
+			lastRequestTask.CallbackOnResultCodeError = callbackOnResultCodeError;
+			lastRequestTask.PrepareHeaders();
+			lastRequestTask.PreparePostData(isEncrypt, isUseJson);
+			connectCoroutine = Connect(showErrorDialog);
+			yield return StartCoroutine(connectCoroutine);
+		}
+	}
+
+	private IEnumerator Connect(bool showErrorDialog)
+	{
+		while (isConnect)
+		{
+			yield return 0;
+		}
+		isConnect = true;
+		isTimeOut = false;
+		isError = false;
+		if (NetworkUI != null && _showLoadingIcon)
+		{
+			NetworkUI.StartLoading();
+		}
+		bool isLogTraceCheckUri = false;
+		if (lastRequestTask is DoMatchingBase || lastRequestTask is FinishTaskBase)
+		{
+			isLogTraceCheckUri = true;
+		}
+		string url = lastRequestTask.Url;
+		_ = lastRequestTask;
+		if (isLogTraceCheckUri)
+		{
+			LogTraceCheck("1");
+		}
+		using UnityWebRequest unityWebRequest = GetUnityWebRequestInstance(url);
+		yield return unityWebRequest.SendWebRequest();
+		if (isLogTraceCheckUri)
+		{
+			LogTraceCheck("2");
+		}
+		float endTime = Time.realtimeSinceStartup + 30f;
+		if (lastRequestTask.GetType().Equals(typeof(CheckSpecialTitleTask)))
+		{
+			endTime = Time.realtimeSinceStartup + 2f;
+		}
+		while (!unityWebRequest.isDone && Time.realtimeSinceStartup < endTime)
+		{
+			yield return 0;
+		}
+		if (isLogTraceCheckUri)
+		{
+			LogTraceCheck("3");
+		}
+		if (NetworkUI != null)
+		{
+			NetworkUI.StopLoading();
+		}
+		if (!unityWebRequest.isDone)
+		{
+			isTimeOut = true;
+			LocalLog.AccumulateTraceLog("Connect is TimeOut");
+			disposeUnityWebRequest(unityWebRequest);
+			if (!lastRequestTask.isSkipCommonTimeOutPopUp())
+			{
+				if (lastRequestTask.GetType().Equals(typeof(PackOpenTask)) || lastRequestTask.GetType().Equals(typeof(BuildDeckBuyTask)) || lastRequestTask.GetType().Equals(typeof(SleeveBuyTask)) || lastRequestTask.GetType().Equals(typeof(SkinBuyMultiRewardTask)) || lastRequestTask.GetType().Equals(typeof(SkinBuyMultiTask)) || lastRequestTask.GetType().Equals(typeof(SkinBuySingleTask)) || lastRequestTask.GetType().Equals(typeof(ItemPurchaseBuyTask)) || lastRequestTask.GetType().Equals(typeof(SpotCardExchangeTask)) || lastRequestTask.GetType().Equals(typeof(CardCreateTask)) || lastRequestTask.GetType().Equals(typeof(CardDestructTask)) || lastRequestTask.GetType().Equals(typeof(StoryFinishTask)) || lastRequestTask.GetType().Equals(typeof(PracticeFinishTask)) || lastRequestTask.GetType().Equals(typeof(BingoDrawTask)) || lastRequestTask.GetType().Equals(typeof(MypageTreasureBoxCpOpenTask)) || lastRequestTask.GetType().Equals(typeof(MypageReceiveSpecialTreasureTask)) || lastRequestTask.GetType().Equals(typeof(FreeCardPackCampaignFinishTask)))
+				{
+					NetworkUI.OpenGoToTitleErrorPopUp(Data.SystemText.Get("ErrorHeader_0012"), Data.SystemText.Get("Error_0012"), "");
+				}
+				else
+				{
+					NetworkUI.OpenTimeOutErrorPopUp();
+				}
+			}
+			if (lastRequestTask.CallbackOnFailure != null)
+			{
+				if (lastRequestTask.GetType().Equals(typeof(PaymentPCFinishTask)))
+				{
+					NetworkUI.OpenGoToTitleErrorPopUp(Data.SystemText.Get("ErrorHeader_0012"), Data.SystemText.Get("Error_0012"), "");
+				}
+				else
+				{
+					lastRequestTask.CallbackOnFailure(NetworkTask.ResultCode.TimeOut);
+				}
+			}
+			Toolbox.DeviceManager.ClearIpAddress();
+		}
+		else if (!string.IsNullOrEmpty(unityWebRequest.error))
+		{
+			LocalLog.AccumulateTraceLog("Connect is Error!" + unityWebRequest.error + " responseCode:" + unityWebRequest.responseCode);
+			isError = true;
+			if (showErrorDialog && !lastRequestTask.isSkipCommonHttpStatusErrorPopUp())
+			{
+				if (lastRequestTask.GetType().Equals(typeof(PackOpenTask)) || lastRequestTask.GetType().Equals(typeof(PaymentPCFinishTask)))
+				{
+					NetworkUI.OpenGoToTitleErrorPopUp(Data.SystemText.Get("ErrorHeader_0012"), Data.SystemText.Get("Error_0012"), "");
+				}
+				else
+				{
+					NetworkUI.OpenHttpStatusErrorPopUp();
+				}
+			}
+			disposeUnityWebRequest(unityWebRequest);
+			if (lastRequestTask.CallbackOnFailure != null)
+			{
+				lastRequestTask.CallbackOnFailure(NetworkTask.ResultCode.Error);
+			}
+			Toolbox.DeviceManager.ClearIpAddress();
+		}
+		else if (unityWebRequest.isDone)
+		{
+			if (lastRequestTask.CallbackOnUnityWebRequestDone != null)
+			{
+				lastRequestTask.CallbackOnUnityWebRequestDone(unityWebRequest);
+			}
+			else if (unityWebRequest.downloadHandler.text != null && unityWebRequest.downloadHandler.text != "")
+			{
+				try
+				{
+					byte[] bytes = ((!isEncrypt) ? Convert.FromBase64String(unityWebRequest.downloadHandler.text) : CryptAES.decrypt(unityWebRequest.downloadHandler.text));
+					string json = (isUseJson ? MessagePackSerializer.ToJson(bytes) : MessagePackSerializer.ToJson(bytes));
+					lastRequestTask.SetResponseData(JsonMapper.ToObject(json));
+				}
+				catch (Exception ex)
+				{
+					string text = unityWebRequest.downloadHandler.text;
+					disposeUnityWebRequest(unityWebRequest);
+					if (!lastRequestTask.GetType().Equals(typeof(CheckSpecialTitleTask)))
+					{
+						if (!isEncrypt)
+						{
+							LocalLog.AccumulateTraceLog(ex.ToString());
+							throw ex;
+						}
+						Debug.LogError(text);
+						Debug.LogError(ex.Message);
+						Debug.LogError(ex.StackTrace);
+						if (text.Contains("php"))
+						{
+							if (text.Length > 1800)
+							{
+								throw new Exception(text.Substring(1, 1800));
+							}
+							throw new Exception(text);
+						}
+						HandleDeserializeException(ex);
+					}
+				}
+				try
+				{
+					if (lastRequestTask != null)
+					{
+						if (lastRequestTask.GetType().Equals(typeof(CheckSpecialTitleTask)))
+						{
+							((CheckSpecialTitleTask)lastRequestTask).ParseTitleCheckData();
+						}
+						else
+						{
+							NetworkTask.ERROR_CODE_STATUS num = lastRequestTask.CheckResultCodeToPopupCreate_ReturnStatus();
+							if (num == NetworkTask.ERROR_CODE_STATUS.ERROR)
+							{
+								isError = true;
+							}
+							if (num == NetworkTask.ERROR_CODE_STATUS.ERROR_TO_MAINTENANCE_POPUP && lastRequestTask.CallbackOnFailure != null)
+							{
+								lastRequestTask.CallbackOnFailure(NetworkTask.ResultCode.Maintenance);
+							}
+							if (num == NetworkTask.ERROR_CODE_STATUS.ERROR && lastRequestTask.CallbackOnFailure != null)
+							{
+								lastRequestTask.CallbackOnFailure(NetworkTask.ResultCode.Title);
+							}
+						}
+					}
+				}
+				catch (Exception ex2)
+				{
+					disposeUnityWebRequest(unityWebRequest);
+					if (!lastRequestTask.GetType().Equals(typeof(CheckSpecialTitleTask)))
+					{
+						LocalLog.AccumulateTraceLog("NetworkManager Connect Error 2：" + ex2);
+						throw ex2;
+					}
+				}
+			}
+			else
+			{
+				LocalLog.AccumulateTraceLog("NetworkManager Connect Error 3");
+			}
+		}
+		ClearLastRequestTask();
+		disposeUnityWebRequest(unityWebRequest);
+		isConnect = false;
+	}
+
+	private void LogTraceCheck(string logMsg)
+	{
+		LocalLog.AccumulateLastTraceLog("NetworkTrace msg " + logMsg);
+		LocalLog.SubmitAccumulateLastTraceLog();
+	}
+
+	private bool IsBattle()
+	{
+		if (ToolboxGame.RealTimeNetworkAgent != null && BattleManagerBase.GetIns() != null && BattleManagerBase.GetIns().GetCurrentPhase() is MainPhase)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	private UnityWebRequest GetUnityWebRequestInstance(string serverUrl)
+	{
+		try
+		{
+			UnityWebRequest unityWebRequest = new UnityWebRequest(serverUrl, "POST");
+			unityWebRequest.uploadHandler = new UploadHandlerRaw(lastRequestTask.Body);
+			unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
+			foreach (KeyValuePair<string, string> item in lastRequestTask.Header)
+			{
+				unityWebRequest.SetRequestHeader(item.Key, item.Value);
+			}
+			return unityWebRequest;
+		}
+		catch (Exception ex)
+		{
+			string text = "";
+			foreach (KeyValuePair<string, string> item2 in lastRequestTask.Header)
+			{
+				text += string.Format("header==={0} : {1}" + Environment.NewLine, item2.Key, item2.Value);
+			}
+			Debug.LogError(ex?.ToString() + "：" + text);
+			return null;
+		}
+	}
+
+	private void HandleDeserializeException(Exception e)
+	{
+		SoftwareReset.exec();
+		throw new Exception("復号化に失敗しました。" + e);
+	}
+
+	public void ClearLastRequestTask()
+	{
+		if ((NetworkUI != null && !NetworkUI.IsKeepLastRequest()) || lastRequestTask.isServerResultCodeOK())
+		{
+			if (IsBattle())
+			{
+				LocalLog.AccumulateLastTraceLog("ClearLastRequestTask " + lastRequestTask);
+			}
+			lastRequestTask = null;
+		}
+	}
+
+	public IEnumerator Retry()
+	{
+		if (lastRequestTask == null)
+		{
+			NetworkUI.OpenRetryFailErrorPopup();
+			yield break;
+		}
+		if (connectCoroutine != null)
+		{
+			StopConnectCoroutine();
+		}
+		connectCoroutine = Connect(showErrorDialog: true);
+		yield return StartCoroutine(connectCoroutine);
+	}
+
+	public void Certification()
+	{
+		_certification.GenerateUdid();
+	}
+
+	public void ReturnToTitle()
+	{
+		NetworkUI.SetKeepLastRequest(flag: false);
+		ClearLastRequestTask();
+		NetworkUI.SoftwareRest();
+	}
+
+	public void GoToMypage()
+	{
+		NetworkUI.SetKeepLastRequest(flag: false);
+		ClearLastRequestTask();
+		NetworkUI.GoToMypage();
+	}
+
+	public void GoToStore()
+	{
+		lastRequestTask.GotoStore();
+		NetworkUI.SetKeepLastRequest(flag: false);
+		ClearLastRequestTask();
+		NetworkUI.SoftwareRest();
+	}
+
+	public void QuitApplication()
+	{
+		NetworkUI.SetKeepLastRequest(flag: false);
+		ClearLastRequestTask();
+		if (Toolbox.mute != null)
+		{
+			Toolbox.mute.Close();
+			Toolbox.mute = null;
+		}
+		Application.Quit();
+	}
+
+	private void disposeUnityWebRequest(UnityWebRequest unityWebRequest)
+	{
+		unityWebRequest.Dispose();
+	}
+
+	public void StopConnectCoroutine()
+	{
+		if (connectCoroutine != null)
+		{
+			if (RealTimeNetworkAgent.IsNormalNetworkBattle())
+			{
+				LocalLog.AccumulateLastTraceLog("NetworkManager_StopConnectCoroutine " + StackTraceUtility.ExtractStackTrace());
+			}
+			StopCoroutine(connectCoroutine);
+			isConnect = false;
+		}
+	}
+
+	private void OnDestroy()
+	{
+		if (RealTimeNetworkAgent.IsNormalNetworkBattle())
+		{
+			LocalLog.AccumulateLastTraceLog("NetworkManager_Destroy");
+		}
+	}
+}

SVSim.BattleEngine/Engine/Cute/NetworkTask.cs

@@ -0,0 +1,570 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using LitJson;
+using MessagePack;
+using UnityEngine.Networking;
+using Wizard;
+using Wizard.Battle.Recovery;
+
+namespace Cute;
+
+public class NetworkTask
+{
+	public enum ResultCode
+	{
+		Success,
+		Error,
+		TimeOut,
+		Title,
+		Maintenance
+	}
+
+	public enum ERROR_CODE_STATUS
+	{
+		NONE,
+		ERROR,
+		ERROR_TO_MAINTENANCE_POPUP
+	}
+
+	protected Dictionary<string, string> header = new Dictionary<string, string>();
+
+	protected byte[] body;
+
+	protected int resultCode;
+
+	private SkipCuteCheckResultCodes skipCuteCheckResultCodes;
+
+	private bool skipCommonTimeOutPopUp;
+
+	private bool skipCommonHttpStatusErrorPopUp;
+
+	public virtual string Url { get; set; }
+
+	public Action<ResultCode> CallbackOnSuccess { get; set; }
+
+	public Action<ResultCode> CallbackOnFailure { get; set; }
+
+	public Action<int> CallbackOnResultCodeError { get; set; }
+
+	public Action<UnityWebRequest> CallbackOnUnityWebRequestDone { get; set; }
+
+	public Dictionary<string, string> Header => header;
+
+	public byte[] Body => body;
+
+	public PostParams Params { get; set; }
+
+	public JsonData ResponseData { get; private set; }
+
+	public bool IsResourceVersionUpError { get; private set; }
+
+	public bool IsResultSuccess => resultCode == 1;
+
+	public NetworkTask()
+	{
+		skipCuteCheckResultCodes = new SkipCuteCheckResultCodes();
+		Params = new PostParams();
+	}
+
+	public void Initialize()
+	{
+		ResponseData = null;
+		resultCode = 0;
+	}
+
+	public Dictionary<string, string> PrepareHeaders()
+	{
+		AddHeaderUdid();
+		AddHeaderShortUdid();
+		AddHeaderSessionId();
+		AddHeaderParam();
+		AddHeaderDevice();
+		AddHeaderAppVersion();
+		AddHeaderResVersion();
+		AddHeaderDeviceId();
+		AddHeaderDeviceName();
+		AddHeaderGraphicsDeviceName();
+		AddHeaderIpAddress();
+		AddHeaderPlatformOsVersion();
+		AddHeaderKeyChain();
+		AddHeaderIDFA();
+		AddHeaderLocale();
+		AddHeaderLanguage();
+		AddHeaderCountryCode();
+		AddHeaderPlatform();
+		AddHeaderIsWSS();
+		AddHeaderIsIpv6();
+		AddHeaderDevAccessSecretKey();
+		AddCardMasterHash();
+		return header;
+	}
+
+	public byte[] PreparePostData(bool encrypt = true, bool isUseJson = false)
+	{
+		return CreateBody(encrypt, isUseJson);
+	}
+
+	public void SetResponseData(JsonData data)
+	{
+		ResponseData = data;
+		resultCode = getDataHeader()["result_code"].ToInt();
+	}
+
+	public int GetResultCode()
+	{
+		return resultCode;
+	}
+
+	public ERROR_CODE_STATUS CheckResultCodeToPopupCreate_ReturnStatus(int rc = 0)
+	{
+		INetworkUI networkUI = Toolbox.NetworkManager.NetworkUI;
+		if (isAppVersionUP())
+		{
+			RecoveryRecordManagerBase.DeleteRecoveryFile();
+			networkUI.OpenGotoStoreErrorPopup();
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		if (isResourceVersionUp())
+		{
+			IsResourceVersionUpError = true;
+			setResourceVersion();
+			if (!Url.Contains(CuteNetworkDefine.ApiUrlList[CuteNetworkDefine.ApiType.GameStartCheck]))
+			{
+				RecoveryRecordManagerBase.DeleteRecoveryFile();
+				networkUI.OpenResourceVersionUpPopUp();
+				Parse();
+				return ERROR_CODE_STATUS.ERROR;
+			}
+		}
+		if (isSessionError())
+		{
+			networkUI.OpenSessionErrorPopUp();
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		setSession();
+		if (isUnknownServerError() || isServerProcessedError() || isServerDataBaseError())
+		{
+			networkUI.OpenStrictServerErrorPopUp(resultCode);
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		if (isAccountBlockError())
+		{
+			networkUI.OpenAccountBlockErrorPopUp(resultCode);
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		if (isNeteaseAccountBlockError())
+		{
+			NtDataTranslateManager.GetInstance().ShowRejectLogin();
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		if (isAccountLimitedBlockError())
+		{
+			string accountLimitedBlockEndTime = getAccountLimitedBlockEndTime();
+			networkUI.OpenAccountLimitedBlockErrorPopUp(resultCode, accountLimitedBlockEndTime);
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		if (IsAllMaintenanceError())
+		{
+			string maintenanceEndTime = getMaintenanceEndTime();
+			networkUI.OpenAllMaintenancePopUp(resultCode, maintenanceEndTime);
+			return ERROR_CODE_STATUS.ERROR_TO_MAINTENANCE_POPUP;
+		}
+		if (IsEachFunctionMaintenanceError())
+		{
+			networkUI.OpenEachFunctionMaintenancePopUp(resultCode);
+			return ERROR_CODE_STATUS.ERROR_TO_MAINTENANCE_POPUP;
+		}
+		if (IsCardMaintenanceError())
+		{
+			if (CallbackOnResultCodeError != null)
+			{
+				CallbackOnResultCodeError(resultCode);
+			}
+			return ERROR_CODE_STATUS.ERROR_TO_MAINTENANCE_POPUP;
+		}
+		if (!skipCuteCheckResultCodes.isSkipAll() && !skipCuteCheckResultCodes.Contains(resultCode))
+		{
+			cuteCheckResultCode();
+		}
+		Parse();
+		if (isServerResultCodeOK())
+		{
+			if (CallbackOnSuccess != null)
+			{
+				CallbackOnSuccess(ResultCode.Success);
+			}
+			return ERROR_CODE_STATUS.NONE;
+		}
+		if (CallbackOnResultCodeError != null)
+		{
+			CallbackOnResultCodeError(resultCode);
+			return ERROR_CODE_STATUS.ERROR;
+		}
+		return ERROR_CODE_STATUS.NONE;
+	}
+
+	private void cuteCheckResultCode()
+	{
+		INetworkUI networkUI = Toolbox.NetworkManager.NetworkUI;
+		if (networkUI.isCloseDialogGroupError(resultCode))
+		{
+			networkUI.OpenCloseOnlyErrorPopUp(resultCode);
+		}
+		else if (!isServerResultCodeOK())
+		{
+			networkUI.OpenOtherServerErrorPopUp(resultCode);
+		}
+	}
+
+	protected virtual string getAccountLimitedBlockEndTime()
+	{
+		return ResponseData["data"]["account_block_end_time"].ToString();
+	}
+
+	protected virtual string getMaintenanceEndTime()
+	{
+		if (ResponseData["data"].Count > 0 && ResponseData["data"].Keys.Contains("maintenance_end_time") && ResponseData["data"]["maintenance_end_time"].ToString().Length > 0)
+		{
+			return ResponseData["data"]["maintenance_end_time"].ToString();
+		}
+		return "";
+	}
+
+	protected virtual string getUdid()
+	{
+		return Certification.Udid;
+	}
+
+	protected virtual byte[] CreateBody(bool encrypt = true, bool isUseJson = false)
+	{
+		if (isUseJson)
+		{
+			body = _createBodyJson(Params, encrypt);
+		}
+		else
+		{
+			body = _createBodyMsgpack(Params, encrypt);
+		}
+		return body;
+	}
+
+	protected byte[] _createBodyJson(PostParams Params, bool encrypt = true)
+	{
+		byte[] bytes = Encoding.ASCII.GetBytes(JsonMapper.ToJson(Params));
+		if (!encrypt)
+		{
+			return bytes;
+		}
+		return CryptAES.encrypt(bytes);
+	}
+
+	protected byte[] _createBodyMsgpack(PostParams Params, bool encrypt = true)
+	{
+		byte[] array = MessagePackSerializer.FromJson(JsonMapper.ToJson(Params));
+		if (!encrypt)
+		{
+			return array;
+		}
+		return CryptAES.encrypt(array);
+	}
+
+	protected virtual int Parse()
+	{
+		return resultCode;
+	}
+
+	private void AddHeaderUdid()
+	{
+		if (Url.Contains(CuteNetworkDefine.ApiUrlList[CuteNetworkDefine.ApiType.SignUp]) || Url.Contains(CuteNetworkDefine.ApiUrlList[CuteNetworkDefine.ApiType.CheckSpecialTitle]) || Url.Contains(CuteNetworkDefine.ApiUrlList[CuteNetworkDefine.ApiType.CheckiCloudUser]) || Url.Contains(CuteNetworkDefine.ApiUrlList[CuteNetworkDefine.ApiType.MigrateiCloudUser]))
+		{
+			string value = Cryptographer.encode(getUdid());
+			header["UDID"] = value;
+		}
+	}
+
+	private void AddHeaderShortUdid()
+	{
+		string value = Cryptographer.encode(Certification.ShortUdid.ToString());
+		header["SHORT_UDID"] = value;
+	}
+
+	private void AddHeaderSessionId()
+	{
+		header["SID"] = Certification.SessionId;
+	}
+
+	private void AddHeaderParam()
+	{
+		string udid = getUdid();
+		string viewer_id = CryptAES.encrypt(Certification.ViewerId.ToString());
+		Params.viewer_id = viewer_id;
+		Params.steam_id = Certification.SteamID;
+		Params.steam_session_ticket = Certification.SteamSessionTicket;
+		string text = Convert.ToBase64String(MessagePackSerializer.FromJson(JsonMapper.ToJson(Params)));
+		Uri uri = new Uri(Url.Trim());
+		string text2 = udid + uri.AbsolutePath + text;
+		if (Certification.ViewerId != 0)
+		{
+			text2 += Certification.ViewerId;
+		}
+		string value = Cryptographer.ComputeHash(text2);
+		header["PARAM"] = value;
+	}
+
+	private void AddHeaderDevice()
+	{
+		header["DEVICE"] = Toolbox.DeviceManager.GetDeviceType().ToString();
+	}
+
+	private void AddHeaderAppVersion()
+	{
+		header["APP_VER"] = Toolbox.DeviceManager.GetAppVersionName();
+	}
+
+	private void AddHeaderResVersion()
+	{
+		header["RES_VER"] = Toolbox.SavedataManager.GetResourceVersion();
+	}
+
+	private void AddHeaderDeviceId()
+	{
+		header["DEVICE_ID"] = Toolbox.DeviceManager.GetDeviceUniqueIdentifier();
+	}
+
+	private void AddHeaderDeviceName()
+	{
+		header["DEVICE_NAME"] = Uri.EscapeDataString(Toolbox.DeviceManager.GetDeviceName());
+	}
+
+	private void AddHeaderGraphicsDeviceName()
+	{
+		header["GRAPHICS_DEVICE_NAME"] = Uri.EscapeDataString(Toolbox.DeviceManager.GetGraphicsDeviceName(textureCheck: true));
+	}
+
+	private void AddHeaderIpAddress()
+	{
+		header["IP_ADDRESS"] = Toolbox.DeviceManager.GetIpAddress();
+	}
+
+	private void AddHeaderPlatformOsVersion()
+	{
+		header["PLATFORM_OS_VERSION"] = Uri.EscapeDataString(Toolbox.DeviceManager.GetOsVersion());
+	}
+
+	private void AddHeaderPlatform()
+	{
+		header["PLATFORM"] = CustomPreference.GetPlatform().ToString();
+	}
+
+	private void AddHeaderIsWSS()
+	{
+		header["WSS"] = (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.IS_SELECT_WSS) ? "1" : "0");
+	}
+
+	private void AddHeaderIsIpv6()
+	{
+		header["IPV6_CONNECTION"] = (PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.IS_SELECT_IPV6) ? "1" : "0");
+	}
+
+	private void AddCardMasterHash()
+	{
+		string cardMasterHash = CardMasterLocalFileUtility.GetCardMasterHash();
+		if (!string.IsNullOrEmpty(cardMasterHash))
+		{
+			header["CARD_MASTER_HASH"] = cardMasterHash;
+		}
+	}
+
+	private void AddHeaderDevAccessSecretKey()
+	{
+	}
+
+	private void AddHeaderCarrier()
+	{
+		header["CARRIER"] = Toolbox.DeviceManager.GetCarrier();
+	}
+
+	private void AddHeaderKeyChain()
+	{
+		header["KEYCHAIN"] = Certification.GetKeyChainViewerId();
+	}
+
+	private void AddHeaderIDFA()
+	{
+		header["IDFA"] = Certification.GetIDFA();
+	}
+
+	private void AddHeaderLocale()
+	{
+		header["LOCALE"] = Toolbox.DeviceManager.GetLocale();
+	}
+
+	private void AddHeaderLanguage()
+	{
+		string textLanguage = CustomPreference.GetTextLanguage();
+		header["LANGUAGE"] = textLanguage;
+	}
+
+	private void AddHeaderCountryCode()
+	{
+		header["REGION_CODE"] = PlayerStaticData.UserRegionCode;
+	}
+
+	private bool isSessionError()
+	{
+		return resultCode == 201;
+	}
+
+	private bool isUnknownServerError()
+	{
+		return resultCode == 102;
+	}
+
+	private bool isAccountBlockError()
+	{
+		return resultCode == 203;
+	}
+
+	private bool isNeteaseAccountBlockError()
+	{
+		return resultCode == 330;
+	}
+
+	private bool isAccountLimitedBlockError()
+	{
+		return resultCode == 217;
+	}
+
+	private bool isServerProcessedError()
+	{
+		return resultCode == 213;
+	}
+
+	private bool isServerDataBaseError()
+	{
+		return resultCode == 100;
+	}
+
+	public bool isServerResultCodeOK()
+	{
+		if (resultCode != 1 && resultCode != 3502)
+		{
+			return resultCode == 1768;
+		}
+		return true;
+	}
+
+	private bool IsAllMaintenanceError()
+	{
+		return resultCode == 101;
+	}
+
+	private bool IsEachFunctionMaintenanceError()
+	{
+		if (resultCode >= 2000)
+		{
+			return resultCode <= 2999;
+		}
+		return false;
+	}
+
+	private bool IsCardMaintenanceError()
+	{
+		if (resultCode != 1710)
+		{
+			return resultCode == 5013;
+		}
+		return true;
+	}
+
+	private void setSession()
+	{
+		JsonData dataHeader = getDataHeader();
+		if (dataHeader.Keys.Contains("sid") && dataHeader["sid"] != null && !string.IsNullOrEmpty(dataHeader["sid"].ToString()))
+		{
+			Certification.SessionId = dataHeader["sid"].ToString();
+		}
+	}
+
+	private bool isAppVersionUP()
+	{
+		if (resultCode == 204)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	public void GotoStore()
+	{
+		BrowserURL.Open(getDataHeader()["store_url"].ToString());
+	}
+
+	private bool isResourceVersionUp()
+	{
+		if (getDataHeader().Keys.Contains("required_res_ver"))
+		{
+			return true;
+		}
+		return false;
+	}
+
+	private JsonData getDataHeader()
+	{
+		return ResponseData["data_headers"];
+	}
+
+	private void setResourceVersion()
+	{
+		string resourceVersion = getDataHeader()["required_res_ver"].ToString();
+		Toolbox.SavedataManager.SetResourceVersion(resourceVersion);
+	}
+
+	public void AddSkipCuteCheckResultCode(int resultCode)
+	{
+		skipCuteCheckResultCodes.Add(resultCode);
+	}
+
+	public void AddSkipCuteCheckResultCode(List<int> resultCodes)
+	{
+		skipCuteCheckResultCodes.Add(resultCodes);
+	}
+
+	public void SkipAllCuteResultCodeCheckErrorPopup()
+	{
+		skipCuteCheckResultCodes.setSkipAll(pSkipAll: true);
+	}
+
+	public void SkipCuteTimeOutPopup()
+	{
+		skipCommonTimeOutPopUp = true;
+	}
+
+	public bool isSkipCommonTimeOutPopUp()
+	{
+		return skipCommonTimeOutPopUp;
+	}
+
+	public void SkipCuteHttpStatusErrorPopup()
+	{
+		skipCommonHttpStatusErrorPopUp = true;
+	}
+
+	public bool isSkipCommonHttpStatusErrorPopUp()
+	{
+		return skipCommonHttpStatusErrorPopUp;
+	}
+
+	public void ClearSkipCuteCheckResultCode()
+	{
+		skipCuteCheckResultCodes.Clear();
+	}
+
+	public void SkipAllNetworkChecks()
+	{
+		SkipAllCuteResultCodeCheckErrorPopup();
+		SkipCuteTimeOutPopup();
+		SkipCuteHttpStatusErrorPopup();
+	}
+}

SVSim.BattleEngine/Engine/Cute/PostParams.cs

@@ -0,0 +1,10 @@
+namespace Cute;
+
+public class PostParams
+{
+	public string viewer_id = "";
+
+	public ulong steam_id;
+
+	public string steam_session_ticket;
+}

SVSim.BattleEngine/Engine/Cute/SkipCuteCheckResultCodes.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+
+namespace Cute;
+
+internal class SkipCuteCheckResultCodes
+{
+	private List<int> resultCodes = new List<int>();
+
+	private bool skipAll;
+
+	public void setSkipAll(bool pSkipAll)
+	{
+		skipAll = pSkipAll;
+	}
+
+	public bool isSkipAll()
+	{
+		return skipAll;
+	}
+
+	public void Add(int resultCode)
+	{
+		resultCodes.Add(resultCode);
+	}
+
+	public void Add(List<int> pResultCodes)
+	{
+		resultCodes.AddRange(pResultCodes);
+	}
+
+	public bool Contains(int resultCode)
+	{
+		return resultCodes.Contains(resultCode);
+	}
+
+	public void Clear()
+	{
+		resultCodes.Clear();
+	}
+}