mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 16:34:41 +01:00
872 lines
22 KiB
C#
872 lines
22 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using SimpleJSON;
|
|
using UnityEngine;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public static class Miscs
|
|
{
|
|
public class RenderLineInfo
|
|
{
|
|
private static string _shaderName = "miHoYo/UI/Image Tint Color";
|
|
|
|
private Camera _camera;
|
|
|
|
private GameObject _lineObj;
|
|
|
|
private LineRenderer _lr;
|
|
|
|
private Vector3 _screenPos_start;
|
|
|
|
private Vector3 _screenPos_end;
|
|
|
|
public RenderLineInfo(Camera camera, Vector3 start, Vector3 end, Color color, float width)
|
|
{
|
|
_camera = camera;
|
|
_screenPos_start = start;
|
|
_screenPos_end = end;
|
|
_lineObj = new GameObject();
|
|
_lineObj.AddComponent<LineRenderer>();
|
|
_lr = _lineObj.GetComponent<LineRenderer>();
|
|
_lr.material = new Material(Shader.Find(_shaderName));
|
|
_lr.SetColors(color, color);
|
|
_lr.SetWidth(width, width);
|
|
}
|
|
|
|
public void Draw()
|
|
{
|
|
_lineObj.SetActive(true);
|
|
Vector3 screenPos_start = _screenPos_start;
|
|
screenPos_start.x = (float)_camera.pixelWidth * screenPos_start.x;
|
|
screenPos_start.y = (float)_camera.pixelHeight * screenPos_start.y;
|
|
Vector3 screenPos_end = _screenPos_end;
|
|
screenPos_end.x = (float)_camera.pixelWidth * screenPos_end.x;
|
|
screenPos_end.y = (float)_camera.pixelHeight * screenPos_end.y;
|
|
Vector3 position = _camera.ScreenToWorldPoint(screenPos_start);
|
|
Vector3 position2 = _camera.ScreenToWorldPoint(screenPos_end);
|
|
_lineObj.transform.position = position;
|
|
_lr.SetPosition(0, position);
|
|
_lr.SetPosition(1, position2);
|
|
}
|
|
|
|
public void Hide()
|
|
{
|
|
_lineObj.SetActive(false);
|
|
}
|
|
|
|
public bool IsValid()
|
|
{
|
|
return _lineObj != null;
|
|
}
|
|
}
|
|
|
|
public const string HCOIN_ICON_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconHC";
|
|
|
|
public const string SCOIN_ICON_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconSC";
|
|
|
|
public const string FRIENDPOINT_ICON_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconFP";
|
|
|
|
public const string SKILLPOINT_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconSP";
|
|
|
|
public const string STAMINA_ICON_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconST";
|
|
|
|
public const string EXP_ICON_PREFAB_PATH = "SpriteOutput/GeneralIcon/IconEXP";
|
|
|
|
public const string AVATARFRAGMENT_ICON_PREFAB_PATH = "SpriteOutput/AvatarFragmentIcons";
|
|
|
|
public const string AVATARCARD_ICON_PREFAB_PATH = "SpriteOutput/AvatarCardIcons";
|
|
|
|
public const string MATERIAL_ICON_PREFAB_PATH = "SpriteOutput/MaterialIcons";
|
|
|
|
public const string WEAPON_ICON_PREFAB_PATH = "SpriteOutput/WeaponIcons";
|
|
|
|
public const string STIGMATA_ICON_PREFAB_PATH = "SpriteOutput/StigmataIcons";
|
|
|
|
public const float EPSILON = 0.0001f;
|
|
|
|
public const float DEGREE_LERP_END_DIFF = 2f;
|
|
|
|
public const float LENGTH_LERP_END_DIFF = 0.1f;
|
|
|
|
public const float VERY_BIG_FLOAT = 999999f;
|
|
|
|
public static string[] EMPTY_STRINGS = new string[0];
|
|
|
|
private static List<RenderLineInfo> _renderLines = null;
|
|
|
|
private static bool _bEnableDraw = false;
|
|
|
|
public static string FixNumberStringToLength(uint number, int length)
|
|
{
|
|
if (length <= 0)
|
|
{
|
|
throw new Exception("Invalid Type or State!");
|
|
}
|
|
string text = string.Empty + number;
|
|
while (text.Length < length)
|
|
{
|
|
text = "0" + text;
|
|
}
|
|
return text;
|
|
}
|
|
|
|
public static int ExtractOneNumFromString(string Str)
|
|
{
|
|
return int.Parse(Regex.Match(Str, "\\d+").Value);
|
|
}
|
|
|
|
public static string LoadTextFileToString(string filePath)
|
|
{
|
|
TextAsset textAsset = LoadResource(filePath, BundleType.DATA_FILE) as TextAsset;
|
|
string text = textAsset.text;
|
|
Resources.UnloadAsset(textAsset);
|
|
return text;
|
|
}
|
|
|
|
public static object ParseJsonParameterValue(JSONNode aNode)
|
|
{
|
|
switch (aNode["Type"])
|
|
{
|
|
case "Float":
|
|
return aNode["Value"].AsFloat;
|
|
case "Int":
|
|
return aNode["Value"].AsInt;
|
|
case "Double":
|
|
return aNode["Value"].AsDouble;
|
|
case "Bool":
|
|
return aNode["Value"].AsBool;
|
|
case "String":
|
|
return aNode["Value"].Value;
|
|
case "Array":
|
|
{
|
|
JSONArray asArray = aNode["Value"].AsArray;
|
|
switch (aNode["ArrayElemType"])
|
|
{
|
|
case "Float":
|
|
{
|
|
float[] array2 = new float[asArray.Count];
|
|
for (int j = 0; j < asArray.Count; j++)
|
|
{
|
|
array2[j] = asArray[j].AsFloat;
|
|
}
|
|
return array2;
|
|
}
|
|
case "Int":
|
|
{
|
|
int[] array5 = new int[asArray.Count];
|
|
for (int m = 0; m < asArray.Count; m++)
|
|
{
|
|
array5[m] = asArray[m].AsInt;
|
|
}
|
|
return array5;
|
|
}
|
|
case "Double":
|
|
{
|
|
double[] array3 = new double[asArray.Count];
|
|
for (int k = 0; k < asArray.Count; k++)
|
|
{
|
|
array3[k] = asArray[k].AsDouble;
|
|
}
|
|
return array3;
|
|
}
|
|
case "Bool":
|
|
{
|
|
bool[] array4 = new bool[asArray.Count];
|
|
for (int l = 0; l < asArray.Count; l++)
|
|
{
|
|
array4[l] = asArray[l].AsBool;
|
|
}
|
|
return array4;
|
|
}
|
|
case "String":
|
|
{
|
|
string[] array = new string[asArray.Count];
|
|
for (int i = 0; i < asArray.Count; i++)
|
|
{
|
|
array[i] = asArray[i].Value;
|
|
}
|
|
return array;
|
|
}
|
|
default:
|
|
throw new Exception("Invalid Type or State!");
|
|
}
|
|
}
|
|
default:
|
|
throw new Exception("Invalid Type or State!");
|
|
}
|
|
}
|
|
|
|
public static void ParseJsonParameterGroup(JSONNode aNode, Hashtable dynamicParamTable)
|
|
{
|
|
ParseJsonParameterGroupWithParamPrefix(aNode, dynamicParamTable, string.Empty);
|
|
}
|
|
|
|
public static void ParseJsonParameterGroupWithParamPrefix(JSONNode aNode, Hashtable dynamicParamTable, string paramPrefix)
|
|
{
|
|
for (int i = 0; i < aNode["Parameters"].Count; i++)
|
|
{
|
|
dynamicParamTable.Add(paramPrefix + aNode["Parameters"][i]["Param"].Value, ParseJsonParameterValue(aNode["Parameters"][i]));
|
|
}
|
|
}
|
|
|
|
public static float DistancForVec3IgnoreY(Vector3 Vec3A, Vector3 Vec3B)
|
|
{
|
|
Vec3A.y = 0f;
|
|
Vec3B.y = 0f;
|
|
return Vector3.Distance(Vec3A, Vec3B);
|
|
}
|
|
|
|
public static float AngleForVec3IgnoreY(Vector3 DirFrom, Vector3 DirTo)
|
|
{
|
|
Vector3 vector = new Vector3(DirFrom.x, 0f, DirFrom.z);
|
|
Vector3 vector2 = new Vector3(DirTo.x, 0f, DirTo.z);
|
|
return Mathf.Acos(Vector3.Dot(vector.normalized, vector2.normalized));
|
|
}
|
|
|
|
public static Vector3 LerpAngleForVec3IgnoreY(Vector3 DirFrom, Vector3 DirTo, float ratio)
|
|
{
|
|
Vector3 vector = new Vector3(DirFrom.x, 0f, DirFrom.z);
|
|
Vector3 vector2 = new Vector3(DirTo.x, 0f, DirTo.z);
|
|
vector.Normalize();
|
|
vector2.Normalize();
|
|
float num = Mathf.Atan2(DirFrom.z, DirFrom.x);
|
|
float num2 = Mathf.Atan2(DirTo.z, DirTo.x);
|
|
float f = ratio * num2 + (1f - ratio) * num;
|
|
return new Vector3(Mathf.Cos(f), 0f, Mathf.Sin(f));
|
|
}
|
|
|
|
public static float AngleFromToIgnoreY(Vector3 dirFrom, Vector3 dirTo)
|
|
{
|
|
dirFrom.y = 0f;
|
|
dirTo.y = 0f;
|
|
float num = Vector3.Angle(dirFrom, dirTo);
|
|
float num2 = Mathf.Sign(Vector3.Dot(Vector3.up, Vector3.Cross(dirFrom, dirTo)));
|
|
return num * num2;
|
|
}
|
|
|
|
public static float AngleToGround(Vector3 dir)
|
|
{
|
|
Vector3 to = Vector3.ProjectOnPlane(dir, Vector3.up);
|
|
float num = Vector3.Angle(dir, to);
|
|
return (!(dir.y > 0f)) ? (0f - num) : num;
|
|
}
|
|
|
|
public static float SignedAngleDiff(float from, float to)
|
|
{
|
|
float num;
|
|
for (num = to - from; num > 180f; num -= 360f)
|
|
{
|
|
}
|
|
for (; num < -180f; num += 360f)
|
|
{
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static float AbsAngleDiff(float from, float to)
|
|
{
|
|
return Mathf.Abs(SignedAngleDiff(from, to));
|
|
}
|
|
|
|
public static float NormalizedRotateAngle(float from, float to)
|
|
{
|
|
float num = SignedAngleDiff(from, to);
|
|
return from + num;
|
|
}
|
|
|
|
public static float NormalizedClamp(float value, float min, float max)
|
|
{
|
|
value = Mathf.Clamp(value, min, max);
|
|
return (value - min) / (max - min);
|
|
}
|
|
|
|
public static int RightMost1BitIndex(int x)
|
|
{
|
|
int num = -1;
|
|
while (x != 0)
|
|
{
|
|
num++;
|
|
x >>= 1;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static bool IsFloatInRange(float value, float lower, float upper)
|
|
{
|
|
return value > lower && value < upper;
|
|
}
|
|
|
|
public static bool ArrayContains<T>(T[] array, T element)
|
|
{
|
|
return Array.IndexOf(array, element) != -1;
|
|
}
|
|
|
|
public static void ArrayAppend<T>(ref T[] array, T element)
|
|
{
|
|
T[] array2 = new T[array.Length + 1];
|
|
Array.Copy(array, array2, array.Length);
|
|
array2[array2.Length - 1] = element;
|
|
array = array2;
|
|
}
|
|
|
|
public static void ArrayClearOutNulls<T>(ref T[] array)
|
|
{
|
|
List<T> list = new List<T>();
|
|
T[] array2 = array;
|
|
foreach (T val in array2)
|
|
{
|
|
if (val != null)
|
|
{
|
|
list.Add(val);
|
|
}
|
|
}
|
|
array = list.ToArray();
|
|
}
|
|
|
|
public static int ArrayRefCountOf<T>(T[] arr, T element) where T : class
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < arr.Length; i++)
|
|
{
|
|
if (object.ReferenceEquals(element, arr[i]))
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static Sprite GetSpriteByPrefab(string prefabPath)
|
|
{
|
|
Sprite sprite = LoadResource<Sprite>(prefabPath);
|
|
if (sprite != null)
|
|
{
|
|
return sprite;
|
|
}
|
|
GameObject gameObject = LoadResource<GameObject>(prefabPath);
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = LoadResource<GameObject>("SpriteOutput/SpecialIcons/ItemEmpty");
|
|
}
|
|
return gameObject.GetComponent<SpriteRenderer>().sprite;
|
|
}
|
|
|
|
public static Sprite GetItemSpriteByPrefab(int id)
|
|
{
|
|
StorageDataItemBase dummyStorageDataItem = Singleton<StorageModule>.Instance.GetDummyStorageDataItem(id);
|
|
string iconPath = dummyStorageDataItem.GetIconPath();
|
|
return GetSpriteByPrefab(iconPath);
|
|
}
|
|
|
|
public static IEnumerator LoadAsyncAsset(string path, Action<object> callback)
|
|
{
|
|
ResourceRequest resReq = Resources.LoadAsync(path);
|
|
while (!resReq.isDone)
|
|
{
|
|
yield return 0;
|
|
}
|
|
if (callback != null)
|
|
{
|
|
callback(resReq.asset);
|
|
}
|
|
}
|
|
|
|
public static string GetBeforeTimeToShow(DateTime time)
|
|
{
|
|
TimeSpan timeSpan = TimeUtil.Now - time;
|
|
if (timeSpan.TotalMinutes < 60.0)
|
|
{
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_TimeMinutesBefore", timeSpan.Minutes);
|
|
}
|
|
if (timeSpan.TotalHours < 24.0)
|
|
{
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_TimeHoursBefore", timeSpan.Hours);
|
|
}
|
|
if (timeSpan.TotalDays < 7.0)
|
|
{
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_TimeDaysBefore", timeSpan.Days);
|
|
}
|
|
return time.ToString("yyyy-MM-dd");
|
|
}
|
|
|
|
public static int GetTimeSpanToShow(DateTime time, out string label)
|
|
{
|
|
DateTime now = TimeUtil.Now;
|
|
TimeSpan timeSpan = ((!(now > time)) ? (time - now) : (now - time));
|
|
if (timeSpan.TotalMinutes < 60.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Minute");
|
|
return timeSpan.Minutes;
|
|
}
|
|
if (timeSpan.TotalHours < 24.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Hour");
|
|
return timeSpan.Hours;
|
|
}
|
|
if (timeSpan.TotalDays < 7.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Day");
|
|
return timeSpan.Days;
|
|
}
|
|
label = string.Empty;
|
|
return 0;
|
|
}
|
|
|
|
public static int GetDiffTimeToShow(DateTime from, DateTime to, out string label)
|
|
{
|
|
TimeSpan timeSpan = to - from;
|
|
if (timeSpan.TotalMinutes < 60.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Minute");
|
|
return timeSpan.Minutes;
|
|
}
|
|
if (timeSpan.TotalHours < 24.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Hour");
|
|
return timeSpan.Hours;
|
|
}
|
|
if (timeSpan.TotalDays < 7.0)
|
|
{
|
|
label = LocalizationGeneralLogic.GetText("Menu_Desc_Day");
|
|
return timeSpan.Days;
|
|
}
|
|
label = string.Empty;
|
|
return 0;
|
|
}
|
|
|
|
public static string GetTimeString(DateTime time)
|
|
{
|
|
return time.ToString("yyyy-MM-dd HH:mm");
|
|
}
|
|
|
|
public static DateTime GetDateTimeFromTimeStamp(uint timeStamp)
|
|
{
|
|
return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(timeStamp).ToLocalTime();
|
|
}
|
|
|
|
public static uint GetTimeStampFromDateTime(DateTime datetime)
|
|
{
|
|
return (uint)(datetime - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).ToLocalTime()).TotalSeconds;
|
|
}
|
|
|
|
public static void PrettyPrintLayerMask(LayerMask mask)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append(mask.value + "\n");
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (mask.ContainsLayer(i))
|
|
{
|
|
stringBuilder.Append(LayerMask.LayerToName(i) + "\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Color GetDifficultyColor(LevelDiffculty difficulty)
|
|
{
|
|
switch (difficulty)
|
|
{
|
|
case LevelDiffculty.Normal:
|
|
return MiscData.GetColor("ChapterDifficultyNormal");
|
|
case LevelDiffculty.Hard:
|
|
return MiscData.GetColor("ChapterDifficultyHard");
|
|
case LevelDiffculty.Hell:
|
|
return MiscData.GetColor("ChapterDifficultyHell");
|
|
default:
|
|
return MiscData.GetColor("ChapterDifficultyNormal");
|
|
}
|
|
}
|
|
|
|
public static string GetDifficultyDesc(LevelDiffculty difficulty)
|
|
{
|
|
switch (difficulty)
|
|
{
|
|
case LevelDiffculty.Normal:
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_DifficultyNormal");
|
|
case LevelDiffculty.Hard:
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_DifficultyHard");
|
|
case LevelDiffculty.Hell:
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_DifficultyHell");
|
|
default:
|
|
return LocalizationGeneralLogic.GetText("Menu_Desc_DifficultyNormal");
|
|
}
|
|
}
|
|
|
|
public static bool IsPosition2InRect(Vector2 position, Rect rect)
|
|
{
|
|
return position.x >= rect.xMin && position.x <= rect.xMax && position.y >= rect.yMin && position.y <= rect.yMax;
|
|
}
|
|
|
|
public static IEnumerator WWWRequestWithTimeOut(string url, Action<string> callback, Action timeOutCallback, float timeoutSecond = 5f, byte[] postData = null, Dictionary<string, string> headers = null, bool needDispose = true)
|
|
{
|
|
float timer = 0f;
|
|
bool timeout = false;
|
|
WWW www = new WWW(url, postData, headers);
|
|
while (!www.isDone)
|
|
{
|
|
if (timer > timeoutSecond)
|
|
{
|
|
timeout = true;
|
|
break;
|
|
}
|
|
timer += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
if (string.IsNullOrEmpty(www.error))
|
|
{
|
|
if (timeout)
|
|
{
|
|
if (timeOutCallback != null)
|
|
{
|
|
timeOutCallback();
|
|
}
|
|
}
|
|
else if (callback != null)
|
|
{
|
|
callback(www.text);
|
|
}
|
|
}
|
|
if (needDispose)
|
|
{
|
|
www.Dispose();
|
|
}
|
|
}
|
|
|
|
public static IEnumerator WWWRequestWithRetry(string url, Action<string> callback, Action timeOutCallback, float timeoutSecond = 5f, int retryTime = 3, byte[] postData = null, Dictionary<string, string> headers = null)
|
|
{
|
|
int counter = 0;
|
|
while (counter < retryTime)
|
|
{
|
|
counter++;
|
|
float timer = 0f;
|
|
bool timeout = false;
|
|
WWW localWWW = new WWW(url, postData, headers);
|
|
while (!localWWW.isDone)
|
|
{
|
|
if (timer > timeoutSecond)
|
|
{
|
|
timeout = true;
|
|
break;
|
|
}
|
|
timer += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
if (!string.IsNullOrEmpty(localWWW.error) || timeout)
|
|
{
|
|
string warningMsg = ((!timeout) ? localWWW.error : "timeout");
|
|
if (counter >= retryTime && timeOutCallback != null)
|
|
{
|
|
timeOutCallback();
|
|
}
|
|
continue;
|
|
}
|
|
if (callback != null)
|
|
{
|
|
callback(localWWW.text);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static string Truncate(string str, int n = 10)
|
|
{
|
|
return (str.Length <= n) ? str : str.Substring(0, n);
|
|
}
|
|
|
|
public static string GetDebugActorName(BaseActor actor)
|
|
{
|
|
if (actor == null)
|
|
{
|
|
return "<!null>";
|
|
}
|
|
if (!actor.IsActive())
|
|
{
|
|
if (actor.gameObject != null)
|
|
{
|
|
return string.Format("<!inactive {0}({1:x})>", Truncate(actor.gameObject.name), actor.runtimeID);
|
|
}
|
|
return string.Format("<!dead:{0}>", actor.runtimeID);
|
|
}
|
|
return string.Format("<{0}({1:x})>", Truncate(actor.gameObject.name), actor.runtimeID);
|
|
}
|
|
|
|
public static string GetDebugEntityName(BaseMonoEntity entity)
|
|
{
|
|
if (entity == null)
|
|
{
|
|
return "<!null>";
|
|
}
|
|
return string.Format("<{0}({1:x})>", Truncate(entity.gameObject.name), entity.GetRuntimeID());
|
|
}
|
|
|
|
public static string GetAnimIDAttackPropertyOutput(BaseActor actor, string animEventID)
|
|
{
|
|
if (actor == null)
|
|
{
|
|
return string.Format("<!null attack proeprty {0} on {1}>", GetDebugActorName(actor), animEventID);
|
|
}
|
|
if (actor is AvatarActor)
|
|
{
|
|
return SharedAnimEventData.ResolveAnimEvent(((AvatarActor)actor).config, animEventID).AttackProperty.GetDebugOutput();
|
|
}
|
|
if (actor is MonsterActor)
|
|
{
|
|
return SharedAnimEventData.ResolveAnimEvent(((MonsterActor)actor).config, animEventID).AttackProperty.GetDebugOutput();
|
|
}
|
|
if (actor is PropObjectActor)
|
|
{
|
|
return SharedAnimEventData.ResolveAnimEvent(((PropObjectActor)actor).config, animEventID).AttackProperty.GetDebugOutput();
|
|
}
|
|
return string.Format("<!null attack proeprty {0} on {1}>", GetDebugActorName(actor), animEventID);
|
|
}
|
|
|
|
public static T LoadResource<T>(string path, BundleType type = BundleType.RESOURCE_FILE) where T : UnityEngine.Object
|
|
{
|
|
if (Singleton<AssetBundleManager>.Instance == null)
|
|
{
|
|
return Resources.Load<T>(path);
|
|
}
|
|
switch (type)
|
|
{
|
|
case BundleType.DATA_FILE:
|
|
return Singleton<AssetBundleManager>.Instance.LoadData<T>(path);
|
|
case BundleType.RESOURCE_FILE:
|
|
return Singleton<AssetBundleManager>.Instance.LoadRes<T>(path);
|
|
default:
|
|
return (T)null;
|
|
}
|
|
}
|
|
|
|
public static AsyncAssetRequst LoadResourceAsync(string path, BundleType type = BundleType.RESOURCE_FILE)
|
|
{
|
|
if (Singleton<AssetBundleManager>.Instance == null)
|
|
{
|
|
ResourceRequest operation = Resources.LoadAsync(path);
|
|
return new AsyncAssetRequst(operation);
|
|
}
|
|
switch (type)
|
|
{
|
|
case BundleType.DATA_FILE:
|
|
return Singleton<AssetBundleManager>.Instance.LoadDataAsync(path);
|
|
case BundleType.RESOURCE_FILE:
|
|
return Singleton<AssetBundleManager>.Instance.LoadResAsync(path);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static UnityEngine.Object LoadResource(string path, BundleType type = BundleType.RESOURCE_FILE)
|
|
{
|
|
return LoadResource<UnityEngine.Object>(path, type);
|
|
}
|
|
|
|
public static Color ParseColor(string hexString)
|
|
{
|
|
Color color = Color.white;
|
|
if (!ColorUtility.TryParseHtmlString(hexString, out color))
|
|
{
|
|
}
|
|
return color;
|
|
}
|
|
|
|
public static void Shuffle<T>(this IList<T> list)
|
|
{
|
|
int num = list.Count;
|
|
while (num > 1)
|
|
{
|
|
num--;
|
|
int index = UnityEngine.Random.Range(0, num);
|
|
T value = list[index];
|
|
list[index] = list[num];
|
|
list[num] = value;
|
|
}
|
|
}
|
|
|
|
public static string GetBaseName(string path)
|
|
{
|
|
int num = path.LastIndexOf('/');
|
|
return (num != -1) ? path.Substring(num + 1) : path;
|
|
}
|
|
|
|
public static bool IsAlmostZero(float f)
|
|
{
|
|
return f < 0.0001f && f > -0.0001f;
|
|
}
|
|
|
|
public static void SetPitch(Transform tran, float pitch)
|
|
{
|
|
Vector3 eulerAngles = tran.eulerAngles;
|
|
eulerAngles.x = pitch;
|
|
tran.eulerAngles = eulerAngles;
|
|
}
|
|
|
|
public static void TriggerDrawLine()
|
|
{
|
|
_bEnableDraw = !_bEnableDraw;
|
|
if (!_bEnableDraw)
|
|
{
|
|
ClearLine_GameView();
|
|
}
|
|
}
|
|
|
|
public static void DrawLine_GameView()
|
|
{
|
|
if (!_bEnableDraw)
|
|
{
|
|
return;
|
|
}
|
|
if (_renderLines == null)
|
|
{
|
|
_renderLines = new List<RenderLineInfo>();
|
|
}
|
|
if (_renderLines.Count <= 0)
|
|
{
|
|
RenderLineInfo item = new RenderLineInfo(Camera.main, new Vector3(0f, 0.5f, 10f), new Vector3(1f, 0.5f, 10f), Color.red, 0.02f);
|
|
RenderLineInfo item2 = new RenderLineInfo(Camera.main, new Vector3(0.5f, 1f, 10f), new Vector3(0.5f, 0f, 10f), Color.red, 0.02f);
|
|
_renderLines.Add(item);
|
|
_renderLines.Add(item2);
|
|
}
|
|
bool flag = false;
|
|
foreach (RenderLineInfo renderLine in _renderLines)
|
|
{
|
|
if (renderLine.IsValid())
|
|
{
|
|
renderLine.Draw();
|
|
}
|
|
else
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
_renderLines.Clear();
|
|
}
|
|
}
|
|
|
|
public static void ClearLine_GameView()
|
|
{
|
|
foreach (RenderLineInfo renderLine in _renderLines)
|
|
{
|
|
renderLine.Hide();
|
|
}
|
|
}
|
|
|
|
public static bool WildcardMatch(string wildcard, string input, bool ignoreCase = false)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int i = 0;
|
|
int num3 = 0;
|
|
while (num < input.Length && i < wildcard.Length && wildcard[i] != '*')
|
|
{
|
|
if (wildcard[i] != '?' && string.Compare(input, num, wildcard, i, 1, ignoreCase) != 0)
|
|
{
|
|
return false;
|
|
}
|
|
num++;
|
|
i++;
|
|
}
|
|
while (num < input.Length)
|
|
{
|
|
if (i < wildcard.Length && wildcard[i] == '*')
|
|
{
|
|
if (++i >= wildcard.Length)
|
|
{
|
|
return true;
|
|
}
|
|
num2 = num + 1;
|
|
num3 = i;
|
|
}
|
|
else if (i < wildcard.Length && (string.Compare(input, num, wildcard, i, 1, ignoreCase) == 0 || wildcard[i] == '?'))
|
|
{
|
|
num++;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
num = num2++;
|
|
i = num3;
|
|
}
|
|
}
|
|
for (; i < wildcard.Length && wildcard[i] == '*'; i++)
|
|
{
|
|
}
|
|
return i >= wildcard.Length;
|
|
}
|
|
|
|
[RuntimeInitializeOnLoadMethod]
|
|
public static void CreateExceptionWarningLogger()
|
|
{
|
|
GameObject gameObject = new GameObject();
|
|
gameObject.AddComponent<MonoDeviceDebugGUI>();
|
|
UnityEngine.Object.DontDestroyOnLoad(gameObject);
|
|
}
|
|
|
|
public static string ListToString(List<int> list)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (int item in list)
|
|
{
|
|
stringBuilder.Append(item.ToString());
|
|
stringBuilder.Append(", ");
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static Transform FindFirstChildGivenLayerAndCollider(Transform start, int layer)
|
|
{
|
|
Transform transform = null;
|
|
foreach (Transform item in start)
|
|
{
|
|
if (item.gameObject.layer == layer && item.gameObject.GetComponent<Collider>() != null)
|
|
{
|
|
return item;
|
|
}
|
|
transform = FindFirstChildGivenLayerAndCollider(item, layer);
|
|
if (transform != null)
|
|
{
|
|
return transform;
|
|
}
|
|
}
|
|
return transform;
|
|
}
|
|
|
|
public static bool CheckOutsideWallAndDrag(Transform transform)
|
|
{
|
|
BaseMonoAvatar localAvatar = Singleton<AvatarManager>.Instance.GetLocalAvatar();
|
|
if (localAvatar != null)
|
|
{
|
|
bool flag = false;
|
|
Vector3 vector = new Vector3(localAvatar.transform.position.x, 0.1f, localAvatar.transform.position.z);
|
|
Vector3 vector2 = new Vector3(transform.position.x, 0.1f, transform.position.z);
|
|
RaycastHit hitInfo;
|
|
if (Physics.Linecast(vector, vector2, out hitInfo, 1 << InLevelData.OBSTACLE_COLLIDER_LAYER))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (!flag && Physics.Linecast(vector, vector2, out hitInfo, 1 << InLevelData.STAGE_COLLIDER_LAYER) && !Physics.Linecast(vector2, vector, 1 << InLevelData.STAGE_COLLIDER_LAYER))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
Vector3 point = hitInfo.point;
|
|
Vector3 normalized = (vector - vector2).normalized;
|
|
CapsuleCollider componentInChildren = transform.GetComponentInChildren<CapsuleCollider>();
|
|
float num = 0f;
|
|
num = ((!(componentInChildren != null)) ? 0.5f : (componentInChildren.radius + 0.1f));
|
|
Vector3 vector3 = point + normalized * num;
|
|
transform.position = new Vector3(vector3.x, transform.position.y, vector3.z);
|
|
}
|
|
return flag;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|