using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BetterMonitor.Models;
using BetterMonitor.Patches.ManualCameraRendererPatch;
using BetterMonitor.Patches.ScrapShapePatch;
using BetterMonitor.Resources;
using BetterMonitor.Utilities;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.CoreModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine")]
[assembly: AssemblyCompany("BetterMonitor")]
[assembly: AssemblyDescription("Enhances the on-board monitor. Makes identifying objects and telling the way home easier.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BetterMonitor")]
[assembly: AssemblyTitle("BetterMonitor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 BetterMonitor
{
public class Config
{
public ConfigEntry<bool> VerboseLogging { get; private set; }
public ConfigEntry<bool> DisplayScrapByValue { get; private set; }
public ConfigEntry<bool> AlignMonitorToPlayer { get; private set; }
public ConfigEntry<CompassLocationType> CompassLocation { get; private set; }
public Config(ConfigFile config)
{
VerboseLogging = config.Bind<bool>("Logging", "Verbose logging", true, "Log all events to the console (Useful for identifying issues during customization)");
DisplayScrapByValue = config.Bind<bool>("Scraps", "Show value", true, "Scrap icon changes shape by their value (Customize the icons in the 'ScrapIcons' folder)");
AlignMonitorToPlayer = config.Bind<bool>("Monitor", "Align view to player", true, "Rotate the camera view so that the player is always facing up");
CompassLocation = config.Bind<CompassLocationType>("Monitor", "Compass location", CompassLocationType.AroundPlayerWithProximity, "Where the compass should be placed on the monitor");
}
}
[BepInPlugin("BetterMonitor", "BetterMonitor", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public static Plugin Instance { get; private set; }
public static Config Configuration { get; private set; }
private void Awake()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
Instance = this;
Configuration = new Config(((BaseUnityPlugin)this).Config);
Harmony val = new Harmony("com.fumiko.bettermonitor");
if (Configuration.DisplayScrapByValue.Value)
{
val.PatchAll(typeof(ScrapObjectPatch));
ScrapObjectPatch.Initialize();
}
if (Configuration.CompassLocation.Value != 0)
{
val.PatchAll(typeof(MonitorPatch));
}
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin BetterMonitor is loaded!");
}
public static void LogError(string s)
{
if (Configuration.VerboseLogging.Value)
{
((BaseUnityPlugin)Instance).Logger.LogError((object)s);
}
}
public static void LogInfo(string s)
{
if (Configuration.VerboseLogging.Value)
{
((BaseUnityPlugin)Instance).Logger.LogInfo((object)s);
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "BetterMonitor";
public const string PLUGIN_NAME = "BetterMonitor";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace BetterMonitor.Utilities
{
public static class BytesExtensions
{
public static Sprite ToSprite(this byte[] bytes, int width = 256, int height = 256, float pixelsPerUnit = 100f, SpriteMeshType meshType = 1)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
Texture2D texture = bytes.ToTexture2D(width, height);
return texture.ToSprite(pixelsPerUnit, meshType);
}
public static Texture2D ToTexture2D(this byte[] bytes, int width = 256, int height = 256)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Expected O, but got Unknown
Texture2D val = new Texture2D(width, height);
return ImageConversion.LoadImage(val, bytes) ? val : null;
}
}
public static class Texture2DExtensions
{
public static Sprite ToSprite(this Texture2D texture, float pixelsPerUnit = 100f, SpriteMeshType meshType = 1)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: 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)
return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), Vector2.one * 0.5f, pixelsPerUnit, 0u, meshType);
}
}
}
namespace BetterMonitor.Resources
{
public static class ModResources
{
private static readonly Assembly Assembly = typeof(ModResources).GetTypeInfo().Assembly;
public static Stream Get(string path)
{
return Assembly.GetManifestResourceStream("BetterMonitor.Resources." + path);
}
}
}
namespace BetterMonitor.Patches.ScrapShapePatch
{
[HarmonyPatch(typeof(GrabbableObject))]
public static class ScrapObjectPatch
{
private static readonly string ScrapIconsPath = Path.Combine(Paths.PluginPath, "ScrapIcons");
private static readonly int MainTexture = Shader.PropertyToID("_UnlitColorMap");
private static readonly SortedList<int, Texture> ScrapIcons = new SortedList<int, Texture>();
private static readonly Dictionary<string, Texture> NamedScrapReplacements = new Dictionary<string, Texture>();
public static void Initialize()
{
if (!Directory.Exists(ScrapIconsPath))
{
InitializeDirectory();
}
LoadScrapIcons();
}
private static void LoadScrapIcons()
{
Plugin.LogInfo("Loading scrap icons from " + ScrapIconsPath);
foreach (string item in Directory.EnumerateFiles(ScrapIconsPath))
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
string extension = Path.GetExtension(item);
if (!(extension.ToLowerInvariant() != ".png"))
{
Texture2D value = File.ReadAllBytes(item).ToTexture2D();
if (int.TryParse(fileNameWithoutExtension, out var result))
{
ScrapIcons.Add(result, (Texture)(object)value);
Plugin.LogInfo("Added icon for scrap value " + fileNameWithoutExtension);
}
else
{
NamedScrapReplacements.Add(fileNameWithoutExtension, (Texture)(object)value);
Plugin.LogInfo("Added icon for scrap " + fileNameWithoutExtension);
}
}
}
if (ScrapIcons.Count > 0)
{
return;
}
using Stream stream = ModResources.Get("ScrapIcons.0.png");
byte[] array = new byte[stream.Length];
if (stream.Read(array, 0, array.Length) == 0)
{
ScrapIcons.Add(0, (Texture)(object)array.ToTexture2D());
}
}
private static void InitializeDirectory()
{
Directory.CreateDirectory(ScrapIconsPath);
string[] array = new string[3] { "0.png", "59.png", "89.png" };
string[] array2 = array;
foreach (string text in array2)
{
string path = Path.Combine(ScrapIconsPath, text);
using FileStream destination = File.Create(path);
ModResources.Get("ScrapIcons." + text).CopyTo(destination);
}
}
[HarmonyPostfix]
[HarmonyPatch("Start")]
public static void StartPostfix(GrabbableObject __instance)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
MeshRenderer val = default(MeshRenderer);
if (__instance.itemProperties.isScrap && ((Component)__instance.radarIcon).TryGetComponent<MeshRenderer>(ref val))
{
MaterialPropertyBlock val2 = new MaterialPropertyBlock();
((Renderer)val).GetPropertyBlock(val2);
val2.SetTexture(MainTexture, FindScrapIcon(__instance));
((Renderer)val).SetPropertyBlock(val2);
}
}
private static Texture FindScrapIcon(GrabbableObject item)
{
if (NamedScrapReplacements.TryGetValue(item.itemProperties.itemName, out var value))
{
return value;
}
for (int i = 0; i < ScrapIcons.Count; i++)
{
int num = ScrapIcons.Keys[i];
if (num >= item.scrapValue)
{
return ScrapIcons.Values[Mathf.Max(0, i - 1)];
}
}
IList<Texture> values = ScrapIcons.Values;
return values[values.Count - 1];
}
}
}
namespace BetterMonitor.Patches.ManualCameraRendererPatch
{
[HarmonyPatch(typeof(ManualCameraRenderer))]
public static class MonitorPatch
{
[HarmonyPostfix]
[HarmonyPatch("Update")]
public static void UpdatePostfix(ManualCameraRenderer __instance)
{
TransformAndName val = __instance.radarTargets[__instance.targetTransformIndex];
if (!((Object)(object)__instance.cam != (Object)(object)__instance.mapCamera) && !((Object)(object)val.transform == (Object)null))
{
AlignCameraToPlayer(((Component)__instance.cam).transform, val.transform);
UpdateCompass(__instance, val.transform);
}
}
private static void UpdateCompass(ManualCameraRenderer __instance, Transform radarTarget)
{
//IL_0022: 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_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: 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_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: 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_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)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: 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_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
if (__instance.shipArrowUI.activeSelf)
{
Vector3 val = StartOfRound.Instance.elevatorTransform.position - radarTarget.position;
val.y = 0f;
if (Plugin.Configuration.AlignMonitorToPlayer.Value)
{
Quaternion rotation = radarTarget.rotation;
val = Quaternion.AngleAxis(0f - rotation.y, Vector3.up) * val;
}
if (Plugin.Configuration.CompassLocation.Value == CompassLocationType.AroundPlayer)
{
__instance.shipArrowPointer.localPosition = ((Vector3)(ref val)).normalized * 50f;
}
else
{
float num = Mathf.Lerp(40f, 90f, ((Vector3)(ref val)).sqrMagnitude / 196f);
__instance.shipArrowPointer.localPosition = ((Vector3)(ref val)).normalized * num;
}
__instance.shipArrowPointer.forward = val;
}
}
private static void AlignCameraToPlayer(Transform camera, Transform player)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_0037: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.Configuration.AlignMonitorToPlayer.Value)
{
Quaternion rotation = player.rotation;
camera.rotation = Quaternion.Euler(90f, ((Quaternion)(ref rotation)).eulerAngles.y, 0f);
}
}
}
}
namespace BetterMonitor.Models
{
public enum CompassLocationType
{
BottomRight,
AroundPlayer,
AroundPlayerWithProximity
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
