using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCTransition;
using LethalExpansionCore.Utils;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using ThiccCompany.Replacements;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;
[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("ModelReplacementAPI")]
[assembly: IgnoresAccessChecksTo("UnityEngine")]
[assembly: AssemblyCompany("LCTransition")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Allows MTF transitioning in Lethal Company")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("LCTransition")]
[assembly: AssemblyTitle("LCTransition")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
static <Module>()
{
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkData>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<NetworkData>();
}
}
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 LCTransition
{
[BepInPlugin("LCTransition", "LCTransition", "1.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public static Dictionary<string, Type> FemModels = new Dictionary<string, Type>();
public static ManualLogSource logger;
private void Awake()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin LCTransition is loaded!");
Harmony val = new Harmony("LCTransition");
Assembly executingAssembly = Assembly.GetExecutingAssembly();
val.PatchAll();
NetcodeWeaver();
OverrideThiccCompanyConfig();
SceneManager.sceneLoaded += OnSceneLoaded;
logger = ((BaseUnityPlugin)this).Logger;
}
private void NetcodeWeaver()
{
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);
}
}
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
CustomiseBlahajSettings();
}
private void OverrideThiccCompanyConfig()
{
foreach (var (key, type2) in ModelReplacementAPI.RegisteredModelReplacements)
{
if (type2.Assembly == typeof(DefaultOrangeReplacement).Assembly)
{
FemModels.Add(key, type2);
}
}
ModelReplacementAPI.RegisteredModelReplacements.Clear();
ModelReplacementAPI.RegisteredModelReplacementDefault = null;
ModelReplacementAPI.RegisteredModelReplacementExceptions.Clear();
ModelReplacementAPI.RegisteredModelReplacementOverride = null;
}
private void CustomiseBlahajSettings()
{
if (AssetGather.Instance.scraps.ContainsKey("blahaj"))
{
AssetGather.Instance.scraps["blahaj"].twoHanded = true;
}
}
}
public struct NetworkData : IEquatable<NetworkData>, INetworkSerializable
{
public ulong steamId;
public bool feminised;
public NetworkData(ulong steamId)
{
feminised = false;
this.steamId = steamId;
}
public bool Equals(NetworkData other)
{
return steamId == other.steamId && feminised == other.feminised;
}
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
//IL_000b: 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_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)
((BufferSerializer<ulong>*)(&serializer))->SerializeValue<ulong>(ref steamId, default(ForPrimitives));
((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref feminised, default(ForPrimitives));
}
}
public struct ServerData
{
public ulong steamId;
public int feminisationLevels;
public ServerData(ulong steamId)
{
feminisationLevels = 0;
this.steamId = steamId;
}
}
public class NetworkHandler : NetworkBehaviour
{
private const int FEMINISATION_THRESHOLD = 5400;
public NetworkList<NetworkData> networkData = new NetworkList<NetworkData>();
public Dictionary<ulong, ServerData> serverData = new Dictionary<ulong, ServerData>();
private Type defaultFemModel;
public static NetworkHandler Instance { get; private set; }
public void Awake()
{
defaultFemModel = typeof(DefaultOrangeReplacement);
foreach (Type value in Plugin.FemModels.Values)
{
ModelReplacementAPI.RegisterModelReplacementException(value);
}
}
public override void OnNetworkSpawn()
{
if ((NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer) && (Object)(object)Instance != (Object)null)
{
((Component)Instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
Load();
}
private IDictionary<ulong, int> getNetworkDataIndexesBySteamId()
{
Dictionary<ulong, int> dictionary = new Dictionary<ulong, int>();
for (int i = 0; i < networkData.Count; i++)
{
dictionary[networkData[i].steamId] = i;
}
return dictionary;
}
public void Update()
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
IDictionary<ulong, int> networkDataIndexesBySteamId = getNetworkDataIndexesBySteamId();
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (!networkDataIndexesBySteamId.ContainsKey(val.playerSteamId))
{
NetworkData networkData = new NetworkData(val.playerSteamId);
this.networkData.Add(networkData);
networkDataIndexesBySteamId[val.playerSteamId] = this.networkData.Count - 1;
}
if (!serverData.ContainsKey(val.playerSteamId))
{
serverData[val.playerSteamId] = new ServerData(val.playerSteamId);
}
int num = networkDataIndexesBySteamId[val.playerSteamId];
GrabbableObject currentlyHeldObjectServer = val.currentlyHeldObjectServer;
if (!val.isPlayerDead && (Object)(object)currentlyHeldObjectServer != (Object)null && ((Object)currentlyHeldObjectServer.itemProperties).name == "blahaj")
{
ServerData value = serverData[val.playerSteamId];
value.feminisationLevels++;
serverData[val.playerSteamId] = value;
}
if (val.isPlayerDead)
{
NetworkData networkData2 = this.networkData[num];
networkData2.feminised = false;
this.networkData[num] = networkData2;
ServerData value2 = serverData[val.playerSteamId];
value2.feminisationLevels = 0;
serverData[val.playerSteamId] = value2;
}
if (!val.isPlayerDead && val.isPlayerAlone)
{
NetworkData networkData3 = this.networkData[num];
if (serverData[val.playerSteamId].feminisationLevels >= 5400)
{
networkData3.feminised = true;
this.networkData[num] = networkData3;
}
}
}
}
PlayerControllerB[] array3 = array;
BodyReplacementBase val4 = default(BodyReplacementBase);
foreach (PlayerControllerB val2 in array3)
{
int num2 = networkDataIndexesBySteamId[val2.playerSteamId];
if (this.networkData[num2].feminised)
{
UnlockableItem val3 = StartOfRound.Instance.unlockablesList.unlockables[val2.currentSuitID];
Type type = defaultFemModel;
string key = val3.unlockableName.ToLower().Replace(" ", "");
bool flag = Plugin.FemModels.ContainsKey(key);
if (flag)
{
type = Plugin.FemModels[key];
}
ModelReplacementAPI.SetPlayerModelReplacement(val2, type);
if (!flag && ModelReplacementAPI.GetPlayerModelReplacement(val2, ref val4))
{
((Renderer)val4.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).material = val3.suitMaterial;
((Renderer)val4.replacementModelShadow.GetComponentInChildren<SkinnedMeshRenderer>()).material = val3.suitMaterial;
((Renderer)val4.replacementViewModel.GetComponentInChildren<SkinnedMeshRenderer>()).material = val3.suitMaterial;
if ((Object)(object)val4.replacementDeadBody != (Object)null)
{
((Renderer)val4.replacementDeadBody.GetComponentInChildren<SkinnedMeshRenderer>()).material = val3.suitMaterial;
}
}
}
else
{
ModelReplacementAPI.RemovePlayerModelReplacement(val2);
}
}
}
public void Save()
{
GameNetworkManager instance = GameNetworkManager.Instance;
if (instance.isHostingGame)
{
ES3.Save<Dictionary<ulong, ServerData>>("LCTransition_ServerData", serverData, instance.currentSaveFileName);
}
}
public void Load()
{
GameNetworkManager instance = GameNetworkManager.Instance;
if (!instance.isHostingGame)
{
return;
}
serverData = ES3.Load<Dictionary<ulong, ServerData>>("LCTransition_ServerData", instance.currentSaveFileName, new Dictionary<ulong, ServerData>());
IDictionary<ulong, int> networkDataIndexesBySteamId = getNetworkDataIndexesBySteamId();
foreach (KeyValuePair<ulong, ServerData> serverDatum in serverData)
{
bool flag = serverDatum.Value.feminisationLevels >= 5400;
Plugin.logger.LogInfo((object)string.Format("Player {0} has feminisation level {1} and {2} feminised", serverDatum.Key, serverDatum.Value.feminisationLevels, flag ? "is" : "isn't"));
if (networkDataIndexesBySteamId.ContainsKey(serverDatum.Key))
{
int num = networkDataIndexesBySteamId[serverDatum.Key];
NetworkData networkData = this.networkData[num];
networkData.feminised = flag;
this.networkData[num] = networkData;
}
else
{
this.networkData.Add(new NetworkData
{
steamId = serverDatum.Key,
feminised = flag
});
}
}
}
public override void OnDestroy()
{
Instance = null;
((NetworkBehaviour)this).OnDestroy();
}
protected override void __initializeVariables()
{
if (networkData == null)
{
throw new Exception("NetworkHandler.networkData cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)networkData).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)networkData, "networkData");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)networkData);
((NetworkBehaviour)this).__initializeVariables();
}
protected internal override string __getTypeName()
{
return "NetworkHandler";
}
}
[HarmonyPatch]
public class NetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
if (!((Object)(object)networkPrefab != (Object)null))
{
AssetBundle val = AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("LCTransition.Resources.transitionassets"));
networkPrefab = (GameObject)val.LoadAsset("TransitionNetworkHandler");
networkPrefab.AddComponent<NetworkHandler>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//IL_0036: 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)
if ((NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer) && !((Object)(object)networkPrefab == (Object)null))
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "SaveGame")]
private static void Save()
{
NetworkHandler.Instance.Save();
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LCTransition";
public const string PLUGIN_NAME = "LCTransition";
public const string PLUGIN_VERSION = "1.1.0";
}
}
namespace LCTransition.Properties
{
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
ResourceManager resourceManager = new ResourceManager("LCTransition.Properties.Resources", typeof(Resources).Assembly);
resourceMan = resourceManager;
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal static byte[] transitionassets
{
get
{
object @object = ResourceManager.GetObject("transitionassets", resourceCulture);
return (byte[])@object;
}
}
internal Resources()
{
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
