882 lines
22 KiB
C#
882 lines
22 KiB
C#
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Web;
|
|
using metagen;
|
|
using game;
|
|
using Type = System.Type;
|
|
|
|
public static class Extensions
|
|
{
|
|
public static bool IsEmpty(this Vector3 self)
|
|
{
|
|
return float.IsNegativeInfinity(self.x) &&
|
|
float.IsNegativeInfinity(self.y) &&
|
|
float.IsNegativeInfinity(self.z);
|
|
}
|
|
|
|
public static Vector2 FromXZ(this Vector3 self)
|
|
{
|
|
return new Vector2(self.x, self.z);
|
|
}
|
|
|
|
public static Vector3 FromXY(this Vector2 self)
|
|
{
|
|
return new Vector3(self.x, 0, self.y);
|
|
}
|
|
|
|
public static Vector3 ToXZ(this Vector3 self)
|
|
{
|
|
return new Vector3(self.x, 0, self.z);
|
|
}
|
|
|
|
public static bool IsValid(this Vector3 v)
|
|
{
|
|
return !float.IsNaN(v.x) && !float.IsNaN(v.y) && !float.IsNaN(v.z);
|
|
}
|
|
|
|
public static bool BitIsSet(this uint self, int bit)
|
|
{
|
|
return (self & (uint)(1 << bit)) != 0;
|
|
}
|
|
|
|
public static uint BitSet(this uint self, int bit, bool flag)
|
|
{
|
|
if(flag)
|
|
{
|
|
self |= (uint)(1 << bit);
|
|
return self;
|
|
}
|
|
else
|
|
{
|
|
self &= ~(uint)(1 << bit);
|
|
return self;
|
|
}
|
|
}
|
|
|
|
public static int CopyToEx(this Stream src, Stream dest)
|
|
{
|
|
int size = (src.CanSeek) ? Math.Min((int)(src.Length - src.Position), 0x2000) : 0x2000;
|
|
byte[] buffer = new byte[size];
|
|
int total = 0;
|
|
int n;
|
|
do
|
|
{
|
|
n = src.Read(buffer, 0, buffer.Length);
|
|
dest.Write(buffer, 0, n);
|
|
total += n;
|
|
} while (n != 0);
|
|
return total;
|
|
}
|
|
|
|
public static int CopyToEx(this MemoryStream src, Stream dest)
|
|
{
|
|
int total = (int)(src.Length - src.Position);
|
|
dest.Write(src.GetBuffer(), (int)src.Position, total);
|
|
return total;
|
|
}
|
|
|
|
public static int CopyToEx(this Stream src, MemoryStream dest)
|
|
{
|
|
if(src.CanSeek)
|
|
{
|
|
int total = 0;
|
|
int pos = (int)dest.Position;
|
|
int length = (int)(src.Length - src.Position) + pos;
|
|
dest.SetLength(length);
|
|
|
|
while(pos < length)
|
|
{
|
|
int n = src.Read(dest.GetBuffer(), pos, length - pos);
|
|
total += n;
|
|
pos += n;
|
|
}
|
|
return total;
|
|
}
|
|
else
|
|
return src.CopyToEx((Stream)dest);
|
|
}
|
|
|
|
public static void SetData(this MemoryStream ms, byte[] b, int offset, int blen)
|
|
{
|
|
ms.SetLength(0);
|
|
ms.Write(b, offset, blen);
|
|
ms.Position = 0;
|
|
}
|
|
|
|
public static string Reverse(this string s)
|
|
{
|
|
char[] charArray = s.ToCharArray();
|
|
Array.Reverse(charArray);
|
|
return new string(charArray);
|
|
}
|
|
|
|
public static bool ExtractVersion(this string v, out int maj, out int min, out int pat)
|
|
{
|
|
maj = 0;
|
|
min = 0;
|
|
pat = 0;
|
|
|
|
if(v == null || v.Length == 0)
|
|
return false;
|
|
|
|
string[] pieces = v.Split('.');
|
|
|
|
try
|
|
{
|
|
if(pieces.Length == 2)
|
|
{
|
|
maj = int.Parse(pieces[0]);
|
|
min = int.Parse(pieces[1]);
|
|
return true;
|
|
}
|
|
else if(pieces.Length == 3)
|
|
{
|
|
maj = int.Parse(pieces[0]);
|
|
min = int.Parse(pieces[1]);
|
|
pat = int.Parse(pieces[2]);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static string RemoveQueryStringByKey(this string url, string key)
|
|
{
|
|
if(string.IsNullOrEmpty(url))
|
|
return url;
|
|
|
|
var uri = new Uri(url);
|
|
|
|
// this gets all the query string key value pairs as a collection
|
|
var newQueryString = HttpUtility.ParseQueryString(uri.Query);
|
|
|
|
// this removes the key if exists
|
|
newQueryString.Remove(key);
|
|
|
|
return uri.ReplaceURIQueryString(newQueryString);
|
|
}
|
|
|
|
public static string ReplaceURIQueryString(this Uri uri, NameValueCollection newQueryString)
|
|
{
|
|
// this gets the page path from root without QueryString
|
|
string pagePathWithoutQueryString = uri.GetLeftPart(UriPartial.Path);
|
|
|
|
return newQueryString.Count > 0 ?
|
|
$"{pagePathWithoutQueryString}?{newQueryString}" :
|
|
pagePathWithoutQueryString;
|
|
}
|
|
|
|
public static GameObject GetChild(this GameObject o, string name)
|
|
{
|
|
Transform t = o.transform.Find(name);
|
|
if(t == null)
|
|
Error.Verify(false, "Child not found {0}", name);
|
|
return t.gameObject;
|
|
}
|
|
|
|
public static T GetChild<T>(this GameObject o, string name) where T : Component
|
|
{
|
|
return o.GetChild(name).AsComponent<T>();
|
|
}
|
|
|
|
public static T GetChild<T>(this GameObject o) where T : Component
|
|
{
|
|
var res = o.GetComponentInChildren<T>();
|
|
VerifyComponent(o, res);
|
|
return res;
|
|
}
|
|
|
|
public static GameObject FindChild(this GameObject o, string name)
|
|
{
|
|
Transform t = o.transform.Find(name);
|
|
if(t)
|
|
return t.gameObject;
|
|
return null;
|
|
}
|
|
|
|
public static GameObject FindChildRecursive(this GameObject o, string name)
|
|
{
|
|
Transform t = o.transform.FindRecursive(name);
|
|
if(t == null)
|
|
return null;
|
|
return t.gameObject;
|
|
}
|
|
|
|
public static Transform GetChild(this Transform o, string name)
|
|
{
|
|
Transform t = o.transform.Find(name);
|
|
if(t == null)
|
|
Error.Verify(false, "Child not found {0}", name);
|
|
return t;
|
|
}
|
|
|
|
public static void SetActiveAllChildren(this GameObject o, bool flag)
|
|
{
|
|
for(int i=0;i<o.transform.childCount;++i)
|
|
o.transform.GetChild(i).gameObject.SetActive(flag);
|
|
}
|
|
|
|
public static string GetFullPath(this GameObject o)
|
|
{
|
|
return o.transform.GetFullPath();
|
|
}
|
|
|
|
public static void SetLayerRecursive(this GameObject obj, int layer, int except_layer = -1)
|
|
{
|
|
if(obj.layer == except_layer)
|
|
return;
|
|
|
|
obj.layer = layer;
|
|
|
|
for(int i = 0; i < obj.transform.childCount; ++i)
|
|
SetLayerRecursive(obj.transform.GetChild(i).gameObject, layer, except_layer);
|
|
}
|
|
|
|
//NOTE: using Unity's built-in non-allocating Find
|
|
public static Transform FindRecursive(this Transform current, string name)
|
|
{
|
|
if(current.parent)
|
|
{
|
|
if(current.parent.Find(name) == current)
|
|
return current;
|
|
}
|
|
//NOTE: switching to mem-allocating version only if there's no parent
|
|
else if(current.name == name)
|
|
return current;
|
|
|
|
for(int i = 0; i < current.childCount; ++i)
|
|
{
|
|
var chld = current.GetChild(i);
|
|
var tmp = chld.FindRecursive(name);
|
|
if(tmp != null)
|
|
return tmp;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static GameObject GetParent(this GameObject o)
|
|
{
|
|
return o.transform.parent.gameObject;
|
|
}
|
|
|
|
public static string GetFullPath(this Transform t)
|
|
{
|
|
return t.GetPathWhile(current => current != null);
|
|
}
|
|
|
|
public delegate bool TransformPathBuilderCondition(Transform current);
|
|
|
|
public static string GetPathWhile(this Transform t, TransformPathBuilderCondition condition)
|
|
{
|
|
string path = "";
|
|
Transform tmp = t;
|
|
while(condition(tmp))
|
|
{
|
|
path = tmp.gameObject.name + (path.Length > 0 ? ("/" + path) : "");
|
|
tmp = tmp.parent;
|
|
}
|
|
return path;
|
|
}
|
|
|
|
public static bool BelongsTo(this GameObject o, GameObject other)
|
|
{
|
|
Transform current = o.transform;
|
|
while(current != null)
|
|
{
|
|
if(current.gameObject == other)
|
|
return true;
|
|
current = current.parent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static string EscapeSlash(this string src)
|
|
{
|
|
return src.Replace('/', '\u2215');
|
|
}
|
|
|
|
public struct ComponentsList
|
|
{
|
|
public bool busy;
|
|
public object list;
|
|
}
|
|
|
|
//generic cache of component lists
|
|
static List<ComponentsList> comp_lists = new List<ComponentsList>();
|
|
|
|
public static List<T> RequestComponentsList<T>() where T : Component
|
|
{
|
|
//1. try to find non-busy existing one
|
|
{
|
|
for(int i=0;i<comp_lists.Count;++i)
|
|
{
|
|
var cl = comp_lists[i];
|
|
if(cl.busy)
|
|
continue;
|
|
|
|
var lst = cl.list as List<T>;
|
|
if(lst == null)
|
|
continue;
|
|
|
|
cl.busy = true;
|
|
comp_lists[i] = cl;
|
|
return lst;
|
|
}
|
|
}
|
|
|
|
//2. otherwise create new one
|
|
{
|
|
var cl = new ComponentsList();
|
|
var lst = new List<T>();
|
|
cl.list = lst;
|
|
cl.busy = true;
|
|
comp_lists.Add(cl);
|
|
return lst;
|
|
}
|
|
}
|
|
|
|
public static void ReleaseComponentsList<T>(List<T> lst) where T : Component
|
|
{
|
|
for(int i=0;i<comp_lists.Count;++i)
|
|
{
|
|
var cl = comp_lists[i];
|
|
if(cl.list == lst)
|
|
{
|
|
lst.Clear();
|
|
cl.busy = false;
|
|
comp_lists[i] = cl;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static GameObject CloneTpl(this GameObject tpl)
|
|
{
|
|
GameObject o = GameObject.Instantiate(tpl) as GameObject;
|
|
o.transform.SetParent(tpl.transform.parent);
|
|
o.transform.localPosition = tpl.transform.localPosition;
|
|
o.transform.localRotation = tpl.transform.localRotation;
|
|
o.transform.localScale = tpl.transform.localScale;
|
|
return o;
|
|
}
|
|
|
|
public static void GetComponentsRecursive<T>(this Component self, List<T> res) where T : Component
|
|
{
|
|
self.GetComponentsInChildren<T>(includeInactive: true, result: res);
|
|
}
|
|
|
|
public static T GetFirstComponent<T>(this Component self) where T : Component
|
|
{
|
|
T c = self.GetComponent<T>();
|
|
if(c != null)
|
|
return c;
|
|
var tfm = self.transform;
|
|
for(int i = 0; i < tfm.childCount; ++i)
|
|
{
|
|
var cc = tfm.GetChild(i).GetFirstComponent<T>();
|
|
if(cc != null)
|
|
return cc;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
public static T AddComponentOnce<T>(this GameObject self) where T : Component
|
|
{
|
|
T c = self.GetComponent<T>();
|
|
if(c == null)
|
|
c = self.AddComponent<T>();
|
|
return c;
|
|
}
|
|
|
|
public static T AsComponent<T>(this GameObject o) where T : Component
|
|
{
|
|
var res = o.GetComponent<T>();
|
|
VerifyComponent(o, res);
|
|
return res;
|
|
}
|
|
|
|
static void VerifyComponent<T>(GameObject o, T res) where T : Component
|
|
{
|
|
Error.Verify(res != null, "Object {0} must have component {1}\n", o.GetFullPath(), typeof(T).Name);
|
|
}
|
|
|
|
public static void AddRendererSortingOrderRecursive(this Transform tfm, int add_order, string layer = null)
|
|
{
|
|
var r = tfm.GetComponent<Renderer>();
|
|
if(r != null)
|
|
{
|
|
if(layer != null)
|
|
r.sortingLayerName = layer;
|
|
r.sortingOrder += add_order;
|
|
}
|
|
for(int i=0;i<tfm.childCount;++i)
|
|
tfm.GetChild(i).AddRendererSortingOrderRecursive(add_order, layer);
|
|
}
|
|
|
|
public static void SetRendererSortingOrderRecursive(this Transform tfm, int order, string layer = null)
|
|
{
|
|
var r = tfm.GetComponent<Renderer>();
|
|
if(r != null)
|
|
{
|
|
if(layer != null)
|
|
r.sortingLayerName = layer;
|
|
r.sortingOrder = order;
|
|
}
|
|
for(int i=0;i<tfm.childCount;++i)
|
|
tfm.GetChild(i).SetRendererSortingOrderRecursive(order, layer);
|
|
}
|
|
|
|
public static void UpdateRendererSortingOrderRecursive(this Transform tfm, int base_order, string layer = null)
|
|
{
|
|
var r = tfm.GetComponent<Renderer>();
|
|
if(r != null)
|
|
{
|
|
if(layer != null)
|
|
r.sortingLayerName = layer;
|
|
r.sortingOrder += base_order;
|
|
}
|
|
for(int i=0;i<tfm.childCount;++i)
|
|
tfm.GetChild(i).UpdateRendererSortingOrderRecursive(base_order, layer);
|
|
}
|
|
|
|
static HashSet<object> mem_history = new HashSet<object>();
|
|
|
|
public static int GetApproxMemSize(this object obj, int str_symb_size = 2, bool is_top = true)
|
|
{
|
|
if(is_top)
|
|
mem_history.Clear();
|
|
|
|
if(mem_history.Contains(obj))
|
|
return 0;
|
|
mem_history.Add(obj);
|
|
|
|
int ptr_size = IntPtr.Size;
|
|
if(obj == null)
|
|
return ptr_size;
|
|
|
|
int size = 0;
|
|
Type type = obj.GetType();
|
|
var info = type.GetFields(
|
|
System.Reflection.BindingFlags.Instance |
|
|
System.Reflection.BindingFlags.Public |
|
|
System.Reflection.BindingFlags.NonPublic
|
|
);
|
|
foreach(var field in info)
|
|
{
|
|
if(field.FieldType.IsEnum)
|
|
size += 4; //????
|
|
else if(field.FieldType.IsValueType)
|
|
size += System.Runtime.InteropServices.Marshal.SizeOf(field.FieldType);
|
|
else
|
|
{
|
|
size += ptr_size;
|
|
if(field.FieldType.IsArray)
|
|
{
|
|
var array = field.GetValue(obj) as Array;
|
|
if(array != null)
|
|
{
|
|
var elementType = array.GetType().GetElementType();
|
|
if(elementType.IsValueType)
|
|
size += System.Runtime.InteropServices.Marshal.SizeOf(elementType) * array.Length;
|
|
else
|
|
{
|
|
size += ptr_size * array.Length;
|
|
if(elementType == typeof(string))
|
|
size += str_symb_size * array.Length;
|
|
}
|
|
}
|
|
}
|
|
else if(field.FieldType == typeof(string) && field.GetValue(obj) != null)
|
|
size += (field.GetValue(obj) as string).Length * str_symb_size;
|
|
else
|
|
size += field.GetValue(obj).GetApproxMemSize(str_symb_size, false);
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public static readonly DateTime UnixEpoch = new DateTime(1970,1,1,0,0,0,0,DateTimeKind.Utc);
|
|
|
|
public static double ToStamp(this DateTime date)
|
|
{
|
|
return date.ToUniversalTime().Subtract(UnixEpoch).TotalSeconds;
|
|
}
|
|
|
|
public static DateTime ToDateTime(this double unix_stamp)
|
|
{
|
|
return UnixEpoch.AddSeconds(unix_stamp).ToLocalTime();
|
|
}
|
|
|
|
public static DateTime ToDateTimeUTC(this double unix_stamp)
|
|
{
|
|
return UnixEpoch.AddSeconds(unix_stamp).ToUniversalTime();
|
|
}
|
|
|
|
public static DateTime ToDateTime(this uint unix_stamp)
|
|
{
|
|
return ToDateTime((double)unix_stamp);
|
|
}
|
|
|
|
public static DateTime ToDateTimeUTC(this uint unix_stamp)
|
|
{
|
|
return ToDateTimeUTC((double)unix_stamp);
|
|
}
|
|
|
|
public static DateTime ToDateTime(this CodeStage.AntiCheat.ObscuredTypes.ObscuredUInt unix_stamp)
|
|
{
|
|
return ToDateTime((uint)unix_stamp);
|
|
}
|
|
|
|
public static bool IsSameDay(this DateTime date_time, DateTime other)
|
|
{
|
|
return date_time.Year == other.Year && date_time.Month == other.Month && date_time.Day == other.Day;
|
|
}
|
|
|
|
//public static uint CalcHash(this ConfBase conf)
|
|
//{
|
|
// //NOTE: we want to ignore id related changes
|
|
// uint backup_id = conf.id;
|
|
// string backup_strid = conf.strid;
|
|
|
|
// conf.id = 0;
|
|
// conf.strid = "";
|
|
|
|
// uint hash = MetaData.CalcHash(conf);
|
|
|
|
// conf.id = backup_id;
|
|
// conf.strid = backup_strid;
|
|
|
|
// return hash;
|
|
//}
|
|
|
|
public static DateTime Max(DateTime lhs, DateTime rhs)
|
|
{
|
|
return lhs > rhs ? lhs : rhs;
|
|
}
|
|
|
|
public static TimeSpan Max(TimeSpan lhs, TimeSpan rhs)
|
|
{
|
|
return lhs > rhs ? lhs : rhs;
|
|
}
|
|
|
|
public static bool IsValid(this DateTime date)
|
|
{
|
|
var reference = UnixEpoch;
|
|
if(date.Kind == DateTimeKind.Local)
|
|
reference = reference.ToLocalTime();
|
|
return date.Ticks > reference.Ticks; //TODO?
|
|
}
|
|
|
|
public static string GetSceneName(this ConfBase self)
|
|
{
|
|
return self.strid.Replace("@", "").Replace("/", "_");
|
|
}
|
|
|
|
public static Color AsColor(this int n)
|
|
{
|
|
uint val = (uint)n;
|
|
|
|
// scramble the bits up using Robert Jenkins' 32 bit integer hash function
|
|
val = (val+0x7ed55d16) + (val<<12);
|
|
val = (val^0xc761c23c) ^ (val>>19);
|
|
val = (val+0x165667b1) + (val<<5);
|
|
val = (val+0xd3a2646c) ^ (val<<9);
|
|
val = (val+0xfd7046c5) + (val<<3);
|
|
val = (val^0xb55a4f09) ^ (val>>16);
|
|
|
|
float r = (float)((val>>0) & 0xFF);
|
|
float g = (float)((val>>8) & 0xFF);
|
|
float b = (float)((val>>16) & 0xFF);
|
|
|
|
float max = (float)Mathf.Max(Mathf.Max(r, g), b);
|
|
float min = (float)Mathf.Min(Mathf.Min(r, g), b);
|
|
float intensity = 0.75f;
|
|
|
|
// Saturate and scale the color
|
|
if(min == max)
|
|
{
|
|
return new Color(intensity, 0.0f, 0.0f, 1.0f);
|
|
}
|
|
else
|
|
{
|
|
float coef = (float)intensity/(max - min);
|
|
return new Color(
|
|
(r - min)*coef,
|
|
(g - min)*coef,
|
|
(b - min)*coef,
|
|
1.0f
|
|
);
|
|
}
|
|
}
|
|
|
|
public static string Trace<T>(this IList<T> list)
|
|
{
|
|
string res = "<empty list>";
|
|
for(int i=0; i<list.Count; ++i)
|
|
{
|
|
string asstr = list[i] == null ? "<null>" : list[i].ToString();
|
|
res = i == 0 ? asstr : TempStringBuffer.Concat(res, ", ", asstr);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
public static string Trace<K, V>(this Dictionary<K, V> dict, string separator = ": ")
|
|
{
|
|
string res = "";
|
|
foreach(var pair in dict)
|
|
{
|
|
string asstr = $"{pair.Key}{separator}{pair.Value}";
|
|
res = string.IsNullOrEmpty(res) ? asstr : TempStringBuffer.Concat(res, ", ", asstr);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
public static V GetOr<K, V>(this IDictionary<K, V> dict, K key, V default_val)
|
|
{
|
|
V res;
|
|
if(!dict.TryGetValue(key, out res))
|
|
res = default_val;
|
|
return res;
|
|
}
|
|
|
|
//NOTE: T should be Enum. There is no 'official' Enum constraint in C#
|
|
public static T ParseEnum<T>(this string enum_val) where T : struct, IConvertible
|
|
{
|
|
return (T)System.Enum.Parse(typeof(T), enum_val);
|
|
}
|
|
|
|
//NOTE: T should be Enum. There is no 'official' Enum constraint in C#
|
|
public static T RotateEnum<T>(this T enum_val) where T : struct, IConvertible
|
|
{
|
|
int int_val = (int)(object)enum_val;
|
|
int_val++;
|
|
enum_val = (T)(object)int_val;
|
|
if(!Enum.IsDefined(typeof(T), enum_val))
|
|
enum_val = (T)(object)0;
|
|
return enum_val;
|
|
}
|
|
|
|
|
|
//NOTE: this method contains boxing allocation, use with caution
|
|
public static string ToEnumName<T>(this int raw_enum_val) where T : struct, IConvertible
|
|
{
|
|
return Enum.GetName(typeof(T), raw_enum_val);
|
|
}
|
|
|
|
//
|
|
|
|
public static bool ToBool(this byte val)
|
|
{
|
|
return val > 0;
|
|
}
|
|
|
|
public static byte ToByte(this bool val)
|
|
{
|
|
return (byte)(val ? 1 : 0);
|
|
}
|
|
|
|
public static void SelectChild(this GameObject obj, string name)
|
|
{
|
|
foreach(Transform tfm in obj.transform)
|
|
{
|
|
GameObject child = tfm.gameObject;
|
|
child.SetActive(child.name == name);
|
|
}
|
|
}
|
|
|
|
public static void ChildSetActive(this GameObject obj, bool activate)
|
|
{
|
|
foreach(Transform tfm in obj.transform)
|
|
tfm.gameObject.SetActive(activate);
|
|
}
|
|
|
|
public static string ShortAlias(this ConfBase proto)
|
|
{
|
|
string stats_str = proto.strid;
|
|
return stats_str.BaseName();
|
|
}
|
|
|
|
public static string BaseName(this string stats_str)
|
|
{
|
|
return stats_str.Substring(stats_str.LastIndexOf("/") + 1); // name only without path to conf
|
|
}
|
|
|
|
public static string StatsAlias(this ConfBase proto)
|
|
{
|
|
return proto.strid.Substring(1); //omit '@'
|
|
}
|
|
|
|
public static string StatsAliasWithout(this ConfBase proto, string to_remove)
|
|
{
|
|
return proto.StatsAlias().Replace(to_remove, "");
|
|
}
|
|
|
|
public static uint SafeId(this ConfBase proto)
|
|
{
|
|
return proto == null ? 0 : proto.id;
|
|
}
|
|
|
|
public static string ReplaceFirst(this string text, string search, string replace)
|
|
{
|
|
int pos = text.IndexOf(search);
|
|
if (pos < 0)
|
|
return text;
|
|
return $"{text.Substring(0, pos)}{replace}{text.Substring(pos + search.Length)}";
|
|
}
|
|
|
|
public static void RestoreLocalSettingsToDefault(this Transform transform)
|
|
{
|
|
transform.localPosition = Vector3.zero;
|
|
transform.localRotation = Quaternion.identity;
|
|
transform.localScale = Vector3.one;
|
|
}
|
|
|
|
public static void InvertVectors(ref Vector3 vector_a, ref Vector3 vector_b)
|
|
{
|
|
var temp_start_pos = vector_a;
|
|
vector_a = vector_b;
|
|
vector_b = temp_start_pos;
|
|
}
|
|
|
|
// public static T RandomValue<T>(this List<T> list) where T : class
|
|
// {
|
|
// if(list.Count == 0)
|
|
// return null;
|
|
// return list[UnityEngine.Random.Range(0, list.Count)];
|
|
// }
|
|
//
|
|
// public static uint RandomValue(this List<uint> list)
|
|
// {
|
|
// if(list.Count == 0)
|
|
// return 0;
|
|
// return list[UnityEngine.Random.Range(0, list.Count)];
|
|
// }
|
|
|
|
public static int Max(this int[] array)
|
|
{
|
|
if(array.Length == 0)
|
|
return 0;
|
|
|
|
int max = array[0];
|
|
for(int i = 0; i < array.Length; ++i)
|
|
if(max < array[i])
|
|
max = array[i];
|
|
|
|
return max;
|
|
}
|
|
|
|
public static float GetMaxX(this List<Vector3> vectors_list)
|
|
{
|
|
var max_x = float.MinValue;
|
|
foreach(var vector in vectors_list)
|
|
if(vector.x > max_x)
|
|
max_x = vector.x;
|
|
|
|
return max_x;
|
|
}
|
|
|
|
public static float GetMaxY(this List<Vector3> vectors_list)
|
|
{
|
|
var max_y = float.MinValue;
|
|
foreach(var vector in vectors_list)
|
|
if(vector.y > max_y)
|
|
max_y = vector.y;
|
|
|
|
return max_y;
|
|
}
|
|
|
|
public static void SetAlpha(this Image self, float alpha)
|
|
{
|
|
var color = self.color;
|
|
color.a = alpha;
|
|
self.color = color;
|
|
}
|
|
|
|
public static string UnescapeName(this string str, int NAME_MAX_LENGTH)
|
|
{
|
|
string res = str.Unescape();
|
|
|
|
int len = Math.Min(res.Length, NAME_MAX_LENGTH);
|
|
res = res.Substring(0, len);
|
|
return res;
|
|
}
|
|
|
|
public static string Unescape(this string str)
|
|
{
|
|
try
|
|
{
|
|
return System.Text.RegularExpressions.Regex.Unescape(str);
|
|
}
|
|
catch(Exception)
|
|
{
|
|
Log.Error("Could not unescape string '" + str + "'");
|
|
return "???";
|
|
}
|
|
}
|
|
|
|
public static bool IsStorageFullException(this Exception e)
|
|
{
|
|
const long ERROR_HANDLE_DISK_FULL = 0x27;
|
|
const long ERROR_DISK_FULL = 0x70;
|
|
long hr = Marshal.GetHRForException(e) & 0xFFFF;
|
|
return hr == ERROR_HANDLE_DISK_FULL || hr == ERROR_DISK_FULL;
|
|
}
|
|
|
|
public static void SimulateStorageFullException()
|
|
{
|
|
//const int HR_ERROR_HANDLE_DISK_FULL = unchecked((int)0x80070027);
|
|
const int HR_ERROR_DISK_FULL = unchecked((int)0x80070070);
|
|
|
|
var ioe = new IOException("Pretending that storage is full!", HR_ERROR_DISK_FULL);
|
|
throw ioe;
|
|
}
|
|
|
|
public static string Truncate(this string str, int max_length)
|
|
{
|
|
if(string.IsNullOrEmpty(str))
|
|
return str;
|
|
return str.Length <= max_length ? str : str.Substring(0, max_length);
|
|
}
|
|
|
|
public static Sprite GetSprite(this GameObject go)
|
|
{
|
|
if(go == null)
|
|
return null;
|
|
var sr = go.transform.GetFirstComponent<SpriteRenderer>();
|
|
return sr == null ? null : sr.sprite;
|
|
}
|
|
|
|
public static long ParseStockAmount(this string amount_str)
|
|
{
|
|
//NOTE: a hopefully bulletproof parsing that will floor non-integer amounts sent by 3rd-parties
|
|
return (long)double.Parse(amount_str, System.Globalization.CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public static void MaskSet(this ref long mask, int bit, bool val)
|
|
{
|
|
if(val)
|
|
mask |= (long)(1 << bit);
|
|
else
|
|
mask &= ~(1 << bit);
|
|
}
|
|
|
|
public static bool MaskIsSet(this long mask, int bit)
|
|
{
|
|
return (mask & 1 << bit) != 0;
|
|
}
|
|
}
|