using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JLL.Components;
using JLLConfigurator.Modules;
using JLLConfigurator.Patches;
using JLLConfigurator.Utils;
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: AssemblyCompany("Tomatobird.JLLConfigurator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+987f5271c313ec1e8838e19ec65fa5832c997a62")]
[assembly: AssemblyProduct("JLLConfigurator")]
[assembly: AssemblyTitle("Tomatobird.JLLConfigurator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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 JLLConfigurator
{
[BepInPlugin("Tomatobird.JLLConfigurator", "JLLConfigurator", "0.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class JLLConfigurator : BaseUnityPlugin
{
internal static JRandomPropPlacerModule jRandomPropPlacerModule;
internal static ConfigFile config;
public static JLLConfigurator Instance { get; private set; }
internal static ManualLogSource Logger { get; private set; }
internal static Harmony? Harmony { get; set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
config = ((BaseUnityPlugin)this).Config;
jRandomPropPlacerModule = new JRandomPropPlacerModule(((BaseUnityPlugin)this).Config);
Patch();
Logger.LogInfo((object)"Tomatobird.JLLConfigurator v0.1.0 has loaded!");
}
internal static void Patch()
{
//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: Expected O, but got Unknown
if (Harmony == null)
{
Harmony = new Harmony("Tomatobird.JLLConfigurator");
}
Logger.LogDebug((object)"Patching...");
jRandomPropPlacerModule.TryPatch(Harmony, typeof(JRandomPropPlacerPatcher));
Logger.LogDebug((object)"Finished patching!");
}
internal static void Unpatch()
{
Logger.LogDebug((object)"Unpatching...");
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Logger.LogDebug((object)"Finished unpatching!");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "Tomatobird.JLLConfigurator";
public const string PLUGIN_NAME = "JLLConfigurator";
public const string PLUGIN_VERSION = "0.1.0";
}
}
namespace JLLConfigurator.Utils
{
internal class CurveUtil
{
internal static AnimationCurve CreateCurve(string s)
{
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Expected O, but got Unknown
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
string[] array = s.Split(';');
if (array.Length == 1 && float.TryParse(array[0], out var result))
{
return AnimationCurve.Constant(0f, 1f, result);
}
List<Keyframe> list = new List<Keyframe>();
string[] array2 = array;
foreach (string text in array2)
{
string[] array3 = text.Split(",");
if (array3.Length == 2)
{
string s2 = array3[0].Trim();
string s3 = array3[1].Trim();
if (float.TryParse(s2, out var result2) && float.TryParse(s3, out var result3))
{
list.Add(new Keyframe(result2, result3));
}
}
else if (array3.Length == 6)
{
string s4 = array3[0].Trim();
string s5 = array3[1].Trim();
string s6 = array3[2].Trim();
string s7 = array3[3].Trim();
string s8 = array3[4].Trim();
string s9 = array3[5].Trim();
if (float.TryParse(s4, out var result4) && float.TryParse(s5, out var result5) && float.TryParse(s6, out var result6) && float.TryParse(s7, out var result7) && float.TryParse(s8, out var result8) && float.TryParse(s9, out var result9))
{
list.Add(new Keyframe(result4, result5, result6, result7, result8, result9));
}
}
}
return new AnimationCurve(list.ToArray());
}
internal static string CurveToString(AnimationCurve curve)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
List<string> list = new List<string>();
if (curve == null || curve.length == 0)
{
return "";
}
Keyframe[] keys = curve.keys;
for (int i = 0; i < keys.Length; i++)
{
Keyframe val = keys[i];
string item = $"{((Keyframe)(ref val)).time},{((Keyframe)(ref val)).value},{((Keyframe)(ref val)).inTangent},{((Keyframe)(ref val)).outTangent},{((Keyframe)(ref val)).inWeight},{((Keyframe)(ref val)).outWeight};";
list.Add(item);
}
string text = "";
foreach (string item2 in list)
{
text += item2;
}
return text.TrimEnd(';');
}
}
}
namespace JLLConfigurator.Patches
{
[HarmonyPatch(typeof(JRandomPropPlacer))]
internal class JRandomPropPlacerPatcher
{
[HarmonyPatch("SpawnProps")]
[HarmonyPrefix]
internal static bool SpawnProps_Prefix(JRandomPropPlacer __instance)
{
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
if (JLLConfigurator.jRandomPropPlacerModule.DisableSpawning.Value)
{
JLLConfigurator.Logger.LogInfo((object)"JRandomPropPlacer blocked from spawnning props.");
return false;
}
if (__instance.spawnableProps == null)
{
return true;
}
SpawnableProp[] spawnableProps = __instance.spawnableProps;
foreach (SpawnableProp val in spawnableProps)
{
if (val != null && !((Object)(object)val.prefabToSpawn == (Object)null))
{
if (!JRandomPropPlacerModule.ConfigCache.TryGetValue(((Object)val.prefabToSpawn).name, out JRandomPropPlacerModule.PropSetSettings value))
{
JLLConfigurator.Logger.LogDebug((object)("Generating configs for " + ((Object)val.prefabToSpawn).name));
value = new JRandomPropPlacerModule.PropSetSettings(JLLConfigurator.config, val);
JRandomPropPlacerModule.ConfigCache.Add(((Object)val.prefabToSpawn).name, value);
}
val.randomAmount = CurveUtil.CreateCurve(value.randomAmount.Value);
val.prefabWidth = value.prefabWidth.Value;
val.spawnRotation = value.spawnRotation.Value;
val.spawnFlushAgainstWall = value.spawnFlushAgainstWall.Value;
val.distanceFromEntrances = value.distanceFromEntrances.Value;
val.distanceBetweenSpawns = value.distanceBetweenSpawns.Value;
val.randomSpawnRange = value.randomSpawnRange.Value;
}
}
return true;
}
}
}
namespace JLLConfigurator.Modules
{
internal abstract class ConfigModule
{
public ConfigEntry<bool> Enabled;
public string Name { get; }
internal ConfigModule(ConfigFile config, string moduleName)
{
Name = moduleName;
Enabled = config.Bind<bool>("General", "Enable" + moduleName + "Config", true, "Enable configuration of " + moduleName + "?");
BindSettings(config);
}
internal abstract void BindSettings(ConfigFile config);
public void TryPatch(Harmony harmony, Type patchClass)
{
if (Enabled.Value)
{
JLLConfigurator.Logger.LogDebug((object)("Patching " + patchClass.Name));
harmony.PatchAll(patchClass);
}
}
}
internal class JRandomPropPlacerModule : ConfigModule
{
internal class PropSetSettings
{
public ConfigEntry<string> randomAmount;
public ConfigEntry<float> prefabWidth;
public ConfigEntry<SpawnRotation> spawnRotation;
public ConfigEntry<bool> spawnFlushAgainstWall;
public ConfigEntry<float> distanceFromEntrances;
public ConfigEntry<float> distanceBetweenSpawns;
public ConfigEntry<float> randomSpawnRange;
public PropSetSettings(ConfigFile config, SpawnableProp prop)
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
string text = "JRandomPropPlacer.Prop." + ((Object)prop.prefabToSpawn).name;
randomAmount = config.Bind<string>(text, "RandomAmount", CurveUtil.CurveToString(prop.randomAmount), "The randomizer curve used to randomize how many props should spawn. Values are evaluated from 0 to 1. Ex: 0,5 ; 0.5,5 ; 1,10 for a curve with first half flat at value 5 then linear increase to value 15 on other half. You can type in a single constant value as well. Ex: 10 You can also define in/out tangets and weights for each key like so: 0.4,0.2,1.1,2,0.4,0.6 (Check Keyframe declaration in unity documentation!)");
prefabWidth = config.Bind<float>(text, "PrefabWidth", prop.prefabWidth, "Define width of the prefab.");
spawnRotation = config.Bind<SpawnRotation>(text, "SpawnRotation", prop.spawnRotation, "Define spawn rotation.");
spawnFlushAgainstWall = config.Bind<bool>(text, "SpawnFlushAgainstWall", prop.spawnFlushAgainstWall, "Should prop spawn flush against wall?");
distanceFromEntrances = config.Bind<float>(text, "DistanceFromEntrances", prop.distanceFromEntrances, "Define distance from entrances.");
distanceBetweenSpawns = config.Bind<float>(text, "DistanceBetweenSpawns", prop.distanceBetweenSpawns, "Define distance between sapawns.");
randomSpawnRange = config.Bind<float>(text, "RandomSpawnRange", prop.randomSpawnRange, "Define random spawn range.");
}
}
public static Dictionary<string, PropSetSettings> ConfigCache = new Dictionary<string, PropSetSettings>();
public ConfigEntry<bool> DisableSpawning { get; private set; } = null;
public JRandomPropPlacerModule(ConfigFile config)
: base(config, "JRandomPropPlacer")
{
}
internal override void BindSettings(ConfigFile config)
{
DisableSpawning = config.Bind<bool>(base.Name, "DisableSpawning", false, "Should JRandomPropPlacer be allowed to spawn objects? Setting this on effectively disables JRandomPropPlacer.");
}
}
}
