using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using CleaningCompany.Misc;
using CleaningCompany.Monos;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
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("SellBodies")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SellBodies")]
[assembly: AssemblyTitle("SellBodies")]
[assembly: AssemblyVersion("1.0.0.0")]
internal class <Module>
{
static <Module>()
{
}
}
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;
}
}
}
namespace CleaningCompany
{
[BepInPlugin("malco.sell_bodies", "Sell Bodies", "1.0.0")]
[BepInDependency("evaisa.lethallib", "0.10.0")]
public class Plugin : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("malco.sell_bodies");
private const string GUID = "malco.sell_bodies";
private const string NAME = "Sell Bodies";
private const string VERSION = "1.0.0";
private static string root = "Assets/CleaningAssets/";
private Dictionary<string, int> minBodyValues;
private Dictionary<string, bool> BodiesToDrop;
private Dictionary<string, int> maxBodyValues;
private Dictionary<string, float> bodyWeights;
private Dictionary<string, string> pathToName = new Dictionary<string, string>
{
{
root + "HoarderItem.asset",
"Hoarding bug"
},
{
root + "SpiderItem.asset",
"Bunker Spider"
},
{
root + "ThumperItem.asset",
"Crawler"
},
{
root + "CentipedeItem.asset",
"Centipede"
},
{
root + "NutcrackerItem.asset",
"Nutcracker"
},
{
root + "BrackenBodyItem.asset",
"Flowerman"
},
{
root + "BaboonItem.asset",
"Baboon hawk"
},
{
root + "MouthDogItem.asset",
"MouthDog"
}
};
public Dictionary<string, Item> BodySpawns = new Dictionary<string, Item>();
public List<GameObject> tools = new List<GameObject>();
private AssetBundle bundle;
public static Plugin instance;
public static PluginConfig cfg { get; private set; }
private void Awake()
{
cfg = new PluginConfig(((BaseUnityPlugin)this).Config);
cfg.InitBindings();
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "sellbodies");
bundle = AssetBundle.LoadFromFile(text);
instance = this;
ApplyConfig();
SetupScrap();
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Sell Bodies is patched!");
}
private void ApplyConfig()
{
bodyWeights = new Dictionary<string, float>
{
{
root + "HoarderItem.asset",
cfg.HOARDER_WEIGHT
},
{
root + "SpiderItem.asset",
cfg.SPIDER_WEIGHT
},
{
root + "ThumperItem.asset",
cfg.THUMPER_WEIGHT
},
{
root + "NutcrackerItem.asset",
cfg.NUTCRACKER_WEIGHT
},
{
root + "CentipedeItem.asset",
cfg.CENTIPEDE_WEIGHT
},
{
root + "BrackenBodyItem.asset",
cfg.BRACKEN_WEIGHT
},
{
root + "BaboonItem.asset",
cfg.BABOON_WEIGHT
},
{
root + "MouthDogItem.asset",
cfg.MOUTHDOG_WEIGHT
}
};
maxBodyValues = new Dictionary<string, int>
{
{
root + "HoarderItem.asset",
cfg.HOARDER_MAX
},
{
root + "SpiderItem.asset",
cfg.SPIDER_MAX
},
{
root + "ThumperItem.asset",
cfg.THUMPER_MAX
},
{
root + "NutcrackerItem.asset",
cfg.NUTCRACKER_MAX
},
{
root + "CentipedeItem.asset",
cfg.CENTIPEDE_MAX
},
{
root + "BrackenBodyItem.asset",
cfg.BRACKEN_MAX
},
{
root + "BaboonItem.asset",
cfg.BABOON_MAX
},
{
root + "MouthDogItem.asset",
cfg.MOUTHDOG_MAX
}
};
minBodyValues = new Dictionary<string, int>
{
{
root + "HoarderItem.asset",
cfg.HOARDER_MIN
},
{
root + "SpiderItem.asset",
cfg.SPIDER_MIN
},
{
root + "ThumperItem.asset",
cfg.THUMPER_MIN
},
{
root + "NutcrackerItem.asset",
cfg.NUTCRACKER_MIN
},
{
root + "CentipedeItem.asset",
cfg.CENTIPEDE_MIN
},
{
root + "BrackenBodyItem.asset",
cfg.BRACKEN_MIN
},
{
root + "BaboonItem.asset",
cfg.BABOON_MIN
},
{
root + "MouthDogItem.asset",
cfg.MOUTHDOG_MIN
}
};
BodiesToDrop = new Dictionary<string, bool>
{
{
root + "HoarderItem.asset",
cfg.HOARDER
},
{
root + "SpiderItem.asset",
cfg.SPIDER
},
{
root + "ThumperItem.asset",
cfg.THUMPER
},
{
root + "NutcrackerItem.asset",
cfg.NUTCRACKER
},
{
root + "CentipedeItem.asset",
cfg.CENTIPEDE
},
{
root + "BrackenBodyItem.asset",
cfg.BRACKEN
},
{
root + "BaboonItem.asset",
cfg.BABOON
},
{
root + "MouthDogItem.asset",
cfg.MOUTHDOG
}
};
}
private void SetupScrap()
{
foreach (KeyValuePair<string, string> item in pathToName)
{
Item val = bundle.LoadAsset<Item>(item.Key);
Utilities.FixMixerGroups(val.spawnPrefab);
val.twoHanded = true;
val.spawnPrefab.AddComponent<BodySyncer>();
val.maxValue = maxBodyValues[item.Key];
val.minValue = minBodyValues[item.Key];
val.weight = bodyWeights[item.Key];
NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
Items.RegisterItem(val);
if (BodiesToDrop[item.Key])
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Set " + item.Value + " to drop " + val.itemName));
BodySpawns.Add(item.Value, val);
}
else
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Disregarding " + val.itemName + " - disabled in config"));
}
}
}
}
}
namespace CleaningCompany.Patches
{
[HarmonyPatch(typeof(EnemyAI))]
internal class EnemyAIPatcher
{
private static ulong currentEnemy = 9999999uL;
[HarmonyPostfix]
[HarmonyPatch("KillEnemyServerRpc")]
private static void SpawnScrapBody(EnemyAI __instance)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
if (currentEnemy != ((NetworkBehaviour)__instance).NetworkObject.NetworkObjectId && ((NetworkBehaviour)__instance).IsHost)
{
currentEnemy = ((NetworkBehaviour)__instance).NetworkObject.NetworkObjectId;
string enemyName = __instance.enemyType.enemyName;
if (Plugin.instance.BodySpawns.ContainsKey(enemyName))
{
GameObject val = Object.Instantiate<GameObject>(Plugin.instance.BodySpawns[enemyName].spawnPrefab, ((Component)__instance).transform.position + Vector3.up, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
((Component)__instance).GetComponent<NetworkObject>().Despawn(true);
}
}
}
}
}
namespace CleaningCompany.Monos
{
internal class BodySyncer : NetworkBehaviour
{
public override void OnNetworkSpawn()
{
if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
{
((MonoBehaviour)this).StartCoroutine(WaitToSync());
}
((NetworkBehaviour)this).OnNetworkSpawn();
}
private IEnumerator WaitToSync()
{
yield return (object)new WaitForSeconds(1f);
PhysicsProp prop = ((Component)this).GetComponent<PhysicsProp>();
int price = Random.Range(((GrabbableObject)prop).itemProperties.minValue, ((GrabbableObject)prop).itemProperties.maxValue);
SyncDetailsClientRpc(price, new NetworkBehaviourReference((NetworkBehaviour)(object)prop));
}
[ClientRpc]
private void SyncDetailsClientRpc(int price, NetworkBehaviourReference netRef)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1512427331u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, price);
((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1512427331u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
PhysicsProp val3 = default(PhysicsProp);
((NetworkBehaviourReference)(ref netRef)).TryGet<PhysicsProp>(ref val3, (NetworkManager)null);
if ((Object)(object)val3 != (Object)null)
{
((GrabbableObject)val3).scrapValue = price;
((GrabbableObject)val3).itemProperties.creditsWorth = price;
((Component)val3).GetComponentInChildren<ScanNodeProperties>().subText = $"Value: ${price}";
Debug.Log((object)"Successfully synced body values");
}
else
{
Debug.LogError((object)"Failed to resolve network reference!");
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_BodySyncer()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(1512427331u, new RpcReceiveHandler(__rpc_handler_1512427331));
}
private static void __rpc_handler_1512427331(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//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_0042: 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_0060: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int price = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref price);
NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
target.__rpc_exec_stage = (__RpcExecStage)2;
((BodySyncer)(object)target).SyncDetailsClientRpc(price, netRef);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "BodySyncer";
}
}
}
namespace CleaningCompany.Misc
{
public class PluginConfig
{
private readonly ConfigFile configFile;
public bool SPIDER { get; set; }
public bool THUMPER { get; set; }
public bool NUTCRACKER { get; set; }
public bool CENTIPEDE { get; set; }
public bool HOARDER { get; set; }
public bool BRACKEN { get; set; }
public bool MOUTHDOG { get; set; }
public bool BABOON { get; set; }
public int SPIDER_MIN { get; set; }
public int THUMPER_MIN { get; set; }
public int NUTCRACKER_MIN { get; set; }
public int CENTIPEDE_MIN { get; set; }
public int HOARDER_MIN { get; set; }
public int BRACKEN_MIN { get; set; }
public int MOUTHDOG_MIN { get; set; }
public int BABOON_MIN { get; set; }
public int NUTCRACKER_MAX { get; set; }
public int SPIDER_MAX { get; set; }
public int THUMPER_MAX { get; set; }
public int CENTIPEDE_MAX { get; set; }
public int HOARDER_MAX { get; set; }
public int BRACKEN_MAX { get; set; }
public int MOUTHDOG_MAX { get; set; }
public int BABOON_MAX { get; set; }
public float NUTCRACKER_WEIGHT { get; set; }
public float SPIDER_WEIGHT { get; set; }
public float THUMPER_WEIGHT { get; set; }
public float CENTIPEDE_WEIGHT { get; set; }
public float HOARDER_WEIGHT { get; set; }
public float BRACKEN_WEIGHT { get; set; }
public float MOUTHDOG_WEIGHT { get; set; }
public float BABOON_WEIGHT { get; set; }
public PluginConfig(ConfigFile cfg)
{
configFile = cfg;
}
private T ConfigEntry<T>(string section, string key, T defaultVal, string description)
{
return configFile.Bind<T>(section, key, defaultVal, description).Value;
}
public void InitBindings()
{
CENTIPEDE_MIN = ConfigEntry("Body Values", "Min price of Centipede Bodies", 45, "");
CENTIPEDE_MAX = ConfigEntry("Body Values", "Max price of Centipede Bodies", 70, "");
HOARDER_MIN = ConfigEntry("Body Values", "Min price of Hoarding Bug Bodies", 55, "");
HOARDER_MAX = ConfigEntry("Body Values", "Max price of Hoarding Bug Bodies", 88, "");
SPIDER_MIN = ConfigEntry("Body Values", "Min price of Spider Bodies", 70, "");
SPIDER_MAX = ConfigEntry("Body Values", "Max price of Spider Bodies", 110, "");
THUMPER_MIN = ConfigEntry("Body Values", "Min price of Thumper Bodies", 120, "");
THUMPER_MAX = ConfigEntry("Body Values", "Max price of Thumper Bodies", 160, "");
NUTCRACKER_MIN = ConfigEntry("Body Values", "Min price of Nutcracker Bodies", 125, "");
NUTCRACKER_MAX = ConfigEntry("Body Values", "Max price of Nutcracker Bodies", 150, "");
BRACKEN_MAX = ConfigEntry("Body Values", "Max price of Bracken Bodies", 140, "");
BRACKEN_MIN = ConfigEntry("Body Values", "Min price of Bracken Bodies", 100, "");
BRACKEN_MAX = ConfigEntry("Body Values", "Max price of Baboon Hawk Bodies", 155, "");
BABOON_MIN = ConfigEntry("Body Values", "Min price of Baboon Hawk Bodies", 105, "");
MOUTHDOG_MAX = ConfigEntry("Body Values", "Max price of Eyeless Dog Bodies", 200, "");
MOUTHDOG_MIN = ConfigEntry("Body Values", "Min price of Eyeless Dog Bodies", 175, "");
CENTIPEDE = ConfigEntry("Body Weights", "Enable selling of centipede bodies", defaultVal: true, "");
HOARDER = ConfigEntry("Body Weights", "Enable selling of hoarder bodies", defaultVal: true, "");
SPIDER = ConfigEntry("Body Weights", "Enable selling of spider bodies", defaultVal: true, "");
THUMPER = ConfigEntry("Body Weights", "Enable selling of crawler / half / thumper bodies", defaultVal: true, "");
NUTCRACKER = ConfigEntry("Body Weights", "Enable selling of nutcracker bodies", defaultVal: true, "");
MOUTHDOG = ConfigEntry("Body Weights", "Enable selling of eyeless dog bodies", defaultVal: true, "");
BABOON = ConfigEntry("Body Weights", "Enable selling of baboon hawk bodies", defaultVal: true, "");
BRACKEN = ConfigEntry("Body Weights", "Enable selling of bracken bodies", defaultVal: true, "");
CENTIPEDE_WEIGHT = ConfigEntry("Body Weights", "Weight of Centipede Bodies", 1.65f, "");
HOARDER_WEIGHT = ConfigEntry("Body Weights", "Weight of Hoarding Bug Bodies", 1.6f, "");
SPIDER_WEIGHT = ConfigEntry("Body Weights", "Weight of Spider Bodies", 2.3f, "");
THUMPER_WEIGHT = ConfigEntry("Body Weights", "Weight of Thumper Bodies", 2.9f, "");
NUTCRACKER_WEIGHT = ConfigEntry("Body Weights", "Weight of Nutcracker Bodies", 2.9f, "");
MOUTHDOG_WEIGHT = ConfigEntry("Body Weights", "Weight of Eyeless Dog Bodies", 3f, "");
BABOON_WEIGHT = ConfigEntry("Body Weights", "Weight of Baboon Hawk Bodies", 2.5f, "");
BRACKEN_WEIGHT = ConfigEntry("Body Weights", "Weight of Bracken Bodies", 1.9f, "");
}
}
}
