using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BoneLib;
using BoneLib.BoneMenu;
using DestructibleAvatar;
using DestructibleAvatar.FusionModule;
using DestructibleAvatar.FusionModule.Messages;
using HarmonyLib;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Interaction;
using Il2CppSLZ.VRMK;
using LabFusion.Entities;
using LabFusion.Network;
using LabFusion.Network.Serialization;
using LabFusion.Player;
using LabFusion.SDK.Modules;
using LabFusion.Utilities;
using MelonLoader;
using MelonLoader.Preferences;
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: MelonInfo(typeof(Core), "DestructibleAvatar", "1.0.0", "notnotnotswipez", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("DestructibleAvatar")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DestructibleAvatar")]
[assembly: AssemblyTitle("DestructibleAvatar")]
[assembly: NeutralResourcesLanguage("en-US")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace DestructibleAvatar
{
public enum SettingsControlMode
{
HOST,
CLIENT
}
public class Core : MelonMod
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static ServerEvent <>9__4_2;
internal void <OnInitializeMelon>b__4_2()
{
shouldAcceptExternalDetachments.SetServerOverride(overrideEnabled: false, overrideValue: false);
}
}
public static ServerStateOverrideSetting shouldAcceptExternalDetachments = new ServerStateOverrideSetting();
public static MelonPreferences_Category mainCategory = MelonPreferences.CreateCategory("DestructibleAvatar");
public static MelonPreferences_Entry<SettingsControlMode> settingsControlMode = mainCategory.CreateEntry<SettingsControlMode>("SettingsControlMode", SettingsControlMode.CLIENT, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
public static MelonPreferences_Entry<bool> shouldAcceptExternalDetachmentsSetting = mainCategory.CreateEntry<bool>("ShouldAcceptExternalDetachments", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
public override void OnInitializeMelon()
{
//IL_000b: 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_004a: 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_00a1: Expected O, but got Unknown
//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_008a: Expected O, but got Unknown
Page val = Page.Root.CreatePage("Destructible Avatar", Color.green, 0, true);
val.CreateEnum("Settings Mode", Color.yellow, (Enum)settingsControlMode.Value, (Action<Enum>)delegate(Enum v)
{
settingsControlMode.Value = (SettingsControlMode)(object)v;
BroadcastServerSetting();
mainCategory.SaveToFile(false);
});
val.CreateBool("Accept Detachment Requests", Color.yellow, shouldAcceptExternalDetachmentsSetting.Value, (Action<bool>)delegate(bool v)
{
shouldAcceptExternalDetachmentsSetting.Value = v;
BroadcastServerSetting();
shouldAcceptExternalDetachments.SetLocal(v);
mainCategory.SaveToFile(false);
});
object obj = <>c.<>9__4_2;
if (obj == null)
{
ServerEvent val2 = delegate
{
shouldAcceptExternalDetachments.SetServerOverride(overrideEnabled: false, overrideValue: false);
};
<>c.<>9__4_2 = val2;
obj = (object)val2;
}
MultiplayerHooking.OnDisconnected += (ServerEvent)obj;
MultiplayerHooking.OnPlayerJoined += (PlayerUpdate)delegate
{
BroadcastServerSetting();
};
ModuleManager.RegisterModule<DestructibleAvatarModule>();
}
public void BroadcastServerSetting()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (NetworkInfo.HasServer && NetworkInfo.IsHost)
{
DestructibleServerSettingMessageData destructibleServerSettingMessageData = new DestructibleServerSettingMessageData
{
serverOverrideActive = (settingsControlMode.Value == SettingsControlMode.HOST),
serverSetting = shouldAcceptExternalDetachmentsSetting.Value
};
MessageRelay.RelayModule<DestructibleServerSettingMessageHandler, DestructibleServerSettingMessageData>(destructibleServerSettingMessageData, CommonMessageRoutes.ReliableToOtherClients);
}
}
}
[RegisterTypeInIl2Cpp]
public class DestructiblePerson : MonoBehaviour
{
private Transform emptyRigMatch;
private RigManager rigManager;
private bool onRig = false;
private Transform physicsRig;
public BodyPart leftShoulder;
public BodyPart leftForearm;
public BodyPart leftHand;
public BodyPart rightShoulder;
public BodyPart rightForearm;
public BodyPart rightHand;
public BodyPart chest;
public BodyPart spine;
public BodyPart head;
public BodyPart leftThigh;
public BodyPart leftKnee;
public BodyPart leftFoot;
public BodyPart rightThigh;
public BodyPart rightKnee;
public BodyPart rightFoot;
private bool leftLegMissing = false;
private bool rightLegMissing = false;
private bool checkDetachments = false;
public float upperStrengthMult = 1f;
public float jointStrengthMult = 1f;
public bool completeSettingsOverride = false;
public float massChestOverride = 1f;
public float massPelvisOverride = 1f;
public float massHeadOverride = 1f;
public float massArmOverride = 1f;
public float massLegOverride = 1f;
public float strengthUpperOverride = 1f;
public float strengthLowerOverride = 1f;
public float intelligenceOverride = 1f;
public float vitalityOverride = 1f;
public float agilityOverride = 1f;
public float speedOverride = 1f;
public static Dictionary<int, DestructiblePerson> rigToPersonCache = new Dictionary<int, DestructiblePerson>();
private Rigidbody pelvisBody;
private Vector3 lastPelvisVelocity;
private Dictionary<ConfigurableJoint, BodyPart> jointToCheckWithPart = new Dictionary<ConfigurableJoint, BodyPart>();
private List<BodyPart> allBodyParts = new List<BodyPart>();
private byte playerId = 0;
public void SetCompleteSettingOverride(bool settingOverride)
{
completeSettingsOverride = settingOverride;
}
public void SetMassChestOverride(float mass)
{
massChestOverride = mass;
}
public void SetMassPelvisOverride(float mass)
{
massPelvisOverride = mass;
}
public void SetMassHeadOverride(float mass)
{
massHeadOverride = mass;
}
public void SetMassArmOverride(float mass)
{
massArmOverride = mass;
}
public void SetMassLegOverride(float mass)
{
massLegOverride = mass;
}
public void SetStrengthUpperOverride(float strength)
{
strengthUpperOverride = strength;
}
public void SetStrengthLowerOverride(float strength)
{
strengthLowerOverride = strength;
}
public void SetIntelligenceOverride(float intelligence)
{
intelligenceOverride = intelligence;
}
public void SetVitalityOverride(float vitality)
{
vitalityOverride = vitality;
}
public void SetAgilityOverride(float agility)
{
agilityOverride = agility;
}
public void SetSpeedOverride(float speed)
{
speedOverride = speed;
}
private void CreateParts()
{
leftShoulder = new BodyPart(0, "ShoulderLf", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/Cylinder", "ShoulderLf");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/Cylinder", "ShoulderLf");
});
leftForearm = new BodyPart(1, "ElbowLf", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/l_Arm_Elbow_CurveSHJnt/Cylinder", "ElbowLf");
Transform val4 = ((Component)physicsRig).transform.Find("ElbowLf/BodyLogSlot");
if (Object.op_Implicit((Object)(object)val4))
{
((Component)val4).gameObject.SetActive(false);
}
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/l_Arm_Elbow_CurveSHJnt/Cylinder", "ElbowLf");
Transform val3 = ((Component)physicsRig).transform.Find("ElbowLf/BodyLogSlot");
if (Object.op_Implicit((Object)(object)val3))
{
((Component)val3).gameObject.SetActive(true);
}
});
leftHand = new BodyPart(2, "Hand (left)", emptyRigMatch, delegate(GameObject go)
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/l_Arm_Elbow_CurveSHJnt/l_WristSHJnt/l_Hand_1SHJnt/Cylinder", "Hand (left)");
MakeFakeHandJoint(rigManager.physicsRig.leftHand, go);
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/l_Arm_ClavicleSHJnt/l_AC_AuxSHJnt/l_Arm_ShoulderSHJnt/l_Arm_Elbow_CurveSHJnt/l_WristSHJnt/l_Hand_1SHJnt/Cylinder", "Hand (left)");
});
rightShoulder = new BodyPart(3, "ShoulderRt", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/Cylinder", "ShoulderRt");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/Cylinder", "ShoulderRt");
});
rightForearm = new BodyPart(4, "ElbowRt", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/r_Arm_Elbow_CurveSHJnt/Cylinder", "ElbowRt");
Transform val2 = ((Component)physicsRig).transform.Find("ElbowRt/BodyLogSlot");
if (Object.op_Implicit((Object)(object)val2))
{
((Component)val2).gameObject.SetActive(false);
}
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/r_Arm_Elbow_CurveSHJnt/Cylinder", "ElbowRt");
Transform val = ((Component)physicsRig).transform.Find("ElbowRt/BodyLogSlot");
if (Object.op_Implicit((Object)(object)val))
{
((Component)val).gameObject.SetActive(true);
}
});
rightHand = new BodyPart(5, "Hand (right)", emptyRigMatch, delegate(GameObject go)
{
DisablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/r_Arm_Elbow_CurveSHJnt/r_WristSHJnt/r_Hand_1SHJnt/Cylinder", "Hand (right)");
MakeFakeHandJoint(rigManager.physicsRig.rightHand, go);
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/r_Arm_ClavicleSHJnt/r_AC_AuxSHJnt/r_Arm_ShoulderSHJnt/r_Arm_Elbow_CurveSHJnt/r_WristSHJnt/r_Hand_1SHJnt/Cylinder", "Hand (right)");
});
chest = new BodyPart(6, "Chest", emptyRigMatch, delegate
{
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder0");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder1");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder2");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder3");
DisablePhysicsPart("Chest");
}, delegate
{
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder0");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder1");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder2");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Cylinder3");
EnablePhysicsPart("Chest");
});
spine = new BodyPart(7, "Spine", emptyRigMatch, delegate
{
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Cylinder");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Cylinder1");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Cylinder");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Cylinder1");
DisablePhysicsPart("Spine");
}, delegate
{
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Cylinder");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Cylinder1");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Cylinder");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Cylinder1");
EnablePhysicsPart("Spine");
});
head = new BodyPart(8, "Head", emptyRigMatch, delegate
{
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Cylinder");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Neck_02SHJnt/Neck_TopSHJnt/Head_TopSHJnt/Cylinder");
DisableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Neck_02SHJnt/Neck_TopSHJnt/Head_JawSHJnt/Cylinder");
DisablePhysicsPart("Head");
}, delegate
{
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Cylinder");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Neck_02SHJnt/Neck_TopSHJnt/Head_TopSHJnt/Cylinder");
EnableVisualPart("MAINSHJnt/ROOTSHJnt/Spine_01SHJnt/Spine_02SHJnt/Spine_TopSHJnt/Neck_01SHJnt/Neck_02SHJnt/Neck_TopSHJnt/Head_JawSHJnt/Cylinder");
EnablePhysicsPart("Head");
});
leftThigh = new BodyPart(9, "HipLf", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/Cylinder", "HipLf");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/Cylinder", "HipLf");
});
leftKnee = new BodyPart(10, "KneeLf", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/l_Leg_KneeSHJnt/Cylinder", "KneeLf");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/l_Leg_KneeSHJnt/Cylinder", "KneeLf");
});
leftFoot = new BodyPart(11, "Foot (left)", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/l_Leg_KneeSHJnt/l_Leg_AnkleSHJnt/Cylinder", "Foot (left)");
leftLegMissing = true;
if (rightLegMissing)
{
DisableRigLegs();
}
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/l_Leg_HipSHJnt/l_Leg_KneeSHJnt/l_Leg_AnkleSHJnt/Cylinder", "Foot (left)");
leftLegMissing = false;
if (!rightLegMissing)
{
EnableRigLegs();
}
});
rightThigh = new BodyPart(12, "HipRt", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/Cylinder", "HipRt");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/Cylinder", "HipRt");
});
rightKnee = new BodyPart(13, "KneeRt", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/r_Leg_KneeSHJnt/Cylinder", "KneeRt");
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/r_Leg_KneeSHJnt/Cylinder", "KneeRt");
});
rightFoot = new BodyPart(14, "Foot (right)", emptyRigMatch, delegate
{
DisablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/r_Leg_KneeSHJnt/r_Leg_AnkleSHJnt/Cylinder", "Foot (right)");
rightLegMissing = true;
if (leftLegMissing)
{
DisableRigLegs();
}
}, delegate
{
EnablePart("MAINSHJnt/ROOTSHJnt/r_Leg_HipSHJnt/r_Leg_KneeSHJnt/r_Leg_AnkleSHJnt/Cylinder", "Foot (right)");
rightLegMissing = false;
if (!leftLegMissing)
{
EnableRigLegs();
}
});
spine.AddChild(chest);
chest.AddChild(leftShoulder);
chest.AddChild(rightShoulder);
chest.AddChild(head);
leftThigh.AddChild(leftKnee);
leftKnee.AddChild(leftFoot);
rightThigh.AddChild(rightKnee);
rightKnee.AddChild(rightFoot);
spine.AddChild(leftThigh);
spine.AddChild(rightThigh);
leftShoulder.AddChild(leftForearm);
leftForearm.AddChild(leftHand);
rightShoulder.AddChild(rightForearm);
rightForearm.AddChild(rightHand);
allBodyParts.Add(head);
allBodyParts.Add(leftShoulder);
allBodyParts.Add(leftForearm);
allBodyParts.Add(leftHand);
allBodyParts.Add(rightShoulder);
allBodyParts.Add(rightForearm);
allBodyParts.Add(rightHand);
allBodyParts.Add(chest);
allBodyParts.Add(spine);
allBodyParts.Add(leftThigh);
allBodyParts.Add(leftKnee);
allBodyParts.Add(leftFoot);
allBodyParts.Add(rightThigh);
allBodyParts.Add(rightKnee);
allBodyParts.Add(rightFoot);
MakeJointWithPart("Head", head);
MakeJointWithPart("ShoulderLf", leftShoulder);
MakeJointWithPart("ElbowLf", leftForearm);
MakeJointWithPart("Hand (left)", leftHand);
MakeJointWithPart("ShoulderRt", rightShoulder);
MakeJointWithPart("ElbowRt", rightForearm);
MakeJointWithPart("Hand (right)", rightHand);
MakeJointWithPart("HipLf", leftThigh);
MakeJointWithPart("KneeLf", leftKnee);
MakeJointWithPart("Foot (left)", leftFoot);
MakeJointWithPart("HipRt", rightThigh);
MakeJointWithPart("KneeRt", rightKnee);
MakeJointWithPart("Foot (right)", rightFoot);
}
public void NetworkDetachment(int id)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
if (NetworkInfo.HasServer)
{
DetachRequestMessageData detachRequestMessageData = new DetachRequestMessageData
{
target = playerId,
limb = (byte)id
};
MessageRelay.RelayModule<DetachRequestMessageHandler, DetachRequestMessageData>(detachRequestMessageData, CommonMessageRoutes.ReliableToOtherClients);
}
}
public void LocalDetachment(int id, bool broadcast = false)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
GetBodyPart(id).Detach();
if (FusionPlayer.IsLocalPlayer(rigManager) && NetworkInfo.HasServer && broadcast)
{
DetachLimbMessageData detachLimbMessageData = new DetachLimbMessageData
{
target = playerId,
limb = (byte)id
};
MessageRelay.RelayModule<DetachLimbMessageHandler, DetachLimbMessageData>(detachLimbMessageData, CommonMessageRoutes.ReliableToOtherClients);
}
}
private void TryHandleLimbDetachmentViaForces(BodyPart bodyPart)
{
if (!bodyPart.detached)
{
if (FusionPlayer.IsLocalPlayer(rigManager))
{
LocalDetachment(bodyPart.id, broadcast: true);
}
else
{
NetworkDetachment(bodyPart.id);
}
}
}
public BodyPart GetBodyPart(int id)
{
for (int i = 0; i < allBodyParts.Count; i++)
{
if (allBodyParts[i].id == id)
{
return allBodyParts[i];
}
}
return null;
}
public void SetUpperStrength(float strength)
{
upperStrengthMult = strength;
}
public void SetJointStrength(float strength)
{
jointStrengthMult = strength;
}
private void MakeJointWithPart(string physicsPart, BodyPart bodyPart)
{
ConfigurableJoint component = ((Component)((Component)physicsRig).transform.Find(physicsPart)).GetComponent<ConfigurableJoint>();
jointToCheckWithPart.Add(component, bodyPart);
}
private void OnDisable()
{
if (Object.op_Implicit((Object)(object)rigManager) && ((Object)Player.RigManager).GetInstanceID() == ((Object)rigManager).GetInstanceID())
{
ReformEntireRig();
}
}
private void CheckVelocityBreakage()
{
//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)
foreach (KeyValuePair<ConfigurableJoint, BodyPart> item in jointToCheckWithPart)
{
BodyPart value = item.Value;
if (!value.detached)
{
Vector3 currentForce = ((Joint)item.Key).currentForce;
float magnitude = ((Vector3)(ref currentForce)).magnitude;
if (magnitude > 2000f * jointStrengthMult)
{
TryHandleLimbDetachmentViaForces(value);
}
}
}
}
private void FixedUpdate()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: 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_001d: 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_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_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
Vector3 velocity = pelvisBody.velocity;
if (!checkDetachments)
{
lastPelvisVelocity = velocity;
return;
}
if (leftLegMissing && rightLegMissing && Object.op_Implicit((Object)(object)rigManager) && !rigManager.physicsRig.legLf.shutdown)
{
DisableRigLegs();
}
CheckVelocityBreakage();
Vector3 val = velocity - lastPelvisVelocity;
float magnitude = ((Vector3)(ref val)).magnitude;
if (magnitude > 5f)
{
TryHandleLimbDetachmentViaForces(leftThigh);
TryHandleLimbDetachmentViaForces(rightThigh);
}
else if (magnitude > 3f)
{
if (Random.Range(0f, 1f) < 0.5f)
{
TryHandleLimbDetachmentViaForces(leftThigh);
}
else
{
TryHandleLimbDetachmentViaForces(rightThigh);
}
}
if (magnitude > 2f)
{
float num = magnitude - 2f;
float num2 = Mathf.InverseLerp(0f, 7f, magnitude) * 2f;
if (((Object)rigManager).GetInstanceID() == ((Object)Player.RigManager).GetInstanceID())
{
rigManager.health.TAKEDAMAGE(num2);
}
}
lastPelvisVelocity = velocity;
}
private void DisableRigLegs()
{
rigManager.physicsRig.RagdollRig();
rigManager.physicsRig.DisableBallLoco();
rigManager.physicsRig.PhysicalLegs();
rigManager.physicsRig.legLf.ShutdownLimb();
rigManager.physicsRig.legRt.ShutdownLimb();
}
private void EnableRigLegs()
{
rigManager.physicsRig.TurnOnRig();
rigManager.physicsRig.UnRagdollRig();
rigManager.physicsRig.EnableBallLoco();
rigManager.physicsRig.KinematicLegs();
}
public void ReformEntireRig()
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
spine.Retach();
checkDetachments = false;
if (NetworkInfo.HasServer && FusionPlayer.IsLocalPlayer(rigManager))
{
ReformAvatarMessageData reformAvatarMessageData = new ReformAvatarMessageData
{
target = playerId
};
MessageRelay.RelayModule<ReformAvatarMessageHandler, ReformAvatarMessageData>(reformAvatarMessageData, CommonMessageRoutes.ReliableToOtherClients);
}
MelonCoroutines.Start(WaitAndStartBreakage());
}
private void MakeFakeHandJoint(Hand targetHand, GameObject go)
{
if (targetHand.HasAttachedObject())
{
Grip val = ((Il2CppObjectBase)targetHand.AttachedReceiver).TryCast<Grip>();
if (Object.op_Implicit((Object)(object)val))
{
Rigidbody componentInParent = ((Component)val).GetComponentInParent<Rigidbody>();
FixedJoint val2 = go.gameObject.AddComponent<FixedJoint>();
((Joint)val2).breakForce = 4000f;
((Joint)val2).connectedBody = componentInParent;
val.ForceDetach(true);
}
}
}
private void Start()
{
emptyRigMatch = ((Component)this).transform.Find("EmptyRigMatch");
rigManager = ((Component)this).GetComponentInParent<RigManager>();
if (Object.op_Implicit((Object)(object)rigManager))
{
onRig = true;
physicsRig = ((Component)rigManager.physicsRig).transform;
CreateParts();
if (!rigToPersonCache.ContainsKey(((Object)rigManager).GetInstanceID()))
{
rigToPersonCache.Add(((Object)rigManager).GetInstanceID(), this);
}
else
{
rigToPersonCache[((Object)rigManager).GetInstanceID()] = this;
}
pelvisBody = ((Component)((Rig)rigManager.physicsRig).m_pelvis).GetComponent<Rigidbody>();
MelonCoroutines.Start(WaitAndStartBreakage());
NetworkPlayer val = default(NetworkPlayer);
if (NetworkInfo.HasServer && NetworkPlayerManager.TryGetPlayer(rigManager, ref val))
{
playerId = val.PlayerID.SmallID;
}
}
}
private void OnEnable()
{
if (onRig && Object.op_Implicit((Object)(object)rigManager))
{
if (!rigToPersonCache.ContainsKey(((Object)rigManager).GetInstanceID()))
{
rigToPersonCache.Add(((Object)rigManager).GetInstanceID(), this);
}
else
{
rigToPersonCache[((Object)rigManager).GetInstanceID()] = this;
}
}
}
private void OnDestroy()
{
if (Object.op_Implicit((Object)(object)rigManager))
{
rigToPersonCache.Remove(((Object)rigManager).GetInstanceID());
}
}
[HideFromIl2Cpp]
private IEnumerator WaitAndStartBreakage()
{
yield return (object)new WaitForSecondsRealtime(10f);
checkDetachments = true;
}
private void DisablePart(string pathFromAvatar, string pathFromPhysicsRig)
{
DisableVisualPart(pathFromAvatar);
DisablePhysicsPart(pathFromPhysicsRig);
}
private void DisableVisualPart(string pathFromAvatar)
{
Transform val = ((Component)this).transform.Find(pathFromAvatar);
if (Object.op_Implicit((Object)(object)val))
{
((Component)val).gameObject.SetActive(false);
}
else
{
MelonLogger.Msg("Failed to find: " + pathFromAvatar);
}
}
private void DisablePhysicsPart(string pathFromPhysicsRig)
{
GameObject gameObject = ((Component)((Component)physicsRig).transform.Find(pathFromPhysicsRig)).gameObject;
foreach (Collider componentsInChild in gameObject.GetComponentsInChildren<Collider>())
{
if (((Component)componentsInChild).gameObject.layer == 8)
{
((Component)componentsInChild).gameObject.layer = 9;
}
}
}
private void EnablePart(string pathFromAvatar, string pathFromPhysicsRig)
{
EnableVisualPart(pathFromAvatar);
EnablePhysicsPart(pathFromPhysicsRig);
}
private void EnableVisualPart(string pathFromAvatar)
{
((Component)((Component)this).transform.Find(pathFromAvatar)).gameObject.SetActive(true);
}
private void EnablePhysicsPart(string pathFromPhysicsRig)
{
GameObject gameObject = ((Component)((Component)physicsRig).transform.Find(pathFromPhysicsRig)).gameObject;
foreach (Collider componentsInChild in gameObject.GetComponentsInChildren<Collider>())
{
if (((Component)componentsInChild).gameObject.layer == 9)
{
((Component)componentsInChild).gameObject.layer = 8;
}
}
}
}
public class BodyPart
{
private List<BodyPart> children = new List<BodyPart>();
private string path;
private Transform physicsCopy;
private Action<GameObject> onDetach;
private Action onReform;
public bool detached = false;
public int id = 0;
public BodyPart(int id, string path, Transform physicsCopy, Action<GameObject> onDetach, Action onReform)
{
this.path = path;
this.physicsCopy = physicsCopy;
this.onDetach = onDetach;
this.onReform = onReform;
this.id = id;
}
public void Detach()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
if (detached)
{
return;
}
GameObject val = new GameObject();
val.SetActive(false);
Link(val.transform);
GameObject val2 = Object.Instantiate<GameObject>(val);
Return(val.transform);
Object.DestroyImmediate((Object)(object)val);
GameObject gameObject = ((Component)val2.transform.Find(path)).gameObject;
foreach (MarrowJoint componentsInChild in gameObject.GetComponentsInChildren<MarrowJoint>())
{
Object.DestroyImmediate((Object)(object)componentsInChild);
}
foreach (ConfigurableJoint componentsInChild2 in gameObject.GetComponentsInChildren<ConfigurableJoint>())
{
Object.DestroyImmediate((Object)(object)componentsInChild2);
}
val2.SetActive(true);
InvokeDetachAction(val2.transform);
}
public void AddChild(BodyPart part)
{
children.Add(part);
}
public void Retach()
{
InvokeRetachAction();
}
private void Link(Transform parent)
{
Transform val = physicsCopy.Find(path);
val.parent = parent;
foreach (BodyPart child in children)
{
child.Link(parent);
}
}
private void InvokeDetachAction(Transform parent)
{
Transform val = parent.Find(path);
onDetach(((Component)val.GetChild(0)).gameObject);
detached = true;
foreach (BodyPart child in children)
{
child.InvokeDetachAction(parent);
}
}
private void InvokeRetachAction()
{
onReform();
detached = false;
foreach (BodyPart child in children)
{
child.InvokeRetachAction();
}
}
private void Return(Transform original)
{
Transform val = original.Find(path);
val.parent = physicsCopy;
foreach (BodyPart child in children)
{
child.Return(original);
}
}
}
[HarmonyPatch(typeof(Hand), "UpdateHovering")]
public class HandHoverPatchPrefix
{
public static bool Prefix(Hand __instance)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Invalid comparison between Unknown and I4
int instanceID = ((Object)Player.RigManager).GetInstanceID();
if (((Object)__instance.manager).GetInstanceID() == instanceID && DestructiblePerson.rigToPersonCache.ContainsKey(instanceID))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[instanceID];
if ((int)__instance.handedness == 1 && destructiblePerson.leftHand.detached)
{
__instance.HoveringReceiver = null;
__instance.farHoveringReciever = null;
return false;
}
if ((int)__instance.handedness == 2 && destructiblePerson.rightHand.detached)
{
__instance.HoveringReceiver = null;
__instance.farHoveringReciever = null;
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(InventorySlotReceiver), "OnHandDrop")]
public class InventorySlotDropPatch
{
public static bool Prefix(IGrippable host)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Invalid comparison between Unknown and I4
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Invalid comparison between Unknown and I4
Hand lastHand = host.GetLastHand();
if (!Object.op_Implicit((Object)(object)lastHand))
{
return true;
}
if (DestructiblePerson.rigToPersonCache.ContainsKey(((Object)lastHand.manager).GetInstanceID()))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[((Object)lastHand.manager).GetInstanceID()];
if ((int)lastHand.handedness == 1 && destructiblePerson.leftHand.detached)
{
return false;
}
if ((int)lastHand.handedness == 2 && destructiblePerson.rightHand.detached)
{
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(HeadSFX), "DeathVocal")]
public class HeadSFXPatchPrefix
{
public static void Prefix(HeadSFX __instance)
{
if (DestructiblePerson.rigToPersonCache.ContainsKey(((Object)((Rig)__instance._physRig).manager).GetInstanceID()))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[((Object)((Rig)__instance._physRig).manager).GetInstanceID()];
destructiblePerson.ReformEntireRig();
}
}
}
[HarmonyPatch(typeof(Avatar), "ComputeBaseStats")]
public class ComputeStatsPostfix
{
public static void Postfix(Avatar __instance)
{
DestructiblePerson component = ((Component)__instance).GetComponent<DestructiblePerson>();
if (Object.op_Implicit((Object)(object)component))
{
if (!component.completeSettingsOverride)
{
__instance._strengthUpper *= component.upperStrengthMult;
return;
}
__instance._strengthUpper = component.strengthUpperOverride;
__instance._strengthLower = component.strengthLowerOverride;
__instance._vitality = component.vitalityOverride;
__instance._intelligence = component.intelligenceOverride;
__instance._speed = component.speedOverride;
__instance._agility = component.agilityOverride;
__instance._massArm = component.massArmOverride;
__instance._massLeg = component.massLegOverride;
__instance._massChest = component.massChestOverride;
__instance._massHead = component.massHeadOverride;
__instance._massPelvis = component.massPelvisOverride;
}
}
}
[HarmonyPatch(typeof(LocalRagdoll), "Knockout", new Type[]
{
typeof(float),
typeof(bool)
})]
public class LocalRagdollPostfix
{
public static void Postfix()
{
if (DestructiblePerson.rigToPersonCache.ContainsKey(((Object)Player.RigManager).GetInstanceID()))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[((Object)Player.RigManager).GetInstanceID()];
destructiblePerson.ReformEntireRig();
}
}
}
}
namespace DestructibleAvatar.FusionModule
{
internal class DestructibleAvatarModule : Module
{
public override string Name => "DestructibleAvatar";
public override string Author => "notnotnotswipez";
public override Version Version => new Version("1.0.0");
public override ConsoleColor Color => ConsoleColor.Yellow;
protected override void OnModuleRegistered()
{
ModuleMessageManager.RegisterHandler<DestructibleServerSettingMessageHandler>();
ModuleMessageManager.RegisterHandler<DetachLimbMessageHandler>();
ModuleMessageManager.RegisterHandler<DetachRequestMessageHandler>();
ModuleMessageManager.RegisterHandler<ReformAvatarMessageHandler>();
}
protected override void OnModuleUnregistered()
{
}
}
public class ServerStateOverrideSetting
{
private bool localSetting = false;
private bool serverOverride = false;
private bool serverSetting = false;
public bool ShouldProceed()
{
if (NetworkInfo.HasServer && serverOverride)
{
return serverSetting;
}
return localSetting;
}
public bool GetLocal()
{
return localSetting;
}
public void SetLocal(bool value)
{
localSetting = value;
}
public void SetServerOverride(bool overrideEnabled, bool overrideValue)
{
serverOverride = overrideEnabled;
serverSetting = overrideValue;
}
}
}
namespace DestructibleAvatar.FusionModule.Messages
{
public class DestructibleServerSettingMessageData : INetSerializable
{
public bool serverOverrideActive;
public bool serverSetting;
public void Serialize(INetSerializer serializer)
{
serializer.SerializeValue(ref serverOverrideActive);
serializer.SerializeValue(ref serverSetting);
}
}
public class DestructibleServerSettingMessageHandler : ModuleMessageHandler
{
protected override void OnHandleMessage(ReceivedMessage received)
{
DestructibleServerSettingMessageData destructibleServerSettingMessageData = ((ReceivedMessage)(ref received)).ReadData<DestructibleServerSettingMessageData>();
if (!NetworkInfo.IsHost)
{
Core.shouldAcceptExternalDetachments.SetServerOverride(destructibleServerSettingMessageData.serverOverrideActive, destructibleServerSettingMessageData.serverSetting);
}
}
}
public class DetachRequestMessageData : INetSerializable
{
public byte target;
public byte limb;
public void Serialize(INetSerializer serializer)
{
serializer.SerializeValue(ref target);
serializer.SerializeValue(ref limb);
}
}
public class DetachRequestMessageHandler : ModuleMessageHandler
{
protected override void OnHandleMessage(ReceivedMessage received)
{
DetachRequestMessageData detachRequestMessageData = ((ReceivedMessage)(ref received)).ReadData<DetachRequestMessageData>();
if (detachRequestMessageData.target == PlayerIDManager.LocalID.SmallID && Core.shouldAcceptExternalDetachments.ShouldProceed())
{
int instanceID = ((Object)Player.RigManager).GetInstanceID();
if (DestructiblePerson.rigToPersonCache.ContainsKey(instanceID))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[instanceID];
destructiblePerson.LocalDetachment(detachRequestMessageData.limb, broadcast: true);
}
}
}
}
public class DetachLimbMessageData : INetSerializable
{
public byte target;
public byte limb;
public void Serialize(INetSerializer serializer)
{
serializer.SerializeValue(ref target);
serializer.SerializeValue(ref limb);
}
}
public class DetachLimbMessageHandler : ModuleMessageHandler
{
protected override void OnHandleMessage(ReceivedMessage received)
{
DetachLimbMessageData detachLimbMessageData = ((ReceivedMessage)(ref received)).ReadData<DetachLimbMessageData>();
NetworkPlayer val = default(NetworkPlayer);
if (NetworkPlayerManager.TryGetPlayer(detachLimbMessageData.target, ref val))
{
int instanceID = ((Object)val.RigRefs.RigManager).GetInstanceID();
if (DestructiblePerson.rigToPersonCache.ContainsKey(instanceID))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[instanceID];
destructiblePerson.LocalDetachment(detachLimbMessageData.limb);
}
}
}
}
public class ReformAvatarMessageData : INetSerializable
{
public byte target;
public void Serialize(INetSerializer serializer)
{
serializer.SerializeValue(ref target);
}
}
public class ReformAvatarMessageHandler : ModuleMessageHandler
{
protected override void OnHandleMessage(ReceivedMessage received)
{
ReformAvatarMessageData reformAvatarMessageData = ((ReceivedMessage)(ref received)).ReadData<ReformAvatarMessageData>();
NetworkPlayer val = default(NetworkPlayer);
if (NetworkPlayerManager.TryGetPlayer(reformAvatarMessageData.target, ref val))
{
int instanceID = ((Object)val.RigRefs.RigManager).GetInstanceID();
if (DestructiblePerson.rigToPersonCache.ContainsKey(instanceID))
{
DestructiblePerson destructiblePerson = DestructiblePerson.rigToPersonCache[instanceID];
destructiblePerson.ReformEntireRig();
}
}
}
}
}
