using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCThirdPerson;
using Microsoft.CodeAnalysis;
using ModelReplacement.AvatarBodyUpdater;
using MoreCompany.Cosmetics;
using UnityEngine;
using UnityEngine.Pool;
using _3rdPerson.Helper;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ModelReplacementAPI")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("https://github.com/BunyaPineTree/LethalCompany_ModelReplacementAPI")]
[assembly: AssemblyProduct("meow.ModelReplacementAPI")]
[assembly: AssemblyCopyright("Copyright © meow 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6390E70C-AB5E-42ED-BA29-F173942DC3A9")]
[assembly: AssemblyFileVersion("1.5.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.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 ModelReplacement
{
public abstract class BodyReplacementBase : MonoBehaviour
{
public bool renderLocalDebug = false;
public bool renderBase = false;
public bool renderModel = false;
protected GameObject replacementModel;
protected GameObject deadBody = null;
protected GameObject replacementDeadBody = null;
private MeshRenderer nameTagObj = null;
private MeshRenderer nameTagObj2 = null;
private bool moreCompanyCosmeticsReparented = false;
private static readonly string[] shaderPrefixWhitelist = new string[5] { "HDRP/", "GUI/", "Sprites/", "UI/", "Unlit/" };
private bool localPlayer => (ulong)StartOfRound.Instance.thisClientPlayerId == controller.playerClientId;
public AvatarUpdater avatar { get; private set; }
public PlayerControllerB controller { get; private set; }
public string suitName { get; set; } = "";
public AvatarUpdater ragdollAvatar { get; private set; }
protected abstract GameObject LoadAssetsAndReturnModel();
protected virtual void AddModelScripts()
{
}
private void Awake()
{
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0201: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Unknown result type (might be due to invalid IL or missing references)
controller = ((Component)this).GetComponent<PlayerControllerB>();
ModelReplacementAPI.Instance.Logger.LogInfo((object)("Awake " + controller.playerUsername));
replacementModel = LoadAssetsAndReturnModel();
if ((Object)(object)replacementModel == (Object)null)
{
ModelReplacementAPI.Instance.Logger.LogFatal((object)"LoadAssetsAndReturnModel() returned null. Verify that your assetbundle works and your asset name is correct. ");
}
Renderer[] componentsInChildren = replacementModel.GetComponentsInChildren<Renderer>();
Material sharedMaterial = ((Renderer)((Component)controller.thisPlayerModel).GetComponent<SkinnedMeshRenderer>()).sharedMaterial;
sharedMaterial = new Material(sharedMaterial);
Dictionary<Material, Material> dictionary = new Dictionary<Material, Material>();
List<Material> list = CollectionPool<List<Material>, Material>.Get();
Renderer[] array = componentsInChildren;
foreach (Renderer val in array)
{
val.GetSharedMaterials(list);
for (int j = 0; j < list.Count; j++)
{
Material val2 = list[j];
if (!dictionary.TryGetValue(val2, out var value))
{
value = (dictionary[val2] = GetReplacementMaterial(sharedMaterial, val2));
}
list[j] = value;
}
val.SetMaterials(list);
}
CollectionPool<List<Material>, Material>.Release(list);
try
{
AddModelScripts();
}
catch (Exception ex)
{
ModelReplacementAPI.Instance.Logger.LogError((object)("Could not set all model scripts.\n Error: " + ex.Message));
}
replacementModel = Object.Instantiate<GameObject>(replacementModel);
GameObject obj = replacementModel;
((Object)obj).name = ((Object)obj).name + "(" + controller.playerUsername + ")";
SetRenderers(enabled: false);
replacementModel.transform.localPosition = new Vector3(0f, 0f, 0f);
replacementModel.SetActive(true);
Bounds bounds = ((Renderer)controller.thisPlayerModel).bounds;
Vector3 extents = ((Bounds)(ref bounds)).extents;
float y = extents.y;
bounds = GetBounds();
float num = y / ((Bounds)(ref bounds)).extents.y;
Transform transform = replacementModel.transform;
transform.localScale *= num;
avatar = new AvatarUpdater();
ragdollAvatar = new AvatarUpdater();
avatar.AssignModelReplacement(((Component)controller).gameObject, replacementModel);
MeshRenderer[] componentsInChildren2 = ((Component)controller).gameObject.GetComponentsInChildren<MeshRenderer>();
nameTagObj = componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "LevelSticker").First();
nameTagObj2 = componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "BetaBadge").First();
ModelReplacementAPI.Instance.Logger.LogInfo((object)("AwakeEnd " + controller.playerUsername));
AfterAwake();
}
private void Update()
{
if (!renderLocalDebug)
{
if (RenderBodyReplacement())
{
SetRenderers(enabled: true);
((Renderer)controller.thisPlayerModel).enabled = false;
((Renderer)controller.thisPlayerModelLOD1).enabled = false;
((Renderer)controller.thisPlayerModelLOD2).enabled = false;
((Renderer)nameTagObj).enabled = false;
((Renderer)nameTagObj2).enabled = false;
}
else
{
SetRenderers(enabled: false);
}
}
else
{
SkinnedMeshRenderer[] componentsInChildren = ((Component)controller).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
Renderer val = (Renderer)(object)componentsInChildren[i];
val.enabled = renderBase;
}
SetRenderers(renderModel);
}
GameObject val2 = null;
try
{
val2 = ((Component)controller.deadBody).gameObject;
}
catch
{
}
if (Object.op_Implicit((Object)(object)val2) && (Object)(object)replacementDeadBody == (Object)null)
{
CreateAndParentRagdoll(controller.deadBody);
}
if (Object.op_Implicit((Object)(object)replacementDeadBody) && (Object)(object)val2 == (Object)null)
{
Object.Destroy((Object)(object)replacementDeadBody);
replacementDeadBody = null;
}
avatar.UpdateModel();
ragdollAvatar.UpdateModel();
AttemptReparentMoreCompanyCosmetics();
AfterUpdate();
}
private void OnDestroy()
{
ModelReplacementAPI.Instance.Logger.LogInfo((object)("Destroy body component for " + controller.playerUsername));
((Renderer)controller.thisPlayerModel).enabled = true;
((Renderer)controller.thisPlayerModelLOD1).enabled = true;
((Renderer)controller.thisPlayerModelLOD2).enabled = true;
((Renderer)nameTagObj).enabled = true;
((Renderer)nameTagObj2).enabled = true;
AttemptUnparentMoreCompanyCosmetics();
Object.Destroy((Object)(object)replacementModel);
Object.Destroy((Object)(object)replacementDeadBody);
}
protected virtual Material GetReplacementMaterial(Material gameMaterial, Material modelMaterial)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
if (shaderPrefixWhitelist.Any((string prefix) => ((Object)modelMaterial.shader).name.StartsWith(prefix)))
{
return modelMaterial;
}
Material val = new Material(gameMaterial);
val.color = modelMaterial.color;
val.mainTexture = modelMaterial.mainTexture;
val.mainTextureOffset = modelMaterial.mainTextureOffset;
val.mainTextureScale = modelMaterial.mainTextureScale;
val.SetShaderKeywords(modelMaterial.GetShaderKeywords());
val.SetEnabledKeywords(modelMaterial.GetEnabledKeywords());
return val;
}
private void CreateAndParentRagdoll(DeadBodyInfo bodyinfo)
{
deadBody = ((Component)bodyinfo).gameObject;
SkinnedMeshRenderer componentInChildren = deadBody.GetComponentInChildren<SkinnedMeshRenderer>();
replacementDeadBody = Object.Instantiate<GameObject>(replacementModel);
GameObject obj = replacementDeadBody;
((Object)obj).name = ((Object)obj).name + "(Ragdoll)";
ragdollAvatar.AssignModelReplacement(deadBody, replacementDeadBody);
Renderer[] componentsInChildren = replacementDeadBody.GetComponentsInChildren<Renderer>();
foreach (Renderer val in componentsInChildren)
{
val.enabled = true;
}
((Renderer)componentInChildren).enabled = false;
GameObject[] bodyBloodDecals = bodyinfo.bodyBloodDecals;
foreach (GameObject val2 in bodyBloodDecals)
{
Transform parent = val2.transform.parent;
Transform avatarTransformFromBoneName = ragdollAvatar.GetAvatarTransformFromBoneName(((Object)parent).name);
if (Object.op_Implicit((Object)(object)avatarTransformFromBoneName))
{
Object.Instantiate<GameObject>(val2, avatarTransformFromBoneName);
}
}
}
private void SetRenderers(bool enabled)
{
Renderer[] componentsInChildren = replacementModel.GetComponentsInChildren<Renderer>();
foreach (Renderer val in componentsInChildren)
{
val.enabled = enabled;
}
}
public bool RenderBodyReplacement()
{
if (!localPlayer)
{
return true;
}
if (ModelReplacementAPI.thirdPersonPresent)
{
return DangerousViewState();
}
if (ModelReplacementAPI.LCthirdPersonPresent)
{
return DangerousLCViewState();
}
return false;
}
private Bounds GetBounds()
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
Bounds result = default(Bounds);
IEnumerable<Bounds> source = from r in replacementModel.GetComponentsInChildren<SkinnedMeshRenderer>()
select ((Renderer)r).bounds;
Bounds val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.x).First();
float x2 = ((Bounds)(ref val)).max.x;
val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.y).First();
float y = ((Bounds)(ref val)).max.y;
val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.z).First();
float z = ((Bounds)(ref val)).max.z;
val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.x).First();
float x3 = ((Bounds)(ref val)).min.x;
val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.y).First();
float y2 = ((Bounds)(ref val)).min.y;
val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.z).First();
float z2 = ((Bounds)(ref val)).min.z;
((Bounds)(ref result)).SetMinMax(new Vector3(x3, y2, z2), new Vector3(z, y, z));
return result;
}
private bool DangerousViewState()
{
return ThirdPersonCamera.ViewState;
}
private bool DangerousLCViewState()
{
return ThirdPersonPlugin.Instance.Enabled;
}
private void AttemptUnparentMoreCompanyCosmetics()
{
if (ModelReplacementAPI.moreCompanyPresent && moreCompanyCosmeticsReparented)
{
DangerousUnparent();
}
}
private void AttemptReparentMoreCompanyCosmetics()
{
if (ModelReplacementAPI.moreCompanyPresent && !moreCompanyCosmeticsReparented)
{
DangerousParent();
}
}
private void DangerousUnparent()
{
CosmeticApplication[] componentsInChildren = ((Component)controller).gameObject.GetComponentsInChildren<CosmeticApplication>();
if (!componentsInChildren.Any())
{
return;
}
CosmeticApplication[] array = componentsInChildren;
foreach (CosmeticApplication val in array)
{
foreach (CosmeticInstance spawnedCosmetic in val.spawnedCosmetics)
{
((Component)spawnedCosmetic).transform.parent = null;
}
moreCompanyCosmeticsReparented = false;
}
}
private void DangerousParent()
{
CosmeticApplication[] componentsInChildren = ((Component)controller).gameObject.GetComponentsInChildren<CosmeticApplication>();
if (componentsInChildren.Any())
{
CosmeticApplication[] array = componentsInChildren;
foreach (CosmeticApplication val in array)
{
Transform avatarTransformFromBoneName = avatar.GetAvatarTransformFromBoneName("spine.004");
Transform avatarTransformFromBoneName2 = avatar.GetAvatarTransformFromBoneName("spine.003");
Transform avatarTransformFromBoneName3 = avatar.GetAvatarTransformFromBoneName("arm.R_lower");
Transform avatarTransformFromBoneName4 = avatar.GetAvatarTransformFromBoneName("spine");
Transform avatarTransformFromBoneName5 = avatar.GetAvatarTransformFromBoneName("shin.L");
Transform avatarTransformFromBoneName6 = avatar.GetAvatarTransformFromBoneName("shin.R");
val.head = avatarTransformFromBoneName;
val.chest = avatarTransformFromBoneName2;
val.lowerArmRight = avatarTransformFromBoneName3;
val.hip = avatarTransformFromBoneName4;
val.shinLeft = avatarTransformFromBoneName5;
val.shinRight = avatarTransformFromBoneName6;
val.RefreshAllCosmeticPositions();
moreCompanyCosmeticsReparented = true;
}
Console.WriteLine(" reparent done");
}
}
protected virtual void AfterStart()
{
}
private void Start()
{
AfterStart();
}
protected virtual void AfterAwake()
{
}
protected virtual void AfterUpdate()
{
}
}
public static class PluginInfo
{
public const string GUID = "meow.ModelReplacementAPI";
public const string NAME = "ModelReplacementAPI";
public const string VERSION = "1.5.0";
public const string WEBSITE = "https://github.com/BunyaPineTree/LethalCompany_ModelReplacementAPI";
}
[BepInPlugin("meow.ModelReplacementAPI", "ModelReplacementAPI", "1.5.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class ModelReplacementAPI : BaseUnityPlugin
{
[HarmonyPatch(typeof(GrabbableObject))]
public class LocateHeldObjectsOnModelReplacementPatch
{
[HarmonyPatch("LateUpdate")]
[HarmonyPostfix]
public static void LateUpdatePatch(ref GrabbableObject __instance)
{
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)__instance.parentObject == (Object)null) && !((Object)(object)__instance.playerHeldBy == (Object)null))
{
BodyReplacementBase component = ((Component)__instance.playerHeldBy).gameObject.GetComponent<BodyReplacementBase>();
if (!((Object)(object)component == (Object)null) && component.RenderBodyReplacement() && (!component.renderLocalDebug || component.renderModel))
{
Transform itemHolder = component.avatar.itemHolder;
itemHolder.localPosition = component.avatar.itemHolderPositionOffset;
((Component)__instance).transform.rotation = itemHolder.rotation * component.avatar.itemHolderRotationOffset;
((Component)__instance).transform.Rotate(__instance.itemProperties.rotationOffset);
((Component)__instance).transform.position = itemHolder.position;
Vector3 positionOffset = __instance.itemProperties.positionOffset;
positionOffset = itemHolder.rotation * positionOffset;
Transform transform = ((Component)__instance).transform;
transform.position += positionOffset;
}
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
public class RepairBrokenBodyReplacementsPatch
{
[HarmonyPatch("ReviveDeadPlayers")]
[HarmonyPostfix]
public static void ReviveDeadPlayersPatch(ref StartOfRound __instance)
{
PlayerControllerB[] allPlayerScripts = __instance.allPlayerScripts;
foreach (PlayerControllerB val in allPlayerScripts)
{
if (val.isPlayerDead && !((Object)(object)((Component)val).gameObject.GetComponent<BodyReplacementBase>() == (Object)null))
{
Console.WriteLine("Reinstantiating model replacement for " + val.playerUsername + " ");
Type type = ((object)((Component)val).gameObject.GetComponent<BodyReplacementBase>()).GetType();
Object.Destroy((Object)(object)((Component)val).gameObject.GetComponent<BodyReplacementBase>());
((Component)val).gameObject.AddComponent(type);
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
public class SetRegisteredBodyReplacements
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
public static void UpdatePatch(ref PlayerControllerB __instance)
{
try
{
if (__instance.playerSteamId == 0)
{
return;
}
if (RegisteredModelReplacementOverride != null)
{
SetPlayerModelReplacement(__instance, RegisteredModelReplacementOverride);
return;
}
int currentSuitID = __instance.currentSuitID;
string unlockableName = StartOfRound.Instance.unlockablesList.unlockables[currentSuitID].unlockableName;
unlockableName = unlockableName.ToLower().Replace(" ", "");
if (RegisteredModelReplacements.ContainsKey(unlockableName))
{
Type type = RegisteredModelReplacements[unlockableName];
SetPlayerModelReplacement(__instance, type);
}
else
{
RemovePlayerModelReplacement(__instance);
}
}
catch (Exception)
{
}
}
}
public static bool moreCompanyPresent;
public static bool thirdPersonPresent;
public static bool LCthirdPersonPresent;
public static ModelReplacementAPI Instance;
public ManualLogSource Logger;
private static Dictionary<string, Type> RegisteredModelReplacements = new Dictionary<string, Type>();
private static Type RegisteredModelReplacementOverride = null;
private void Awake()
{
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
Logger = Logger.CreateLogSource("meow.ModelReplacementAPI");
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
moreCompanyPresent = Chainloader.PluginInfos.ContainsKey("me.swipez.melonloader.morecompany");
thirdPersonPresent = Chainloader.PluginInfos.ContainsKey("verity.3rdperson");
LCthirdPersonPresent = Chainloader.PluginInfos.ContainsKey("LCThirdPerson");
Harmony val = new Harmony("meow.ModelReplacementAPI");
val.PatchAll();
Logger.LogInfo((object)"Plugin meow.ModelReplacementAPI is loaded!");
}
public static void RegisterModelReplacementOverride(Type type)
{
if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
{
Instance.Logger.LogError((object)$"Cannot register body replacement override type {type.GetType()}, must inherit from BodyReplacementBase");
return;
}
if (RegisteredModelReplacementOverride != null)
{
Instance.Logger.LogError((object)$"Cannot register body replacement override, already registered to {RegisteredModelReplacementOverride.GetType()}.");
return;
}
Instance.Logger.LogInfo((object)$"Registering body replacement override type {type.GetType()}.");
RegisteredModelReplacementOverride = type;
}
public static void RegisterSuitModelReplacement(string suitNameToReplace, Type type)
{
suitNameToReplace = suitNameToReplace.ToLower().Replace(" ", "");
if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
{
Instance.Logger.LogError((object)$"Cannot register body replacement type {type.GetType()}, must inherit from BodyReplacementBase");
return;
}
if (RegisteredModelReplacements.ContainsKey(suitNameToReplace))
{
Instance.Logger.LogError((object)$"Cannot register body replacement type {type.GetType()}, suit name to replace {suitNameToReplace} is already registered.");
return;
}
Instance.Logger.LogInfo((object)$"Registering body replacement type {type.GetType()} to suit name {suitNameToReplace}.");
RegisteredModelReplacements.Add(suitNameToReplace, type);
}
public static void SetPlayerModelReplacement(PlayerControllerB player, Type type)
{
if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
{
Instance.Logger.LogError((object)("Cannot set body replacement of type " + type.Name + ", must inherit from BodyReplacementBase"));
return;
}
BodyReplacementBase component = ((Component)player.thisPlayerBody).gameObject.GetComponent<BodyReplacementBase>();
int currentSuitID = player.currentSuitID;
string unlockableName = StartOfRound.Instance.unlockablesList.unlockables[currentSuitID].unlockableName;
if ((Object)(object)component != (Object)null)
{
if (((object)component).GetType() == type)
{
if (!(component.suitName != unlockableName))
{
return;
}
Console.WriteLine("Suit name mismatch " + component.suitName + " =/ " + unlockableName + ", Destroying");
Object.Destroy((Object)(object)component);
}
else
{
Object.Destroy((Object)(object)component);
}
}
BodyReplacementBase bodyReplacementBase = ((Component)player.thisPlayerBody).gameObject.AddComponent(type) as BodyReplacementBase;
bodyReplacementBase.suitName = unlockableName;
}
public static void RemovePlayerModelReplacement(PlayerControllerB player)
{
BodyReplacementBase component = ((Component)player.thisPlayerBody).gameObject.GetComponent<BodyReplacementBase>();
if (Object.op_Implicit((Object)(object)component))
{
Object.Destroy((Object)(object)component);
}
}
public static void RefreshAllModelReplacements()
{
}
}
}
namespace ModelReplacement.AvatarBodyUpdater
{
public class AvatarUpdater
{
private SkinnedMeshRenderer playerModelRenderer = null;
private Animator replacementAnimator = null;
private bool hasUpperChest = false;
private Vector3 rootPositionOffset = new Vector3(0f, 0f, 0f);
private Vector3 rootScale = new Vector3(1f, 1f, 1f);
private static Dictionary<string, HumanBodyBones> modelToAvatarBone = new Dictionary<string, HumanBodyBones>
{
{
"spine",
(HumanBodyBones)0
},
{
"spine.001",
(HumanBodyBones)7
},
{
"shoulder.L",
(HumanBodyBones)11
},
{
"arm.L_upper",
(HumanBodyBones)13
},
{
"arm.L_lower",
(HumanBodyBones)15
},
{
"hand.L",
(HumanBodyBones)17
},
{
"finger5.L",
(HumanBodyBones)36
},
{
"finger5.L.001",
(HumanBodyBones)37
},
{
"finger4.L",
(HumanBodyBones)33
},
{
"finger4.L.001",
(HumanBodyBones)34
},
{
"finger3.L",
(HumanBodyBones)30
},
{
"finger3.L.001",
(HumanBodyBones)31
},
{
"finger2.L",
(HumanBodyBones)27
},
{
"finger2.L.001",
(HumanBodyBones)28
},
{
"finger1.L",
(HumanBodyBones)24
},
{
"finger1.L.001",
(HumanBodyBones)26
},
{
"shoulder.R",
(HumanBodyBones)12
},
{
"arm.R_upper",
(HumanBodyBones)14
},
{
"arm.R_lower",
(HumanBodyBones)16
},
{
"hand.R",
(HumanBodyBones)18
},
{
"finger5.R",
(HumanBodyBones)51
},
{
"finger5.R.001",
(HumanBodyBones)52
},
{
"finger4.R",
(HumanBodyBones)48
},
{
"finger4.R.001",
(HumanBodyBones)49
},
{
"finger3.R",
(HumanBodyBones)45
},
{
"finger3.R.001",
(HumanBodyBones)46
},
{
"finger2.R",
(HumanBodyBones)42
},
{
"finger2.R.001",
(HumanBodyBones)43
},
{
"finger1.R",
(HumanBodyBones)39
},
{
"finger1.R.001",
(HumanBodyBones)41
},
{
"spine.004",
(HumanBodyBones)10
},
{
"thigh.L",
(HumanBodyBones)1
},
{
"shin.L",
(HumanBodyBones)3
},
{
"foot.L",
(HumanBodyBones)5
},
{
"toe.L",
(HumanBodyBones)19
},
{
"thigh.R",
(HumanBodyBones)2
},
{
"shin.R",
(HumanBodyBones)4
},
{
"foot.R",
(HumanBodyBones)6
},
{
"toe.R",
(HumanBodyBones)20
}
};
public Vector3 itemHolderPositionOffset { get; private set; } = Vector3.zero;
public Quaternion itemHolderRotationOffset { get; private set; } = Quaternion.identity;
public Transform itemHolder { get; private set; } = null;
public void AssignModelReplacement(GameObject player, GameObject replacement)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB component = player.GetComponent<PlayerControllerB>();
if (Object.op_Implicit((Object)(object)component))
{
playerModelRenderer = component.thisPlayerModel;
}
else
{
playerModelRenderer = player.GetComponentInChildren<SkinnedMeshRenderer>();
}
if ((Object)(object)playerModelRenderer == (Object)null)
{
Console.WriteLine("failed to start AvatarBodyUpdater");
return;
}
replacementAnimator = replacement.GetComponentInChildren<Animator>();
OffsetBuilder component2 = ((Component)replacementAnimator).gameObject.GetComponent<OffsetBuilder>();
itemHolderPositionOffset = component2.itemPositonOffset;
itemHolderRotationOffset = component2.itemRotationOffset;
itemHolder = component2.itemHolder.transform;
rootPositionOffset = component2.rootPositionOffset;
rootScale = component2.rootScale;
Transform boneTransform = replacementAnimator.GetBoneTransform((HumanBodyBones)54);
hasUpperChest = (Object)(object)boneTransform != (Object)null;
}
public bool CanUpdateModel()
{
if ((Object)(object)playerModelRenderer == (Object)null)
{
return false;
}
if ((Object)(object)replacementAnimator == (Object)null)
{
return false;
}
return true;
}
public void UpdateModel()
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
if (!CanUpdateModel())
{
return;
}
Transform[] bones = playerModelRenderer.bones;
foreach (Transform val in bones)
{
Transform avatarTransformFromBoneName = GetAvatarTransformFromBoneName(((Object)val).name);
if (!((Object)(object)avatarTransformFromBoneName == (Object)null))
{
avatarTransformFromBoneName.rotation = val.rotation;
RotationOffset component = ((Component)avatarTransformFromBoneName).GetComponent<RotationOffset>();
if (Object.op_Implicit((Object)(object)component))
{
avatarTransformFromBoneName.rotation *= component.offset;
}
if (((Object)val).name == "spine" || ((Object)val).name.Contains("PlayerRagdoll"))
{
avatarTransformFromBoneName.position = val.position;
avatarTransformFromBoneName.position += val.TransformVector(rootPositionOffset);
}
}
}
}
public Transform GetAvatarTransformFromBoneName(string boneName)
{
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
if (boneName == "spine.002")
{
if (hasUpperChest)
{
return replacementAnimator.GetBoneTransform((HumanBodyBones)8);
}
return null;
}
if (boneName == "spine.003")
{
if (hasUpperChest)
{
return replacementAnimator.GetBoneTransform((HumanBodyBones)54);
}
return replacementAnimator.GetBoneTransform((HumanBodyBones)8);
}
if (boneName.Contains("PlayerRagdoll"))
{
return replacementAnimator.GetBoneTransform((HumanBodyBones)0);
}
if (modelToAvatarBone.ContainsKey(boneName))
{
return replacementAnimator.GetBoneTransform(modelToAvatarBone[boneName]);
}
return null;
}
}
public class RotationOffset : MonoBehaviour
{
public Quaternion offset = Quaternion.identity;
}
public class OffsetBuilder : MonoBehaviour
{
public Vector3 rootPositionOffset;
public Vector3 rootScale;
public Vector3 itemPositonOffset;
public Quaternion itemRotationOffset;
public GameObject itemHolder;
public Transform rootTransform;
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
