Unity客户端架构-Util

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System;
using System.IO;
using LitJson;
using clientTBL;
using ProtoTblConfig;

public class Util : MonoBehaviour {

public static T Add<T>(GameObject go) where T : Component
{
if (go != null)
{
T[] components = go.GetComponents<T>();
for (int i = 0; i < components.Length; i++ )
{
if (components[i] != null)
{
UnityEngine.Object.Destroy(components[i]);
}
}
return go.gameObject.AddComponent<T>();
}

return (T)((object)null);
}

public static T Add<T>(Transform go) where T : Component
{
return Util.Add<T>(go.gameObject);
}

public static Uri AppContentDataUri
{
get
{
string dataPath = Application.dataPath;
if (Application.platform == RuntimePlatform.IPhonePlayer)
{
return new UriBuilder
{
Scheme = "file",
Path = Path.Combine(dataPath, "Raw/")
}.Uri;
}

if (Application.platform == RuntimePlatform.Android)
{
return new Uri("jar:file//" + dataPath + "!/assets/");
}

return new UriBuilder
{
Scheme = "file",
Path = Path.Combine(dataPath, "StreamingAssets/")
}.Uri;
}
}

public static Uri AppPersistentDataUri
{
get
{
return new UriBuilder
{
Scheme = "file",
Path = Application.persistentDataPath + "/"
}.Uri;
}
}

public static void SafeDestroy(GameObject go)
{
if (go != null)
{
UnityEngine.Object.Destroy(go);
}
}

public static void SafeDestroy(Transform go)
{
if (go != null)
{
Util.SafeDestroy(go.gameObject);
}
}

public static void ClearMemory()
{
GC.Collect();
Resources.UnloadUnusedAssets();
}

public static GameObject LoadPrefab(string path)
{
return Resource.LoadPrefab(path);
}

public static string LoadText(string path)
{
return Util.LoadTextFile(path, ".txt");
}

public static string LoadXml(string path)
{
return Util.LoadTextFile(path, ".xml");
}

public static string LoadTextFile(string path, string ext)
{
return Resource.LoadTextFile(path, ext);
}

public static Texture2D LoadTexture(string path)
{
return Resource.LoadTexture(path);
}

public static Dictionary<string, string> TextDic = new Dictionary<string, string>();
public static string GetTextFromConfig(string id)
{
try
{
return TextDic[id];
}
catch (System.Exception e)
{
return id;
}
}

public static DialogType ConvertPanelType(string name)
{
switch (name)
{
case "LoginPanel":
return DialogType.Login;
case "MainPanel":
return DialogType.Main;
case "WorldPanel":
return DialogType.World;
case "DuplicatePanel":
return DialogType.Duplicate;

}
return DialogType.None;
}

public static string ConvertPanelName(DialogType type)
{
switch (type)
{
case DialogType.Login:
return "LoginPanel";
case DialogType.Main:
return "MainPanel";
case DialogType.World:
return "WorldPanel";
case DialogType.Duplicate:
return "DuplicatePanel";
}

return string.Empty;
}

public static GameObject AddChild(GameObject prefab, Transform parent)
{
return NGUITools.AddChild(parent.gameObject, prefab);
}

public static T Get<T>(GameObject go, string subnode) where T : Component
{

if (go != null)
{
Transform transform = go.transform.FindChild(subnode);
if (transform != null)
{
return transform.GetComponent<T>();
}
}

return (T)((object)null);
}

public static T Get<T>(Component go, string subnode) where T : Component
{
if (go != null)
{
return go.transform.FindChild(subnode).GetComponent<T>();
}

return (T)((object)null);
}

public static GameObject Peer(GameObject go, string subnode)
{
return Util.Peer(go.transform, subnode);
}

public static GameObject Peer(Transform go, string subnode)
{
Transform transform = go.parent.FindChild(subnode);
if (transform == null)
{
return null;
}

return transform.gameObject;
}

public static GameObject Child(GameObject go, string subnode)
{
return Util.Child(go.transform, subnode);
}

public static GameObject Child(Transform go, string subnode)
{
Transform transform = go.FindChild(subnode);
if (transform == null)
{
return null;
}

return transform.gameObject;
}

public static Vector3 StrToVector3(string position, char c)
{
string[] array = position.Split(new char[]
{
c
});

float x = Util.Float(array[0]);
float y = Util.Float(array[1]);
float z = Util.Float(array[2]);

return new Vector3(x, y, z);
}

public static float Float(object o)
{
return (float)Math.Round((double)Convert.ToSingle(o), 2);
}

public static void HideDialog(DialogType type)
{
if (type == DialogType.None)
{
return;
}

Transform dialog = io.dialogManager.GetDialog(type);
if (dialog != null)
{
dialog.gameObject.SetActive(false);
}
}

public static void ShowDialog(DialogType type)
{
if (type == DialogType.None)
{
return;
}

Transform dialog = io.dialogManager.GetDialog(type);
if (dialog != null)
{
dialog.gameObject.SetActive(true);
}

}

public static void CloseDialog(DialogType type)
{
if (type == DialogType.None)
{
return;
}

Transform dialog = io.dialogManager.GetDialog(type);
Util.SafeDestroy(dialog);

}

public static void CloseDialog(string name)
{
Util.CloseDialog(Util.ConvertPanelType(name));
}

public static void ClearPanel()
{
List<GameObject> allPanel = io.container.AllPanel;
for (int i = 0; i < allPanel.Count; i++)
{
Util.SafeDestroy(allPanel[i]);
}
}

public static int CloseOpenDialogs()
{
int num = 0;

List<GameObject> allPanel = io.container.AllPanel;
for (int i = 0; i < allPanel.Count; i++ )
{
GameObject gameObject = allPanel[i];
if (gameObject)
{
DialogType dialogType = Util.ConvertPanelType(gameObject.name);
if (dialogType != DialogType.None)
{
Util.CloseDialog(dialogType);
num++;
}
}
}

return num;

}

private static bool CanOpen(DialogType type)
{
List<GameObject> allPanel = io.container.AllPanel;
for (int i = 0; i < allPanel.Count; i++)
{
GameObject gameObject = allPanel[i];
if (gameObject)
{
DialogType dialogType = Util.ConvertPanelType(gameObject.name);
if (dialogType == type)
{
return false;
}
}
}

return true;
}

public static void SetBackground(string background)
{
GameObject gameObject = GameObject.FindWithTag("BackGround");
if (gameObject == null)
{
return;
}

UITexture component = gameObject.GetComponent<UITexture>();
if (!string.IsNullOrEmpty(background))
{
Texture2D texture2D = Util.LoadTexture(background);
component.mainTexture = texture2D;
}
else
{
component.mainTexture = null;
}
}

public static void UnloadTexture(GameObject go)
{
if (go != null)
{
UITexture component = go.GetComponent<UITexture>();
if (component != null)
{
Resources.UnloadAsset(component.material.mainTexture);
}
}
}

public static void UnloadTexture(UITexture texture)
{
if (texture == null)
{
return;
}

Resources.UnloadAsset(texture.material.mainTexture);
}
}