using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Service;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("RenderLimits")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+13ac2c33375513b53f8858c13d207c03d08d0797")]
[assembly: AssemblyProduct("RenderLimits")]
[assembly: AssemblyTitle("RenderLimits")]
[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.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]
[Microsoft.CodeAnalysis.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]
[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 Service
{
public class ConfigWrapper
{
private readonly ConfigFile ConfigFile;
private readonly Dictionary<string, Action<Terminal, string>> SettingHandlers = new Dictionary<string, Action<Terminal, string>>();
public ConfigWrapper(string command, ConfigFile configFile)
{
//IL_0025: 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)
//IL_0043: Expected O, but got Unknown
//IL_0043: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
ConfigFile = configFile;
new ConsoleCommand(command, "[key] [value] - Toggles or sets a config value.", (ConsoleEvent)delegate(ConsoleEventArgs args)
{
if (args.Length >= 2 && SettingHandlers.TryGetValue(args[1].ToLower(), out Action<Terminal, string> value))
{
if (args.Length == 2)
{
value(args.Context, "");
}
else
{
value(args.Context, string.Join(" ", args.Args.Skip(2)));
}
}
}, false, false, false, false, false, (ConsoleOptionsFetcher)(() => SettingHandlers.Keys.ToList()), false, false, false);
}
private void HandleChange(ConfigEntry<string> configEntry, Action onChange)
{
Action onChange2 = onChange;
configEntry.SettingChanged += delegate
{
onChange2();
};
}
private void HandleChange(ConfigEntry<string> configEntry, Action<string> onChange)
{
Action<string> onChange2 = onChange;
ConfigEntry<string> configEntry2 = configEntry;
configEntry2.SettingChanged += delegate
{
onChange2(configEntry2.Value);
};
onChange2(configEntry2.Value);
}
private void HandleChange(ConfigEntry<string> configEntry, Action<int> onChange)
{
Action<int> onChange2 = onChange;
HandleChange(configEntry, onSettingChanged);
void onSettingChanged(string value)
{
if (TryParseInt(value, out var result))
{
onChange2(result);
}
}
}
private void HandleChange(ConfigEntry<string> configEntry, Action<float> onChange)
{
Action<float> onChange2 = onChange;
HandleChange(configEntry, onSettingChanged);
void onSettingChanged(string value)
{
if (TryParseFloat(value, out var result))
{
onChange2(result);
}
}
}
public ConfigEntry<bool> Bind(string group, string name, bool value, string description)
{
ConfigEntry<bool> val = ConfigFile.Bind<bool>(group, name, value, description);
Register<bool>(val);
return val;
}
public ConfigEntry<string> Bind(string group, string name, string value, string description, Action onChange)
{
ConfigEntry<string> val = ConfigFile.Bind<string>(group, name, value, description);
Register(val);
HandleChange(val, onChange);
return val;
}
public ConfigEntry<string> Bind(string group, string name, string value, string description, Action<string> onChange)
{
ConfigEntry<string> val = ConfigFile.Bind<string>(group, name, value, description);
Register(val);
HandleChange(val, onChange);
return val;
}
public ConfigEntry<string> Bind(string group, string name, string value, string description, Action<int> onChange)
{
ConfigEntry<string> val = ConfigFile.Bind<string>(group, name, value, description);
Register(val);
HandleChange(val, onChange);
return val;
}
public ConfigEntry<string> Bind(string group, string name, string value, string description, Action<float> onChange)
{
ConfigEntry<string> val = ConfigFile.Bind<string>(group, name, value, description);
Register(val);
HandleChange(val, onChange);
return val;
}
private static void AddMessage(Terminal context, string message)
{
context.AddString(message);
Player localPlayer = Player.m_localPlayer;
if (localPlayer != null)
{
((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
}
}
private void Register(ConfigEntry<string> setting)
{
ConfigEntry<string> setting2 = setting;
string name = ((ConfigEntryBase)setting2).Definition.Key;
string key = name.ToLower().Replace(' ', '_');
SettingHandlers.Add(key, delegate(Terminal terminal, string value)
{
SetValue<string>(terminal, setting2, name, value);
});
}
private void Register<T>(ConfigEntry<T> setting)
{
ConfigEntry<T> setting2 = setting;
string name = ((ConfigEntryBase)setting2).Definition.Key;
string key = name.ToLower().Replace(' ', '_');
SettingHandlers.Add(key, delegate(Terminal terminal, string value)
{
SetValue<T>(terminal, setting2, name, value);
});
}
public static int ParseInt(string value, int defaultValue)
{
if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return defaultValue;
}
public static bool TryParseInt(ConfigEntry<string> setting, out int result)
{
return TryParseInt(setting.Value, out result);
}
public static bool TryParseInt(string value, out int result)
{
return int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
}
public static int ParseInt(ConfigEntry<string> setting)
{
if (int.TryParse(setting.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return ParseInt((string)((ConfigEntryBase)setting).DefaultValue, 0);
}
private static float ParseFloat(string value, float defaultValue)
{
if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return defaultValue;
}
public static float ParseFloat(ConfigEntry<string> setting)
{
if (float.TryParse(setting.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return ParseFloat((string)((ConfigEntryBase)setting).DefaultValue, 0f);
}
public static bool TryParseFloat(string value, out float result)
{
return float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
}
private static void SetValue<T>(Terminal context, ConfigEntry<T> setting, string name, string value)
{
if (value == "")
{
AddMessage(context, $"{name}: {setting.Value}.");
return;
}
setting.Value = (T)(object)value;
AddMessage(context, name + " set to " + value + ".");
}
}
public class Helper
{
public static void AddMessage(Terminal context, string message, bool priority = true)
{
context.AddString(message);
MessageHud instance = MessageHud.instance;
if (!Object.op_Implicit((Object)(object)instance))
{
return;
}
if (priority)
{
MsgData[] array = instance.m_msgQeue.ToArray();
instance.m_msgQeue.Clear();
Player localPlayer = Player.m_localPlayer;
if (localPlayer != null)
{
((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
}
MsgData[] array2 = array;
foreach (MsgData item in array2)
{
instance.m_msgQeue.Enqueue(item);
}
instance.m_msgQueueTimer = 10f;
}
else
{
Player localPlayer2 = Player.m_localPlayer;
if (localPlayer2 != null)
{
((Character)localPlayer2).Message((MessageType)1, message, 0, (Sprite)null);
}
}
}
public static void Command(string name, string description, ConsoleEvent action, ConsoleOptionsFetcher? fetcher = null)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
new ConsoleCommand(name, description, Catch(action), false, false, false, false, false, fetcher, false, false, false);
}
public static void AddError(Terminal context, string message, bool priority = true)
{
AddMessage(context, "Error: " + message, priority);
}
public static ConsoleEvent Catch(ConsoleEvent action)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
ConsoleEvent action2 = action;
return (ConsoleEvent)delegate(ConsoleEventArgs args)
{
try
{
if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
throw new InvalidOperationException("Player not found.");
}
action2.Invoke(args);
}
catch (InvalidOperationException ex)
{
AddError(args.Context, ex.Message);
}
};
}
}
}
namespace RenderLimits
{
public class Configuration
{
public static ConfigEntry<string> configActivateArea;
public static ConfigEntry<string> configLoadedArea;
public static ConfigEntry<string> configGeneratedArea;
public static ConfigEntry<string> configRealTerrainVisibility;
public static ConfigEntry<string> configClutterVisibility;
public static ConfigEntry<string> configForceActive;
public static HashSet<Vector2i> ForceActive = new HashSet<Vector2i>();
public static ConfigEntry<string> configMaximumGeneratedArea;
public static ConfigEntry<bool> configAllowForceActive;
public static ConfigEntry<string> configPixelLightCount;
public static ConfigEntry<string> configShadowCascades;
public static ConfigEntry<string> configShadowQuality;
public static ConfigEntry<string> configShadowDistance;
public static ConfigEntry<string> configShadowResolution;
public static ConfigEntry<string> configLodBias;
public static int ActiveArea => ConfigWrapper.ParseInt(configActivateArea);
public static int LoadedArea => ConfigWrapper.ParseInt(configLoadedArea);
public static int GeneratedArea => ConfigWrapper.ParseInt(configGeneratedArea);
public static int RealTerrainVisibility => ConfigWrapper.ParseInt(configRealTerrainVisibility);
public static int ClutterVisibility => ConfigWrapper.ParseInt(configClutterVisibility);
public static int MaximumGeneratedArea => Math.Max(1, ConfigWrapper.ParseInt(configMaximumGeneratedArea));
public static bool AllowForceActive => configAllowForceActive.Value;
private static void ParseForceActive(string value)
{
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
foreach (Vector2i item in (from s in value.Split(new char[1] { '|' })
select s.Trim() into s
select s.Split(new char[1] { ',' }) into s
where s.Length == 2
select s).Select((Func<string[], Vector2i>)delegate(string[] s)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: 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)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
try
{
return new Vector2i(int.Parse(s[0]), int.Parse(s[1]));
}
catch
{
return default(Vector2i);
}
}))
{
hashSet.Add(item);
}
ForceActive = hashSet;
}
public static void SaveForceActive()
{
configForceActive.Value = string.Join("|", ForceActive.Select((Vector2i s) => $"{s.x},{s.y}"));
}
public static void Init(ConfigFile configFile)
{
ConfigWrapper configWrapper = new ConfigWrapper("render_config", configFile);
string group = "1. Zones";
configActivateArea = configWrapper.Bind(group, "Active zones", "1", "Amounts of zones that are active around the player. Creatures are active in this area.", (Action)delegate
{
LimitManager.UpdateLocalLimits();
ZoneSystemPatches.Update();
});
configLoadedArea = configWrapper.Bind(group, "Loaded zones", "2", "Amounts of zones loaded around the player. Structures are visible in this area. ", (Action)delegate
{
LimitManager.UpdateLocalLimits();
ZoneSystemPatches.Update();
TerrainVisibility.Update();
});
configGeneratedArea = configWrapper.Bind(group, "Generated zones", "4", "Amounts of zones generated around the player. Large static objects like trees are visible in this area.", (Action)delegate
{
LimitManager.UpdateLocalLimits();
ZoneSystemPatches.Update();
});
configRealTerrainVisibility = configWrapper.Bind(group, "Real terrain visibility", "0", "Visibility in meters. If 0, automatically calculated from loaded area.", TerrainVisibility.Update);
configForceActive = configWrapper.Bind(group, "Force active", "", "Zones that are always active.", (Action)delegate
{
ParseForceActive(configForceActive.Value);
LimitManager.UpdateLocalLimits();
});
group = "2. Quality";
configClutterVisibility = configWrapper.Bind(group, "Clutter visibility", "45", "Visibility in meters.", ClutterDistance.Update);
configLodBias = configWrapper.Bind(group, "Lod bias", "", "Level of detail limit (increase to show smaller objects, vanilla is from 1 to 5 but even 100 works).", delegate(int value)
{
QualitySettings.lodBias = value;
});
configPixelLightCount = configWrapper.Bind(group, "Pixel light count", "", "Light detail (bigger the better, vanilla is from 2 to 8).", delegate(int value)
{
QualitySettings.pixelLightCount = value;
});
configShadowCascades = configWrapper.Bind(group, "Shadow cascades", "", "Improves shadows near the camera (bigger the better, vanilla is from 2 to 4).", delegate(int value)
{
QualitySettings.shadowCascades = value;
});
configShadowQuality = configWrapper.Bind(group, "Shadow quality", "", "0: off, 1: hard only, 2: all.", delegate(int value)
{
QualitySettings.shadows = (ShadowQuality)Math.Max(0, Math.Min(2, value));
});
configShadowDistance = configWrapper.Bind(group, "Shadow distance", "", "Max distance for shadows in meters (vanilla is from 80 to 150).", delegate(float value)
{
QualitySettings.shadowDistance = value;
});
configShadowResolution = configWrapper.Bind(group, "Shadow resolution", "", "Shadow quality. From 0 to 3.", delegate(int value)
{
QualitySettings.shadowResolution = (ShadowResolution)Math.Max(0, Math.Min(3, value));
});
group = "3. Server limits";
configMaximumGeneratedArea = configWrapper.Bind(group, "Maximum generated zones", "10", "Maximum generated zones that can be received from clients.", (Action<int>)delegate
{
});
configAllowForceActive = configWrapper.Bind(group, "Allow force active", value: false, "Whether clients can have force active areas.");
ParseForceActive(configForceActive.Value);
LimitManager.UpdateLocalLimits();
}
public static void InitSettings()
{
if (ConfigWrapper.TryParseInt(configLodBias.Value, out var result))
{
QualitySettings.lodBias = result;
}
if (ConfigWrapper.TryParseInt(configPixelLightCount.Value, out var result2))
{
QualitySettings.pixelLightCount = result2;
}
if (ConfigWrapper.TryParseInt(configShadowCascades.Value, out var result3))
{
QualitySettings.shadowCascades = result3;
}
if (ConfigWrapper.TryParseInt(configShadowQuality.Value, out var result4))
{
QualitySettings.shadows = (ShadowQuality)Math.Max(0, Math.Min(2, result4));
}
if (ConfigWrapper.TryParseFloat(configShadowDistance.Value, out var result5))
{
QualitySettings.shadowDistance = result5;
}
if (ConfigWrapper.TryParseInt(configShadowResolution.Value, out var result6))
{
QualitySettings.shadowResolution = (ShadowResolution)Math.Max(0, Math.Min(3, result6));
}
}
}
[HarmonyPatch(typeof(ClutterSystem), "Awake")]
public class ClutterDistance
{
private static void Postfix(ClutterSystem __instance)
{
Set(__instance);
}
private static void Set(ClutterSystem obj)
{
obj.m_distance = Configuration.ClutterVisibility;
obj.ClearAll();
}
public static void Update()
{
if (Object.op_Implicit((Object)(object)ClutterSystem.instance))
{
Set(ClutterSystem.instance);
}
}
}
public class ForceActiveCommand
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static ConsoleEvent <>9__0_0;
public static Func<Vector2i, bool> <>9__0_4;
public static Func<Vector2i, bool> <>9__0_5;
public static Func<Vector2i, string> <>9__0_2;
public static Func<Vector2i, string> <>9__0_3;
public static ConsoleEvent <>9__0_1;
internal void <.ctor>b__0_0(ConsoleEventArgs args)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
string text = "toggle";
if (args.Length > 1)
{
text = args[1];
}
int num = 0;
if (args.Length > 2 && int.TryParse(args[2], out var result))
{
num = result;
}
Vector2i zone = ZoneSystem.GetZone(ZNet.instance.GetReferencePosition());
Vector2i val = default(Vector2i);
for (int i = -num; i <= num; i++)
{
for (int j = -num; j <= num; j++)
{
((Vector2i)(ref val))..ctor(zone.x + i, zone.y + j);
bool flag = Configuration.ForceActive.Contains(val);
bool num2 = text == "add" || (text != "remove" && !flag);
if (num2 && flag)
{
Helper.AddMessage(args.Context, $"Zone {val.x},{val.y} is already in active zones.");
}
if (!num2 && !flag)
{
Helper.AddMessage(args.Context, $"Zone {val.x},{val.y} is not in active zones.");
}
if (!num2 && flag)
{
Helper.AddMessage(args.Context, $"Zone {val.x},{val.y} removed from active zones.");
Configuration.ForceActive.Remove(val);
}
if (num2 && !flag)
{
Helper.AddMessage(args.Context, $"Zone {val.x},{val.y} added to active zones.");
Configuration.ForceActive.Add(val);
}
}
}
Configuration.SaveForceActive();
LimitManager.UpdateLocalLimits();
}
internal void <.ctor>b__0_1(ConsoleEventArgs args)
{
Dictionary<Vector2i, ZoneData> zones = ZoneSystem.instance.m_zones;
List<Vector2i> list = new List<Vector2i>();
list.AddRange(zones.Keys.Where((Vector2i zone) => Configuration.ForceActive.Contains(zone)));
List<Vector2i> source = list;
List<Vector2i> list2 = new List<Vector2i>();
list2.AddRange(zones.Keys.Where((Vector2i zone) => !Configuration.ForceActive.Contains(zone)));
List<Vector2i> source2 = list2;
Helper.AddMessage(args.Context, "Forced: " + string.Join(", ", source.Select((Vector2i zone) => $"{zone.x},{zone.y}")));
Helper.AddMessage(args.Context, "Default: " + string.Join(", ", source2.Select((Vector2i zone) => $"{zone.x},{zone.y}")));
}
internal bool <.ctor>b__0_4(Vector2i zone)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
return Configuration.ForceActive.Contains(zone);
}
internal bool <.ctor>b__0_5(Vector2i zone)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
return !Configuration.ForceActive.Contains(zone);
}
internal string <.ctor>b__0_2(Vector2i zone)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return $"{zone.x},{zone.y}";
}
internal string <.ctor>b__0_3(Vector2i zone)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return $"{zone.x},{zone.y}";
}
}
public ForceActiveCommand()
{
//IL_0024: 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_002f: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
object obj = <>c.<>9__0_0;
if (obj == null)
{
ConsoleEvent val = delegate(ConsoleEventArgs args)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
string text = "toggle";
if (args.Length > 1)
{
text = args[1];
}
int num = 0;
if (args.Length > 2 && int.TryParse(args[2], out var result))
{
num = result;
}
Vector2i zone2 = ZoneSystem.GetZone(ZNet.instance.GetReferencePosition());
Vector2i val3 = default(Vector2i);
for (int i = -num; i <= num; i++)
{
for (int j = -num; j <= num; j++)
{
((Vector2i)(ref val3))..ctor(zone2.x + i, zone2.y + j);
bool flag = Configuration.ForceActive.Contains(val3);
bool num2 = text == "add" || (text != "remove" && !flag);
if (num2 && flag)
{
Helper.AddMessage(args.Context, $"Zone {val3.x},{val3.y} is already in active zones.");
}
if (!num2 && !flag)
{
Helper.AddMessage(args.Context, $"Zone {val3.x},{val3.y} is not in active zones.");
}
if (!num2 && flag)
{
Helper.AddMessage(args.Context, $"Zone {val3.x},{val3.y} removed from active zones.");
Configuration.ForceActive.Remove(val3);
}
if (num2 && !flag)
{
Helper.AddMessage(args.Context, $"Zone {val3.x},{val3.y} added to active zones.");
Configuration.ForceActive.Add(val3);
}
}
}
Configuration.SaveForceActive();
LimitManager.UpdateLocalLimits();
};
<>c.<>9__0_0 = val;
obj = (object)val;
}
Helper.Command("force_active", "[add/remove/toggle] [around=0] - Toggles the force active of the current zone.", (ConsoleEvent)obj);
object obj2 = <>c.<>9__0_1;
if (obj2 == null)
{
ConsoleEvent val2 = delegate(ConsoleEventArgs args)
{
Dictionary<Vector2i, ZoneData> zones = ZoneSystem.instance.m_zones;
List<Vector2i> list = new List<Vector2i>();
list.AddRange(zones.Keys.Where((Vector2i zone) => Configuration.ForceActive.Contains(zone)));
List<Vector2i> source = list;
List<Vector2i> list2 = new List<Vector2i>();
list2.AddRange(zones.Keys.Where((Vector2i zone) => !Configuration.ForceActive.Contains(zone)));
List<Vector2i> source2 = list2;
Helper.AddMessage(args.Context, "Forced: " + string.Join(", ", source.Select((Vector2i zone) => $"{zone.x},{zone.y}")));
Helper.AddMessage(args.Context, "Default: " + string.Join(", ", source2.Select((Vector2i zone) => $"{zone.x},{zone.y}")));
};
<>c.<>9__0_1 = val2;
obj2 = (object)val2;
}
Helper.Command("check_active", "- Prints currently loaded zones.", (ConsoleEvent)obj2);
}
}
[HarmonyPatch(typeof(SpawnArea), "UpdateSpawn")]
public class SpawnArea_UpdateSpawn
{
private static float GetRange(SpawnArea sa)
{
//IL_0019: 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)
//IL_0023: 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)
if (Configuration.ForceActive.Count == 0)
{
return sa.m_triggerDistance;
}
Vector2i zone = ZoneSystem.GetZone(((Component)sa).transform.position);
if (!Configuration.ForceActive.Contains(zone))
{
return sa.m_triggerDistance;
}
return 999999f;
}
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: 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_0035: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpawnArea), "m_triggerDistance"), (string)null)
}).Set(OpCodes.Call, (object)AccessTools.Method(typeof(SpawnArea_UpdateSpawn), "GetRange", (Type[])null, (Type[])null)).InstructionEnumeration();
}
}
[HarmonyPatch(typeof(CreatureSpawner), "UpdateSpawner")]
public class CreatureSpawner_UpdateSpawner
{
private static float GetRange(CreatureSpawner cs)
{
//IL_0019: 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)
//IL_0023: 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)
if (Configuration.ForceActive.Count == 0)
{
return cs.m_triggerDistance;
}
Vector2i zone = ZoneSystem.GetZone(((Component)cs).transform.position);
if (!Configuration.ForceActive.Contains(zone))
{
return cs.m_triggerDistance;
}
return 999999f;
}
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: 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_0035: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(CreatureSpawner), "m_triggerDistance"), (string)null)
}).Set(OpCodes.Call, (object)AccessTools.Method(typeof(CreatureSpawner_UpdateSpawner), "GetRange", (Type[])null, (Type[])null)).InstructionEnumeration();
}
}
public class PlayerLimits
{
public int ActiveArea = Math.Max(0, activeArea);
public int LoadedArea = Math.Max(activeArea + 1, loadedArea);
public int GeneratedArea = Math.Max(0, generatedArea - loadedArea);
public int TotalArea;
public HashSet<Vector2i> ForceActive { get; set; }
public PlayerLimits(int loadedArea, int activeArea, int generatedArea, HashSet<Vector2i> forceActive)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: 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)
TotalArea = generatedArea;
HashSet<Vector2i> hashSet2;
if (forceActive != null)
{
HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
foreach (Vector2i item in forceActive)
{
hashSet.Add(item);
}
hashSet2 = hashSet;
}
else
{
hashSet2 = new HashSet<Vector2i>();
}
ForceActive = hashSet2;
base..ctor();
}
}
public static class LimitManager
{
public static string RPC_PLAYERSETTINGS = "RenderLimits_PlayerSettings";
private static readonly Dictionary<long, PlayerLimits> PlayerLimits = new Dictionary<long, PlayerLimits>();
private static long CurrentId = 0L;
private static int MaxTotalArea = 0;
public static void SetCurrentPlayer(long uid)
{
CurrentId = uid;
}
public static PlayerLimits GetPlayerLimits(long uid)
{
if (!PlayerLimits.ContainsKey(uid))
{
PlayerLimits[uid] = new PlayerLimits(1, 2, 4, new HashSet<Vector2i>());
}
return PlayerLimits[uid];
}
public static void SetPlayerLimits(long uid, int loadedArea, int activeArea, int generatedArea, HashSet<Vector2i> forceActive)
{
PlayerLimits[uid] = new PlayerLimits(loadedArea, activeArea, generatedArea, forceActive);
MaxTotalArea = CalculateMaxTotal();
}
public static void RemovePlayer(long uid)
{
PlayerLimits.Remove(uid);
MaxTotalArea = CalculateMaxTotal();
}
private static int CalculateMaxTotal()
{
return PlayerLimits.Values.Max((PlayerLimits limits) => limits.TotalArea);
}
public static int GetMaxTotal()
{
return MaxTotalArea;
}
public static PlayerLimits GetCurrent()
{
return GetPlayerLimits(CurrentId);
}
public static PlayerLimits GetLocalLimits()
{
return GetPlayerLimits(0L);
}
public static void UpdateLocalLimits()
{
SetPlayerLimits(0L, Configuration.LoadedArea, Configuration.ActiveArea, Configuration.GeneratedArea, Configuration.ForceActive);
if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
SetPlayerLimits(Player.m_localPlayer.GetPlayerID(), Configuration.LoadedArea, Configuration.ActiveArea, Configuration.GeneratedArea, Configuration.ForceActive);
SendPlayerLimitsToServer();
}
}
private static void SendPlayerLimitsToServer()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_006a: 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_0071: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)ZNet.instance) || ZNet.instance.IsServer())
{
return;
}
ZRpc serverRPC = ZNet.instance.GetServerRPC();
ZPackage val = new ZPackage();
val.Write(Configuration.LoadedArea);
val.Write(Configuration.ActiveArea);
val.Write(Configuration.GeneratedArea);
val.Write(Configuration.ForceActive.Count);
foreach (Vector2i item in Configuration.ForceActive)
{
val.Write(item);
}
if (serverRPC != null)
{
serverRPC.Invoke(RPC_PLAYERSETTINGS, new object[1] { val });
}
}
public static void RPC_PlayerSettings(ZRpc rpc, ZPackage pkg)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
if (!ZNet.instance.IsServer())
{
return;
}
ZNetPeer peer = ZNet.instance.GetPeer(rpc);
int loadedArea = pkg.ReadInt();
int activeArea = pkg.ReadInt();
int generatedArea = Math.Min(Configuration.MaximumGeneratedArea, pkg.ReadInt());
HashSet<Vector2i> hashSet = new HashSet<Vector2i>();
if (Configuration.AllowForceActive)
{
int num = pkg.ReadInt();
for (int i = 0; i < num; i++)
{
hashSet.Add(pkg.ReadVector2i());
}
}
SetPlayerLimits(peer.m_uid, loadedArea, activeArea, generatedArea, hashSet);
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
public class ZNet_RPC_PeerInfo_Patch
{
private static void Postfix(ZNet __instance, ZRpc rpc)
{
if (__instance.GetPeer(rpc).m_uid != 0L)
{
if (__instance.IsServer())
{
rpc.Register<ZPackage>(LimitManager.RPC_PLAYERSETTINGS, (Action<ZRpc, ZPackage>)LimitManager.RPC_PlayerSettings);
}
else
{
LimitManager.UpdateLocalLimits();
}
}
}
}
[HarmonyPatch(typeof(ZNet), "Disconnect")]
public class ZNet_Disconnect
{
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
if (__instance.IsServer())
{
LimitManager.RemovePlayer(peer.m_uid);
}
}
}
[HarmonyPatch(typeof(SpawnSystem), "GetNrOfInstances", new Type[]
{
typeof(GameObject),
typeof(Vector3),
typeof(float),
typeof(bool),
typeof(bool)
})]
public class SpawnLimits
{
private static void Prefix(ref Vector3 center, ref float maxRange)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (ZoneSystem.instance.m_activeArea != 2 && maxRange == 0f)
{
maxRange = 181f;
if (center == Vector3.zero && Object.op_Implicit((Object)(object)ZNet.instance))
{
center.x = ZNet.instance.m_referencePosition.x;
center.y = ZNet.instance.m_referencePosition.y;
center.z = ZNet.instance.m_referencePosition.z;
}
}
}
}
[HarmonyPatch(typeof(Heightmap), "Initialize")]
public class TerrainVisibility
{
private static void Postfix(Heightmap __instance)
{
Set(__instance);
}
private static void Set(Heightmap obj)
{
Material materialInstance = obj.m_materialInstance;
int num = Configuration.RealTerrainVisibility;
if (num == 0)
{
num = (int)(((double)Configuration.LoadedArea + 0.8) * 64.0);
}
if (Object.op_Implicit((Object)(object)materialInstance))
{
materialInstance.SetFloat("_LodHideDistance", (float)num);
}
}
public static void Update()
{
Heightmap[] array = Object.FindObjectsByType<Heightmap>((FindObjectsInactive)0, (FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
Set(array[i]);
}
}
}
[HarmonyPatch(typeof(ZoneSystem))]
public class ZoneSystemPatches
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void Awake_Postfix(ZoneSystem __instance)
{
Set(__instance);
}
private static void Set(ZoneSystem obj)
{
PlayerLimits localLimits = LimitManager.GetLocalLimits();
obj.m_activeArea = localLimits.LoadedArea;
obj.m_activeDistantArea = localLimits.GeneratedArea;
}
public static void Update()
{
if (Object.op_Implicit((Object)(object)ZoneSystem.instance))
{
Set(ZoneSystem.instance);
}
}
[HarmonyPatch("CreateLocalZones")]
[HarmonyPostfix]
private static void CreateLocalZones_Postfix(ZoneSystem __instance, ref bool __result)
{
//IL_0024: 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_002b: Unknown result type (might be due to invalid IL or missing references)
HashSet<Vector2i> forceActive = LimitManager.GetLocalLimits().ForceActive;
if (forceActive.Count == 0 || __result)
{
return;
}
foreach (Vector2i item in forceActive)
{
if (__instance.PokeLocalZone(item))
{
__result = true;
break;
}
}
}
private static int GetTotalArea()
{
return LimitManager.GetMaxTotal();
}
[HarmonyPatch("CreateGhostZones")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> CreateGhostZones_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ZoneSystem), "m_activeArea"), (string)null)
}).SetAndAdvance(OpCodes.Call, (object)AccessTools.Method(typeof(ZoneSystemPatches), "GetTotalArea", (Type[])null, (Type[])null)).SetOpcodeAndAdvance(OpCodes.Nop)
.SetOpcodeAndAdvance(OpCodes.Nop)
.SetOpcodeAndAdvance(OpCodes.Nop)
.SetOpcodeAndAdvance(OpCodes.Nop)
.InstructionEnumeration();
}
[HarmonyPatch("IsActiveAreaLoaded")]
[HarmonyPostfix]
private static void IsActiveAreaLoaded_Postfix(ZoneSystem __instance, ref bool __result)
{
//IL_0024: 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)
HashSet<Vector2i> forceActive = LimitManager.GetLocalLimits().ForceActive;
if (forceActive.Count == 0 || !__result)
{
return;
}
foreach (Vector2i item in forceActive)
{
if (!__instance.m_zones.ContainsKey(item))
{
__result = false;
break;
}
}
}
}
[HarmonyPatch(typeof(ZNetScene))]
public class ZNetScenePatches
{
[HarmonyPatch("InActiveArea", new Type[]
{
typeof(Vector2i),
typeof(Vector2i)
})]
[HarmonyPrefix]
private static bool InActiveArea_Prefix(Vector2i zone, Vector2i refCenterZone, ref bool __result)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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)
//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_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
PlayerLimits current = LimitManager.GetCurrent();
if (current.ForceActive.Contains(zone))
{
__result = true;
return false;
}
int activeArea = current.ActiveArea;
__result = zone.x >= refCenterZone.x - activeArea && zone.x <= refCenterZone.x + activeArea && zone.y <= refCenterZone.y + activeArea && zone.y >= refCenterZone.y - activeArea;
return false;
}
[HarmonyPatch("InActiveArea", new Type[]
{
typeof(Vector2i),
typeof(Vector2i),
typeof(int)
})]
[HarmonyPrefix]
private static bool InActiveArea2_Prefix(Vector2i zone, Vector2i refCenterZone, ref bool __result)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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)
//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_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
PlayerLimits current = LimitManager.GetCurrent();
if (current.ForceActive.Contains(zone))
{
__result = true;
return false;
}
int activeArea = current.ActiveArea;
__result = zone.x >= refCenterZone.x - activeArea && zone.x <= refCenterZone.x + activeArea && zone.y <= refCenterZone.y + activeArea && zone.y >= refCenterZone.y - activeArea;
return false;
}
[HarmonyPatch("OutsideActiveArea", new Type[]
{
typeof(Vector3),
typeof(Vector3)
})]
[HarmonyPrefix]
private static bool OutsideActiveArea_Prefix(Vector3 point, Vector3 refPoint, ref bool __result)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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_0018: 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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: 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_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
PlayerLimits current = LimitManager.GetCurrent();
int activeArea = current.ActiveArea;
Vector2i zone = ZoneSystem.GetZone(point);
if (current.ForceActive.Contains(zone))
{
__result = false;
return false;
}
Vector2i zone2 = ZoneSystem.GetZone(refPoint);
__result = zone.x < zone2.x - activeArea || zone.x > zone2.x + activeArea || zone.y > zone2.y + activeArea || zone.y < zone2.y - activeArea;
return false;
}
}
[HarmonyPatch(typeof(ZDOMan))]
public class ZDOManPatches
{
[HarmonyPatch("CreateSyncList")]
[HarmonyPrefix]
private static void CreateSyncList_Prefix(ZDOPeer peer)
{
LimitManager.SetCurrentPlayer(peer.m_peer.m_uid);
}
[HarmonyPatch("CreateSyncList")]
[HarmonyPostfix]
private static void CreateSyncList_Postfix()
{
LimitManager.SetCurrentPlayer(0L);
}
[HarmonyPatch("ReleaseNearbyZDOS")]
[HarmonyPrefix]
private static void ReleaseNearbyZDOS_Prefix(long uid)
{
LimitManager.SetCurrentPlayer(uid);
}
[HarmonyPatch("ReleaseNearbyZDOS")]
[HarmonyPostfix]
private static void ReleaseNearbyZDOS_Postfix()
{
LimitManager.SetCurrentPlayer(0L);
}
[HarmonyPatch("FindDistantObjects")]
[HarmonyPrefix]
private static bool FindDistantObjects_Prefix(Vector2i sector)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
return !LimitManager.GetCurrent().ForceActive.Contains(sector);
}
[HarmonyPatch("FindSectorObjects")]
[HarmonyPrefix]
private static void FindSectorObjects_Prefix(ref int area, ref int distantArea)
{
PlayerLimits current = LimitManager.GetCurrent();
area = current.LoadedArea;
if (distantArea != 0)
{
distantArea = current.GeneratedArea;
}
}
[HarmonyPatch("FindSectorObjects")]
[HarmonyPostfix]
private static void FindSectorObjects_Postfix(ZDOMan __instance, Vector2i sector, int area, List<ZDO> sectorObjects)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: 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_002b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
HashSet<Vector2i> forceActive = LimitManager.GetCurrent().ForceActive;
if (forceActive.Count == 0)
{
return;
}
foreach (Vector2i item in forceActive)
{
if (item.x < sector.x - area || item.x > sector.x + area || item.y > sector.y + area || item.y < sector.y - area)
{
__instance.FindObjects(item, sectorObjects);
}
}
}
}
[HarmonyPatch(typeof(ZDOPeer))]
public class ZDOPeerPatches
{
[HarmonyPatch("ZDOSectorInvalidated")]
[HarmonyPrefix]
private static void CreateSyncList_Prefix(ZDOPeer __instance)
{
LimitManager.SetCurrentPlayer(__instance.m_peer.m_uid);
}
[HarmonyPatch("ZDOSectorInvalidated")]
[HarmonyPostfix]
private static void CreateSyncList_Postfix()
{
LimitManager.SetCurrentPlayer(0L);
}
}
[BepInPlugin("render_limits", "Render Limits", "1.14")]
public class RenderLimits : BaseUnityPlugin
{
private const string GUID = "render_limits";
private const string NAME = "Render Limits";
private const string VERSION = "1.14";
public void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Configuration.Init(((BaseUnityPlugin)this).Config);
new Harmony("render_limits").PatchAll();
}
}
[HarmonyPatch(typeof(GraphicsSettingsManager), "ApplyQualitySettings")]
public class ApplyQualitySettings
{
private static void Postfix()
{
Configuration.InitSettings();
}
}
[HarmonyPatch(typeof(Terminal), "InitTerminal")]
public class SetCommands
{
private static void Postfix()
{
new ForceActiveCommand();
}
}
}
