305 lines
8.8 KiB
C#
305 lines
8.8 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using Unity.VisualScripting;
|
|
using UnityEngine;
|
|
using Object = UnityEngine.Object;
|
|
using System.Globalization;
|
|
using UnityEditor;
|
|
|
|
namespace AibisDream.Utility
|
|
{
|
|
public static class CommonUtil
|
|
{
|
|
private const float Epsilon = 1e-5f;
|
|
|
|
private static Camera _mainCam;
|
|
|
|
/// <summary>
|
|
/// 判断为0
|
|
/// </summary>
|
|
/// <param name="value">浮点数</param>
|
|
/// <returns>是否为0</returns>
|
|
public static bool IsZero(float value)
|
|
{
|
|
// 如果value小于epsilon，则认为它等于0
|
|
return Mathf.Abs(value) < Epsilon;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 判断浮点数是否相等
|
|
/// </summary>
|
|
/// <param name="value1">value1</param>
|
|
/// <param name="value2">value2</param>
|
|
/// <returns>是否相等</returns>
|
|
public static bool IsEqual(float value1, float value2)
|
|
{
|
|
return Mathf.Abs(value1 - value2) < Epsilon;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 简单延时实现
|
|
/// </summary>
|
|
/// <param name="delayTime">延时</param>
|
|
/// <param name="action">函数</param>
|
|
public static async Task Delay(int delayTime, Action action)
|
|
{
|
|
await Task.Delay(delayTime);
|
|
action?.Invoke();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 受限数值
|
|
/// </summary>
|
|
/// <param name="target">目标数</param>
|
|
/// <param name="max">上限</param>
|
|
/// <param name="min">下限</param>
|
|
/// <returns>结果</returns>
|
|
public static float Limit(float target, float max, float min)
|
|
{
|
|
if (target <= min)
|
|
{
|
|
return min;
|
|
}
|
|
|
|
if (target >= max)
|
|
{
|
|
return max;
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
public static int Limit(int target, int max, int min)
|
|
{
|
|
if (target <= min)
|
|
{
|
|
return min;
|
|
}
|
|
|
|
if (target >= max)
|
|
{
|
|
return max;
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 步进循环
|
|
/// </summary>
|
|
/// <param name="target">操作数</param>
|
|
/// <param name="min">最小值</param>
|
|
/// <param name="max">最大值</param>
|
|
/// <param name="step">步进</param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException">范围错误</exception>
|
|
public static int LoopStep(int target, int min, int max, int step = 1)
|
|
{
|
|
if (min > max)
|
|
{
|
|
throw new ArgumentException("min should be less than or equal to max.");
|
|
}
|
|
|
|
var range = max - min + 1;
|
|
|
|
// 计算新的目标值
|
|
var newTarget = target + step;
|
|
|
|
// 计算结果在范围内的值
|
|
if (newTarget > max)
|
|
{
|
|
newTarget = min + (newTarget - max - 1) % range;
|
|
}
|
|
else if (newTarget < min)
|
|
{
|
|
newTarget = max - (min - newTarget - 1) % range;
|
|
}
|
|
|
|
return newTarget;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 属性复制
|
|
/// </summary>
|
|
/// <param name="source">属性源</param>
|
|
/// <param name="target">属性目标</param>
|
|
public static void CopyFields(object source, object target)
|
|
{
|
|
var sourceFields = source.GetType().GetFields();
|
|
var targetFields = target.GetType().GetFields();
|
|
|
|
foreach (var sourceField in sourceFields)
|
|
{
|
|
if (sourceField.IsStatic) return;
|
|
|
|
var targetField = targetFields.FirstOrDefault(p =>
|
|
p.Name == sourceField.Name && p.FieldType == sourceField.FieldType);
|
|
if (targetField != null && !targetField.IsStatic())
|
|
{
|
|
targetField.SetValue(target, sourceField.GetValue(source));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 角度转换
|
|
/// </summary>
|
|
/// <param name="angle">180度角</param>
|
|
/// <returns>360度角</returns>
|
|
public static float Angle360(float angle)
|
|
{
|
|
return angle < 0 ? angle + 360 : angle;
|
|
}
|
|
|
|
#region 链式扩展
|
|
|
|
public static T As<T>(this object selfObj) where T : class
|
|
{
|
|
return selfObj as T;
|
|
}
|
|
|
|
public static T Self<T>(this T self, Action<T> onDo)
|
|
{
|
|
onDo?.Invoke(self);
|
|
return self;
|
|
}
|
|
|
|
public static T Self<T>(this T self, Func<T, T> onDo)
|
|
{
|
|
return onDo.Invoke(self);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 静态扩展
|
|
|
|
public static void SetAlpha(this SpriteRenderer renderer, float targetAlpha)
|
|
{
|
|
Color color = renderer.color;
|
|
color.a = targetAlpha;
|
|
renderer.color = color;
|
|
}
|
|
|
|
public static void DestroyAllChildren(this Transform self)
|
|
{
|
|
if (self == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
List<Transform> children = new List<Transform>();
|
|
foreach (Transform child in self)
|
|
{
|
|
children.Add(child);
|
|
}
|
|
|
|
foreach (var child in children)
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (!EditorApplication.isPlaying)
|
|
{
|
|
Object.DestroyImmediate(child.gameObject);
|
|
continue;
|
|
}
|
|
#endif
|
|
Object.Destroy(child.gameObject);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
///<summary>
|
|
/// 去除原始对话中名称部分
|
|
/// </summary>
|
|
/// <param name="lineText">对话原文</param>
|
|
/// <returns>去除名称后结果</returns>
|
|
public static string RemoveName(string lineText)
|
|
{
|
|
var textArr = lineText.Split(":");
|
|
return textArr.Length > 1 ? textArr[1].Trim() : lineText;
|
|
}
|
|
|
|
public static Vector2 GetPivotByType(PivotType pivotType)
|
|
{
|
|
return pivotType switch
|
|
{
|
|
PivotType.Top => new Vector2(0.5f, 1),
|
|
PivotType.Bottom => new Vector2(0.5f, 0),
|
|
PivotType.Left => new Vector2(0, 0.5f),
|
|
PivotType.Right => new Vector2(1, 0.5f),
|
|
PivotType.TopLeft => new Vector2(0, 1),
|
|
PivotType.TopRight => new Vector2(1, 1),
|
|
PivotType.BottomLeft => new Vector2(0, 0),
|
|
PivotType.BottomRight => new Vector2(1, 0),
|
|
PivotType.Center => new Vector2(0.5f, 0.5f),
|
|
_ => Vector2.zero
|
|
};
|
|
}
|
|
|
|
public static string Escape(string rawText)
|
|
{
|
|
return rawText.Replace("^", "#").Replace("[[", "{").Replace("]]", "}");
|
|
}
|
|
|
|
public static List<Type> FindTypesWithAttribute<TAttribute>()
|
|
where TAttribute : Attribute
|
|
{
|
|
return Assembly.GetExecutingAssembly()
|
|
.GetTypes()
|
|
.Where(t => t.GetCustomAttributes(typeof(TAttribute), false).Length > 0)
|
|
.ToList();
|
|
}
|
|
|
|
public static string RemoveRichTextTags(this string str)
|
|
{
|
|
return Regex.Replace(str.Replace("<br>", "\n"), "[<|{].*?[>|}]", string.Empty);
|
|
}
|
|
|
|
public static int[,] DeserializeIntArray(string str)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(str))
|
|
{
|
|
return new int[0, 0];
|
|
}
|
|
|
|
var array = str.Trim().Split(';');
|
|
var result = new int[array.Length, array[0].Split(',').Length];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
var row = array[i].Split(',');
|
|
for (int j = 0; j < row.Length; j++)
|
|
{
|
|
result[i, j] = int.Parse(row[j], NumberStyles.Integer, CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string SerializeIntArray(int[,] array)
|
|
{
|
|
var result = new StringBuilder();
|
|
for (int i = 0; i < array.GetLength(0); i++)
|
|
{
|
|
for (int j = 0; j < array.GetLength(1); j++)
|
|
{
|
|
result.Append(array[i, j]);
|
|
if (j < array.GetLength(1) - 1)
|
|
{
|
|
result.Append(',');
|
|
}
|
|
}
|
|
|
|
if (i < array.GetLength(0) - 1)
|
|
{
|
|
result.Append(';');
|
|
}
|
|
}
|
|
return result.ToString();
|
|
}
|
|
}
|
|
} |