using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.PuppetMasta;
using InjuriesMod.Core;
using InjuriesMod.Modules;
using MelonLoader;
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(ModClass), "Brain Injuries", "2.2.0", "PolskiAnt", "https://thunderstore.io/c/bonelab/p/PolskiAnt/BrainInjuries/")]
[assembly: AssemblyTitle("Brain Injuries")]
[assembly: AssemblyDescription("Adds a little realism to the game (PATCH 6)")]
[assembly: MelonColor(255, 200, 30, 20)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("InjuriesMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("InjuriesMod")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace InjuriesMod.Patches
{
[HarmonyPatch(typeof(SubBehaviourHealth), "TakeDamage")]
public static class DamagePatch
{
private static readonly Random rnd = new Random();
public static void Prefix(SubBehaviourHealth __instance, int m, Attack attack)
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Invalid comparison between Unknown and I4
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Invalid comparison between Unknown and I4
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Invalid comparison between Unknown and I4
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Invalid comparison between Unknown and I4
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Invalid comparison between Unknown and I4
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Invalid comparison between Unknown and I4
if (__instance.muscles == null || m >= ((Il2CppArrayBase<StunGroup>)(object)__instance.muscles).Count)
{
return;
}
PuppetMaster puppetMaster = ((SubBehaviourBase)__instance).behaviour.puppetMaster;
if ((Object)(object)puppetMaster == (Object)null)
{
return;
}
ReactionContext reactionContext = new ReactionContext(puppetMaster);
if (!reactionContext.IsValid())
{
return;
}
string text = ((object)((Il2CppArrayBase<StunGroup>)(object)__instance.muscles)[m]/*cast due to .constrained prefix*/).ToString();
if (!DeathTracker.PriorityDeathCause.ContainsKey(reactionContext.Ptr))
{
DeathTracker.LastHitBone[reactionContext.Ptr] = ((text == "Head" && (int)attack.attackType != 2 && (int)attack.attackType != 1) ? "Unknown" : text);
}
if (text == "Head" && (int)attack.attackType == 2 && ModClass.HeadBluntResistEnabled)
{
attack.damage *= 0.7f;
}
if (text == "Head")
{
DeathTracker.LastAttackType[reactionContext.Ptr] = attack.attackType;
DeathTracker.LastAttackDamage[reactionContext.Ptr] = attack.damage;
if (attack.damage > 5f && ((int)attack.attackType == 2 || (int)attack.attackType == 1))
{
DeathTracker.PriorityDeathCause[reactionContext.Ptr] = "Head";
}
if (attack.damage > 2f && attack.damage <= 5f && (int)attack.attackType == 2 && ModClass.UnconsciousEnabled && !DeathTracker.AlreadyDead.Contains(reactionContext.Ptr) && !DeathTracker.UnconsciousNPCs.Contains(reactionContext.Ptr) && rnd.Next(101) <= 50)
{
DeathTracker.UnconsciousNPCs.Add(reactionContext.Ptr);
DeathTracker.UnconsciousStartTime[reactionContext.Ptr] = Time.time;
MelonCoroutines.Start(ModuleD_Consciousness.Unconscious(reactionContext.Puppet));
}
}
if (text == "Spine" && ModClass.TorsoArmorEnabled)
{
attack.damage *= 0.5f;
}
}
}
[HarmonyPatch(typeof(PuppetMaster), "Kill", new Type[] { })]
public static class DeathPatch
{
public static void Postfix(PuppetMaster __instance)
{
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
return;
}
ReactionContext reactionContext = new ReactionContext(__instance);
if (!reactionContext.IsValid() || DeathTracker.AlreadyDead.Contains(reactionContext.Ptr))
{
return;
}
DeathTracker.AlreadyDead.Add(reactionContext.Ptr);
string value;
string value2;
string text = (DeathTracker.PriorityDeathCause.TryGetValue(reactionContext.Ptr, out value) ? value : ((!DeathTracker.LastHitBone.TryGetValue(reactionContext.Ptr, out value2)) ? "Unknown" : value2));
if (!ModClass.BrainInjuriesEnabled)
{
text = "Disabled";
}
if (DeathTracker.UnconsciousNPCs.Contains(reactionContext.Ptr))
{
((MelonBase)ModClass.Instance).LoggerInstance.Msg("NPC died while unconscious.");
PhysicsHelper.ApplyProfile(reactionContext.Puppet);
DeathTracker.UnconsciousNPCs.Remove(reactionContext.Ptr);
return;
}
((MelonBase)ModClass.Instance).LoggerInstance.Msg("NPC died | cause: " + text);
if (!(text != "Head"))
{
AttackType value3;
AttackType attackType = (AttackType)((!DeathTracker.LastAttackType.TryGetValue(reactionContext.Ptr, out value3)) ? 64 : ((int)value3));
float value4;
float damage = (DeathTracker.LastAttackDamage.TryGetValue(reactionContext.Ptr, out value4) ? value4 : 0f);
MelonCoroutines.Start(ModuleA_Impact.HandleImpact(reactionContext.Puppet, attackType, damage));
}
}
}
[HarmonyPatch(typeof(PuppetMaster))]
public static class PuppetMasterLifecyclePatches
{
[HarmonyPatch("OnEnable")]
[HarmonyPostfix]
public static void OnEnablePostfix(PuppetMaster __instance)
{
if (!((Object)(object)__instance == (Object)null) && !(((Il2CppObjectBase)__instance).Pointer == IntPtr.Zero))
{
IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
if (DeathTracker.TryRegisterSpawn(pointer, out var currentGeneration))
{
PhysicsHelper.EnsureBindPoseCached(__instance);
MelonLogger.Msg($"[Diag] NPC spawned: {pointer}, Gen Token: {currentGeneration}");
}
}
}
[HarmonyPatch("OnDisable")]
[HarmonyPrefix]
public static void OnDisablePrefix(PuppetMaster __instance)
{
if ((Object)(object)__instance != (Object)null && ((Il2CppObjectBase)__instance).Pointer != IntPtr.Zero)
{
PhysicsHelper.ResetProfile(__instance);
DeathTracker.ClearNPC(((Il2CppObjectBase)__instance).Pointer);
}
}
[HarmonyPatch("OnDestroy")]
[HarmonyPrefix]
public static void OnDestroyPrefix(PuppetMaster __instance)
{
if ((Object)(object)__instance != (Object)null && ((Il2CppObjectBase)__instance).Pointer != IntPtr.Zero)
{
PhysicsHelper.ResetProfile(__instance);
DeathTracker.ClearNPC(((Il2CppObjectBase)__instance).Pointer);
}
}
}
}
namespace InjuriesMod.Modules
{
public static class JointSpaceHelper
{
public static Quaternion GetCurrentRelativeRotation(ConfigurableJoint joint, Quaternion initialLocalRotation)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: 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_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: 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_004f: 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: 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_0065: 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_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: 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)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: 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)
Vector3 axis = ((Joint)joint).axis;
Vector3 val = Vector3.Cross(((Joint)joint).axis, joint.secondaryAxis);
Vector3 normalized = ((Vector3)(ref val)).normalized;
val = Vector3.Cross(normalized, axis);
Vector3 normalized2 = ((Vector3)(ref val)).normalized;
Quaternion val2 = Quaternion.LookRotation(normalized, normalized2);
Quaternion localRotation = ((Component)joint).transform.localRotation;
Quaternion val3 = Quaternion.Inverse(val2);
val3 *= Quaternion.Inverse(localRotation) * initialLocalRotation;
return val3 * val2;
}
}
public static class ModuleA_Impact
{
public enum ImmediateReaction
{
FlaccidParalysis,
None,
Posturing,
ForwardBuckle,
Fencing
}
public enum PostureTendency
{
None,
Flexor,
Extensor,
Mixed
}
public static IEnumerator HandleImpact(PuppetMaster puppet, AttackType attackType, float damage)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if (!ModClass.BrainInjuriesEnabled)
{
yield break;
}
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
ImmediateReaction reaction = ChooseImmediateReaction(attackType, damage);
if (!ModClass.BrainInjuriesEnabled)
{
reaction = ImmediateReaction.None;
}
((MelonBase)ModClass.Instance).LoggerInstance.Msg($"[ModuleA] Reaction: {reaction}");
if (ModClass.SeizuresEnabled)
{
if (1 == 0)
{
}
float num = (((int)attackType == 1) ? ModClass.SeizureChancePiercing : (((int)attackType != 2) ? 0f : ModClass.SeizureChanceBlunt));
if (1 == 0)
{
}
float seizureChance = num;
if (seizureChance > 0f && DeathTracker.Rng.NextDouble() * 100.0 < (double)seizureChance)
{
ModuleC_Seizures.Start(ctx.Ptr, Random.Range(0.5f, 0.9f), Random.Range(5f, 10f));
}
}
yield return MelonCoroutines.Start(RunImmediateReaction(ctx.Puppet, reaction, attackType, damage));
}
private static PostureTendency ChoosePostureTendency(AttackType attackType)
{
int[] array = new int[3] { 35, 25, 40 };
PostureTendency[] array2 = new PostureTendency[3]
{
PostureTendency.Flexor,
PostureTendency.Extensor,
PostureTendency.Mixed
};
float num = 0f;
float[] array3 = new float[array2.Length];
for (int i = 0; i < array2.Length; i++)
{
float multiplier = ModClass.GetMultiplier(ModClass.PosturingSettings[array2[i]]);
array3[i] = (float)array[i] * multiplier;
num += array3[i];
}
if (num <= 0f)
{
return PostureTendency.None;
}
double num2 = DeathTracker.Rng.NextDouble() * (double)num;
float num3 = 0f;
for (int j = 0; j < array3.Length; j++)
{
num3 += array3[j];
if (num2 < (double)num3)
{
return array2[j];
}
}
return array2[0];
}
private static ImmediateReaction ChooseImmediateReaction(AttackType attackType, float damage)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Invalid comparison between Unknown and I4
if ((int)attackType == 1)
{
int[] baseWeights = new int[4] { 40, 15, 25, 20 };
return WeightedRandom(new ImmediateReaction[4]
{
ImmediateReaction.FlaccidParalysis,
ImmediateReaction.None,
ImmediateReaction.Posturing,
ImmediateReaction.ForwardBuckle
}, baseWeights);
}
if ((int)attackType == 2)
{
if (damage >= 5f)
{
int[] baseWeights2 = new int[5] { 25, 35, 15, 10, 15 };
return WeightedRandom(new ImmediateReaction[5]
{
ImmediateReaction.FlaccidParalysis,
ImmediateReaction.Posturing,
ImmediateReaction.Fencing,
ImmediateReaction.None,
ImmediateReaction.ForwardBuckle
}, baseWeights2);
}
if (damage >= 2f)
{
int[] baseWeights3 = new int[5] { 15, 15, 45, 15, 10 };
return WeightedRandom(new ImmediateReaction[5]
{
ImmediateReaction.FlaccidParalysis,
ImmediateReaction.Posturing,
ImmediateReaction.Fencing,
ImmediateReaction.None,
ImmediateReaction.ForwardBuckle
}, baseWeights3);
}
int[] baseWeights4 = new int[5] { 20, 5, 0, 60, 15 };
return WeightedRandom(new ImmediateReaction[5]
{
ImmediateReaction.FlaccidParalysis,
ImmediateReaction.Posturing,
ImmediateReaction.Fencing,
ImmediateReaction.None,
ImmediateReaction.ForwardBuckle
}, baseWeights4);
}
int[] baseWeights5 = new int[3] { 45, 45, 10 };
return WeightedRandom(new ImmediateReaction[3]
{
ImmediateReaction.FlaccidParalysis,
ImmediateReaction.None,
ImmediateReaction.ForwardBuckle
}, baseWeights5);
}
private static ImmediateReaction WeightedRandom(ImmediateReaction[] options, int[] baseWeights)
{
float num = 0f;
float[] array = new float[options.Length];
for (int i = 0; i < options.Length; i++)
{
float multiplier = ModClass.GetMultiplier(ModClass.UserSettings[options[i]]);
array[i] = (float)baseWeights[i] * multiplier;
num += array[i];
}
if (num <= 0f)
{
return ImmediateReaction.None;
}
double num2 = DeathTracker.Rng.NextDouble() * (double)num;
float num3 = 0f;
for (int j = 0; j < array.Length; j++)
{
num3 += array[j];
if (num2 < (double)num3)
{
return options[j];
}
}
return options[^1];
}
private static IEnumerator RunImmediateReaction(PuppetMaster puppet, ImmediateReaction reaction, AttackType attackType, float damage)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
ReactionContext ctx = new ReactionContext(puppet);
if (ctx.IsValid())
{
switch (reaction)
{
case ImmediateReaction.Posturing:
{
PostureTendency tendency = ChoosePostureTendency(attackType);
float intensity = Random.Range(0.6f, 1f);
yield return RunPosturing(onsetDelay: (Random.value < 0.5f) ? 0f : Random.Range(0.1f, 0.4f), blendInTime: Mathf.Lerp(0.5f, 0.15f, intensity), holdTime: Mathf.Lerp(2f, 8f, intensity), puppet: ctx.Puppet, tendency: tendency, intensity: intensity, decayTime: 6f);
break;
}
case ImmediateReaction.FlaccidParalysis:
yield return FlaccidParalysis(ctx.Puppet);
break;
case ImmediateReaction.ForwardBuckle:
yield return ForwardBuckle(ctx.Puppet);
break;
case ImmediateReaction.Fencing:
yield return Fencing(ctx.Puppet);
break;
case ImmediateReaction.None:
yield return Collapse(ctx.Puppet);
break;
}
}
}
private static IEnumerator RunPosturing(PuppetMaster puppet, PostureTendency tendency, float intensity, float onsetDelay, float blendInTime, float holdTime, float decayTime)
{
if (tendency == PostureTendency.None || intensity <= 0f)
{
yield break;
}
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, float> originalWeights = PhysicsHelper.SaveMuscleWeights(ctx.Puppet);
if (onsetDelay > 0f)
{
float delayTimer = 0f;
while (delayTimer < onsetDelay)
{
if (ctx.IsValid())
{
delayTimer += Time.deltaTime;
yield return null;
continue;
}
yield break;
}
}
if (!ctx.IsValid())
{
yield break;
}
Quaternion flexElbow = Quaternion.Euler(50f, 0f, 0f);
Quaternion flexWrist = Quaternion.Euler(50f, 0f, 0f);
Quaternion flexShoulder = Quaternion.Euler(0f, 0f, 0f);
Quaternion extendKneeSubtle = Quaternion.Euler(-8f, 0f, 0f);
Quaternion extendAnkleSubtle = Quaternion.Euler(-20f, 0f, 0f);
Quaternion extElbow = Quaternion.Euler(-50f, 0f, 0f);
Quaternion extWrist = Quaternion.Euler(-40f, 0f, 0f);
Quaternion extShoulder = Quaternion.Euler(-15f, 0f, -15f);
Quaternion extendKnee = Quaternion.Euler(15f, 0f, 0f);
Quaternion extendAnkle = Quaternion.Euler(20f, 0f, 0f);
float totalDuration = blendInTime + holdTime + decayTime;
float e = 0f;
try
{
while (e < totalDuration && ctx.IsValid())
{
ModuleC_Seizures.Tick(ctx.Ptr);
float strength = ((e < blendInTime) ? (Mathf.Clamp01(e / blendInTime) * intensity) : ((!(e < blendInTime + holdTime)) ? Mathf.Lerp(intensity, 0f, (e - blendInTime - holdTime) / decayTime) : intensity));
if (!DeathTracker.BindPoseRotations.TryGetValue(ctx.Ptr, out var bindPose))
{
bindPose = PhysicsHelper.SaveInitialLocalRotations(ctx.Puppet);
}
Dictionary<string, Quaternion> livePose = PhysicsHelper.SaveMuscleCurrentPose(ctx.Puppet, bindPose);
foreach (Muscle muscle in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle == null)
{
continue;
}
string name = muscle.name.ToLower();
ConfigurableJoint joint = ((Component)muscle.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)joint == (Object)null || !livePose.TryGetValue(muscle.name, out var currentPose))
{
continue;
}
bool isKnee = name.Contains("knee");
bool isAnkle = name.Contains("ankle");
bool isElbow = name.Contains("elbow");
bool isWrist = name.Contains("wrist");
bool isShoulder = name.Contains("shoulder");
bool isLeg = isKnee || isAnkle || name.Contains("hip");
Quaternion offset = Quaternion.identity;
bool matched = true;
switch (tendency)
{
case PostureTendency.Flexor:
if (isElbow)
{
offset = flexElbow;
}
else if (isWrist)
{
offset = flexWrist;
}
else if (isShoulder)
{
offset = flexShoulder;
}
else if (isKnee)
{
offset = extendKneeSubtle;
}
else if (isAnkle)
{
offset = extendAnkleSubtle;
}
else
{
matched = false;
}
break;
case PostureTendency.Extensor:
if (isElbow)
{
offset = extElbow;
}
else if (isWrist)
{
offset = extWrist;
}
else if (isShoulder)
{
offset = extShoulder;
}
else if (isKnee)
{
offset = extendKnee;
}
else if (isAnkle)
{
offset = extendAnkle;
}
else
{
matched = false;
}
break;
case PostureTendency.Mixed:
if (isElbow)
{
offset = flexElbow;
}
else if (isWrist)
{
offset = flexWrist;
}
else if (isShoulder)
{
offset = flexShoulder;
}
else if (isKnee)
{
offset = extendKnee;
}
else if (isAnkle)
{
offset = extendAnkle;
}
else
{
matched = false;
}
break;
}
if (matched)
{
(float, float) modifiers = ModuleC_Seizures.GetModifiers(ctx.Ptr, muscle.name);
float seizureMultiplier = modifiers.Item1;
float seizureAngleOffset = modifiers.Item2;
Quaternion target = currentPose * Quaternion.Slerp(Quaternion.identity, offset, strength);
target *= Quaternion.Euler(seizureAngleOffset, 0f, 0f);
joint.targetRotation = target;
float legFactor = (isLeg ? 1.5f : 0.7f);
float absoluteMaxForce = (isLeg ? Mathf.Lerp(20f, 400f, strength) : Mathf.Lerp(15f, 200f, strength));
float finalStrength = strength * legFactor * seizureMultiplier;
PhysicsHelper.SetJointDrive(joint, 2300f * finalStrength, 800f * finalStrength, absoluteMaxForce);
muscle.props.muscleWeight = finalStrength;
}
}
e += Time.deltaTime;
yield return null;
bindPose = null;
}
}
finally
{
if ((Object)(object)ctx.Puppet != (Object)null && (Object)(object)ctx.Root != (Object)null)
{
PhysicsHelper.RestoreAndResetJoints(ctx.Puppet, originalWeights);
}
}
}
private static IEnumerator ForwardBuckle(PuppetMaster puppet)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, float> originalWeights = PhysicsHelper.SaveMuscleWeights(ctx.Puppet);
if (!DeathTracker.BindPoseRotations.TryGetValue(ctx.Ptr, out var _))
{
PhysicsHelper.SaveInitialLocalRotations(ctx.Puppet);
}
if (!ctx.IsValid())
{
yield break;
}
Rigidbody chestRb = null;
foreach (Muscle m in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (m != null && m.name.ToLower().Contains("chest"))
{
chestRb = ((Component)m.transform).GetComponent<Rigidbody>();
break;
}
}
if ((Object)(object)chestRb != (Object)null)
{
Vector3 forwardDir = -((Component)chestRb).transform.right;
chestRb.AddForce(forwardDir * 5.5f, (ForceMode)2);
}
float fallDuration = Random.Range(1f, 1.3f);
float e1 = 0f;
try
{
while (e1 < fallDuration && ctx.IsValid())
{
ModuleC_Seizures.Tick(ctx.Ptr);
float bendProgress = Mathf.Clamp01(e1 / 0.45f);
float easeBend = bendProgress * bendProgress;
float currentSpring = Mathf.Lerp(900f, 20f, bendProgress);
float currentDamping = Mathf.Lerp(150f, 5f, bendProgress);
float muscleWeight = Mathf.Lerp(0.85f, 0.05f, bendProgress);
foreach (Muscle muscle in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle == null)
{
continue;
}
string name = muscle.name.ToLower();
ConfigurableJoint joint = ((Component)muscle.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)joint == (Object)null)
{
continue;
}
var (seizureMultiplier, seizureAngleOffset) = ModuleC_Seizures.GetModifiers(ctx.Ptr, muscle.name);
_ = Quaternion.identity;
Quaternion targetOffset;
if (name.Contains("spine"))
{
targetOffset = Quaternion.Slerp(Quaternion.identity, Quaternion.Euler(-75f, 0f, 0f), easeBend);
}
else if (name.Contains("chest"))
{
targetOffset = Quaternion.Slerp(Quaternion.identity, Quaternion.Euler(-60f, 0f, 0f), easeBend);
}
else
{
if (!name.Contains("hip"))
{
if (name.Contains("knee"))
{
float kneeSpring = ((e1 < 0.35f) ? 400f : currentSpring);
PhysicsHelper.SetJointDrive(joint, kneeSpring * seizureMultiplier, currentDamping, kneeSpring * seizureMultiplier);
muscle.props.muscleWeight = ((e1 < 0.35f) ? 0.9f : muscleWeight) * seizureMultiplier;
}
continue;
}
targetOffset = Quaternion.Slerp(Quaternion.identity, Quaternion.Euler(150f, 0f, 0f), easeBend);
}
joint.targetRotation = targetOffset * Quaternion.Euler(seizureAngleOffset, 0f, 0f);
PhysicsHelper.SetJointDrive(joint, currentSpring * seizureMultiplier, currentDamping, currentSpring * seizureMultiplier);
muscle.props.muscleWeight = muscleWeight * seizureMultiplier;
}
e1 += Time.deltaTime;
yield return null;
}
}
finally
{
PhysicsHelper.RestoreAndResetJoints(ctx.Puppet, originalWeights);
}
}
private static IEnumerator FlaccidParalysis(PuppetMaster puppet)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, float> originalWeights = PhysicsHelper.SaveMuscleWeights(ctx.Puppet);
if (!DeathTracker.BindPoseRotations.TryGetValue(ctx.Ptr, out var localRotations))
{
localRotations = PhysicsHelper.SaveInitialLocalRotations(ctx.Puppet);
}
float jerkDuration = Random.Range(0.02f, 0.05f);
float jerkStrength = Random.Range(0.8f, 1.5f);
Dictionary<string, Quaternion> currentPoseBeforeJerk = PhysicsHelper.SaveMuscleCurrentPose(ctx.Puppet, localRotations);
MelonCoroutines.Start(SuppressHitReaction(ctx.Puppet));
Dictionary<string, Quaternion> jerkOffsets = new Dictionary<string, Quaternion>();
foreach (Muscle muscle in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle != null)
{
Vector3 randEuler = new Vector3(Random.Range(-40f, 40f), Random.Range(-50f, 50f), Random.Range(-30f, 30f));
Quaternion cp;
Quaternion basePose = (currentPoseBeforeJerk.TryGetValue(muscle.name, out cp) ? cp : Quaternion.identity);
jerkOffsets[muscle.name] = basePose * Quaternion.Euler(randEuler);
}
}
ApplyImpactImpulse(ctx.Puppet);
float e0 = 0f;
try
{
while (e0 < jerkDuration)
{
if (!ctx.IsValid())
{
yield break;
}
float t = Mathf.Clamp01(e0 / jerkDuration);
foreach (Muscle muscle2 in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle2 != null)
{
ConfigurableJoint joint = ((Component)muscle2.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)joint == (Object)null) && jerkOffsets.TryGetValue(muscle2.name, out var offset) && currentPoseBeforeJerk.TryGetValue(muscle2.name, out var basePose2))
{
joint.targetRotation = Quaternion.Slerp(basePose2, offset, t);
PhysicsHelper.SetJointDrive(joint, 2500f * jerkStrength, 400f * jerkStrength, 60f);
muscle2.props.muscleWeight = jerkStrength;
}
}
}
e0 += Time.deltaTime;
yield return null;
}
if (!ctx.IsValid())
{
yield break;
}
float fallTime = Random.Range(0.8f, 1.2f);
float fallStrengthTorso = 0.2f;
float fallStrengthLegs = 0f;
float e1 = 0f;
while (e1 < fallTime)
{
if (!ctx.IsValid())
{
yield break;
}
float localT = e1 / fallTime;
foreach (Muscle muscle3 in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle3 != null)
{
string name = muscle3.name.ToLower();
ConfigurableJoint joint2 = ((Component)muscle3.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)joint2 == (Object)null))
{
bool isLeg = name.Contains("knee") || name.Contains("ankle") || name.Contains("hip");
float baseStrength = (isLeg ? fallStrengthLegs : fallStrengthTorso);
float currentStrength = Mathf.Lerp(baseStrength, baseStrength * 0.3f, localT);
float absoluteMaxForce = (isLeg ? 2f : 20f);
PhysicsHelper.SetJointDrive(joint2, 300f * currentStrength, 100f * currentStrength, absoluteMaxForce);
muscle3.props.muscleWeight = currentStrength;
}
}
}
e1 += Time.deltaTime;
yield return null;
}
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, Quaternion> frozenTargets = PhysicsHelper.SaveMuscleCurrentPose(ctx.Puppet, localRotations);
float freezeTime = 0.4f;
float legDecay = 4f;
float torsoDecay = 8f;
float e2 = 0f;
float totalDuration = freezeTime + torsoDecay;
float rampIn = 0.1f;
while (e2 < totalDuration && ctx.IsValid())
{
ModuleC_Seizures.Tick(ctx.Ptr);
foreach (Muscle muscle4 in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle4 == null)
{
continue;
}
string name2 = muscle4.name.ToLower();
ConfigurableJoint joint3 = ((Component)muscle4.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)joint3 == (Object)null))
{
bool isLeg2 = name2.Contains("knee") || name2.Contains("ankle") || name2.Contains("hip");
float decayDuration = (isLeg2 ? legDecay : torsoDecay);
float localElapsed = Mathf.Max(0f, e2 - freezeTime);
float strength = ((e2 < freezeTime) ? Mathf.Clamp01(e2 / rampIn) : Mathf.Clamp01(1f - localElapsed / decayDuration));
var (seizureMultiplier, seizureAngleOffset) = ModuleC_Seizures.GetModifiers(ctx.Ptr, muscle4.name);
if (frozenTargets.TryGetValue(muscle4.name, out var frozenTarget))
{
joint3.targetRotation = frozenTarget * Quaternion.Euler(seizureAngleOffset, 0f, 0f);
}
float absoluteMaxForce2 = (isLeg2 ? 40f : 25f);
float legFactor = (isLeg2 ? 0.35f : 0.45f);
float finalStrength = strength * legFactor * seizureMultiplier;
PhysicsHelper.SetJointDrive(joint3, 300f * finalStrength, 300f * finalStrength, absoluteMaxForce2);
}
}
e2 += Time.deltaTime;
yield return null;
}
}
finally
{
PhysicsHelper.RestoreAndResetJoints(ctx.Puppet, originalWeights);
}
}
private static IEnumerator Collapse(PuppetMaster puppet)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, float> originalWeights = PhysicsHelper.SaveMuscleWeights(ctx.Puppet);
MelonCoroutines.Start(SuppressHitReaction(ctx.Puppet));
if (!ctx.IsValid())
{
yield break;
}
foreach (Muscle muscle in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle != null)
{
muscle.name.ToLower();
ConfigurableJoint joint = ((Component)muscle.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)joint == (Object)null))
{
PhysicsHelper.SetJointDrive(joint, 0f, 0f, 0f);
muscle.props.muscleWeight = 0f;
}
}
}
PhysicsHelper.RestoreAndResetJoints(ctx.Puppet, originalWeights);
}
private static IEnumerator Fencing(PuppetMaster puppet)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
Dictionary<string, float> originalWeights = PhysicsHelper.SaveMuscleWeights(ctx.Puppet);
if (!DeathTracker.BindPoseRotations.TryGetValue(ctx.Ptr, out var bindPose))
{
bindPose = PhysicsHelper.SaveInitialLocalRotations(ctx.Puppet);
}
float bs = Random.Range(0.25f, 0.35f);
float d = Random.Range(0.6f, 0.8f);
float rt = Random.Range(0.8f, 1.5f);
float e = 0f;
float suppressWindow = 0.3f;
bool leftIsExtended = Random.value < 0.5f;
Quaternion extendedElbow = Quaternion.Euler(-10f, 0f, 0f);
Quaternion extendedShoulder = Quaternion.Euler(70f, 0f, -30f);
Quaternion extendedWrist = Quaternion.Euler(-10f, 0f, 0f);
Quaternion flexedElbow = Quaternion.Euler(110f, 0f, 0f);
Quaternion flexedShoulder = Quaternion.Euler(20f, 0f, 15f);
Quaternion flexedWrist = Quaternion.Euler(60f, 0f, 0f);
try
{
while (e < bs + d + rt && ctx.IsValid())
{
float progress = PhysicsHelper.GetProgress(e, bs, d, rt);
float strength = PhysicsHelper.GetStrength(e, bs, d, rt);
if (e < suppressWindow)
{
foreach (Muscle m in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (m == null)
{
continue;
}
string mName = m.name.ToLower();
if (!mName.Contains("elbow") && !mName.Contains("shoulder") && !mName.Contains("wrist"))
{
Rigidbody rb = ((Component)m.transform).GetComponent<Rigidbody>();
if (!((Object)(object)rb == (Object)null))
{
rb.angularVelocity = Vector3.ClampMagnitude(rb.angularVelocity, 2f);
}
}
}
}
Dictionary<string, Quaternion> currentPose = PhysicsHelper.SaveMuscleCurrentPose(ctx.Puppet, bindPose);
foreach (Muscle muscle in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (muscle == null)
{
continue;
}
string name = muscle.name.ToLower();
ConfigurableJoint joint = ((Component)muscle.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)joint == (Object)null) && currentPose.TryGetValue(muscle.name, out var basePose))
{
bool thisArmExtended = (name.Contains("_l") ? leftIsExtended : (!leftIsExtended));
Quaternion offset = Quaternion.identity;
bool matched = true;
if (name.Contains("elbow"))
{
offset = (thisArmExtended ? extendedElbow : flexedElbow);
}
else if (name.Contains("shoulder"))
{
offset = (thisArmExtended ? extendedShoulder : flexedShoulder);
}
else if (name.Contains("wrist"))
{
offset = (thisArmExtended ? extendedWrist : flexedWrist);
}
else
{
matched = false;
}
if (matched)
{
Quaternion target = basePose * Quaternion.Slerp(Quaternion.identity, offset, progress);
joint.targetRotation = target;
PhysicsHelper.SetJointDrive(joint, 2300f * strength, 700f * strength, 900f * strength);
muscle.props.muscleWeight = strength;
}
}
}
e += Time.deltaTime;
yield return null;
}
}
finally
{
PhysicsHelper.RestoreAndResetJoints(ctx.Puppet, originalWeights);
}
}
private static void ApplyImpactImpulse(PuppetMaster puppet)
{
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: 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_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
ReactionContext reactionContext = new ReactionContext(puppet);
if (!reactionContext.IsValid())
{
return;
}
Rigidbody val = null;
Rigidbody val2 = null;
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)reactionContext.Puppet.muscles)
{
if (item != null)
{
string text = item.name.ToLower();
if (text.Contains("head"))
{
val = ((Component)item.transform).GetComponent<Rigidbody>();
}
if (text.Contains("chest"))
{
val2 = ((Component)item.transform).GetComponent<Rigidbody>();
}
}
}
Vector3 val3 = new Vector3(Random.Range(-1f, 1f), Random.Range(-0.2f, 0.3f), Random.Range(-1f, 1f));
Vector3 normalized = ((Vector3)(ref val3)).normalized;
float num = Random.Range(5f, 10f);
if ((Object)(object)val != (Object)null)
{
val.AddForce(normalized * num * 0.2f, (ForceMode)1);
}
if ((Object)(object)val2 != (Object)null)
{
val2.AddForce(normalized * num, (ForceMode)1);
}
}
private static IEnumerator SuppressHitReaction(PuppetMaster puppet, float duration = 0.3f)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid())
{
yield break;
}
float elapsed = 0f;
float maxReasonableSpin = 2f;
while (elapsed < duration && ctx.IsValid())
{
foreach (Muscle m in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (m != null)
{
Rigidbody rb = ((Component)m.transform).GetComponent<Rigidbody>();
if (!((Object)(object)rb == (Object)null))
{
Vector3 av = rb.angularVelocity;
rb.angularVelocity = Vector3.ClampMagnitude(av, maxReasonableSpin);
}
}
}
elapsed += Time.fixedDeltaTime;
yield return (object)new WaitForFixedUpdate();
}
}
}
internal class ModuleC_Seizures
{
public struct SeizureData
{
public float intensity;
public float frequency;
public float elapsed;
public float duration;
}
private static readonly Dictionary<IntPtr, SeizureData> _active = new Dictionary<IntPtr, SeizureData>();
public static void Start(IntPtr ptr, float intensity, float duration)
{
if (ModClass.SeizuresEnabled)
{
_active[ptr] = new SeizureData
{
intensity = Mathf.Clamp01(intensity),
frequency = Mathf.Lerp(3f, 8f, intensity) * 0.8f,
elapsed = 0f,
duration = duration
};
((MelonBase)ModClass.Instance).LoggerInstance.Msg($"[ModuleC] Seizure start | instensity: {intensity} | duration: {duration}");
}
}
public static void Tick(IntPtr ptr)
{
if (_active.TryGetValue(ptr, out var value))
{
value.elapsed += Time.deltaTime;
if (value.elapsed >= value.duration)
{
_active.Remove(ptr);
MelonLogger.Msg("[ModuleC] Seizure ended");
}
else
{
_active[ptr] = value;
}
}
}
public static void Stop(IntPtr ptr)
{
_active.Remove(ptr);
}
public static void Clear(IntPtr ptr)
{
_active.Remove(ptr);
}
public static bool IsActive(IntPtr ptr)
{
return _active.ContainsKey(ptr);
}
public static (float strengthMultiplier, float angleOffset) GetModifiers(IntPtr ptr, string muscleName)
{
if (!ModClass.SeizuresEnabled)
{
return (strengthMultiplier: 1f, angleOffset: 0f);
}
if (!_active.TryGetValue(ptr, out var value))
{
return (strengthMultiplier: 1f, angleOffset: 0f);
}
float num = 1f - Mathf.Clamp01((value.elapsed - value.duration * 0.6f) / (value.duration * 0.4f));
float num2 = value.intensity * num;
float num3 = (float)(muscleName.GetHashCode() % 100) * 0.063f;
float item = 1f + num2 * 2f;
float item2 = Mathf.Sin(value.elapsed * value.frequency * (float)Math.PI * 2f + num3) * 20f * num2;
return (strengthMultiplier: item, angleOffset: item2);
}
public static void ClearAll()
{
_active.Clear();
}
}
internal class ModuleD_Consciousness
{
public static IEnumerator Unconscious(PuppetMaster puppet, float duration = 20f)
{
ReactionContext ctx = new ReactionContext(puppet);
if (!ctx.IsValid() || DeathTracker.AlreadyDead.Contains(ctx.Ptr))
{
yield break;
}
BehaviourBaseNav behaviour = null;
AIBrain brain = null;
Animator animator = null;
AIManager manager = null;
try
{
Transform mainTransform = (((Object)(object)ctx.Puppet != (Object)null) ? ((Component)ctx.Puppet).transform : null);
if ((Object)(object)mainTransform != (Object)null)
{
brain = ((Component)mainTransform).GetComponentInParent<AIBrain>();
}
if ((Object)(object)brain != (Object)null)
{
GameObject brainGO = ((Component)brain).gameObject;
behaviour = brain.behaviour;
if ((Object)(object)behaviour == (Object)null)
{
behaviour = brainGO.GetComponentInChildren<BehaviourBaseNav>(true);
}
animator = brainGO.GetComponentInChildren<Animator>(true);
manager = brainGO.GetComponentInChildren<AIManager>(true);
}
else
{
object obj;
if (!((Object)(object)ctx.Root != (Object)null))
{
if (mainTransform == null)
{
obj = null;
}
else
{
Transform root = mainTransform.root;
obj = ((root != null) ? ((Component)root).gameObject : null);
}
}
else
{
obj = ((Component)ctx.Root).gameObject;
}
GameObject topRoot = (GameObject)obj;
if ((Object)(object)topRoot != (Object)null)
{
behaviour = topRoot.GetComponentInChildren<BehaviourBaseNav>(true);
animator = topRoot.GetComponentInChildren<Animator>(true);
manager = topRoot.GetComponentInChildren<AIManager>(true);
}
}
}
catch (Exception ex)
{
Exception ex2 = ex;
((MelonBase)ModClass.Instance).LoggerInstance.Error($"[Unconscious] Exception while fetching components: {ex2}");
}
if ((Object)(object)brain != (Object)null)
{
((Behaviour)brain).enabled = false;
}
if ((Object)(object)animator != (Object)null)
{
((Behaviour)animator).enabled = false;
}
PhysicsHelper.SaveProfile(ctx.Puppet);
if (!ctx.IsValid() || DeathTracker.AlreadyDead.Contains(ctx.Ptr))
{
yield break;
}
ctx.Puppet.angularLimitsEnabled = true;
ctx.Puppet.angularLimits = true;
ctx.Puppet.animationDisabledbyStates = true;
ctx.Puppet.mappingWeight = 0f;
ctx.Puppet.ActivateRagdoll(Object.op_Implicit((Object)(object)manager));
JointDrive val;
foreach (Muscle m in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (m != null)
{
m.props.muscleWeight = 0f;
ConfigurableJoint joint = ((Component)m.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)joint != (Object)null)
{
val = default(JointDrive);
((JointDrive)(ref val)).positionSpring = 0f;
((JointDrive)(ref val)).positionDamper = 5f;
JointDrive drive = (joint.angularXDrive = (joint.slerpDrive = val));
joint.angularYZDrive = drive;
}
}
}
((MelonBase)ModClass.Instance).LoggerInstance.Msg("NPC unconcious!");
float elapsedGuard = 0f;
val = default(JointDrive);
((JointDrive)(ref val)).positionSpring = 1f;
((JointDrive)(ref val)).positionDamper = 100400f;
((JointDrive)(ref val)).maximumForce = 0f;
JointDrive zeroDrive = val;
try
{
while (elapsedGuard < duration)
{
if (!ctx.IsValid() || DeathTracker.AlreadyDead.Contains(ctx.Ptr))
{
yield break;
}
if (!DeathTracker.UnconsciousNPCs.Contains(ctx.Ptr))
{
PhysicsHelper.ApplyProfile(ctx.Puppet);
yield break;
}
if ((Object)(object)behaviour != (Object)null)
{
behaviour.locoState = (LocoState)5;
}
if ((Object)(object)brain != (Object)null && (Object)(object)brain.behaviour != (Object)null)
{
brain.behaviour.mentalState = (MentalState)0;
}
foreach (Muscle m2 in (Il2CppArrayBase<Muscle>)(object)ctx.Puppet.muscles)
{
if (m2 != null)
{
ConfigurableJoint joint2 = ((Component)m2.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)joint2 != (Object)null)
{
joint2.slerpDrive = zeroDrive;
joint2.angularXDrive = zeroDrive;
joint2.angularYZDrive = zeroDrive;
}
}
}
elapsedGuard += Time.deltaTime;
yield return (object)new WaitForFixedUpdate();
}
if (!ctx.IsValid() || DeathTracker.AlreadyDead.Contains(ctx.Ptr) || (int)ctx.Puppet.state == 1 || !DeathTracker.UnconsciousNPCs.Contains(ctx.Ptr))
{
yield break;
}
((MelonBase)ModClass.Instance).LoggerInstance.Msg("NPC woke up!");
if ((Object)(object)animator != (Object)null)
{
((Behaviour)animator).enabled = true;
}
if ((Object)(object)manager != (Object)null)
{
((Behaviour)manager).enabled = true;
}
if ((Object)(object)brain != (Object)null)
{
((Behaviour)brain).enabled = true;
}
if ((Object)(object)behaviour != (Object)null)
{
behaviour.locoState = (LocoState)3;
}
if ((Object)(object)brain != (Object)null && (Object)(object)brain.behaviour != (Object)null)
{
brain.behaviour.mentalState = (MentalState)2;
}
float recoverTime = 1.5f;
float elapsed = 0f;
while (elapsed < recoverTime)
{
if (!ctx.IsValid() || DeathTracker.AlreadyDead.Contains(ctx.Ptr) || !DeathTracker.UnconsciousNPCs.Contains(ctx.Ptr))
{
yield break;
}
float t = elapsed / recoverTime;
ctx.Puppet.mappingWeight = t;
PhysicsHelper.ApplyProfile(ctx.Puppet, t);
elapsed += Time.deltaTime;
yield return null;
}
if (ctx.IsValid())
{
ctx.Puppet.mappingWeight = 1f;
PhysicsHelper.ApplyProfile(ctx.Puppet);
}
}
finally
{
CleanupTracker(ctx.Ptr);
}
}
private static void CleanupTracker(IntPtr ptr)
{
DeathTracker.UnconsciousNPCs.Remove(ptr);
DeathTracker.UnconsciousStartTime.Remove(ptr);
DeathTracker.Profiles.Remove(ptr);
}
}
public static class PhysicsHelper
{
public static void EnsureBindPoseCached(PuppetMaster puppet)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)puppet == (Object)null || ((Il2CppObjectBase)puppet).Pointer == IntPtr.Zero || DeathTracker.BindPoseRotations.ContainsKey(((Il2CppObjectBase)puppet).Pointer))
{
return;
}
Dictionary<string, Quaternion> dictionary = new Dictionary<string, Quaternion>();
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
dictionary[item.name] = item.transform.localRotation;
}
}
DeathTracker.BindPoseRotations[((Il2CppObjectBase)puppet).Pointer] = dictionary;
}
public static Dictionary<string, Quaternion> SaveMuscleCurrentPose(PuppetMaster puppet, Dictionary<string, Quaternion> initialLocalRotations)
{
//IL_0066: 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)
Dictionary<string, Quaternion> dictionary = new Dictionary<string, Quaternion>();
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)component == (Object)null) && initialLocalRotations.TryGetValue(item.name, out var value))
{
dictionary[item.name] = JointSpaceHelper.GetCurrentRelativeRotation(component, value);
}
}
}
return dictionary;
}
public static Dictionary<string, Quaternion> SaveInitialLocalRotations(PuppetMaster puppet)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, Quaternion> dictionary = new Dictionary<string, Quaternion>();
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
dictionary[item.name] = item.transform.localRotation;
}
}
return dictionary;
}
public static void SetJointDrive(ConfigurableJoint joint, float spring, float damper, float maxForce)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
JointDrive val = default(JointDrive);
((JointDrive)(ref val)).positionSpring = spring;
((JointDrive)(ref val)).positionDamper = damper;
((JointDrive)(ref val)).maximumForce = maxForce;
JointDrive angularYZDrive = (joint.angularXDrive = (joint.slerpDrive = val));
joint.angularYZDrive = angularYZDrive;
}
public static void ApplyToSpine(PuppetMaster puppet, float progress, float strength, Quaternion spineRot, Quaternion headRot, Quaternion chestRot, Quaternion hipRot)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: 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_0082: 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_00b9: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item == null)
{
continue;
}
string text = item.name.ToLower();
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)component == (Object)null)
{
continue;
}
Quaternion identity = Quaternion.identity;
if (text.Contains("spine"))
{
identity = spineRot;
}
else if (text.Contains("chest"))
{
identity = chestRot;
}
else if (text.Contains("head"))
{
identity = headRot;
}
else
{
if (!text.Contains("hip"))
{
continue;
}
identity = hipRot;
}
component.targetRotation = Quaternion.Slerp(Quaternion.identity, identity, progress);
SetJointDrive(component, 3000f * strength, 800f * strength, 3000f * strength);
item.props.muscleWeight = strength;
}
}
public static void ApplyToMuscles(PuppetMaster puppet, float progress, float strength, Quaternion elbowRot, Quaternion wristRot, Quaternion shoulderRot, Quaternion kneeRot, Quaternion ankleRot, string sideFilter = null, bool includeLegs = true, bool includeArms = true)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: 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_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
ModuleC_Seizures.Tick(((Il2CppObjectBase)puppet).Pointer);
foreach (Muscle item3 in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item3 == null)
{
continue;
}
string text = item3.name.ToLower();
if (sideFilter != null && !text.Contains(sideFilter))
{
continue;
}
ConfigurableJoint component = ((Component)item3.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)component == (Object)null)
{
continue;
}
Quaternion identity = Quaternion.identity;
bool flag = text.Contains("knee") || text.Contains("ankle") || text.Contains("hip");
bool flag2 = text.Contains("wrist") || text.Contains("shoulder") || text.Contains("elbow");
if ((flag && !includeLegs) || (flag2 && !includeArms))
{
continue;
}
if (text.Contains("elbow"))
{
identity = elbowRot;
}
else if (text.Contains("wrist"))
{
identity = wristRot;
}
else if (text.Contains("shoulder"))
{
identity = shoulderRot;
}
else if (text.Contains("knee"))
{
identity = kneeRot;
}
else
{
if (!text.Contains("ankle"))
{
continue;
}
identity = ankleRot;
}
(float strengthMultiplier, float angleOffset) modifiers = ModuleC_Seizures.GetModifiers(((Il2CppObjectBase)puppet).Pointer, item3.name);
float item = modifiers.strengthMultiplier;
float item2 = modifiers.angleOffset;
Quaternion val = Quaternion.Slerp(Quaternion.identity, identity, progress);
val *= Quaternion.Euler(item2, 0f, 0f);
component.targetRotation = val;
float num = strength * item;
float num2 = (flag ? 0.35f : 1f);
SetJointDrive(component, 3000f * num, 800f * num * num2, 3000f * num * num2);
item3.props.muscleWeight = num;
}
}
public static float GetProgress(float e, float bs, float d, float rt)
{
return (e < bs) ? Mathf.Clamp01(e / bs) : 1f;
}
public static float GetStrength(float e, float bs, float d, float rt)
{
if (e < bs)
{
return Mathf.Clamp01(e / bs);
}
if (e < bs + d)
{
return 1f;
}
return 1f - Mathf.Clamp01((e - bs - d) / rt);
}
public static void RestoreAndResetJoints(PuppetMaster puppet, Dictionary<string, float> originalWeights)
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)puppet == (Object)null || ((Il2CppObjectBase)puppet).Pointer == IntPtr.Zero)
{
return;
}
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
if (originalWeights.TryGetValue(item.name, out var value))
{
item.props.muscleWeight = value;
}
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if (!((Object)(object)component == (Object)null))
{
SetJointDrive(component, 0f, 0f, 0f);
component.targetRotation = Quaternion.identity;
}
}
}
}
public static Dictionary<string, float> SaveMuscleWeights(PuppetMaster puppet)
{
Dictionary<string, float> dictionary = new Dictionary<string, float>();
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
dictionary[item.name] = item.props.muscleWeight;
}
}
return dictionary;
}
public static void SaveProfile(PuppetMaster puppet)
{
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)puppet == (Object)null || ((Il2CppObjectBase)puppet).Pointer == IntPtr.Zero)
{
return;
}
NPCMuscleProfile nPCMuscleProfile = new NPCMuscleProfile();
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
nPCMuscleProfile.MaxForces[item.name] = item._maxForce;
nPCMuscleProfile.MuscleWeights[item.name] = item.props.muscleWeight;
nPCMuscleProfile.MuscleDampers[item.name] = item.props.muscleDamper;
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)component != (Object)null)
{
nPCMuscleProfile.Drives[item.name] = component.slerpDrive;
}
}
}
DeathTracker.Profiles[((Il2CppObjectBase)puppet).Pointer] = nPCMuscleProfile;
}
public static void ApplyProfile(PuppetMaster puppet, float t = 1f)
{
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)puppet == (Object)null || ((Il2CppObjectBase)puppet).Pointer == IntPtr.Zero || !DeathTracker.Profiles.TryGetValue(((Il2CppObjectBase)puppet).Pointer, out var value))
{
return;
}
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item == null)
{
continue;
}
if (value.MaxForces.TryGetValue(item.name, out var value2))
{
item._maxForce = Mathf.Lerp(0f, value2, t);
}
if (value.MuscleWeights.TryGetValue(item.name, out var value3))
{
item.props.muscleWeight = Mathf.Lerp(0f, value3, t);
}
if (value.MuscleDampers.TryGetValue(item.name, out var value4))
{
item.props.muscleDamper = Mathf.Lerp(0f, value4, t);
}
if (t >= 1f)
{
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)component != (Object)null && value.Drives.TryGetValue(item.name, out var value5))
{
component.slerpDrive = value5;
component.angularXDrive = value5;
component.angularYZDrive = value5;
}
}
}
}
public static void ResetProfile(PuppetMaster puppet)
{
if (!DeathTracker.Profiles.TryGetValue(((Il2CppObjectBase)puppet).Pointer, out var value))
{
return;
}
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
if (value.MaxForces.TryGetValue(item.name, out var value2))
{
item._maxForce = value2;
}
if (value.MuscleWeights.TryGetValue(item.name, out var value3))
{
item.props.muscleWeight = value3;
}
if (value.MuscleDampers.TryGetValue(item.name, out var value4))
{
item.props.muscleDamper = value4;
}
}
}
}
public static string ShowStats(PuppetMaster puppet)
{
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: 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)
if ((Object)(object)puppet == (Object)null || ((Il2CppObjectBase)puppet).Pointer == IntPtr.Zero)
{
return "Puppet NULL";
}
float value = -1f;
float value2 = -1f;
float mappingWeight = puppet.mappingWeight;
float value3 = -1f;
float value4 = -1f;
float value5 = -1f;
foreach (Muscle item in (Il2CppArrayBase<Muscle>)(object)puppet.muscles)
{
if (item != null)
{
value = item.props.muscleWeight;
value2 = item.props.muscleDamper;
value3 = item._maxForce;
ConfigurableJoint component = ((Component)item.transform).GetComponent<ConfigurableJoint>();
if ((Object)(object)component != (Object)null)
{
JointDrive slerpDrive = component.slerpDrive;
value4 = ((JointDrive)(ref slerpDrive)).positionSpring;
slerpDrive = component.slerpDrive;
value5 = ((JointDrive)(ref slerpDrive)).positionDamper;
}
break;
}
}
return $"[Diag] mWeight={value}, mDamper={value2}, maxForce={value3} | mapWeight={mappingWeight}, DriveSpring={value4}, DriveDamper={value5}";
}
}
}
namespace InjuriesMod.Core
{
public class NPCMuscleProfile
{
public Dictionary<string, float> MaxForces = new Dictionary<string, float>();
public Dictionary<string, float> MuscleWeights = new Dictionary<string, float>();
public Dictionary<string, float> MuscleDampers = new Dictionary<string, float>();
public Dictionary<string, JointDrive> Drives = new Dictionary<string, JointDrive>();
}
public static class DeathTracker
{
public static Dictionary<IntPtr, NPCMuscleProfile> Profiles = new Dictionary<IntPtr, NPCMuscleProfile>();
public static Dictionary<IntPtr, int> PointerGeneration = new Dictionary<IntPtr, int>();
public static Dictionary<IntPtr, int> LastRegisteredFrame = new Dictionary<IntPtr, int>();
public static HashSet<IntPtr> AlreadyDead = new HashSet<IntPtr>();
public static HashSet<IntPtr> UnconsciousNPCs = new HashSet<IntPtr>();
public static Dictionary<IntPtr, float> UnconsciousStartTime = new Dictionary<IntPtr, float>();
public static Dictionary<IntPtr, string> LastHitBone = new Dictionary<IntPtr, string>();
public static Dictionary<IntPtr, string> PriorityDeathCause = new Dictionary<IntPtr, string>();
public static Dictionary<IntPtr, AttackType> LastAttackType = new Dictionary<IntPtr, AttackType>();
public static Dictionary<IntPtr, float> LastAttackDamage = new Dictionary<IntPtr, float>();
public static Dictionary<IntPtr, Dictionary<string, Quaternion>> BindPoseRotations = new Dictionary<IntPtr, Dictionary<string, Quaternion>>();
public static Random Rng = new Random();
public static bool TryRegisterSpawn(IntPtr ptr, out int currentGeneration)
{
currentGeneration = -1;
if (ptr == IntPtr.Zero)
{
return false;
}
int frameCount = Time.frameCount;
if (LastRegisteredFrame.TryGetValue(ptr, out var value) && value == frameCount)
{
currentGeneration = ((!PointerGeneration.TryGetValue(ptr, out var value2)) ? 1 : value2);
return false;
}
LastRegisteredFrame[ptr] = frameCount;
if (PointerGeneration.TryGetValue(ptr, out var value3))
{
currentGeneration = value3 + 1;
}
else
{
currentGeneration = 1;
}
PointerGeneration[ptr] = currentGeneration;
return true;
}
public static void ClearNPC(IntPtr ptr)
{
if (!(ptr == IntPtr.Zero) && (AlreadyDead.Contains(ptr) || LastHitBone.ContainsKey(ptr) || UnconsciousNPCs.Contains(ptr) || LastAttackType.ContainsKey(ptr) || BindPoseRotations.ContainsKey(ptr) || Profiles.ContainsKey(ptr)))
{
((MelonBase)ModClass.Instance).LoggerInstance.Msg($"Clearing NPC data (ptr: {ptr})");
ModuleC_Seizures.Clear(ptr);
AlreadyDead.Remove(ptr);
UnconsciousNPCs.Remove(ptr);
UnconsciousStartTime.Remove(ptr);
LastHitBone.Remove(ptr);
PriorityDeathCause.Remove(ptr);
LastAttackType.Remove(ptr);
LastAttackDamage.Remove(ptr);
BindPoseRotations.Remove(ptr);
Profiles.Remove(ptr);
}
}
public static void ClearAll()
{
AlreadyDead.Clear();
UnconsciousNPCs.Clear();
UnconsciousStartTime.Clear();
LastHitBone.Clear();
PriorityDeathCause.Clear();
LastAttackType.Clear();
LastAttackDamage.Clear();
BindPoseRotations.Clear();
Profiles.Clear();
}
}
public class ModClass : MelonMod
{
public enum FrequencyScale
{
None,
Rare,
Default,
Common,
Always
}
public static ModClass Instance;
public static bool UnconsciousEnabled = true;
public static bool BrainInjuriesEnabled = true;
public static bool TorsoArmorEnabled = true;
public static bool HeadBluntResistEnabled = true;
public static bool SeizuresEnabled = true;
public static float SeizureChanceBlunt = 20f;
public static float SeizureChancePiercing = 8f;
public static Dictionary<ModuleA_Impact.ImmediateReaction, FrequencyScale> UserSettings = new Dictionary<ModuleA_Impact.ImmediateReaction, FrequencyScale>
{
{
ModuleA_Impact.ImmediateReaction.FlaccidParalysis,
FrequencyScale.Default
},
{
ModuleA_Impact.ImmediateReaction.Posturing,
FrequencyScale.Default
},
{
ModuleA_Impact.ImmediateReaction.ForwardBuckle,
FrequencyScale.Default
},
{
ModuleA_Impact.ImmediateReaction.Fencing,
FrequencyScale.Default
},
{
ModuleA_Impact.ImmediateReaction.None,
FrequencyScale.Default
}
};
public static Dictionary<ModuleA_Impact.PostureTendency, FrequencyScale> PosturingSettings = new Dictionary<ModuleA_Impact.PostureTendency, FrequencyScale>
{
{
ModuleA_Impact.PostureTendency.Flexor,
FrequencyScale.Default
},
{
ModuleA_Impact.PostureTendency.Extensor,
FrequencyScale.Default
},
{
ModuleA_Impact.PostureTendency.Mixed,
FrequencyScale.Default
},
{
ModuleA_Impact.PostureTendency.None,
FrequencyScale.Default
}
};
public override void OnInitializeMelon()
{
Harmony.CreateAndPatchAll(typeof(ModClass).Assembly, (string)null);
SetupBoneMenu();
Instance = this;
((MelonBase)this).LoggerInstance.Msg("Mod loaded!");
}
public static float GetMultiplier(FrequencyScale scale)
{
if (1 == 0)
{
}
float result = scale switch
{
FrequencyScale.None => 0f,
FrequencyScale.Rare => 0.5f,
FrequencyScale.Default => 1f,
FrequencyScale.Common => 2f,
FrequencyScale.Always => 10f,
_ => 1f,
};
if (1 == 0)
{
}
return result;
}
private static void SetupBoneMenu()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_020b: Unknown result type (might be due to invalid IL or missing references)
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_0271: Unknown result type (might be due to invalid IL or missing references)
//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
//IL_034d: Unknown result type (might be due to invalid IL or missing references)
Color val = default(Color);
((Color)(ref val))..ctor(1f, 0.988f, 0.729f);
Color val2 = default(Color);
((Color)(ref val2))..ctor(1f, 0.25f, 0.25f);
Page val3 = Page.Root.CreatePage("Brain Injuries", val2, 0, true);
Page val4 = val3.CreatePage("GENERAL SETTINGS", val, 0, true);
val4.CreateBool("Knockouts / Unconscious", Color.cyan, true, (Action<bool>)delegate(bool v)
{
UnconsciousEnabled = v;
});
val4.CreateBool("Brain Injuries", Color.yellow, true, (Action<bool>)delegate(bool v)
{
BrainInjuriesEnabled = v;
});
val4.CreateBool("Seizures", Color.yellow, true, (Action<bool>)delegate(bool v)
{
SeizuresEnabled = v;
if (!v)
{
ModuleC_Seizures.ClearAll();
}
});
Page val5 = val3.CreatePage("SEIZURE CHANCE", val, 0, true);
val5.CreateFloat("Blunt Seizure Chance %", Color.white, SeizureChanceBlunt, 1f, 0f, 100f, (Action<float>)delegate(float v)
{
SeizureChanceBlunt = v;
});
val5.CreateFloat("Piercing Seizure Chance %", Color.white, SeizureChancePiercing, 1f, 0f, 100f, (Action<float>)delegate(float v)
{
SeizureChancePiercing = v;
});
Page val6 = val3.CreatePage("DAMAGE RESISTANCE", val, 0, true);
val6.CreateBool("Reduced Torso Damage", Color.white, true, (Action<bool>)delegate(bool v)
{
TorsoArmorEnabled = v;
});
val6.CreateBool("Reduced Blunt Head Damage", Color.white, true, (Action<bool>)delegate(bool v)
{
HeadBluntResistEnabled = v;
});
Page val7 = val3.CreatePage("REACTION WEIGHTS", Color.yellow, 0, true);
Page val8 = val7.CreatePage("IMMEDIATE REACTIONS", Color.white, 0, true);
Page val9 = val7.CreatePage("POSTURING TYPES", Color.white, 0, true);
foreach (ModuleA_Impact.ImmediateReaction reaction in UserSettings.Keys.ToList())
{
val8.CreateEnum(reaction.ToString(), Color.white, (Enum)UserSettings[reaction], (Action<Enum>)delegate(Enum obj)
{
UserSettings[reaction] = (FrequencyScale)(object)obj;
});
}
foreach (ModuleA_Impact.PostureTendency reaction2 in PosturingSettings.Keys.ToList())
{
val9.CreateEnum(reaction2.ToString(), Color.white, (Enum)PosturingSettings[reaction2], (Action<Enum>)delegate(Enum obj)
{
PosturingSettings[reaction2] = (FrequencyScale)(object)obj;
});
}
val7.CreateFunction("RESTORE TO DEFAULT", Color.blue, (Action)delegate
{
foreach (ModuleA_Impact.ImmediateReaction item in UserSettings.Keys.ToList())
{
UserSettings[item] = FrequencyScale.Default;
}
foreach (ModuleA_Impact.PostureTendency item2 in PosturingSettings.Keys.ToList())
{
PosturingSettings[item2] = FrequencyScale.Default;
}
SeizureChanceBlunt = 20f;
SeizureChancePiercing = 8f;
MelonLogger.Msg("Restored settings (buttons will still show old values)");
});
}
public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
{
DeathTracker.ClearAll();
((MelonBase)this).LoggerInstance.Msg("Scene cleared.");
}
}
public class ReactionContext
{
public readonly IntPtr Ptr;
public readonly int Generation;
public readonly Transform Root;
public readonly PuppetMaster Puppet;
public ReactionContext(PuppetMaster puppet)
{
Puppet = puppet;
Ptr = (((Object)(object)puppet != (Object)null) ? ((Il2CppObjectBase)puppet).Pointer : IntPtr.Zero);
Root = (((Object)(object)puppet != (Object)null) ? ((Component)puppet).transform : null);
if (Ptr != IntPtr.Zero && DeathTracker.PointerGeneration.TryGetValue(Ptr, out var value))
{
Generation = value;
}
else
{
Generation = -1;
}
}
public bool IsValid()
{
if ((Object)(object)Root == (Object)null || Ptr == IntPtr.Zero || Generation < 0)
{
return false;
}
int value;
return DeathTracker.PointerGeneration.TryGetValue(Ptr, out value) && value == Generation;
}
}
}
