public void _OnComplated_DownloadAudioWWW(IDownloadedItem wItem, object obj)
{
if (!this)
{
return;
}
if (!base.enabled)
{
return;
}
if (wItem.canAccessAssetBundle && !wItem.isCanceled)
{
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio != null && this.audioSrc != null)
{
tsAudio._TempSet_playType = TsAudio._EPlayType.PLAY_ONE_SHOT;
tsAudio.RefAudioSource = this.audioSrc;
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
tsAudio.PlayOneShot();
}
else
{
Debug.LogWarning("TsAudio or AudioSource is null.");
}
}
}
public void OnEvent_Downloaded(IDownloadedItem wItem, object obj)
{
if (!wItem.canAccessAssetBundle)
{
return;
}
AudioClip x = wItem.mainAsset as AudioClip;
if (x == null)
{
TsLog.LogError("Error! It's not AudioClip. DownLoadPath= " + wItem.assetPath, new object[0]);
return;
}
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio == null)
{
TsLog.LogError("Error! Cannot Create TsAudio DownLoadPath= " + wItem.assetPath, new object[0]);
return;
}
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
TsLog.Log("OnEvent_Downloaded() Success Download~! ClipName= " + tsAudio.RefAudioClip.name, new object[0]);
this._downloadedAudioEx.Add(tsAudio);
wItem.unloadImmediate = true;
}
public static GameObject CreateGameObjectWithAudio(string goName, TsAudio.BaseData baseData, AudioClip clip, bool loop, bool isDontDestroyOnLoad)
{
if (string.IsNullOrEmpty(goName))
{
goName = "_Audio: " + clip.name;
}
TsAudio tsAudio = TsAudioCreator.Create(baseData);
if (tsAudio == null)
{
TsLog.LogError("CreateGameObjectWithAudio()~! Failed Create~! goName= " + goName, new object[0]);
return(null);
}
GameObject gameObject = new GameObject(goName, new Type[]
{
typeof(AudioSource)
});
tsAudio.RefAudioSource = gameObject.audio;
tsAudio.RefAudioClip = clip;
TsAudioAdapter tsAudioAdapter = TsAudioAdapter.TryToAddAdapter(gameObject, tsAudio);
tsAudioAdapter.GetAudioEx().baseData.Loop = loop;
tsAudioAdapter.GetAudioEx().baseData.IsDontDestroyOnLoad = isDontDestroyOnLoad;
return(gameObject);
}
public bool StartMiniDrama()
{
this.m_BGMAudio = null;
UIDataManager.MuteMiniDramaSound(true);
if (!UIDataManager.MuteBGM && NrTSingleton <NkQuestManager> .Instance.IsCompletedFirstQuest())
{
TsAudioAdapterBGM[] array = UnityEngine.Object.FindObjectsOfType(typeof(TsAudioAdapterBGM)) as TsAudioAdapterBGM[];
TsAudioAdapterBGM[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
TsAudioAdapterBGM tsAudioAdapterBGM = array2[i];
if (tsAudioAdapterBGM != null && tsAudioAdapterBGM.gameObject != null)
{
string text = tsAudioAdapterBGM.gameObject.name.ToLower();
if (text.Contains("bgm"))
{
this.m_BGMAudio = tsAudioAdapterBGM.GetAudioEx();
this.m_BGMAudio.Stop();
break;
}
}
}
}
foreach (MonoBehaviour current in this._EnableComponent)
{
current.enabled = false;
}
NrTSingleton <NkClientLogic> .Instance.SetNPCTalkState(true);
NrTSingleton <NkCharManager> .Instance.ShowHideAll(false, false, false);
Form form = NrTSingleton <FormsManager> .Instance.GetForm(G_ID.NPCTALK_DLG);
if (form != null)
{
this._bNpcTalk = form.Visible;
}
NrTSingleton <FormsManager> .Instance.HideAll();
UI_MiniDramaCaption uI_MiniDramaCaption = NrTSingleton <FormsManager> .Instance.GetForm(G_ID.MINIDRAMACAPTION_DLG) as UI_MiniDramaCaption;
if (uI_MiniDramaCaption != null)
{
if (!NrTSingleton <FormsManager> .Instance.IsShow(G_ID.MINIDRAMACAPTION_DLG))
{
uI_MiniDramaCaption.Show();
uI_MiniDramaCaption.ShowBG(false);
}
}
else
{
NrTSingleton <FormsManager> .Instance.LoadForm(G_ID.MINIDRAMACAPTION_DLG);
}
this._Camera.Standby();
this._ShowTime = true;
if (TsPlatform.IsMobile)
{
}
return(true);
}
public override void CloseForm(IUIObject obj)
{
this.lb_name.Visible = false;
this.DestroyLoadObject();
NrTSingleton <NkClientLogic> .Instance.SetCanOpenTicket(true);
ItemMallDlg itemMallDlg = NrTSingleton <FormsManager> .Instance.GetForm(G_ID.ITEMMALL_DLG) as ItemMallDlg;
if (itemMallDlg != null)
{
itemMallDlg.SetShowData();
}
if (null != BugFixAudio.PlayOnceRoot)
{
int childCount = BugFixAudio.PlayOnceRoot.transform.childCount;
for (int i = 0; i < childCount; i++)
{
Transform child = BugFixAudio.PlayOnceRoot.transform.GetChild(i);
if (child != null)
{
UnityEngine.Object.Destroy(child.gameObject);
}
}
}
TsAudio.RestoreMuteAllAudio();
TsAudio.RefreshAllMuteAudio();
base.CloseForm(obj);
}
private void SetActionReforge(WWWItem _item, object _param)
{
Main_UI_SystemMessage.CloseUI();
if (null != _item.GetSafeBundle() && null != _item.GetSafeBundle().mainAsset)
{
GameObject gameObject = _item.GetSafeBundle().mainAsset as GameObject;
if (null != gameObject)
{
this.rootGameObject = (UnityEngine.Object.Instantiate(gameObject) as GameObject);
Vector2 screenPos = new Vector2((float)(Screen.width / 2), (float)(Screen.height / 2));
Vector3 effectUIPos = base.GetEffectUIPos(screenPos);
effectUIPos.z = 300f;
this.rootGameObject.transform.position = effectUIPos;
NkUtil.SetAllChildLayer(this.rootGameObject, GUICamera.UILayer);
base.InteractivePanel.MakeChild(this.rootGameObject);
this.aniGameObject = this.rootGameObject.GetComponentInChildren <Animation>();
this.bLoadActionReforge = true;
if (TsPlatform.IsMobile && TsPlatform.IsEditor)
{
NrTSingleton <NkClientLogic> .Instance.SetEditorShaderConvert(ref this.rootGameObject);
}
TsAudio.StoreMuteAllAudio();
TsAudio.SetExceptMuteAllAudio(EAudioType.UI, true);
TsAudio.RefreshAllMuteAudio();
NkInputManager.IsInputMode = false;
}
}
}
public override void OnPrepareSceneChange()
{
UnityEngine.Debug.Log(string.Concat(new object[]
{
"!!!!! ScreenSize Width : ",
Screen.width,
", Height, : ",
Screen.height
}));
NrLoadPageScreen.DecideLoadingType(Scene.CurScene, this.SceneType());
NrLoadPageScreen.StepUpMain(1);
if (NrTSingleton <NrMainSystem> .Instance.m_ReLogin)
{
NrTSingleton <FormsManager> .Instance.LoadForm(G_ID.DLG_LOADINGPAGE);
}
NrLoadPageScreen.ShowHideLoadingImg(false);
UIDataManager.MuteBGM = TsAudio.IsMuteAudio(EAudioType.BGM);
UIDataManager.MuteEffect = TsAudio.IsMuteAudio(EAudioType.SFX);
if (null == NmMainFrameWork.loginCamera)
{
NmMainFrameWork.loginCamera = (Camera)UnityEngine.Object.Instantiate(Camera.main);
NmMainFrameWork.loginCamera.name = "loginCamera";
NmMainFrameWork.loginCamera.gameObject.SetActive(false);
Transform child = NmMainFrameWork.loginCamera.transform.GetChild(0);
if (null != child)
{
UnityEngine.Object.Destroy(child.gameObject);
}
UnityEngine.Object.DontDestroyOnLoad(NmMainFrameWork.loginCamera);
}
NrTSingleton <NkBattleReplayManager> .Instance.Init();
}
public void OnEventAudioClip(IDownloadedItem wItem, object obj)
{
if (wItem != null && !wItem.isCanceled)
{
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio != null)
{
if (wItem.mainAsset == null)
{
TsLog.LogWarning("wItem.mainAsset is null -> Path = {0}", new object[]
{
wItem.assetPath
});
}
else
{
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
wItem.unloadImmediate = true;
this.m_TalkSecond = tsAudio.RefAudioClip.length;
}
tsAudio.PlayClipAtPoint(Vector3.zero);
}
else
{
TsAudioManager.Container.RequestAudioClip("TRIGGER", "COMMON", "Trigger_SpeechBubble", new PostProcPerItem(NrAudioClipDownloaded.OnEventAudioClipDownloadedImmedatePlay));
}
}
this._StartTime = Time.time;
NrTSingleton <EventTriggerMiniDrama> .Instance.ShowTalk(this.m_ActorName, this.m_TalkKey, this.m_TalkSecond);
}
public static void OnEventAudioClipDownloadedImmedatePlay(IDownloadedItem wItem, object obj)
{
if (wItem.isCanceled)
{
return;
}
if (wItem.canAccessAssetBundle)
{
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio != null)
{
if (wItem.mainAsset == null)
{
TsLog.LogWarning("wItem.mainAsset is null -> Path = {0}", new object[]
{
wItem.assetPath
});
}
else
{
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
wItem.unloadImmediate = true;
}
tsAudio.PlayClipAtPoint(Vector3.zero);
}
}
}
public override void OnClose()
{
TsAudio.RestoreMuteAllAudio();
TsAudio.RefreshAllMuteAudio();
if (null != this.rootEffectGameObject)
{
UnityEngine.Object.Destroy(this.rootEffectGameObject);
}
if (this.bLegend)
{
Myth_Legend_Info_DLG myth_Legend_Info_DLG = NrTSingleton <FormsManager> .Instance.GetForm(G_ID.MYTH_LEGEND_INFO_DLG) as Myth_Legend_Info_DLG;
if (myth_Legend_Info_DLG != null)
{
myth_Legend_Info_DLG.InitSetCharKind(this.m_i32SelectCharKind);
}
}
else
{
SolDetail_Info_Dlg solDetail_Info_Dlg = NrTSingleton <FormsManager> .Instance.LoadForm(G_ID.SOLDETAIL_DLG) as SolDetail_Info_Dlg;
if (solDetail_Info_Dlg != null)
{
solDetail_Info_Dlg.SetElementGui();
}
}
Resources.UnloadUnusedAssets();
base.OnClose();
}
public override void OnPrepareSceneChange()
{
NrLoadPageScreen.DecideLoadingType(Scene.CurScene, this.SceneType());
NrLoadPageScreen.StepUpMain(1);
UIDataManager.MuteBGM = TsAudio.IsMuteAudio(EAudioType.BGM);
UIDataManager.MuteEffect = TsAudio.IsMuteAudio(EAudioType.SFX);
}
public void MythRaidBGMOn()
{
TsAudio.StoreMuteAllAudio();
TsAudio.SetExceptMuteAllAudio(EAudioType.UI, true);
TsAudio.RefreshAllMuteAudio();
TsAudioManager.Instance.AudioContainer.RequestAudioClip("BGM", "MYTH", "START", new PostProcPerItem(NrAudioClipDownloaded.OnEventAudioClipDownloadedImmedatePlay), string.Empty, true);
}
public TsAudio GetAudioEx()
{
TsAudio tsAudio = this._GetAudioEx();
tsAudio.CheckAndSetNeedRefs(this);
return(tsAudio);
}
public void OnDownloaded_Sound(IDownloadedItem wItem, object obj)
{
if (base.IsDestroy())
{
return;
}
if (wItem.mainAsset == null)
{
TsLog.LogWarning("wItem.mainAsset is null -> Path = {0}", new object[]
{
wItem.assetPath
});
}
else
{
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio != null)
{
this.m_audioGO = new GameObject("@Audio : RandomBox_Audio", new Type[]
{
typeof(AudioSource)
});
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
tsAudio.RefAudioSource = this.m_audioGO.audio;
tsAudio.Play();
wItem.unloadImmediate = true;
}
}
}
public static GameObject NewAutoDestroyAudioSource(TsAudio audioEx, Vector3 position)
{
if (audioEx.baseData.Tag == TsAudioManager.MINI_SOUND)
{
return(BugFixAudio.NewAudioSource(audioEx, TsAudioManager.Instance.CurrentAudioListener.transform, new Vector3(0f, 0f, 0f)));
}
return(BugFixAudio.NewAudioSource(audioEx, BugFixAudio.PlayAudioOnceRoot.transform, position));
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.MOVIE)
{
return(false);
}
this._audioEx = (TsAudioMovie)audioEx;
return(true);
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.ENVIRONMENT)
{
return(false);
}
this._audioEx = (TsAudioEnvironment)audioEx;
return(true);
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.BGM_STREAM)
{
return(false);
}
this._audioEx = (TsAudioBGMSTREAM)audioEx;
return(true);
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.GAME_DRAMA)
{
return(false);
}
this._audioEx = (TsAudioGameDrama)audioEx;
return(true);
}
private bool _Init()
{
TsAudio.LoadPlayerPrefs();
TsAudio.RefreshAllAudioVolumes();
TsAudio.RefreshAllMuteAudio();
this._defaultAudioListenerSwitcher = new TsAudioListenerSwitcher(base.gameObject);
if (Application.isPlaying)
{
this._currentAudioListenerSwitcher = null;
AudioListener audioListener = this.SearchAndEnable_CurrentAudioListener();
if (audioListener != null)
{
this._currentAudioListenerSwitcher = new TsAudioListenerSwitcher(audioListener.gameObject);
if (this._currentAudioListenerSwitcher == null)
{
TsLog.LogWarning("_currentAudioListenerSwitcher == null", new object[0]);
}
}
else if (Camera.main != null)
{
this._currentAudioListenerSwitcher = new TsAudioListenerSwitcher(Camera.main.gameObject);
if (this._currentAudioListenerSwitcher == null)
{
TsLog.LogWarning("_currentAudioListenerSwitcher == null", new object[0]);
}
}
if (this._currentAudioListenerSwitcher == null)
{
this._currentAudioListenerSwitcher = this._defaultAudioListenerSwitcher;
}
this._currentAudioListenerSwitcher.Switch();
if (this.CurrentAudioListener == null)
{
TsLog.LogError("Failed~! Set Current AudioListener~!", new object[0]);
}
}
else
{
this._defaultAudioListenerSwitcher.Switch();
}
if (Application.isEditor)
{
if (base.gameObject.GetComponent <TsAudioDebugger>() == null)
{
base.gameObject.AddComponent <TsAudioDebugger>();
}
if (base.gameObject.GetComponent <TsTestDownloadAtAudioContainer>() == null)
{
base.gameObject.AddComponent <TsTestDownloadAtAudioContainer>();
}
}
if (this._tempclip == null)
{
this._tempclip = AudioClip.Create("tempclip", 44100, 1, 44100, false, false);
}
return(true);
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.SYSTEM)
{
return(false);
}
this._audioEx = (TsAudioSystem)audioEx;
return(true);
}
public override bool _InitAudioEx(TsAudio audioEx)
{
if (audioEx == null || audioEx.baseData.AudioType != EAudioType.AMBIENT)
{
return(false);
}
this._audioEx = (TsAudioAmbient)audioEx;
return(true);
}
public void OnFinish()
{
TsAudio.RefreshAllAudioVolumes();
if (SystemInfo.processorCount == 1)
{
TsAudio.SetDisableDownloadAudio(EAudioType.AMBIENT, true);
TsAudio.SetDisableDownloadAudio(EAudioType.ENVIRONMENT, true);
}
FacadeHandler.EndNPATCHDownLoad(false);
}
public override void OnClose()
{
TsAudio.RestoreMuteAllAudio();
TsAudio.RefreshAllMuteAudio();
if (null != this.rootEffectGameObject)
{
UnityEngine.Object.Destroy(this.rootEffectGameObject);
}
base.OnClose();
}
public static void AddBGM()
{
if (TsAudio.IsMuteAudio(EAudioType.BGM))
{
return;
}
if (NmMainFrameWork.MobileStartBGM == null)
{
NmMainFrameWork.MobileStartBGM = (GameObject)UnityEngine.Object.Instantiate(Resources.Load(NrTSingleton <UIDataManager> .Instance.FilePath + "Prefabs/00-SOUND-BGM-CUSTOMOZING-LOGIN"));
NmMainFrameWork.MobileStartBGM.transform.parent = TsImmortal.gameObject.transform;
}
}
public override void Update()
{
if (this.bLoadActionReforge && null != this.rootGameObject && null != this.aniGameObject && !this.aniGameObject.isPlaying)
{
UnityEngine.Object.DestroyImmediate(this.rootGameObject);
this.bLoadActionReforge = false;
this.bRequest = false;
this.aniGameObject = null;
TsAudio.RestoreMuteAllAudio();
TsAudio.RefreshAllMuteAudio();
this.SendServer();
NkInputManager.IsInputMode = true;
}
}
private static GameObject NewAudioSource(TsAudio audioEx, Transform parent, Vector3 position)
{
GameObject gameObject = null;
try
{
if (audioEx.RefAudioClip == null)
{
Debug.LogWarning("BugFixAudio RefAudioClip is null.");
GameObject result = null;
return(result);
}
float t = audioEx.RefAudioClip.length + audioEx.baseData.DelayPlayTime;
if (audioEx.RefAudioSource == null || audioEx.baseData.AudioType == EAudioType.UI)
{
gameObject = new GameObject(audioEx.RefAudioClip.name, new Type[]
{
typeof(AudioSource)
});
}
else if (BugFixAudio.BugFixAS != null)
{
gameObject = (UnityEngine.Object.Instantiate(BugFixAudio.BugFixAS, position, Quaternion.identity) as GameObject);
}
if (gameObject == null)
{
Debug.LogError("New AduiSource failed!");
GameObject result = null;
return(result);
}
gameObject.transform.parent = parent;
if (audioEx.baseData.Tag == TsAudioManager.MINI_SOUND)
{
gameObject.transform.localPosition = new Vector3(0f, 0f, 0f);
}
gameObject.name = audioEx.RefAudioClip.name;
gameObject.audio.clip = audioEx.RefAudioClip;
gameObject.audio.loop = audioEx.baseData.Loop;
if (!audioEx.baseData.Loop)
{
UnityEngine.Object.Destroy(gameObject, t);
}
}
catch (Exception message)
{
Debug.LogError(message);
}
return(gameObject);
}
public void LoadMyth_Evolurion(NkSoldierInfo pkSolinfo, byte i8BaseGrade, byte i8ChangeGrade)
{
TsAudio.StoreMuteAllAudio();
TsAudio.SetExceptMuteAllAudio(EAudioType.UI, true);
TsAudio.RefreshAllMuteAudio();
this.m_pkSolinfo = pkSolinfo;
this.m_bBaseGrade = i8BaseGrade;
this.m_bChangeGrade = i8ChangeGrade;
string str = string.Format("{0}", "Effect/Instant/fx_ui_shinhwacard" + NrTSingleton <UIDataManager> .Instance.AddFilePath);
WWWItem wWWItem = Holder.TryGetOrCreateBundle(str + Option.extAsset, NkBundleCallBack.UIBundleStackName);
wWWItem.SetItemType(ItemType.USER_ASSETB);
wWWItem.SetCallback(new PostProcPerItem(this.EvolutionSuccess), null);
TsImmortal.bundleService.RequestDownloadCoroutine(wWWItem, DownGroup.RUNTIME, true);
}
public void OnEvent_Downloaded(IDownloadedItem wItem, object obj)
{
if (!wItem.canAccessAssetBundle)
{
return;
}
TsAudio.RequestData requestData = obj as TsAudio.RequestData;
TsAudio tsAudio = TsAudioCreator.Create(requestData.baseData);
if (tsAudio != null)
{
tsAudio.RefAudioSource = base.audio;
tsAudio.RefAudioClip = (wItem.mainAsset as AudioClip);
tsAudio.Play();
}
}
public override void Show()
{
UIDataManager.MuteSound(false);
TsAudio.StoreMuteAllAudio();
TsAudio.SetExceptMuteAllAudio(EAudioType.SFX, true);
TsAudio.RefreshAllMuteAudio();
if (this.cardOpen == SolRecruitSuccess_RenewalDlg.eCardOpen.ONE)
{
TsAudioManager.Instance.AudioContainer.RequestAudioClip("UI_SFX", "SOULCARD", "ONECARD", new PostProcPerItem(NrAudioClipDownloaded.OnEventAudioClipDownloadedImmedatePlay), string.Empty, false);
}
else
{
TsAudioManager.Instance.AudioContainer.RequestAudioClip("UI_SFX", "SOULCARD", "MANYCARD", new PostProcPerItem(NrAudioClipDownloaded.OnEventAudioClipDownloadedImmedatePlay), string.Empty, false);
}
base.Show();
}
