using System;
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 HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Interaction;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSLZ.VRMK;
using Il2CppSystem;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;
using ViltrumiteMod;
using ViltrumiteMod.Abilities;
using ViltrumiteMod.Abilities.Impl;
[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), "ViltrumiteMod", "1.0.0", "notnotnotswipez", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ViltrumiteMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ViltrumiteMod")]
[assembly: AssemblyTitle("ViltrumiteMod")]
[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]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 ViltrumiteMod
{
public class Core : MelonMod
{
public static float strengthMultiplier = 5f;
public static float speedMultiplier = 5f;
public static float flightSpeed = 10f;
public static bool flightEnabled = true;
public static bool chopEnabled = true;
public static float chopDamage = 1f;
private static AbilityManager activeAbilityManager;
private static MelonPreferences_Category mainCategory = MelonPreferences.CreateCategory("ViltrumiteMod");
private static MelonPreferences_Entry<float> strengthMultiplierEntry = mainCategory.CreateEntry<float>("StrengthMultiplier", 5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
private static MelonPreferences_Entry<float> speedMultiplierEntry = mainCategory.CreateEntry<float>("SpeedMultiplier", 5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
private static MelonPreferences_Entry<float> flightSpeedEntry = mainCategory.CreateEntry<float>("FlightSpeed", 10f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
private static MelonPreferences_Entry<bool> flightEnabledEntry = mainCategory.CreateEntry<bool>("FlightEnabled", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
private static MelonPreferences_Entry<bool> chopEnabledEntry = mainCategory.CreateEntry<bool>("ChopEnabled", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
public override void OnInitializeMelon()
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
strengthMultiplier = strengthMultiplierEntry.Value;
speedMultiplier = speedMultiplierEntry.Value;
flightSpeed = flightSpeedEntry.Value;
flightEnabled = flightEnabledEntry.Value;
chopEnabled = chopEnabledEntry.Value;
Hooking.OnUIRigCreated += delegate
{
activeAbilityManager = new AbilityManager(Player.RigManager);
};
Page val = Page.Root.CreatePage("Viltrumite", Color.yellow, 0, true);
val.CreateFloat("Strength Multiplier", Color.yellow, strengthMultiplier, 5f, 1f, 100f, (Action<float>)delegate(float v)
{
strengthMultiplier = v;
strengthMultiplierEntry.Value = v;
mainCategory.SaveToFile(false);
Player.RigManager.SwapAvatarCrate(((ScannableReference)Player.RigManager.AvatarCrate).Barcode, false, (Action<bool>)null);
});
val.CreateFloat("Speed Multiplier", Color.yellow, speedMultiplier, 0.5f, 1f, 100f, (Action<float>)delegate(float v)
{
speedMultiplier = v;
speedMultiplierEntry.Value = v;
mainCategory.SaveToFile(false);
Player.RigManager.SwapAvatarCrate(((ScannableReference)Player.RigManager.AvatarCrate).Barcode, false, (Action<bool>)null);
});
val.CreateFloat("Flight Speed", Color.yellow, flightSpeed, 0.5f, 1f, 100f, (Action<float>)delegate(float v)
{
flightSpeed = v;
flightSpeedEntry.Value = v;
mainCategory.SaveToFile(false);
});
val.CreateBool("Flight Enabled", Color.green, flightEnabled, (Action<bool>)delegate(bool b)
{
flightEnabled = b;
flightEnabledEntry.Value = b;
mainCategory.SaveToFile(false);
});
val.CreateBool("Chop Enabled", Color.green, chopEnabled, (Action<bool>)delegate(bool b)
{
chopEnabled = b;
chopEnabledEntry.Value = b;
mainCategory.SaveToFile(false);
});
}
public override void OnUpdate()
{
activeAbilityManager?.UpdateLoop();
}
public override void OnFixedUpdate()
{
activeAbilityManager?.FixedUpdateLoop();
}
}
[HarmonyPatch(typeof(Avatar), "RefreshBodyMeasurements", new Type[] { })]
public class AvatarComputeStats
{
public static void Postfix(Avatar __instance)
{
if (Object.op_Implicit((Object)(object)Player.RigManager))
{
RigManager componentInParent = ((Component)__instance).GetComponentInParent<RigManager>();
if (Object.op_Implicit((Object)(object)componentInParent) && ((Object)componentInParent).GetInstanceID() == ((Object)Player.RigManager).GetInstanceID() && !Object.op_Implicit((Object)(object)((Il2CppObjectBase)__instance).TryCast<RealHeptaAvatar>()))
{
__instance._strengthUpper *= Core.strengthMultiplier;
__instance._agility *= Core.speedMultiplier;
}
}
}
}
public static class JointExtensions
{
public static void SetLinearDrive(this ConfigurableJoint joint, float drive, float damp)
{
//IL_0004: 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)
SoftJointLimitSpring linearLimitSpring = default(SoftJointLimitSpring);
((SoftJointLimitSpring)(ref linearLimitSpring)).spring = drive;
((SoftJointLimitSpring)(ref linearLimitSpring)).damper = damp;
joint.linearLimitSpring = linearLimitSpring;
}
public static void SetConnectedPoint(this ConfigurableJoint joint, Vector3 pos)
{
//IL_0036: 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_0026: Unknown result type (might be due to invalid IL or missing references)
((Joint)joint).autoConfigureConnectedAnchor = false;
if (Object.op_Implicit((Object)(object)((Joint)joint).connectedBody))
{
((Joint)joint).connectedAnchor = ((Component)((Joint)joint).connectedBody).transform.InverseTransformPoint(pos);
}
else
{
((Joint)joint).connectedAnchor = pos;
}
}
public static Vector3 GetConnectedPoint(this ConfigurableJoint joint)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: 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_0027: 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)
if (Object.op_Implicit((Object)(object)((Joint)joint).connectedBody))
{
return ((Component)((Joint)joint).connectedBody).transform.TransformPoint(((Joint)joint).connectedAnchor);
}
return ((Joint)joint).connectedAnchor;
}
public static void SetLinearLimit(this ConfigurableJoint joint, float distance)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
SoftJointLimit linearLimit = default(SoftJointLimit);
((SoftJointLimit)(ref linearLimit)).limit = distance;
joint.linearLimit = linearLimit;
}
public static void SetMotion(this ConfigurableJoint joint, ConfigurableJointMotion motion)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
joint.xMotion = motion;
joint.yMotion = motion;
joint.zMotion = motion;
}
public static void SetRotation(this ConfigurableJoint joint, ConfigurableJointMotion motion)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
joint.angularXMotion = motion;
joint.angularYMotion = motion;
joint.angularZMotion = motion;
}
public static void SetRotDrives(this ConfigurableJoint joint, float spring, float damp)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
JointDrive angularXDrive = default(JointDrive);
((JointDrive)(ref angularXDrive)).positionSpring = spring;
((JointDrive)(ref angularXDrive)).positionDamper = damp;
((JointDrive)(ref angularXDrive)).maximumForce = float.PositiveInfinity;
joint.angularXDrive = angularXDrive;
joint.angularYZDrive = joint.angularXDrive;
}
public static void SetPosDrives(this ConfigurableJoint joint, float spring, float damp, float maxForce)
{
//IL_0004: 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_002e: 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)
JointDrive xDrive = default(JointDrive);
((JointDrive)(ref xDrive)).positionSpring = spring;
((JointDrive)(ref xDrive)).positionDamper = damp;
((JointDrive)(ref xDrive)).maximumForce = maxForce;
joint.xDrive = xDrive;
joint.yDrive = joint.xDrive;
joint.zDrive = joint.xDrive;
}
}
}
namespace ViltrumiteMod.Abilities
{
public abstract class Ability
{
public bool active = false;
public RigManager activeManager { get; private set; }
public Ability(RigManager rigManager)
{
activeManager = rigManager;
}
public abstract void Update();
public abstract void FixedUpdate();
public abstract void OnActivate();
public abstract void OnDeactivate();
public abstract bool ShouldActivate();
public abstract bool ShouldDeactivate();
}
public class AbilityManager
{
private RigManager mainManager;
private List<Ability> abilities;
public AbilityManager(RigManager rigManager)
{
mainManager = rigManager;
RegisterAbilities(rigManager);
}
public void RegisterAbilities(RigManager rigManager)
{
mainManager = rigManager;
abilities = new List<Ability>
{
new FlightAbility(rigManager),
new ChopAbility(rigManager)
};
}
public void UpdateLoop()
{
if (!Object.op_Implicit((Object)(object)mainManager))
{
return;
}
foreach (Ability ability in abilities)
{
ability.Update();
if (ability.active)
{
if (ability.ShouldDeactivate())
{
ability.OnDeactivate();
ability.active = false;
}
}
else if (ability.ShouldActivate())
{
ability.OnActivate();
ability.active = true;
}
}
}
public void FixedUpdateLoop()
{
if (!Object.op_Implicit((Object)(object)mainManager))
{
return;
}
foreach (Ability ability in abilities)
{
ability.FixedUpdate();
}
}
}
}
namespace ViltrumiteMod.Abilities.Impl
{
public class ChopAbility : Ability
{
private ChoppingHand leftChoppingHand;
private ChoppingHand rightChoppingHand;
public ChopAbility(RigManager rigManager)
: base(rigManager)
{
leftChoppingHand = new ChoppingHand(rigManager.physicsRig, rigManager.controllerRig, (Handedness)1);
rightChoppingHand = new ChoppingHand(rigManager.physicsRig, rigManager.controllerRig, (Handedness)2);
}
public override void FixedUpdate()
{
}
public override void OnActivate()
{
}
public override void OnDeactivate()
{
}
public override bool ShouldActivate()
{
return true;
}
public override bool ShouldDeactivate()
{
return false;
}
public override void Update()
{
if (active && Core.chopEnabled)
{
float deltaTime = Time.deltaTime;
rightChoppingHand.Update(deltaTime);
leftChoppingHand.Update(deltaTime);
}
}
}
public class ChoppingHand
{
private Hand hand;
private Transform shoulder;
private Transform elbow;
private TriggerRefProxy refProxy;
private Vector3 lastHandPositionForDamage = Vector3.zero;
private BaseController controller;
private Rigidbody handBody;
private List<MarrowBody> entireArm = new List<MarrowBody>();
private MarrowBody[] ignoredBodies;
private List<Collider> ignoredColliders = new List<Collider>();
private ConfigurableJoint resistanceJoint;
private Dictionary<int, IAttackReceiver[]> attackReceiverCache = new Dictionary<int, IAttackReceiver[]>();
private bool activelyChopping = false;
private bool waitingForDebounce = false;
private float timeOutsideBody = 0f;
private const float _maxTimeOutsideBody = 0.2f;
private float _triggerDistance = 0.1f;
private float _handMagnitudeMin = 2f;
private float resistanceSpring = 50000f;
private float resistanceDamp = 400f;
public ChoppingHand(PhysicsRig physicsRig, ControllerRig controllerRig, Handedness handedness)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Invalid comparison between Unknown and I4
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
refProxy = ((Component)((Rig)physicsRig).manager).GetComponentInChildren<TriggerRefProxy>();
if ((int)handedness != 1)
{
if ((int)handedness == 2)
{
hand = physicsRig.rightHand;
entireArm.Add(((Component)((Rig)physicsRig).m_shoulderRt).GetComponent<MarrowBody>());
entireArm.Add(((Component)((Rig)physicsRig).m_elbowRt).GetComponent<MarrowBody>());
shoulder = ((Rig)physicsRig).m_shoulderRt;
elbow = ((Rig)physicsRig).m_elbowRt;
controller = controllerRig.rightController;
}
}
else
{
hand = physicsRig.leftHand;
entireArm.Add(((Component)((Rig)physicsRig).m_shoulderLf).GetComponent<MarrowBody>());
entireArm.Add(((Component)((Rig)physicsRig).m_elbowLf).GetComponent<MarrowBody>());
shoulder = ((Rig)physicsRig).m_shoulderLf;
elbow = ((Rig)physicsRig).m_elbowLf;
controller = controllerRig.leftController;
}
handBody = ((Component)hand).GetComponent<Rigidbody>();
entireArm.Add(((Component)hand).GetComponent<MarrowBody>());
}
public void Update(float deltaTime)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
//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_00aa: Unknown result type (might be due to invalid IL or missing references)
if (waitingForDebounce)
{
if (((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(((Component)hand).transform.position, _triggerDistance + 0.02f, 4096)).Length == 0)
{
waitingForDebounce = false;
}
}
else
{
Vector3 val;
if (!activelyChopping)
{
if (hand.HasAttachedObject() || controller.isBelowGripThreshold)
{
return;
}
val = handBody.velocity;
if (!(((Vector3)(ref val)).magnitude > _handMagnitudeMin))
{
return;
}
{
foreach (Collider item in (Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(((Component)hand).transform.position, _triggerDistance, 4096))
{
MarrowEntity componentInParent = ((Component)item).GetComponentInParent<MarrowEntity>();
if (Object.op_Implicit((Object)(object)componentInParent))
{
ignoredBodies = Il2CppArrayBase<MarrowBody>.op_Implicit((Il2CppArrayBase<MarrowBody>)(object)componentInParent._bodies);
ignoredColliders.Clear();
MarrowBody[] array = ignoredBodies;
foreach (MarrowBody val2 in array)
{
ignoredColliders.AddRange((IEnumerable<Collider>)val2._colliders);
}
IgnoreCapturedBodies(ignore: true);
activelyChopping = true;
MakeResistanceJoint();
break;
}
}
return;
}
}
UpdateResistanceJoint();
val = lastHandPositionForDamage - ((Component)hand).transform.position;
if (((Vector3)(ref val)).magnitude > 0.2f)
{
DamageNearbyReceiver();
lastHandPositionForDamage = ((Component)hand).transform.position;
}
if (IsArmOutsideBody())
{
timeOutsideBody += deltaTime;
}
if (timeOutsideBody >= 0.2f)
{
attackReceiverCache.Clear();
IgnoreCapturedBodies(ignore: false);
Object.Destroy((Object)(object)resistanceJoint);
waitingForDebounce = true;
activelyChopping = false;
timeOutsideBody = 0f;
}
}
}
public void MakeResistanceJoint()
{
//IL_002a: 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)
resistanceJoint = ((Component)hand).gameObject.AddComponent<ConfigurableJoint>();
((Joint)resistanceJoint).autoConfigureConnectedAnchor = false;
((Joint)resistanceJoint).anchor = Vector3.zero;
resistanceJoint.SetConnectedPoint(((Component)hand).transform.position);
resistanceJoint.SetPosDrives(resistanceSpring, resistanceDamp, float.PositiveInfinity);
}
public void UpdateResistanceJoint()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)resistanceJoint))
{
resistanceJoint.SetConnectedPoint(((Component)hand).transform.position);
}
}
public void DamageNearbyReceiver()
{
//IL_0026: 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_0064: 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_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: 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_00a8: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Expected O, but got Unknown
MarrowBody val = null;
float num = float.MaxValue;
MarrowBody[] array = ignoredBodies;
foreach (MarrowBody val2 in array)
{
float num2 = Vector3.Distance(((Component)val2).transform.position, ((Component)hand).transform.position);
if (num > num2)
{
num = num2;
val = val2;
}
}
Attack val3 = new Attack
{
direction = hand.palmPositionTransform.forward,
collider = ((Il2CppArrayBase<Collider>)(object)val._colliders)[0],
attackType = (AttackType)2,
proxy = refProxy,
backFacing = false,
damage = Core.chopDamage,
normal = Vector3.up,
OrderInPool = 0,
origin = ((Component)hand).transform.position
};
int instanceID = ((Object)val).GetInstanceID();
IAttackReceiver[] array2;
if (attackReceiverCache.ContainsKey(instanceID))
{
array2 = attackReceiverCache[instanceID];
}
else
{
array2 = Il2CppArrayBase<IAttackReceiver>.op_Implicit(((Component)val).GetComponents<IAttackReceiver>());
attackReceiverCache.Add(instanceID, array2);
}
for (int j = 0; j < 3; j++)
{
IAttackReceiver[] array3 = array2;
foreach (IAttackReceiver val4 in array3)
{
val4.ReceiveAttack(val3);
}
}
}
public bool IsArmOutsideBody()
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: 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_0022: 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_0039: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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)
bool result = true;
Vector3 position = shoulder.position;
Vector3 position2 = elbow.position;
Vector3 val = position2 - position;
Vector3 val2 = ((Component)hand).transform.position - position2;
if (Physics.Raycast(position, val, ((Vector3)(ref val)).magnitude, 4096))
{
result = false;
}
if (Physics.Raycast(position2, val2, ((Vector3)(ref val2)).magnitude, 4096))
{
result = false;
}
return result;
}
public void IgnoreCapturedBodies(bool ignore)
{
foreach (MarrowBody item in entireArm)
{
MarrowBody[] array = ignoredBodies;
foreach (MarrowBody val in array)
{
val.IgnoreCollision(item, ignore);
}
}
}
}
public class FlightAbility : Ability
{
private BaseController rightController;
private BaseController leftController;
private Hand rightHand;
private Transform head;
private Rigidbody[] bodies;
private float lastPressTime = 0f;
private const float _gapTime = 0.2f;
private int pressCount = 0;
private bool activated = false;
public FlightAbility(RigManager rigManager)
: base(rigManager)
{
rightHand = rigManager.physicsRig.rightHand;
head = ((Rig)rigManager.physicsRig).m_head;
rightController = rigManager.controllerRig.rightController;
leftController = rigManager.controllerRig.leftController;
bodies = Il2CppArrayBase<Rigidbody>.op_Implicit(((Component)rigManager).GetComponentsInChildren<Rigidbody>());
}
public override void OnActivate()
{
Rigidbody[] array = bodies;
foreach (Rigidbody val in array)
{
val.useGravity = false;
}
}
public override void OnDeactivate()
{
Rigidbody[] array = bodies;
foreach (Rigidbody val in array)
{
val.useGravity = true;
}
}
public override bool ShouldActivate()
{
if (!Core.flightEnabled)
{
return false;
}
return activated;
}
public override bool ShouldDeactivate()
{
if (!Core.flightEnabled)
{
return true;
}
return !activated;
}
public override void Update()
{
if (Core.flightEnabled && rightController.GetBButtonDown() && !rightHand.HasAttachedObject())
{
float time = Time.time;
if (time - lastPressTime < 0.2f)
{
pressCount++;
}
else
{
pressCount = 0;
}
lastPressTime = time;
if (pressCount >= 1)
{
activated = !activated;
pressCount = 0;
}
}
}
public override void FixedUpdate()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: 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_003a: 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_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_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
if (!Core.flightEnabled || !activated)
{
return;
}
Vector2 thumbStickAxis = leftController.GetThumbStickAxis();
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(thumbStickAxis.x, 0f, thumbStickAxis.y);
if (((Vector3)(ref val)).magnitude > 0.1f)
{
Vector3 val2 = head.rotation * val;
((Vector3)(ref val2)).Normalize();
Rigidbody[] array = bodies;
foreach (Rigidbody val3 in array)
{
val3.AddForce(val2 * Core.flightSpeed, (ForceMode)5);
}
}
else
{
Rigidbody[] array2 = bodies;
foreach (Rigidbody val4 in array2)
{
val4.AddForce(-val4.velocity, (ForceMode)5);
}
}
}
}
}
