using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using NukeLib.Text;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NukeLib")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+957162b8aa087d5dea0f599cc14f3ff21fc63b2f")]
[assembly: AssemblyProduct("NukeLib")]
[assembly: AssemblyTitle("NukeLib")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace NukeLib
{
[BepInPlugin("com.github.end-4.nukeLib", "NukeLib", "0.5.0")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Log;
public static string workingPath = Assembly.GetExecutingAssembly().Location;
public static string workingDir = Path.GetDirectoryName(workingPath);
public const string PluginGUID = "com.github.end-4.nukeLib";
public const string PluginName = "NukeLib";
public const string PluginVersion = "0.5.0";
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
}
}
}
namespace NukeLib.UI
{
public class EnemyIconController : MonoBehaviour
{
public enum IconStyle
{
Simple,
Vanilla
}
private static bool iconsLoaded = false;
private static bool vanillaIconsLoaded = false;
private static readonly string BundlePath = Path.Combine(Plugin.workingDir, "assets", "nukelib_enemies.bundle");
private static string DEFAULT_ICON = "default";
public IconStyle style;
private static string[] IconNames = new string[41]
{
"default", "big_johninator", "cancerous_rodent", "centaur_mortar", "centaur_orb", "centaur_rocket", "cerberus", "deathcatcher", "drone", "ferryman",
"filth", "flesh_panopticon", "flesh_prison", "gabriel", "gabriel_second", "gutterman", "guttertank", "hideous_mass", "idol", "malicious_face",
"mandalore", "mindflayer", "minos_prime", "minotaur", "mirror_reaper", "power", "providence", "puppet", "schism", "sisyphus",
"sisyphus_prime", "soldier", "stalker", "stray", "mannequin", "streetcleaner", "swordsmachine", "turret", "v2", "very_cancerous_rodent",
"virtue"
};
private static Dictionary<string, Sprite> EnemyIcons = new Dictionary<string, Sprite>();
private static IEnumerable<SpawnableObject> vanillaEnemies;
public EnemyIdentifier enemyIdentifier;
private static void LoadSimpleIcons()
{
AssetBundle val = AssetBundle.LoadFromFile(BundlePath);
for (int i = 0; i < IconNames.Length; i++)
{
string text = IconNames[i];
Sprite value = val.LoadAsset<Sprite>(text);
EnemyIcons.Add(text, value);
}
val.Unload(false);
}
private static void LoadVanillaIcons()
{
vanillaEnemies = Resources.FindObjectsOfTypeAll<SpawnableObjectsDatabase>().SelectMany((SpawnableObjectsDatabase db) => db.enemies);
}
private void Awake()
{
if (style == IconStyle.Simple && !iconsLoaded)
{
LoadSimpleIcons();
iconsLoaded = true;
}
else if (style == IconStyle.Vanilla && !vanillaIconsLoaded)
{
LoadVanillaIcons();
vanillaIconsLoaded = vanillaEnemies.Count() > 0;
}
}
private void Start()
{
SetEnemyIcon(enemyIdentifier);
}
private void SetEnemyIcon(EnemyIdentifier enemyIdentifier)
{
if (style == IconStyle.Vanilla)
{
((Component)this).gameObject.GetComponent<Image>().sprite = vanillaEnemies.FirstOrDefault((Func<SpawnableObject, bool>)delegate(SpawnableObject spawnable)
{
EnemyIdentifier componentInChildren = spawnable.gameObject.GetComponentInChildren<EnemyIdentifier>(true);
return ((componentInChildren != null) ? componentInChildren.FullName : null) == enemyIdentifier.FullName;
})?.gridIcon;
return;
}
string? input = ((object)Unsafe.As<EnemyType, EnemyType>(ref enemyIdentifier.enemyType)/*cast due to .constrained prefix*/).ToString();
string key = DEFAULT_ICON;
string text = input.ToSnakeCase();
if (EnemyIcons.ContainsKey(text))
{
key = text;
}
else
{
switch (enemyIdentifier.FullName.ToLower())
{
case "earthmover mortar":
text = "centaur_mortar";
break;
case "earthmover rocket launcher":
text = "centaur_rocket";
break;
case "earthmover tower":
text = "centaur_orb";
break;
case "cancerous rodent":
text = "cancerous_rodent";
break;
case "very cancerous rodent":
text = "very_cancerous_rodent";
break;
case "big johninator":
text = "big_johninator";
break;
}
if (EnemyIcons.ContainsKey(text))
{
key = text;
}
}
if (EnemyIcons.TryGetValue(key, out Sprite value))
{
((Component)this).gameObject.GetComponent<Image>().sprite = value;
}
}
}
public class SlideFadeToggleEffect : MonoBehaviour
{
private enum State
{
Idle,
Entering,
Exiting
}
private State currentState;
private RectTransform rect;
private CanvasGroup? canvasGroup;
private float originalAlpha;
private Vector2 originalPos;
public float hiddenAlpha;
public float speed = 18f;
public Vector2 hiddenOffset = Vector2.zero;
private float currentExitSpeed;
private Vector2 hiddenPos => originalPos + hiddenOffset;
public event Action OnExitComplete;
private void Set2DLocalPosition(Vector2 newPos)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
((Transform)rect).localPosition = new Vector3(newPos.x, newPos.y, ((Transform)rect).localPosition.z);
}
private void Initialize()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)rect == (Object)null)
{
rect = ((Component)this).GetComponent<RectTransform>();
}
if ((Object)canvasGroup == (Object)null)
{
canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
}
CanvasGroup? obj = canvasGroup;
originalAlpha = ((obj != null) ? obj.alpha : 1f);
originalPos = Vector2.op_Implicit(((Transform)rect).localPosition);
}
private void OnEnable()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
Set2DLocalPosition(hiddenPos);
if ((Object)(object)canvasGroup != (Object)null)
{
canvasGroup.alpha = hiddenAlpha;
}
currentState = State.Entering;
}
public void StartExit()
{
currentState = State.Exiting;
}
private void Awake()
{
Initialize();
}
private void Update()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
if (currentState == State.Idle)
{
return;
}
bool num = currentState == State.Entering;
Vector2 val = (num ? originalPos : hiddenPos);
float num2 = (num ? originalAlpha : hiddenAlpha);
Vector2 val2 = Vector2.op_Implicit(((Transform)rect).localPosition);
CanvasGroup? obj = canvasGroup;
float num3 = ((obj != null) ? obj.alpha : 1f);
float num5;
float num6;
if (num)
{
float num4 = Time.unscaledDeltaTime * speed;
num5 = (Vector2.Distance(val2, val) + 0.1f) * num4;
num6 = (Mathf.Abs(num2 - num3) + 0.1f) * num4;
currentExitSpeed = 0f;
}
else
{
currentExitSpeed += speed * 7f * Time.unscaledDeltaTime;
num5 = currentExitSpeed;
num6 = currentExitSpeed * 0.01f;
}
Set2DLocalPosition(Vector2.MoveTowards(val2, val, num5));
if ((Object)(object)canvasGroup != (Object)null)
{
canvasGroup.alpha = Mathf.MoveTowards(num3, num2, num6);
}
if (Vector2.op_Implicit(((Transform)rect).localPosition) == val && ((Object)(object)canvasGroup == (Object)null || Mathf.Approximately(canvasGroup.alpha, num2)))
{
State num7 = currentState;
currentState = State.Idle;
currentExitSpeed = 0f;
if (num7 == State.Exiting)
{
this.OnExitComplete?.Invoke();
}
}
}
}
public static class SlideFadeToggleEffectExtensions
{
public static void SetActiveAnimated(this GameObject gameObject, bool value, Vector2 hiddenOffset, float speed = 25f)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
SlideFadeToggleEffect slideFadeToggleEffect = gameObject.GetComponent<SlideFadeToggleEffect>();
if ((Object)(object)slideFadeToggleEffect == (Object)null)
{
slideFadeToggleEffect = gameObject.AddComponent<SlideFadeToggleEffect>();
slideFadeToggleEffect.hiddenOffset = hiddenOffset;
slideFadeToggleEffect.speed = speed;
slideFadeToggleEffect.OnExitComplete += delegate
{
gameObject.SetActive(false);
};
}
if (!gameObject.activeSelf)
{
gameObject.SetActive(true);
}
else if ((Object)(object)slideFadeToggleEffect != (Object)null)
{
slideFadeToggleEffect.StartExit();
}
else
{
gameObject.SetActive(false);
}
}
}
public static class UIUtils
{
public static GameObject FindRecursive(this GameObject baseObject, string path)
{
Transform val = baseObject.transform;
string[] array = path.Split("/");
foreach (string text in array)
{
val = ((Component)val).transform.Find(text);
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogWarning((object)(text + " not found for object path " + ((Object)baseObject).name + "/" + path));
return null;
}
}
return ((Component)val).gameObject;
}
public static GameObject FindRecursive(string path)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
int num = path.IndexOf('/');
string firstItem = "";
string path2 = "";
if (num != -1)
{
firstItem = path.Substring(0, num);
path2 = path.Substring(num + 1);
}
Scene activeScene = SceneManager.GetActiveScene();
GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
where ((Object)obj).name == firstItem
select obj).FirstOrDefault();
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogWarning((object)("Root item not found for object path " + path));
return null;
}
return val.FindRecursive(path2);
}
public static void UnfuckLayoutHack(this GameObject uiObject)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)uiObject.transform);
}
}
}
namespace NukeLib.Text
{
public static class TextUtils
{
public static string ToSnakeCase(this string input)
{
if (string.IsNullOrEmpty(input))
{
return input;
}
return Regex.Replace(input, "(?<!^)(?=[A-Z][a-z])|(?<=[a-z0-9])(?=[A-Z])", "_").ToLowerInvariant();
}
public static string WrapText(this string text, int lineLength)
{
string[] array = text.Split(' ');
StringBuilder stringBuilder = new StringBuilder();
StringBuilder stringBuilder2 = new StringBuilder();
string[] array2 = array;
foreach (string text2 in array2)
{
if (stringBuilder2.Length + text2.Length > lineLength)
{
if (stringBuilder2.Length == 0)
{
stringBuilder.AppendLine(text2);
continue;
}
stringBuilder.AppendLine(stringBuilder2.ToString().TrimEnd());
stringBuilder2.Clear();
stringBuilder2.Append(text2).Append(" ");
}
else
{
stringBuilder2.Append(text2).Append(" ");
}
}
if (stringBuilder2.Length > 0)
{
stringBuilder.Append(stringBuilder2.ToString().TrimEnd());
}
return stringBuilder.ToString();
}
}
}
namespace NukeLib.Reflection
{
public static class ReflectionUtils
{
public static T GetPrivate<T>(this object obj, string fieldName)
{
Type type = obj.GetType();
BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
FieldInfo? field = type.GetField(fieldName, bindingAttr);
if (field == null)
{
throw new ArgumentException("Field '" + fieldName + "' doesn't exist in class " + type.Name);
}
return (T)field.GetValue(obj);
}
public static void SetPrivate<T>(this object obj, string fieldName, T value)
{
Type type = obj.GetType();
BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
FieldInfo? field = type.GetField(fieldName, bindingAttr);
if (field == null)
{
throw new ArgumentException("Field '" + fieldName + "' doesn't exist in class " + type.Name);
}
field.SetValue(obj, value);
}
public static T InvokePrivate<T>(this object obj, string methodName, params object[] parameters)
{
Type type = obj.GetType();
BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
MethodInfo? method = type.GetMethod(methodName, bindingAttr);
if (method == null)
{
throw new ArgumentException("Method '" + methodName + "' doesn't exist in class " + type.Name);
}
return (T)method.Invoke(obj, parameters);
}
public static void InvokePrivate(this object obj, string methodName, params object[] parameters)
{
Type type = obj.GetType();
BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
MethodInfo? method = type.GetMethod(methodName, bindingAttr);
if (method == null)
{
throw new ArgumentException("Method '" + methodName + "' doesn't exist in class " + type.Name);
}
method.Invoke(obj, parameters);
}
}
}
namespace NukeLib.ImageUtils
{
public static class ColorUtils
{
public static float PerceivedLightness(this Color color)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
return 0.299f * color.r + 0.587f * color.g + 0.114f * color.b;
}
public static Color Transparentize(this Color color, float value = 1f)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
return new Color(color.r, color.g, color.b, color.a * (1f - value));
}
}
public static class ImageUtils
{
private struct CacheItem
{
public string FilePath;
public Color DominantColor;
}
private static readonly string[] SupportedExtensions = new string[3] { ".png", ".jpg", ".jpeg" };
private static int _maxCacheSize = 1000;
private static readonly Dictionary<string, LinkedListNode<CacheItem>> _cacheDict = new Dictionary<string, LinkedListNode<CacheItem>>();
private static readonly LinkedList<CacheItem> _lruList = new LinkedList<CacheItem>();
public static int MaxCacheSize
{
get
{
return _maxCacheSize;
}
set
{
_maxCacheSize = Mathf.Max(0, value);
TrimCache();
}
}
public static void ClearCache()
{
_cacheDict.Clear();
_lruList.Clear();
}
private static void TrimCache()
{
while (_cacheDict.Count > _maxCacheSize)
{
LinkedListNode<CacheItem> last = _lruList.Last;
if (last != null)
{
_cacheDict.Remove(last.Value.FilePath);
_lruList.RemoveLast();
}
}
}
private static bool TryGetFromCache(string filePath, out Color color)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if (_maxCacheSize > 0 && _cacheDict.TryGetValue(filePath, out LinkedListNode<CacheItem> value))
{
_lruList.Remove(value);
_lruList.AddFirst(value);
color = value.Value.DominantColor;
return true;
}
color = Color.black;
return false;
}
private static void AddToCache(string filePath, Color color)
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
if (_maxCacheSize > 0)
{
if (_cacheDict.TryGetValue(filePath, out LinkedListNode<CacheItem> value))
{
_lruList.Remove(value);
_lruList.AddFirst(value);
value.Value = new CacheItem
{
FilePath = filePath,
DominantColor = color
};
}
else
{
LinkedListNode<CacheItem> linkedListNode = new LinkedListNode<CacheItem>(new CacheItem
{
FilePath = filePath,
DominantColor = color
});
_lruList.AddFirst(linkedListNode);
_cacheDict[filePath] = linkedListNode;
TrimCache();
}
}
}
public static Color GetDominantColor(Texture2D sourceTexture)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
RenderTexture temporary = RenderTexture.GetTemporary(1, 1, 0, (RenderTextureFormat)0);
Graphics.Blit((Texture)(object)sourceTexture, temporary);
RenderTexture.active = temporary;
Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
val.ReadPixels(new Rect(0f, 0f, 1f, 1f), 0, 0);
val.Apply();
Color pixel = val.GetPixel(0, 0);
RenderTexture.active = null;
RenderTexture.ReleaseTemporary(temporary);
Object.Destroy((Object)val);
return pixel;
}
public static Color GetDominantColor(string filePath)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
if (TryGetFromCache(filePath, out var color))
{
return color;
}
if (!File.Exists(filePath))
{
return Color.black;
}
byte[] array = File.ReadAllBytes(filePath);
Texture2D val = new Texture2D(2, 2);
if (!ImageConversion.LoadImage(val, array))
{
Object.Destroy((Object)(object)val);
return Color.black;
}
Color dominantColor = GetDominantColor(val);
Object.Destroy((Object)(object)val);
AddToCache(filePath, dominantColor);
return dominantColor;
}
public static string FindClosestColorImage(Color targetColor, string directoryPath)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
if (!Directory.Exists(directoryPath))
{
return string.Empty;
}
string[] files = Directory.GetFiles(directoryPath, "*.*", SearchOption.TopDirectoryOnly);
string result = string.Empty;
float num = float.MaxValue;
string[] array = files;
foreach (string text in array)
{
string value = Path.GetExtension(text).ToLower();
if (Array.IndexOf(SupportedExtensions, value) != -1)
{
Color dominantColor = GetDominantColor(text);
float num2 = targetColor.r - dominantColor.r;
float num3 = targetColor.g - dominantColor.g;
float num4 = targetColor.b - dominantColor.b;
float num5 = num2 * num2 + num3 * num3 + num4 * num4;
if (num5 < num)
{
num = num5;
result = text;
}
}
}
return result;
}
}
}
namespace NukeLib.Game.Scores
{
public static class LeaderboardHelper
{
public static void DisableLeaderboards()
{
AssistController instance = MonoSingleton<AssistController>.Instance;
if (!((Object)(object)instance == (Object)null))
{
instance.cheatsEnabled = true;
}
}
}
}
namespace NukeLib.Game.Controls
{
public static class Pauser
{
public static void Pause(bool paused)
{
if ((Object)(object)MonoSingleton<NewMovement>.Instance != (Object)null)
{
((Behaviour)MonoSingleton<NewMovement>.Instance).enabled = !paused;
}
if ((Object)(object)MonoSingleton<GunControl>.Instance != (Object)null)
{
MonoSingleton<GunControl>.Instance.activated = !paused;
}
if ((Object)(object)MonoSingleton<CameraController>.Instance != (Object)null)
{
((Behaviour)MonoSingleton<CameraController>.Instance).enabled = !paused;
}
Time.timeScale = (paused ? 0f : 1f);
}
}
}
namespace NukeLib.Debug
{
public static class PrintUtils
{
public static string Stringify<T>(this T[] array, string delimiter = ", ", string prefix = "[", string suffix = "]")
{
string text = prefix;
for (int i = 0; i < array.Length; i++)
{
text += array[i].ToString();
if (i < array.Length - 1)
{
text += delimiter;
}
}
return text + suffix;
}
}
}
namespace NukeLib.Assets
{
public static class FileAssetHelper
{
public static Sprite LoadNewSprite(string filePath, float pixelsPerUnit = 100f, SpriteMeshType spriteType = (SpriteMeshType)1)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = LoadTexture(filePath);
return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0f, 0f), pixelsPerUnit, 0u, spriteType);
}
public static Sprite ConvertTextureToSprite(Texture2D texture, float pixelsPerUnit = 100f, SpriteMeshType spriteType = (SpriteMeshType)1)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0f, 0f), pixelsPerUnit, 0u, spriteType);
}
public static Texture2D LoadTexture(string FilePath)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
if (File.Exists(FilePath))
{
byte[] array = File.ReadAllBytes(FilePath);
Texture2D val = new Texture2D(2, 2);
if (ImageConversion.LoadImage(val, array))
{
return val;
}
}
return null;
}
public static async Task<Texture2D> LoadTextureAsync(string filePath)
{
if (!File.Exists(filePath))
{
return null;
}
string text = "file://" + filePath;
UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(text);
try
{
UnityWebRequestAsyncOperation operation = uwr.SendWebRequest();
while (!((AsyncOperation)operation).isDone)
{
await Task.Yield();
}
if ((int)uwr.result != 1)
{
return null;
}
return DownloadHandlerTexture.GetContent(uwr);
}
finally
{
((IDisposable)uwr)?.Dispose();
}
}
}
}
