134 lines
4.4 KiB
C#
134 lines
4.4 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using MessagePack;
|
|
using Unity.Mathematics;
|
|
using UnityEngine;
|
|
using Random = UnityEngine.Random;
|
|
|
|
using static Unity.Mathematics.math;
|
|
|
|
public static class Extensions
|
|
{
|
|
public static void BroadcastMessageExt<T>(this GameObject go, string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver)
|
|
{
|
|
var monoList = new List<T>();
|
|
go.GetComponentsInChildren(true, monoList);
|
|
foreach (var component in monoList)
|
|
{
|
|
try
|
|
{
|
|
Type type = component.GetType();
|
|
|
|
MethodInfo method = type.GetMethod(methodName, BindingFlags.Instance |
|
|
BindingFlags.NonPublic |
|
|
BindingFlags.Public |
|
|
BindingFlags.Static);
|
|
|
|
method.Invoke(component, new[] { value });
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
//Re-create the Error thrown by the original SendMessage function
|
|
if (options == SendMessageOptions.RequireReceiver)
|
|
Debug.LogError("SendMessage " + methodName + " has no receiver!");
|
|
|
|
//Debug.LogError(e.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Dictionary<Type,Type[]> InterfaceClasses = new Dictionary<Type, Type[]>();
|
|
public static Type[] GetAllInterfaceClasses(this Type type)
|
|
{
|
|
if (InterfaceClasses.ContainsKey(type))
|
|
return InterfaceClasses[type];
|
|
return InterfaceClasses[type] = AppDomain.CurrentDomain.GetAssemblies()
|
|
.SelectMany(ass => ass.GetTypes()).Where(t => t.IsClass && t.GetInterfaces().Contains(type)).ToArray();
|
|
}
|
|
|
|
public static bool IsDefault<T>(this T value) where T : struct
|
|
{
|
|
bool isDefault = value.Equals(default(T));
|
|
|
|
return isDefault;
|
|
}
|
|
|
|
public static Texture2D ToTexture(this Color c)
|
|
{
|
|
Texture2D result = new Texture2D(1, 1);
|
|
result.SetPixels(new[]{c});
|
|
result.Apply();
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string SplitCamelCase( this string str )
|
|
{
|
|
return Regex.Replace(
|
|
Regex.Replace(
|
|
str,
|
|
@"(\P{Ll})(\P{Ll}\p{Ll})",
|
|
"$1 $2"
|
|
),
|
|
@"(\p{Ll})(\P{Ll})",
|
|
"$1 $2"
|
|
);
|
|
}
|
|
|
|
public static T RandomElement<T>(this IEnumerable<T> enumerable) => enumerable.ElementAt(Random.Range(0, enumerable.Count()));
|
|
|
|
public static float2 ToFloat2(this Vector2 v) => new float2(v.x, v.y);
|
|
public static float3 ToFloat3(this Vector3 v) => new float3(v.x, v.y, v.z);
|
|
public static Vector2 ToVector2(this float2 v) => new Vector2(v.x, v.y);
|
|
public static Vector3 ToVector3(this float3 v) => new Vector3(v.x, v.y, v.z);
|
|
|
|
public static IDatabaseEntry Get(this Guid entry) => Database.Get(entry);
|
|
public static T Get<T>(this Guid entry) where T : class, IDatabaseEntry => Database.Get(entry) as T;
|
|
public static Guid GetId(this IDatabaseEntry entry) => entry.Entry.ID;
|
|
public static string ToJson(this IDatabaseEntry entry) => MessagePackSerializer.SerializeToJson(entry);
|
|
public static byte[] Serialize(this IDatabaseEntry entry) => MessagePackSerializer.Serialize(entry);
|
|
|
|
public static bool IsImplementationOf(this Type baseType, Type interfaceType)
|
|
{
|
|
return baseType.GetInterfaces().Any(interfaceType.Equals);
|
|
}
|
|
|
|
private static readonly Dictionary<ICraftedItemInstance, float> Quality = new Dictionary<ICraftedItemInstance, float>();
|
|
public static float CompoundQuality(this ICraftedItemInstance item)
|
|
{
|
|
if (Quality.ContainsKey(item)) return Quality[item];
|
|
|
|
var quality = item.CraftedQuality;
|
|
|
|
var craftedIngredients = item.CraftedIngredients.Where(i => i is ICraftedItemInstance).ToArray();
|
|
if (craftedIngredients.Length > 0)
|
|
{
|
|
quality *= craftedIngredients.Cast<ICraftedItemInstance>().Average(CompoundQuality);
|
|
}
|
|
|
|
Quality[item] = quality;
|
|
|
|
return Quality[item];
|
|
}
|
|
|
|
private static readonly Dictionary<ICraftable, int> Tier = new Dictionary<ICraftable, int>();
|
|
public static int ItemTier(this ICraftable item)
|
|
{
|
|
if (Tier.ContainsKey(item)) return Tier[item];
|
|
|
|
Tier[item] = item.CraftingIngredients.Keys.Max(ci => (Database.Get<IItem>(ci) as ICraftable)?.ItemTier() ?? 0);
|
|
|
|
return Tier[item];
|
|
}
|
|
|
|
public static float Performance(this IEquippable item, float temperature)
|
|
{
|
|
return saturate(item.Equippable.HeatPerformanceCurve.Evaluate(saturate(
|
|
(temperature - item.Equippable.MinimumTemperature) /
|
|
(item.Equippable.MaximumTemperature - item.Equippable.MinimumTemperature))));
|
|
}
|
|
}
|