using System;
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 System.Text;
using API;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Enemies;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("DamageSync")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2d71528a224b10a5c5281c27bf2a5f7e7fa00ea9")]
[assembly: AssemblyProduct("DamageSync")]
[assembly: AssemblyTitle("DamageSync")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
internal static class BitHelper
{
public const int SizeOfHalf = 2;
public const int SizeOfVector3 = 12;
public const int SizeOfQuaternion = 13;
public const int SizeOfHalfVector3 = 6;
public const int SizeOfHalfQuaternion = 7;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint RotateLeft(uint value, int offset)
{
return (value << offset) | (value >> 32 - offset);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint RotateRight(uint value, int offset)
{
return (value >> offset) | (value << 32 - offset);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static long ReverseEndianness(long value)
{
return (long)ReverseEndianness((ulong)value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int ReverseEndianness(int value)
{
return (int)ReverseEndianness((uint)value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static short ReverseEndianness(short value)
{
return (short)ReverseEndianness((ushort)value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static ushort ReverseEndianness(ushort value)
{
return (ushort)((value >> 8) + (value << 8));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint ReverseEndianness(uint value)
{
return RotateRight(value & 0xFF00FFu, 8) + RotateLeft(value & 0xFF00FF00u, 8);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static ulong ReverseEndianness(ulong value)
{
return ((ulong)ReverseEndianness((uint)value) << 32) + ReverseEndianness((uint)(value >> 32));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private unsafe static void _WriteBytes(byte* source, int size, byte[] destination, ref int index)
{
int num = 0;
while (num < size)
{
destination[index++] = source[num++];
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteBytes(byte value, byte[] destination, ref int index)
{
destination[index++] = value;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteBytes(bool value, byte[] destination, ref int index)
{
destination[index++] = (value ? ((byte)1) : ((byte)0));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(ulong value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 8, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(uint value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 4, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(ushort value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 2, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(long value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 8, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(int value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 4, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(short value, byte[] destination, ref int index)
{
if (!BitConverter.IsLittleEndian)
{
value = ReverseEndianness(value);
}
_WriteBytes((byte*)(&value), 2, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static void WriteBytes(float value, byte[] destination, ref int index)
{
int value2 = *(int*)(&value);
if (!BitConverter.IsLittleEndian)
{
value2 = ReverseEndianness(value2);
}
_WriteBytes((byte*)(&value2), 4, destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteBytes(string value, byte[] destination, ref int index)
{
byte[] bytes = Encoding.UTF8.GetBytes(value);
WriteBytes((ushort)bytes.Length, destination, ref index);
Array.Copy(bytes, 0, destination, index, bytes.Length);
index += bytes.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteBytes(byte[] buffer, byte[] destination, ref int index)
{
WriteBytes((ushort)buffer.Length, destination, ref index);
Array.Copy(buffer, 0, destination, index, buffer.Length);
index += buffer.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteHalf(float value, byte[] destination, ref int index)
{
WriteBytes(FloatToHalf(value), destination, ref index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private unsafe static uint AsUInt(float x)
{
return *(uint*)(&x);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private unsafe static float AsFloat(uint x)
{
return *(float*)(&x);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float HalfToFloat(ushort x)
{
int num = (x & 0x7C00) >> 10;
int num2 = (x & 0x3FF) << 13;
int num3 = (int)(AsUInt(num2) >> 23);
return AsFloat((uint)(((x & 0x8000) << 16) | (Convert.ToInt32(num != 0) * ((num + 112 << 23) | num2)) | ((Convert.ToInt32(num == 0) & Convert.ToInt32(num2 != 0)) * ((num3 - 37 << 23) | ((num2 << 150 - num3) & 0x7FE000)))));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ushort FloatToHalf(float x)
{
uint num = AsUInt(x) + 4096;
uint num2 = (num & 0x7F800000) >> 23;
uint num3 = num & 0x7FFFFFu;
return (ushort)(((num & 0x80000000u) >> 16) | (Convert.ToInt32(num2 > 112) * (((num2 - 112 << 10) & 0x7C00) | (num3 >> 13))) | ((Convert.ToInt32(num2 < 113) & Convert.ToInt32(num2 > 101)) * ((8384512 + num3 >> (int)(125 - num2)) + 1 >> 1)) | (Convert.ToUInt32(num2 > 143) * 32767));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte ReadByte(byte[] source, ref int index)
{
return source[index++];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool ReadBool(byte[] source, ref int index)
{
return source[index++] != 0;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static ulong ReadULong(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 8;
ulong num2 = *(ulong*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static long ReadLong(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 8;
long num2 = *(long*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static uint ReadUInt(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 4;
uint num2 = *(uint*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static int ReadInt(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 4;
int num2 = *(int*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static ushort ReadUShort(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 2;
ushort num2 = *(ushort*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static short ReadShort(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* num = ptr + index;
index += 2;
short num2 = *(short*)num;
if (!BitConverter.IsLittleEndian)
{
num2 = ReverseEndianness(num2);
}
return num2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float ReadHalf(byte[] source, ref int index)
{
return HalfToFloat(ReadUShort(source, ref index));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe static float ReadFloat(byte[] source, ref int index)
{
fixed (byte* ptr = source)
{
byte* ptr2 = ptr + index;
index += 4;
if (!BitConverter.IsLittleEndian)
{
int num = ReverseEndianness(*(int*)ptr2);
return *(float*)(&num);
}
return *(float*)ptr2;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string ReadString(byte[] source, ref int index)
{
int num = ReadUShort(source, ref index);
string @string = Encoding.UTF8.GetString(source, index, num);
index += num;
return @string;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WriteBytes(Vector3 value, byte[] destination, ref int index)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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)
WriteBytes(value.x, destination, ref index);
WriteBytes(value.y, destination, ref index);
WriteBytes(value.z, destination, ref index);
}
public static void WriteBytes(Quaternion value, byte[] destination, ref int index)
{
//IL_0000: 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_001b: 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_002d: 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_0036: 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_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: 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_00a1: 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_006b: 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_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: 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_018b: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: 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)
float num = value.x;
byte b = 0;
if (value.y > num)
{
num = value.y;
b = 1;
}
if (value.z > num)
{
num = value.z;
b = 2;
}
if (value.w > num)
{
num = value.w;
b = 3;
}
WriteBytes(b, destination, ref index);
switch (b)
{
case 0:
if (value.x >= 0f)
{
WriteBytes(value.y, destination, ref index);
WriteBytes(value.z, destination, ref index);
WriteBytes(value.w, destination, ref index);
}
else
{
WriteBytes(0f - value.y, destination, ref index);
WriteBytes(0f - value.z, destination, ref index);
WriteBytes(0f - value.w, destination, ref index);
}
break;
case 1:
if (value.y >= 0f)
{
WriteBytes(value.x, destination, ref index);
WriteBytes(value.z, destination, ref index);
WriteBytes(value.w, destination, ref index);
}
else
{
WriteBytes(0f - value.x, destination, ref index);
WriteBytes(0f - value.z, destination, ref index);
WriteBytes(0f - value.w, destination, ref index);
}
break;
case 2:
if (value.z >= 0f)
{
WriteBytes(value.x, destination, ref index);
WriteBytes(value.y, destination, ref index);
WriteBytes(value.w, destination, ref index);
}
else
{
WriteBytes(0f - value.x, destination, ref index);
WriteBytes(0f - value.y, destination, ref index);
WriteBytes(0f - value.w, destination, ref index);
}
break;
case 3:
if (value.w >= 0f)
{
WriteBytes(value.x, destination, ref index);
WriteBytes(value.y, destination, ref index);
WriteBytes(value.z, destination, ref index);
}
else
{
WriteBytes(0f - value.x, destination, ref index);
WriteBytes(0f - value.y, destination, ref index);
WriteBytes(0f - value.z, destination, ref index);
}
break;
}
}
public static Vector3 ReadVector3(byte[] source, ref int index)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(ReadFloat(source, ref index), ReadFloat(source, ref index), ReadFloat(source, ref index));
}
public static Quaternion ReadQuaternion(byte[] source, ref int index)
{
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
byte b = ReadByte(source, ref index);
float num = 0f;
float num2 = 0f;
float num3 = 0f;
float num4 = 0f;
switch (b)
{
case 0:
num2 = ReadFloat(source, ref index);
num3 = ReadFloat(source, ref index);
num4 = ReadFloat(source, ref index);
num = Mathf.Sqrt(1f - num2 * num2 - num3 * num3 - num4 * num4);
break;
case 1:
num = ReadFloat(source, ref index);
num3 = ReadFloat(source, ref index);
num4 = ReadFloat(source, ref index);
num2 = Mathf.Sqrt(1f - num * num - num3 * num3 - num4 * num4);
break;
case 2:
num = ReadFloat(source, ref index);
num2 = ReadFloat(source, ref index);
num4 = ReadFloat(source, ref index);
num3 = Mathf.Sqrt(1f - num * num - num2 * num2 - num4 * num4);
break;
case 3:
num = ReadFloat(source, ref index);
num2 = ReadFloat(source, ref index);
num3 = ReadFloat(source, ref index);
num4 = Mathf.Sqrt(1f - num * num - num2 * num2 - num3 * num3);
break;
}
return new Quaternion(num, num2, num3, num4);
}
public static void WriteHalf(Vector3 value, byte[] destination, ref int index)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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)
WriteHalf(value.x, destination, ref index);
WriteHalf(value.y, destination, ref index);
WriteHalf(value.z, destination, ref index);
}
public static void WriteHalf(Quaternion value, byte[] destination, ref int index)
{
//IL_0000: 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_001b: 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_002d: 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_0036: 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_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: 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_00a1: 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_006b: 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_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: 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_018b: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: 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)
float num = value.x;
byte b = 0;
if (value.y > num)
{
num = value.y;
b = 1;
}
if (value.z > num)
{
num = value.z;
b = 2;
}
if (value.w > num)
{
num = value.w;
b = 3;
}
WriteBytes(b, destination, ref index);
switch (b)
{
case 0:
if (value.x >= 0f)
{
WriteHalf(value.y, destination, ref index);
WriteHalf(value.z, destination, ref index);
WriteHalf(value.w, destination, ref index);
}
else
{
WriteHalf(0f - value.y, destination, ref index);
WriteHalf(0f - value.z, destination, ref index);
WriteHalf(0f - value.w, destination, ref index);
}
break;
case 1:
if (value.y >= 0f)
{
WriteHalf(value.x, destination, ref index);
WriteHalf(value.z, destination, ref index);
WriteHalf(value.w, destination, ref index);
}
else
{
WriteHalf(0f - value.x, destination, ref index);
WriteHalf(0f - value.z, destination, ref index);
WriteHalf(0f - value.w, destination, ref index);
}
break;
case 2:
if (value.z >= 0f)
{
WriteHalf(value.x, destination, ref index);
WriteHalf(value.y, destination, ref index);
WriteHalf(value.w, destination, ref index);
}
else
{
WriteHalf(0f - value.x, destination, ref index);
WriteHalf(0f - value.y, destination, ref index);
WriteHalf(0f - value.w, destination, ref index);
}
break;
case 3:
if (value.w >= 0f)
{
WriteHalf(value.x, destination, ref index);
WriteHalf(value.y, destination, ref index);
WriteHalf(value.z, destination, ref index);
}
else
{
WriteHalf(0f - value.x, destination, ref index);
WriteHalf(0f - value.y, destination, ref index);
WriteHalf(0f - value.z, destination, ref index);
}
break;
}
}
public static Vector3 ReadHalfVector3(byte[] source, ref int index)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(ReadHalf(source, ref index), ReadHalf(source, ref index), ReadHalf(source, ref index));
}
public static Quaternion ReadHalfQuaternion(byte[] source, ref int index)
{
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
byte b = ReadByte(source, ref index);
float num = 0f;
float num2 = 0f;
float num3 = 0f;
float num4 = 0f;
switch (b)
{
case 0:
num2 = ReadHalf(source, ref index);
num3 = ReadHalf(source, ref index);
num4 = ReadHalf(source, ref index);
num = Mathf.Sqrt(1f - num2 * num2 - num3 * num3 - num4 * num4);
break;
case 1:
num = ReadHalf(source, ref index);
num3 = ReadHalf(source, ref index);
num4 = ReadHalf(source, ref index);
num2 = Mathf.Sqrt(1f - num * num - num3 * num3 - num4 * num4);
break;
case 2:
num = ReadHalf(source, ref index);
num2 = ReadHalf(source, ref index);
num4 = ReadHalf(source, ref index);
num3 = Mathf.Sqrt(1f - num * num - num2 * num2 - num4 * num4);
break;
case 3:
num = ReadHalf(source, ref index);
num2 = ReadHalf(source, ref index);
num3 = ReadHalf(source, ref index);
num4 = Mathf.Sqrt(1f - num * num - num2 * num2 - num3 * num3);
break;
}
return new Quaternion(num, num2, num3, num4);
}
}
namespace DamageSync
{
public static class ConfigManager
{
private static ConfigEntry<bool> debug;
public static bool Debug => debug.Value;
static ConfigManager()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
debug = new ConfigFile(Path.Combine(Paths.ConfigPath, "DamageSync.cfg"), true).Bind<bool>("Debug", "enable", false, "Enables debug messages when true.");
}
}
public static class Module
{
public const string GUID = "randomuserhi.DamageSync";
public const string Name = "DamageSync";
public const string Version = "0.0.6";
}
[BepInPlugin("randomuserhi.DamageSync", "DamageSync", "0.0.6")]
internal class Entry : BasePlugin
{
private Harmony harmony;
public override void Load()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
APILogger.Debug("DamageSync", "Loaded DamageSync");
harmony = new Harmony("randomuserhi.DamageSync");
harmony.PatchAll();
APILogger.Debug("DamageSync", "Debug is " + (ConfigManager.Debug ? "Enabled" : "Disabled"));
}
}
}
namespace DamageSync.Patches
{
[HarmonyPatch]
internal class DamageSync
{
[HarmonyPatch(typeof(Dam_EnemyDamageBase), "ProcessReceivedDamage")]
[HarmonyPostfix]
public static void ProcessReceivedDamage(Dam_EnemyDamageBase __instance, float damage, Agent damageSource, Vector3 position, Vector3 direction, ES_HitreactType hitreact, bool tryForceHitreact, int limbID)
{
//IL_000a: 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)
if (SNet.IsMaster)
{
pSetHealthData val = default(pSetHealthData);
((SFloat16)(ref val.health)).Set(((Dam_SyncedDamageBase)__instance).Health, ((Dam_SyncedDamageBase)__instance).HealthMax);
((Dam_SyncedDamageBase)__instance).m_setHealthPacket.Send(val, (SNet_ChannelType)3);
if (limbID >= 0 && limbID < ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)__instance.DamageLimbs).Count)
{
Network.SendLimbHealth(__instance.Owner, limbID, ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)__instance.DamageLimbs)[limbID].m_health);
}
if (ConfigManager.Debug)
{
APILogger.Debug("DamageSync", $"Sent health value: {((Dam_SyncedDamageBase)__instance).Health}");
}
}
}
[HarmonyPatch(typeof(Dam_EnemyDamageBase), "ReceiveSetHealth")]
[HarmonyPostfix]
public static void ReceiveSetHealth(Dam_EnemyDamageBase __instance)
{
if (!SNet.IsMaster && ConfigManager.Debug)
{
APILogger.Debug("DamageSync", $"Received health value: {((Dam_SyncedDamageBase)__instance).Health}");
}
}
}
[HarmonyPatch]
internal static class Network
{
private static byte msgtype = 52;
private static uint magickey = 10183481u;
private static ushort repKey = 65531;
public static void SendLimbHealth(EnemyAgent target, int limbID, float health)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
if (!SNet.IsMaster)
{
return;
}
if (ConfigManager.Debug)
{
APILogger.Debug("DamageSync", $"Sent limb health GlobalId={((Agent)target).GlobalID} id={limbID} health={health}.");
}
if (limbID < 0)
{
return;
}
SNet_ChannelType val = (SNet_ChannelType)0;
SNet_SendGroup val2 = default(SNet_SendGroup);
SNet_SendQuality val3 = default(SNet_SendQuality);
int num = default(int);
SNet.GetSendSettings(ref val, ref val2, ref val3, ref num);
List<SNet_Player> val4 = new List<SNet_Player>();
Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
while (enumerator.MoveNext())
{
PlayerAgent current = enumerator.Current;
if (!current.Owner.IsBot && current.Owner.Lookup != SNet.LocalPlayer.Lookup)
{
val4.Add(current.Owner);
}
}
if (val4.Count != 0)
{
int index = 0;
byte[] array = new byte[18];
BitHelper.WriteBytes(repKey, array, ref index);
BitHelper.WriteBytes(magickey, array, ref index);
BitHelper.WriteBytes(msgtype, array, ref index);
BitHelper.WriteBytes(7, array, ref index);
BitHelper.WriteBytes((ushort)(((Agent)target).m_replicator.Key + 1), array, ref index);
BitHelper.WriteBytes((byte)limbID, array, ref index);
BitHelper.WriteBytes(health, array, ref index);
SNet.Core.SendBytes(Il2CppStructArray<byte>.op_Implicit(array), val3, num, val4);
}
}
[HarmonyPatch(typeof(SNet_Replication), "RecieveBytes")]
[HarmonyWrapSafe]
[HarmonyPrefix]
private static bool RecieveBytes_Prefix(Il2CppStructArray<byte> bytes, uint size, ulong messagerID)
{
//IL_0093: 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)
if (size < 12)
{
return true;
}
ushort num = BitConverter.ToUInt16(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)bytes), 0);
if (repKey == num)
{
if (BitConverter.ToUInt32(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)bytes), 2) != magickey)
{
return true;
}
if (((Il2CppArrayBase<byte>)(object)bytes)[6] != msgtype)
{
return true;
}
int num2 = BitConverter.ToInt32(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)bytes), 7);
byte[] array = new byte[num2];
Array.Copy(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)bytes), 11, array, 0, num2);
int index = 0;
ushort keyPlusOne = BitHelper.ReadUShort(array, ref index);
byte b = BitHelper.ReadByte(array, ref index);
float num3 = BitHelper.ReadFloat(array, ref index);
pReplicator pRep = default(pReplicator);
pRep.keyPlusOne = keyPlusOne;
pAgent val = default(pAgent);
val.pRep = pRep;
Agent val2 = default(Agent);
((pAgent)(ref val)).TryGet(ref val2);
EnemyAgent val3 = ((Il2CppObjectBase)val2).TryCast<EnemyAgent>();
if ((Object)(object)val3 != (Object)null)
{
if (ConfigManager.Debug)
{
APILogger.Debug("DamageSync", $"Received limb health GlobalId={((Agent)val3).GlobalID} id={b} health={num3}.");
}
((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)val3.Damage.DamageLimbs)[(int)b].m_health = num3;
return false;
}
APILogger.Error("DamageSync", "Received limb health packet but could not get player / enemy agent. This should not happen.");
return false;
}
return true;
}
}
}
namespace API
{
internal static class APILogger
{
private static readonly ManualLogSource logger;
static APILogger()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
logger = new ManualLogSource("Rand-API");
Logger.Sources.Add((ILogSource)(object)logger);
}
private static string Format(string module, object msg)
{
return $"[{module}]: {msg}";
}
public static void Info(string module, object data)
{
logger.LogMessage((object)Format(module, data));
}
public static void Verbose(string module, object data)
{
}
public static void Debug(string module, object data)
{
logger.LogDebug((object)Format(module, data));
}
public static void Warn(string module, object data)
{
logger.LogWarning((object)Format(module, data));
}
public static void Error(string module, object data)
{
logger.LogError((object)Format(module, data));
}
}
}
