using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BloodLab.Blood;
using BloodLab.Configuration;
using BloodLab.Core;
using BloodLab.Droplet;
using BloodLab.Effects;
using BloodLab.Stain;
using BloodLab.Utilities;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.PuppetMasta;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(BloodLabMod), "BloodLab", "0.1.0", "leonfwfw", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BloodLab")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BloodLab")]
[assembly: AssemblyTitle("BloodLab")]
[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 BloodLab.Utilities
{
public static class SurfaceUtils
{
public static Quaternion AlignToNormal(Vector3 normal)
{
//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_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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_0045: 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_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: 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)
if (((Vector3)(ref normal)).sqrMagnitude < 0.0001f)
{
normal = Vector3.up;
}
((Vector3)(ref normal)).Normalize();
Vector3 val = ((Mathf.Abs(Vector3.Dot(normal, Vector3.up)) > 0.95f) ? Vector3.forward : Vector3.up);
Quaternion val2 = Quaternion.LookRotation(-normal, val);
float num = Random.Range(0f, 360f);
return val2 * Quaternion.Euler(0f, 0f, num);
}
public static Vector3 SafeOffset(Vector3 point, Vector3 normal, float distance = 0.01f)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: 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_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_0017: Unknown result type (might be due to invalid IL or missing references)
return point + ((Vector3)(ref normal)).normalized * distance;
}
}
}
namespace BloodLab.Stain
{
[RegisterTypeInIl2Cpp]
public class BloodStain : MonoBehaviour
{
private static Mesh _sharedQuadMesh;
private static Shader _cachedShader;
private static bool _shaderResolved;
private MeshRenderer _renderer;
private MaterialPropertyBlock _propertyBlock;
private float _timer;
private float _lifetime;
private float _currentSize;
public Vector3 WorldPosition => ((Component)this).transform.position;
public BloodStain(IntPtr ptr)
: base(ptr)
{
}
private void Awake()
{
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
//IL_0092: 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_00a5: Expected O, but got Unknown
EnsureSharedMesh();
MeshFilter val = ((Component)this).GetComponent<MeshFilter>();
if ((Object)(object)val == (Object)null)
{
val = ((Component)this).gameObject.AddComponent<MeshFilter>();
}
val.sharedMesh = _sharedQuadMesh;
_renderer = ((Component)this).GetComponent<MeshRenderer>();
if ((Object)(object)_renderer == (Object)null)
{
_renderer = ((Component)this).gameObject.AddComponent<MeshRenderer>();
}
((Renderer)_renderer).shadowCastingMode = (ShadowCastingMode)0;
((Renderer)_renderer).receiveShadows = false;
Shader val2 = ResolveWorkingShader();
if ((Object)(object)val2 != (Object)null)
{
((Renderer)_renderer).sharedMaterial = new Material(val2)
{
hideFlags = (HideFlags)61
};
}
_propertyBlock = new MaterialPropertyBlock();
}
public void PlaceOnGround(Vector3 worldPosition, Vector3 groundNormal, Texture2D texture, float startSize)
{
//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)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: 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_0058: Unknown result type (might be due to invalid IL or missing references)
((Component)this).transform.SetParent((Transform)null, false);
((Component)this).transform.position = SurfaceUtils.SafeOffset(worldPosition, groundNormal, 0.006f);
((Component)this).transform.rotation = SurfaceUtils.AlignToNormal(groundNormal);
_currentSize = startSize;
((Component)this).transform.localScale = new Vector3(_currentSize, _currentSize, 1f);
if ((Object)(object)texture != (Object)null && (Object)(object)_renderer != (Object)null && (Object)(object)((Renderer)_renderer).sharedMaterial != (Object)null)
{
_propertyBlock.Clear();
((Renderer)_renderer).GetPropertyBlock(_propertyBlock);
_propertyBlock.SetTexture("_MainTex", (Texture)(object)texture);
((Renderer)_renderer).SetPropertyBlock(_propertyBlock);
}
_timer = 0f;
_lifetime = BloodLabPreferences.SplatLifetime.Value * 3f;
}
public void Grow(float amount, float maxSize)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
_currentSize = Mathf.Min(_currentSize + amount, maxSize);
((Component)this).transform.localScale = new Vector3(_currentSize, _currentSize, 1f);
_timer = 0f;
}
private void Update()
{
if ((Object)(object)this == (Object)null)
{
return;
}
try
{
_timer += Time.deltaTime;
if (_timer >= _lifetime)
{
BloodEffectManager.ReleaseStain(this);
}
}
catch
{
}
}
private static Shader ResolveWorkingShader()
{
if (_shaderResolved)
{
return _cachedShader;
}
_shaderResolved = true;
string[] array = new string[4] { "Sprites/Default", "Unlit/Transparent", "Unlit/Texture", "UI/Default" };
string[] array2 = array;
foreach (string text in array2)
{
Shader val = Shader.Find(text);
if ((Object)(object)val != (Object)null)
{
_cachedShader = val;
return _cachedShader;
}
}
Renderer val2 = Object.FindObjectOfType<Renderer>();
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMaterial != (Object)null && (Object)(object)val2.sharedMaterial.shader != (Object)null)
{
_cachedShader = val2.sharedMaterial.shader;
return _cachedShader;
}
_shaderResolved = false;
return null;
}
private static void EnsureSharedMesh()
{
//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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0050: 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_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: 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_00e3: 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_00fe: 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_0114: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)_sharedQuadMesh != (Object)null))
{
_sharedQuadMesh = new Mesh
{
name = "BloodLab_StainQuadMesh",
hideFlags = (HideFlags)61
};
_sharedQuadMesh.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
{
new Vector3(-0.5f, -0.5f, 0f),
new Vector3(0.5f, -0.5f, 0f),
new Vector3(0.5f, 0.5f, 0f),
new Vector3(-0.5f, 0.5f, 0f)
});
_sharedQuadMesh.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[4]
{
new Vector2(0f, 0f),
new Vector2(1f, 0f),
new Vector2(1f, 1f),
new Vector2(0f, 1f)
});
_sharedQuadMesh.triangles = Il2CppStructArray<int>.op_Implicit(new int[6] { 0, 2, 1, 0, 3, 2 });
_sharedQuadMesh.RecalculateNormals();
_sharedQuadMesh.RecalculateBounds();
}
}
}
}
namespace BloodLab.Effects
{
public enum ImpactSource
{
Projectile,
Melee
}
public struct ImpactData
{
public Vector3 Position;
public Vector3 Normal;
public Vector3 Direction;
public Collider HitCollider;
public GameObject HitObject;
public bool IsLivingEntity;
public float Intensity;
public ImpactSource Source;
}
public static class ImpactHooks
{
[HarmonyPatch(typeof(Projectile), "Awake")]
public static class ProjectileAwakePatch
{
public static void Postfix(Projectile __instance)
{
try
{
if ((Object)(object)__instance == (Object)null || __instance.onCollision == null)
{
return;
}
((UnityEvent<Collider, Vector3, Vector3>)(object)__instance.onCollision).AddListener(UnityAction<Collider, Vector3, Vector3>.op_Implicit((Action<Collider, Vector3, Vector3>)delegate(Collider hitCollider, Vector3 worldPoint, Vector3 normal)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: 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_0054: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!((Object)(object)hitCollider == (Object)null))
{
Vector3 direction = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform.forward : (-normal));
ImpactData data = new ImpactData
{
Position = worldPoint,
Normal = normal,
Direction = direction,
HitCollider = hitCollider,
HitObject = ((Component)hitCollider).gameObject,
IsLivingEntity = IsLivingTarget(hitCollider),
Intensity = 1f,
Source = ImpactSource.Projectile
};
BloodEffectManager.HandleImpact(data);
}
}
catch (Exception ex2)
{
MelonLogger.Error("[BloodLab] cant process projectile impact: " + ex2);
}
}));
}
catch (Exception ex)
{
MelonLogger.Error("[BloodLab] couldnt install hook on Projectile.Awake: " + ex);
}
}
}
[HarmonyPatch(typeof(SubBehaviourHealth), "TakeDamage")]
public static class TakeDamagePatch
{
public static void Postfix(SubBehaviourHealth __instance, int m, Attack attack)
{
//IL_001c: 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_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_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: 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_0048: 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_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: 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_0081: Unknown result type (might be due to invalid IL or missing references)
try
{
Collider collider = attack.collider;
if (!((Object)(object)collider == (Object)null))
{
ResolveMeleeHitPoint(attack.origin, collider, out var point, out var normal);
Vector3 val = point - attack.origin;
Vector3 val2;
if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f))
{
val2 = -normal;
}
else
{
val = point - attack.origin;
val2 = ((Vector3)(ref val)).normalized;
}
Vector3 direction = val2;
ImpactData data = new ImpactData
{
Position = point,
Normal = normal,
Direction = direction,
HitCollider = collider,
HitObject = ((Component)collider).gameObject,
IsLivingEntity = true,
Intensity = Mathf.Clamp01((float)m / 25f),
Source = ImpactSource.Melee
};
BloodEffectManager.HandleImpact(data);
}
}
catch (Exception ex)
{
MelonLogger.Error("[BloodLab] melee damage failed to process lol: " + ex);
}
}
}
private static void ResolveMeleeHitPoint(Vector3 origin, Collider col, out Vector3 point, out Vector3 normal)
{
//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_000a: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: 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)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: 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_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_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds = col.bounds;
Vector3 center = ((Bounds)(ref bounds)).center;
Vector3 val = center - origin;
RaycastHit val2 = default(RaycastHit);
if (((Vector3)(ref val)).sqrMagnitude > 0.0001f && Physics.Raycast(origin, ((Vector3)(ref val)).normalized, ref val2, ((Vector3)(ref val)).magnitude + 1f) && (Object)(object)((RaycastHit)(ref val2)).collider == (Object)(object)col)
{
point = ((RaycastHit)(ref val2)).point;
normal = ((RaycastHit)(ref val2)).normal;
return;
}
point = col.ClosestPoint(origin);
Vector3 val3 = point - origin;
Vector3 val4;
if (!(((Vector3)(ref val3)).sqrMagnitude > 0.0001f))
{
val4 = ((Component)col).transform.up;
}
else
{
val3 = point - origin;
val4 = ((Vector3)(ref val3)).normalized;
}
normal = val4;
}
private static bool IsLivingTarget(Collider hitCollider)
{
AIBrain componentInParent = ((Component)hitCollider).GetComponentInParent<AIBrain>();
return (Object)(object)componentInParent != (Object)null && !componentInParent.isDead;
}
}
}
namespace BloodLab.Droplet
{
[RegisterTypeInIl2Cpp]
public class BloodDroplet : MonoBehaviour
{
private static Mesh _sharedQuadMesh;
private static Shader _cachedShader;
private static bool _shaderResolved;
private Rigidbody _rb;
private SphereCollider _collider;
private MeshRenderer _renderer;
private MaterialPropertyBlock _propertyBlock;
private float _timer;
private float _lifetime;
private bool _hasLanded;
public BloodDroplet(IntPtr ptr)
: base(ptr)
{
}
private void Awake()
{
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
//IL_0092: 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_00a5: Expected O, but got Unknown
EnsureSharedMesh();
MeshFilter val = ((Component)this).GetComponent<MeshFilter>();
if ((Object)(object)val == (Object)null)
{
val = ((Component)this).gameObject.AddComponent<MeshFilter>();
}
val.sharedMesh = _sharedQuadMesh;
_renderer = ((Component)this).GetComponent<MeshRenderer>();
if ((Object)(object)_renderer == (Object)null)
{
_renderer = ((Component)this).gameObject.AddComponent<MeshRenderer>();
}
((Renderer)_renderer).shadowCastingMode = (ShadowCastingMode)0;
((Renderer)_renderer).receiveShadows = false;
Shader val2 = ResolveWorkingShader();
if ((Object)(object)val2 != (Object)null)
{
((Renderer)_renderer).sharedMaterial = new Material(val2)
{
hideFlags = (HideFlags)61
};
}
_propertyBlock = new MaterialPropertyBlock();
_collider = ((Component)this).GetComponent<SphereCollider>();
if ((Object)(object)_collider == (Object)null)
{
_collider = ((Component)this).gameObject.AddComponent<SphereCollider>();
}
_collider.radius = 0.03f;
((Collider)_collider).isTrigger = false;
_rb = ((Component)this).GetComponent<Rigidbody>();
if ((Object)(object)_rb == (Object)null)
{
_rb = ((Component)this).gameObject.AddComponent<Rigidbody>();
}
_rb.useGravity = true;
_rb.mass = 0.001f;
_rb.drag = 0.3f;
_rb.collisionDetectionMode = (CollisionDetectionMode)3;
}
public void SetTexture(Texture2D texture)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)texture == (Object)null) && !((Object)(object)_renderer == (Object)null) && !((Object)(object)((Renderer)_renderer).sharedMaterial == (Object)null))
{
_propertyBlock.Clear();
((Renderer)_renderer).GetPropertyBlock(_propertyBlock);
_propertyBlock.SetTexture("_MainTex", (Texture)(object)texture);
_propertyBlock.SetColor("_Color", Color.white);
((Renderer)_renderer).SetPropertyBlock(_propertyBlock);
}
}
public void Launch(Vector3 position, Vector3 direction, float speed, Transform ignoreRoot)
{
//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)
//IL_0020: 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_008d: 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_00b1: 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_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_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: 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_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: 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)
((Component)this).transform.SetParent((Transform)null, true);
((Component)this).transform.position = position + Vector3.up * 0.03f;
if ((Object)(object)Camera.main != (Object)null)
{
Vector3 val = ((Component)Camera.main).transform.position - ((Component)this).transform.position;
Vector3 normalized = ((Vector3)(ref val)).normalized;
((Component)this).transform.rotation = Quaternion.LookRotation(normalized);
}
float value = BloodLabPreferences.DropletVisualScale.Value;
((Component)this).transform.localScale = Vector3.one * value;
((Collider)_collider).enabled = true;
Il2CppReferenceArray<Collider> val2 = Physics.OverlapSphere(((Component)this).transform.position, 0.18f);
foreach (Collider item in (Il2CppArrayBase<Collider>)(object)val2)
{
if (!((Object)(object)item == (Object)null))
{
Rigidbody attachedRigidbody = item.attachedRigidbody;
if ((Object)(object)attachedRigidbody != (Object)null && !attachedRigidbody.isKinematic)
{
Physics.IgnoreCollision((Collider)(object)_collider, item, true);
}
}
}
_rb.velocity = ((Vector3)(ref direction)).normalized * speed;
_timer = 0f;
_hasLanded = false;
_lifetime = BloodLabPreferences.DropletLifetime.Value;
}
private void Update()
{
if (!((Object)(object)this == (Object)null) && !_hasLanded)
{
_timer += Time.deltaTime;
if (_timer >= _lifetime)
{
BloodEffectManager.ReleaseDroplet(this);
}
}
}
private void OnCollisionEnter(Collision collision)
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: 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_006b: 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_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)this == (Object)null || _hasLanded || collision == null)
{
return;
}
Collider collider = collision.collider;
if ((Object)(object)collider == (Object)null)
{
return;
}
if (IsCharacterCollider(collider))
{
Physics.IgnoreCollision((Collider)(object)_collider, collider, true);
return;
}
_hasLanded = true;
Vector3 val;
ContactPoint contact;
if (collision.contactCount <= 0)
{
val = ((Component)this).transform.position;
}
else
{
contact = collision.GetContact(0);
val = ((ContactPoint)(ref contact)).point;
}
Vector3 groundPosition = val;
Vector3 val2;
if (collision.contactCount <= 0)
{
val2 = Vector3.up;
}
else
{
contact = collision.GetContact(0);
val2 = ((ContactPoint)(ref contact)).normal;
}
Vector3 groundNormal = val2;
BloodEffectManager.HandleDropletLanded(groundPosition, groundNormal);
BloodEffectManager.ReleaseDroplet(this);
}
private static bool IsCharacterCollider(Collider col)
{
if ((Object)(object)((Component)col).GetComponentInParent<AIBrain>() != (Object)null)
{
return true;
}
int num = LayerMask.NameToLayer("EnemyColliders");
if (num >= 0 && ((Component)col).gameObject.layer == num)
{
return true;
}
Rigidbody attachedRigidbody = col.attachedRigidbody;
if ((Object)(object)attachedRigidbody != (Object)null && !attachedRigidbody.isKinematic)
{
return true;
}
return false;
}
private static Shader ResolveWorkingShader()
{
if (_shaderResolved)
{
return _cachedShader;
}
_shaderResolved = true;
string[] array = new string[4] { "Sprites/Default", "Unlit/Transparent", "Unlit/Texture", "UI/Default" };
string[] array2 = array;
foreach (string text in array2)
{
Shader val = Shader.Find(text);
if ((Object)(object)val != (Object)null)
{
_cachedShader = val;
return _cachedShader;
}
}
Renderer val2 = Object.FindObjectOfType<Renderer>();
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMaterial != (Object)null && (Object)(object)val2.sharedMaterial.shader != (Object)null)
{
_cachedShader = val2.sharedMaterial.shader;
return _cachedShader;
}
_shaderResolved = false;
return null;
}
private static void EnsureSharedMesh()
{
//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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0050: 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_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: 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_00e3: 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_00fe: 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_0114: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)_sharedQuadMesh != (Object)null))
{
_sharedQuadMesh = new Mesh
{
name = "BloodLab_DropletQuadMesh",
hideFlags = (HideFlags)61
};
_sharedQuadMesh.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
{
new Vector3(-0.5f, -0.5f, 0f),
new Vector3(0.5f, -0.5f, 0f),
new Vector3(0.5f, 0.5f, 0f),
new Vector3(-0.5f, 0.5f, 0f)
});
_sharedQuadMesh.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[4]
{
new Vector2(0f, 0f),
new Vector2(1f, 0f),
new Vector2(1f, 1f),
new Vector2(0f, 1f)
});
_sharedQuadMesh.triangles = Il2CppStructArray<int>.op_Implicit(new int[6] { 0, 2, 1, 0, 3, 2 });
_sharedQuadMesh.RecalculateNormals();
_sharedQuadMesh.RecalculateBounds();
}
}
}
public static class DropletManager
{
public static void HandleBleed(Vector3 woundWorldPosition, Vector3 woundNormal, float intensity, Transform woundRoot)
{
//IL_004f: 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_005e: 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)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
if (BloodLabPreferences.EnableDripping.Value)
{
int value = BloodLabPreferences.DropletsPerHit.Value;
int num = Mathf.Clamp(Mathf.RoundToInt((float)value * Mathf.Clamp(intensity, 0.5f, 2f)), 1, 40);
for (int i = 0; i < num; i++)
{
BloodDroplet dropletFromPool = BloodEffectManager.GetDropletFromPool();
Vector3 val = Vector3.down * 1.2f + Random.insideUnitSphere * 0.8f;
Vector3 normalized = ((Vector3)(ref val)).normalized;
float speed = Random.Range(0.6f, 2.2f);
dropletFromPool.Launch(woundWorldPosition, normalized, speed, woundRoot);
}
MelonLogger.Msg($"[BloodLab] {num} droplets launched from wound");
}
}
}
}
namespace BloodLab.Core
{
public class BloodLabMod : MelonMod
{
private Harmony _harmony;
public override void OnInitializeMelon()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
try
{
if (!ClassInjector.IsTypeRegisteredInIl2Cpp<BloodDecal>())
{
ClassInjector.RegisterTypeInIl2Cpp<BloodDecal>();
}
if (!ClassInjector.IsTypeRegisteredInIl2Cpp<BloodStain>())
{
ClassInjector.RegisterTypeInIl2Cpp<BloodStain>();
}
if (!ClassInjector.IsTypeRegisteredInIl2Cpp<BloodDroplet>())
{
ClassInjector.RegisterTypeInIl2Cpp<BloodDroplet>();
}
MelonLogger.Msg("[BloodLab] classes registered");
BloodLabPreferences.Initialize();
BloodTextureLibrary.Initialize();
BloodEffectManager.Initialize();
BloodLabBoneMenu.Setup();
_harmony = new Harmony("com.bloodlab.mod");
_harmony.PatchAll();
MelonLogger.Msg("[BloodLab] initialized");
}
catch (Exception ex)
{
MelonLogger.Error("[BloodLab] critical error when yo shi was installing " + ex);
}
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
try
{
BloodTextureLibrary.Reload();
}
catch (Exception ex)
{
MelonLogger.Error("[BloodLab] cant reload texture " + ex);
}
}
}
}
namespace BloodLab.Configuration
{
public static class BloodLabBoneMenu
{
public static void Setup()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
Page root = Page.Root.CreatePage("BloodLab", Color.red, 0, true);
SetupGeneralPage(root);
SetupSplatPage(root);
SetupPoolPage(root);
}
private static void SetupGeneralPage(Page root)
{
//IL_0007: 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_0054: Unknown result type (might be due to invalid IL or missing references)
Page val = root.CreatePage("General", Color.white, 0, true);
val.CreateBool("Physical Droplets", Color.white, BloodLabPreferences.EnableDripping.Value, (Action<bool>)delegate(bool value)
{
BloodLabPreferences.EnableDripping.Value = value;
BloodLabPreferences.Save();
});
val.CreateBool("Impact Particles", Color.white, BloodLabPreferences.EnableParticles.Value, (Action<bool>)delegate(bool value)
{
BloodLabPreferences.EnableParticles.Value = value;
BloodLabPreferences.Save();
});
CreateAdjustableFloat(val, "Overall Intensity", BloodLabPreferences.Intensity, 0.1f, 0.1f, 3f);
CreateAdjustableInt(val, "Droplets Per Hit", BloodLabPreferences.DropletsPerHit, 2, 1, 30);
CreateAdjustableFloat(val, "Droplet Visual Size", BloodLabPreferences.DropletVisualScale, 0.01f, 0.02f, 0.3f);
}
private static void SetupSplatPage(Page root)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
Page page = root.CreatePage("Wall/Floor Splats", Color.white, 0, true);
CreateAdjustableInt(page, "Max Splats", BloodLabPreferences.MaxSplats, 10, 10, 500);
CreateAdjustableFloat(page, "Min Splat Size", BloodLabPreferences.MinSplatSize, 0.02f, 0.02f, 1f);
CreateAdjustableFloat(page, "Max Splat Size", BloodLabPreferences.MaxSplatSize, 0.02f, 0.02f, 1f);
}
private static void SetupPoolPage(Page root)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
Page page = root.CreatePage("Blood Pools", Color.white, 0, true);
CreateAdjustableInt(page, "Max Pools", BloodLabPreferences.MaxStains, 5, 1, 150);
CreateAdjustableFloat(page, "Max Pool Size", BloodLabPreferences.StainMaxSize, 0.05f, 0.1f, 2f);
CreateAdjustableFloat(page, "Growth Per Droplet", BloodLabPreferences.StainGrowthPerDroplet, 0.01f, 0.005f, 0.2f);
CreateAdjustableFloat(page, "Merge Radius", BloodLabPreferences.StainMergeRadius, 0.05f, 0.05f, 1.5f);
}
private static void CreateAdjustableFloat(Page page, string label, MelonPreferences_Entry<float> entry, float step, float min, float max)
{
//IL_0071: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
FunctionElement display = page.CreateFunction($"{label}: {entry.Value:0.00}", Color.white, (Action)delegate
{
});
page.CreateFunction("- " + label, Color.yellow, (Action)delegate
{
entry.Value = Mathf.Clamp(entry.Value - step, min, max);
BloodLabPreferences.Save();
((Element)display).ElementName = $"{label}: {entry.Value:0.00}";
});
page.CreateFunction("+ " + label, Color.green, (Action)delegate
{
entry.Value = Mathf.Clamp(entry.Value + step, min, max);
BloodLabPreferences.Save();
((Element)display).ElementName = $"{label}: {entry.Value:0.00}";
});
}
private static void CreateAdjustableInt(Page page, string label, MelonPreferences_Entry<int> entry, int step, int min, int max)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
FunctionElement display = page.CreateFunction($"{label}: {entry.Value}", Color.white, (Action)delegate
{
});
page.CreateFunction("- " + label, Color.yellow, (Action)delegate
{
entry.Value = Mathf.Clamp(entry.Value - step, min, max);
BloodLabPreferences.Save();
((Element)display).ElementName = $"{label}: {entry.Value}";
});
page.CreateFunction("+ " + label, Color.green, (Action)delegate
{
entry.Value = Mathf.Clamp(entry.Value + step, min, max);
BloodLabPreferences.Save();
((Element)display).ElementName = $"{label}: {entry.Value}";
});
}
}
public static class BloodLabPreferences
{
private static MelonPreferences_Category _category;
public static MelonPreferences_Entry<int> MaxSplats;
public static MelonPreferences_Entry<int> MaxDroplets;
public static MelonPreferences_Entry<int> MaxStains;
public static MelonPreferences_Entry<int> DropletsPerHit;
public static MelonPreferences_Entry<float> DropletVisualScale;
public static MelonPreferences_Entry<float> SplatLifetime;
public static MelonPreferences_Entry<float> DropletLifetime;
public static MelonPreferences_Entry<float> MinSplatSize;
public static MelonPreferences_Entry<float> MaxSplatSize;
public static MelonPreferences_Entry<float> StainMaxSize;
public static MelonPreferences_Entry<float> StainGrowthPerDroplet;
public static MelonPreferences_Entry<float> StainMergeRadius;
public static MelonPreferences_Entry<float> Intensity;
public static MelonPreferences_Entry<bool> EnableDripping;
public static MelonPreferences_Entry<bool> EnableParticles;
public static void Initialize()
{
_category = MelonPreferences.CreateCategory("BloodLab");
MaxSplats = _category.CreateEntry<int>("MaxSplats", 120, (string)null, "max number of splats", false, false, (ValueValidator)null, (string)null);
MaxDroplets = _category.CreateEntry<int>("MaxDroplets", 100, (string)null, "max number of droplets", false, false, (ValueValidator)null, (string)null);
MaxStains = _category.CreateEntry<int>("MaxStains", 40, (string)null, "max number of pools.", false, false, (ValueValidator)null, (string)null);
DropletsPerHit = _category.CreateEntry<int>("DropletsPerHit", 10, (string)null, "how many droplets spawn on wounds", false, false, (ValueValidator)null, (string)null);
DropletVisualScale = _category.CreateEntry<float>("DropletVisualScale", 0.05f, (string)null, "size of each droplet", false, false, (ValueValidator)null, (string)null);
SplatLifetime = _category.CreateEntry<float>("SplatLifetimeSeconds", 45f, (string)null, "time until a splat disappears", false, false, (ValueValidator)null, (string)null);
DropletLifetime = _category.CreateEntry<float>("DropletLifetimeSeconds", 12f, (string)null, "time until a droplet is recycled if it never lands", false, false, (ValueValidator)null, (string)null);
MinSplatSize = _category.CreateEntry<float>("MinSplatSize", 0.05f, (string)null, "min size of a splat.", false, false, (ValueValidator)null, (string)null);
MaxSplatSize = _category.CreateEntry<float>("MaxSplatSize", 0.35f, (string)null, "max size of a splat.", false, false, (ValueValidator)null, (string)null);
StainMaxSize = _category.CreateEntry<float>("StainMaxSize", 0.6f, (string)null, "max size a pool can grow to", false, false, (ValueValidator)null, (string)null);
StainGrowthPerDroplet = _category.CreateEntry<float>("StainGrowthPerDroplet", 0.03f, (string)null, "how much a pool grow every time a droplet lands in it", false, false, (ValueValidator)null, (string)null);
StainMergeRadius = _category.CreateEntry<float>("StainMergeRadius", 0.35f, (string)null, "how close a droplet gotta land to a pool to grow it instead of creating a new one", false, false, (ValueValidator)null, (string)null);
Intensity = _category.CreateEntry<float>("Intensity", 1f, (string)null, "blood intensity multiplier", false, false, (ValueValidator)null, (string)null);
EnableDripping = _category.CreateEntry<bool>("EnableDripping", true, (string)null, "toggle droplets", false, false, (ValueValidator)null, (string)null);
EnableParticles = _category.CreateEntry<bool>("EnableParticles", true, (string)null, "toggle impact particles", false, false, (ValueValidator)null, (string)null);
MelonLogger.Msg("[BloodLab] Preferences loaded.");
}
public static void Save()
{
MelonPreferences_Category category = _category;
if (category != null)
{
category.SaveToFile(false);
}
}
}
}
namespace BloodLab.Blood
{
[RegisterTypeInIl2Cpp]
public class BloodDecal : MonoBehaviour
{
private static Mesh _sharedQuadMesh;
private static Shader _cachedShader;
private static bool _shaderResolved;
private MeshRenderer _renderer;
private MaterialPropertyBlock _propertyBlock;
private float _timer;
private float _lifetime;
public BloodDecal(IntPtr ptr)
: base(ptr)
{
}
private void Awake()
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Expected O, but got Unknown
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
EnsureSharedMesh();
MeshFilter val = ((Component)this).GetComponent<MeshFilter>();
if ((Object)(object)val == (Object)null)
{
val = ((Component)this).gameObject.AddComponent<MeshFilter>();
}
val.sharedMesh = _sharedQuadMesh;
_renderer = ((Component)this).GetComponent<MeshRenderer>();
if ((Object)(object)_renderer == (Object)null)
{
_renderer = ((Component)this).gameObject.AddComponent<MeshRenderer>();
}
((Renderer)_renderer).shadowCastingMode = (ShadowCastingMode)0;
((Renderer)_renderer).receiveShadows = false;
Shader val2 = ResolveWorkingShader();
if ((Object)(object)val2 != (Object)null)
{
((Renderer)_renderer).sharedMaterial = new Material(val2)
{
hideFlags = (HideFlags)61
};
}
_propertyBlock = new MaterialPropertyBlock();
}
public void Setup(Vector3 position, Vector3 normal, Texture2D texture, float size)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: 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_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: 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)
((Component)this).transform.position = SurfaceUtils.SafeOffset(position, normal, 0.008f);
((Component)this).transform.rotation = SurfaceUtils.AlignToNormal(normal);
((Component)this).transform.localScale = new Vector3(size, size, 1f);
if ((Object)(object)texture != (Object)null && (Object)(object)_renderer != (Object)null && (Object)(object)((Renderer)_renderer).sharedMaterial != (Object)null)
{
_propertyBlock.Clear();
((Renderer)_renderer).GetPropertyBlock(_propertyBlock);
_propertyBlock.SetTexture("_MainTex", (Texture)(object)texture);
((Renderer)_renderer).SetPropertyBlock(_propertyBlock);
}
_timer = 0f;
_lifetime = BloodLabPreferences.SplatLifetime.Value;
}
private void Update()
{
_timer += Time.deltaTime;
if (_timer >= _lifetime)
{
BloodEffectManager.ReleaseDecal(this);
}
}
private static Shader ResolveWorkingShader()
{
if (_shaderResolved)
{
return _cachedShader;
}
_shaderResolved = true;
string[] array = new string[4] { "Sprites/Default", "Unlit/Transparent", "Unlit/Texture", "UI/Default" };
string[] array2 = array;
foreach (string text in array2)
{
Shader val = Shader.Find(text);
if ((Object)(object)val != (Object)null)
{
_cachedShader = val;
MelonLogger.Msg("[BloodLab] using shader '" + text + "' for dem decals boy");
return _cachedShader;
}
}
Renderer val2 = Object.FindObjectOfType<Renderer>();
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMaterial != (Object)null && (Object)(object)val2.sharedMaterial.shader != (Object)null)
{
_cachedShader = val2.sharedMaterial.shader;
MelonLogger.Msg("[BloodLab] using '" + ((Object)_cachedShader).name + "' from an object in scene");
return _cachedShader;
}
MelonLogger.Warning("[BloodLab] no usable shader found, lookin for anotha one");
_shaderResolved = false;
return null;
}
private static void EnsureSharedMesh()
{
//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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0050: 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_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: 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_00e3: 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_00fe: 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_0114: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)_sharedQuadMesh != (Object)null))
{
_sharedQuadMesh = new Mesh
{
name = "BloodLab_QuadMesh",
hideFlags = (HideFlags)61
};
_sharedQuadMesh.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
{
new Vector3(-0.5f, -0.5f, 0f),
new Vector3(0.5f, -0.5f, 0f),
new Vector3(0.5f, 0.5f, 0f),
new Vector3(-0.5f, 0.5f, 0f)
});
_sharedQuadMesh.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[4]
{
new Vector2(0f, 0f),
new Vector2(1f, 0f),
new Vector2(1f, 1f),
new Vector2(0f, 1f)
});
_sharedQuadMesh.triangles = Il2CppStructArray<int>.op_Implicit(new int[6] { 0, 2, 1, 0, 3, 2 });
_sharedQuadMesh.RecalculateNormals();
_sharedQuadMesh.RecalculateBounds();
}
}
}
public static class BloodEffectManager
{
private static GameObject _root;
private static BloodEffectPool<BloodDecal> _groundSplatPool;
private static BloodEffectPool<BloodStain> _stainPool;
private static BloodEffectPool<BloodDroplet> _dropletPool;
private static readonly List<BloodStain> _activeStains = new List<BloodStain>();
public static void Initialize()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
_root = new GameObject("BloodLab_Runtime");
Object.DontDestroyOnLoad((Object)(object)_root);
_groundSplatPool = new BloodEffectPool<BloodDecal>(CreateGroundSplatInstance, BloodLabPreferences.MaxSplats.Value, _root.transform);
_stainPool = new BloodEffectPool<BloodStain>(CreateStainInstance, BloodLabPreferences.MaxStains.Value, _root.transform);
_dropletPool = new BloodEffectPool<BloodDroplet>(CreateDropletInstance, BloodLabPreferences.MaxDroplets.Value, _root.transform);
}
public static void HandleImpact(ImpactData data)
{
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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)
float intensity = data.Intensity * BloodLabPreferences.Intensity.Value;
if (data.IsLivingEntity)
{
Transform woundRoot = (((Object)(object)data.HitCollider != (Object)null) ? ((Component)data.HitCollider).transform.root : null);
DropletManager.HandleBleed(data.Position, data.Normal, intensity, woundRoot);
}
else
{
SpawnGroundSplat(data.Position, data.Normal, intensity, small: false);
}
}
public static void SpawnGroundSplat(Vector3 position, Vector3 normal, float intensity, bool small)
{
//IL_005f: 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)
Texture2D randomTexture = BloodTextureLibrary.GetRandomTexture(BloodTextureCategory.Blood);
if (!((Object)(object)randomTexture == (Object)null))
{
float value = BloodLabPreferences.MinSplatSize.Value;
float value2 = BloodLabPreferences.MaxSplatSize.Value;
float num = Random.Range(value, value2) * Mathf.Clamp01(intensity + 0.2f);
float size = (small ? (num * 0.6f) : num);
BloodDecal bloodDecal = _groundSplatPool.Get();
bloodDecal.Setup(position, normal, randomTexture, size);
}
}
public static void ReleaseDecal(BloodDecal decal)
{
_groundSplatPool.Release(decal);
}
public static void HandleDropletLanded(Vector3 groundPosition, Vector3 groundNormal)
{
//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_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
float value = BloodLabPreferences.StainMergeRadius.Value;
float value2 = BloodLabPreferences.StainGrowthPerDroplet.Value;
float value3 = BloodLabPreferences.StainMaxSize.Value;
BloodStain bloodStain = null;
float num = value * value;
foreach (BloodStain activeStain in _activeStains)
{
if (!((Object)(object)activeStain == (Object)null))
{
Vector3 val = activeStain.WorldPosition - groundPosition;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
if (sqrMagnitude <= num)
{
num = sqrMagnitude;
bloodStain = activeStain;
}
}
}
if ((Object)(object)bloodStain != (Object)null)
{
bloodStain.Grow(value2, value3);
return;
}
Texture2D randomTexture = BloodTextureLibrary.GetRandomTexture(BloodTextureCategory.Stain);
if ((Object)(object)randomTexture == (Object)null)
{
MelonLogger.Warning("[BloodLab] No texture loaded in the 'Stain' category.");
return;
}
BloodStain bloodStain2 = _stainPool.Get();
bloodStain2.PlaceOnGround(groundPosition, groundNormal, randomTexture, value2);
_activeStains.Add(bloodStain2);
}
public static void ReleaseStain(BloodStain stain)
{
if ((Object)(object)stain == (Object)null)
{
return;
}
try
{
_activeStains.Remove(stain);
((Component)stain).transform.SetParent(_root.transform, false);
_stainPool.Release(stain);
}
catch
{
}
}
public static BloodDroplet GetDropletFromPool()
{
BloodDroplet bloodDroplet = _dropletPool.Get();
Texture2D randomTexture = BloodTextureLibrary.GetRandomTexture(BloodTextureCategory.Droplet);
bloodDroplet.SetTexture(randomTexture);
return bloodDroplet;
}
public static void ReleaseDroplet(BloodDroplet droplet)
{
_dropletPool.Release(droplet);
}
private static BloodDecal CreateGroundSplatInstance()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
GameObject val = new GameObject("BloodLab_GroundSplat");
val.AddComponent<MeshFilter>();
val.AddComponent<MeshRenderer>();
Component val2 = val.AddComponent(Il2CppType.Of<BloodDecal>());
return ((Il2CppObjectBase)val2).TryCast<BloodDecal>();
}
private static BloodStain CreateStainInstance()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
GameObject val = new GameObject("BloodLab_Pool");
val.AddComponent<MeshFilter>();
val.AddComponent<MeshRenderer>();
Component val2 = val.AddComponent(Il2CppType.Of<BloodStain>());
return ((Il2CppObjectBase)val2).TryCast<BloodStain>();
}
private static BloodDroplet CreateDropletInstance()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
GameObject val = new GameObject("BloodLab_Droplet");
val.AddComponent<MeshFilter>();
val.AddComponent<MeshRenderer>();
Component val2 = val.AddComponent(Il2CppType.Of<BloodDroplet>());
return ((Il2CppObjectBase)val2).TryCast<BloodDroplet>();
}
}
public class BloodEffectPool<T> where T : Component
{
private readonly Stack<T> _available = new Stack<T>();
private readonly List<T> _all = new List<T>();
private readonly Func<T> _factory;
private readonly int _maxSize;
private readonly Transform _root;
public int ActiveCount => _all.Count - _available.Count;
public BloodEffectPool(Func<T> factory, int maxSize, Transform root)
{
_factory = factory;
_maxSize = maxSize;
_root = root;
}
public T Get()
{
T val;
if (_available.Count > 0)
{
val = _available.Pop();
}
else if (_all.Count < _maxSize)
{
val = _factory();
((Component)val).transform.SetParent(_root, false);
_all.Add(val);
}
else
{
val = _all[0];
_all.RemoveAt(0);
_all.Add(val);
}
((Component)val).gameObject.SetActive(true);
return val;
}
public void Release(T instance)
{
if (!((Object)(object)instance == (Object)null))
{
((Component)instance).gameObject.SetActive(false);
if (!_available.Contains(instance))
{
_available.Push(instance);
}
}
}
}
public enum BloodTextureCategory
{
Blood,
Droplet,
Stain
}
public static class BloodTextureLibrary
{
private static readonly string[] SupportedExtensions = new string[3] { ".png", ".jpg", ".jpeg" };
private static readonly Dictionary<BloodTextureCategory, string> FolderNames = new Dictionary<BloodTextureCategory, string>
{
{
BloodTextureCategory.Blood,
"Blood"
},
{
BloodTextureCategory.Droplet,
"Droplet"
},
{
BloodTextureCategory.Stain,
"Stain"
}
};
private static readonly Dictionary<BloodTextureCategory, List<Texture2D>> _texturesByCategory = new Dictionary<BloodTextureCategory, List<Texture2D>>();
public static void Initialize()
{
string text = Path.Combine(MelonEnvironment.UserDataDirectory, "BLOODLAB");
foreach (BloodTextureCategory key in FolderNames.Keys)
{
_texturesByCategory[key] = new List<Texture2D>();
}
Reload();
}
public static void Reload()
{
foreach (BloodTextureCategory key in FolderNames.Keys)
{
ReloadCategory(key);
}
}
private static void ReloadCategory(BloodTextureCategory category)
{
string text = Path.Combine(MelonEnvironment.UserDataDirectory, "BLOODLAB", FolderNames[category]);
if (!_texturesByCategory.TryGetValue(category, out var value))
{
value = new List<Texture2D>();
_texturesByCategory[category] = value;
}
foreach (Texture2D item in value)
{
if ((Object)(object)item != (Object)null)
{
Object.Destroy((Object)(object)item);
}
}
value.Clear();
if (!Directory.Exists(text))
{
Directory.CreateDirectory(text);
MelonLogger.Warning("[BloodLab] textures folder made in '" + text + "'. put your images there boy");
return;
}
string[] files = Directory.GetFiles(text);
string[] array = files;
foreach (string path in array)
{
string value2 = Path.GetExtension(path).ToLowerInvariant();
if (Array.IndexOf(SupportedExtensions, value2) >= 0)
{
Texture2D val = LoadTexture(path);
if ((Object)(object)val != (Object)null)
{
((Object)val).name = Path.GetFileNameWithoutExtension(path);
value.Add(val);
}
}
}
MelonLogger.Msg($"[BloodLab] {value.Count} textures loaded to '{category}' from '{text}'.");
}
private static Texture2D LoadTexture(string path)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
try
{
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
Il2CppStructArray<byte> val2 = Il2CppStructArray<byte>.op_Implicit(array);
if (!ImageConversion.LoadImage(val, val2))
{
MelonLogger.Warning("[BloodLab] we cant decode '" + path + "'");
Object.Destroy((Object)(object)val);
return null;
}
((Texture)val).wrapMode = (TextureWrapMode)1;
((Object)val).hideFlags = (HideFlags)61;
return val;
}
catch (Exception value)
{
MelonLogger.Error($"[BloodLab] texture failed to load '{path}': {value}");
return null;
}
}
public static Texture2D GetRandomTexture(BloodTextureCategory category)
{
if (!_texturesByCategory.TryGetValue(category, out var value) || value.Count == 0)
{
return null;
}
return value[Random.Range(0, value.Count)];
}
}
}
