using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using FistVR;
using H3MP.Scripts;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("Packer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("H3MP networking tools for easy syncing mods")]
[assembly: AssemblyFileVersion("0.9.0.0")]
[assembly: AssemblyInformationalVersion("0.9.0+4451aca4407294906a656f22f8ac49eee81db56c")]
[assembly: AssemblyProduct("Packer.NetworkingTools")]
[assembly: AssemblyTitle("Networking Tools")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string id = null, string name = null, string version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string id = null, string name = null, string version = null)
{
}
}
}
namespace H3MP.Networking
{
[BepInPlugin("Packer.NetworkingTools", "Networking Tools", "0.9.0")]
[BepInProcess("h3vr.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class NetworkingToolsPlugin : BaseUnityPlugin
{
internal static ManualLogSource Logger { get; private set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
}
}
public class CustomConnection
{
public delegate void UpdateHandlerDelegate(int clientID, PacketData packet);
private bool Ready = false;
public string Name;
private string ToClientName = "ToClient";
private int toClient_ID;
private string ToServerName = "ToServer";
private int toServer_ID;
public int ToClientID => toClient_ID;
public int ToServerID => toServer_ID;
public event UpdateHandlerDelegate ServerHandlerEvent;
public event UpdateHandlerDelegate ClientHandlerEvent;
public CustomConnection(string connectionName)
{
ToClientName = connectionName + "ToClient";
ToServerName = connectionName + "ToServer";
Name = connectionName;
}
public void Setup()
{
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Expected O, but got Unknown
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Expected O, but got Unknown
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_019f: Expected O, but got Unknown
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Expected O, but got Unknown
if (Ready)
{
return;
}
Ready = true;
NetworkingToolsPlugin.Logger.LogMessage((object)(Name + " Setup"));
if (Tools.IsHost())
{
if (Mod.registeredCustomPacketIDs.ContainsKey(ToClientName))
{
toClient_ID = Mod.registeredCustomPacketIDs[ToClientName];
}
else
{
toClient_ID = Server.RegisterCustomPacketType(ToClientName, 0);
}
Mod.customPacketHandlers[toClient_ID] = new CustomPacketHandler(ClientReceiver_Handler);
if (Mod.registeredCustomPacketIDs.ContainsKey(ToServerName))
{
toServer_ID = Mod.registeredCustomPacketIDs[ToServerName];
}
else
{
toServer_ID = Server.RegisterCustomPacketType(ToServerName, 0);
}
Mod.customPacketHandlers[toServer_ID] = new CustomPacketHandler(ServerReceiver_Handler);
return;
}
if (Mod.registeredCustomPacketIDs.ContainsKey(ToClientName))
{
toClient_ID = Mod.registeredCustomPacketIDs[ToClientName];
Mod.customPacketHandlers[toClient_ID] = new CustomPacketHandler(ClientReceiver_Handler);
}
else
{
ClientSend.RegisterCustomPacketType(ToClientName);
Mod.CustomPacketHandlerReceived += new CustomPacketHandlerReceivedDelegate(ClientIdentifier_Received);
}
if (Mod.registeredCustomPacketIDs.ContainsKey(ToServerName))
{
toServer_ID = Mod.registeredCustomPacketIDs[ToServerName];
Mod.customPacketHandlers[toServer_ID] = new CustomPacketHandler(ServerReceiver_Handler);
}
else
{
ClientSend.RegisterCustomPacketType(ToServerName);
Mod.CustomPacketHandlerReceived += new CustomPacketHandlerReceivedDelegate(ServerIdentifier_Received);
}
}
public void ServerToClients(PacketData packet)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
Packet val = new Packet(packet.ToArray());
ServerSend.SendTCPDataToAll(val, true);
NetworkingToolsPlugin.Logger.LogDebug((object)"Server To Clients");
}
public void ServerToSelectClients(PacketData packet, List<int> clientIDs)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
Packet val = new Packet(packet.ToArray());
ServerSend.SendTCPDataToClients(val, clientIDs, -1, true);
NetworkingToolsPlugin.Logger.LogDebug((object)"Server To Select Clients");
}
public void ServerToClient(int clientID, PacketData packet)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
Packet val = new Packet(packet.ToArray());
ServerSend.SendTCPData(clientID, val, true);
NetworkingToolsPlugin.Logger.LogDebug((object)"Server To Client");
}
public void ClientToServer(PacketData packet)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
Packet val = new Packet(packet.ToArray());
ClientSend.SendTCPData(val, true);
NetworkingToolsPlugin.Logger.LogDebug((object)"Client To Server - Send Data");
}
private void ClientReceiver_Handler(int clientID, Packet packet)
{
if (this.ClientHandlerEvent != null)
{
PacketData packetData = new PacketData(packet.ToArray());
packetData.readPos = packet.readPos;
this.ClientHandlerEvent(clientID, packetData);
}
NetworkingToolsPlugin.Logger.LogMessage((object)"Client - Client Receiver");
}
private void ServerReceiver_Handler(int clientID, Packet packet)
{
if (this.ServerHandlerEvent != null)
{
PacketData packetData = new PacketData(packet.ToArray());
packetData.readPos = packet.readPos;
this.ServerHandlerEvent(clientID, packetData);
}
NetworkingToolsPlugin.Logger.LogMessage((object)"Server - Server Receiver");
}
private void ClientIdentifier_Received(string identifier, int index)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
if (identifier == ToClientName)
{
NetworkingToolsPlugin.Logger.LogMessage((object)"Client Handshake");
toClient_ID = index;
Mod.customPacketHandlers[index] = new CustomPacketHandler(ClientReceiver_Handler);
Mod.CustomPacketHandlerReceived -= new CustomPacketHandlerReceivedDelegate(ClientIdentifier_Received);
}
}
private void ServerIdentifier_Received(string identifier, int index)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
if (identifier == ToServerName)
{
NetworkingToolsPlugin.Logger.LogMessage((object)"Server Handshake");
toServer_ID = index;
Mod.customPacketHandlers[index] = new CustomPacketHandler(ServerReceiver_Handler);
Mod.CustomPacketHandlerReceived -= new CustomPacketHandlerReceivedDelegate(ServerIdentifier_Received);
}
}
}
public class PacketData : IDisposable
{
public List<byte> buffer;
public byte[] readableBuffer;
public int readPos;
private bool disposed = false;
public PacketData()
{
buffer = new List<byte>();
readPos = 0;
}
public PacketData(int _id)
{
buffer = new List<byte>();
readPos = 0;
Write(_id);
}
public PacketData(byte[] _data)
{
buffer = new List<byte>();
readPos = 0;
SetBytes(_data);
}
public void SetBytes(byte[] _data)
{
Write(_data);
readableBuffer = buffer.ToArray();
}
public void WriteLength()
{
buffer.InsertRange(0, BitConverter.GetBytes(buffer.Count));
}
public void InsertInt(int _value)
{
buffer.InsertRange(0, BitConverter.GetBytes(_value));
}
public byte[] ToArray()
{
readableBuffer = buffer.ToArray();
return readableBuffer;
}
public int Length()
{
return buffer.Count;
}
public int UnreadLength()
{
return Length() - readPos;
}
public void Reset(bool _shouldReset = true)
{
if (_shouldReset)
{
buffer.Clear();
readableBuffer = null;
readPos = 0;
}
else
{
readPos -= 4;
}
}
public void Write(byte _value)
{
buffer.Add(_value);
}
public void Write(byte[] _value)
{
buffer.AddRange(_value);
}
public void Write(short _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(ushort _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(int _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(uint _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(long _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(float _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(double _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(bool _value)
{
buffer.AddRange(BitConverter.GetBytes(_value));
}
public void Write(string _value)
{
Write(_value.Length);
buffer.AddRange(Encoding.ASCII.GetBytes(_value));
}
public void Write(Vector3 _value)
{
//IL_0002: 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_001c: Unknown result type (might be due to invalid IL or missing references)
Write(_value.x);
Write(_value.y);
Write(_value.z);
}
public void Write(Vector2 _value)
{
//IL_0002: 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)
Write(_value.x);
Write(_value.y);
}
public void Write(Quaternion _value)
{
//IL_0002: 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_001c: 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)
Write(_value.x);
Write(_value.y);
Write(_value.z);
Write(_value.w);
}
public void Write(Damage damage)
{
//IL_0003: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
Write(damage.point);
Write(damage.Source_IFF);
Write(damage.Source_Point);
Write(damage.Dam_Blunt);
Write(damage.Dam_Piercing);
Write(damage.Dam_Cutting);
Write(damage.Dam_TotalKinetic);
Write(damage.Dam_Thermal);
Write(damage.Dam_Chilling);
Write(damage.Dam_EMP);
Write(damage.Dam_TotalEnergetic);
Write(damage.Dam_Stunning);
Write(damage.Dam_Blinding);
Write(damage.hitNormal);
Write(damage.strikeDir);
Write(damage.edgeNormal);
Write(damage.damageSize);
Write((byte)damage.Class);
}
public void Write(SosigConfigTemplate config)
{
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_0494: Unknown result type (might be due to invalid IL or missing references)
//IL_0499: Unknown result type (might be due to invalid IL or missing references)
//IL_049d: Unknown result type (might be due to invalid IL or missing references)
Write(config.AppliesDamageResistToIntegrityLoss);
Write(config.DoesDropWeaponsOnBallistic);
Write(config.TotalMustard);
Write(config.BleedDamageMult);
Write(config.BleedRateMultiplier);
Write(config.BleedVFXIntensity);
Write(config.SearchExtentsModifier);
Write(config.ShudderThreshold);
Write(config.ConfusionThreshold);
Write(config.ConfusionMultiplier);
Write(config.ConfusionTimeMax);
Write(config.StunThreshold);
Write(config.StunMultiplier);
Write(config.StunTimeMax);
Write(config.HasABrain);
Write(config.HasNightVision);
Write(config.RegistersPassiveThreats);
Write(config.CanBeKnockedOut);
Write(config.MaxUnconsciousTime);
Write(config.IgnoresNeedForWeapons);
Write(config.AssaultPointOverridesSkirmishPointWhenFurtherThan);
Write(config.ViewDistance);
Write(config.HearingDistance);
Write(config.MaxFOV);
Write(config.StateSightRangeMults);
Write(config.StateHearingRangeMults);
Write(config.StateFOVMults);
Write(config.CanPickup_Ranged);
Write(config.CanPickup_Melee);
Write(config.CanPickup_Other);
Write(config.MaxThreatingIFFReactionRange_Visual);
Write(config.MaxThreatingIFFReactionRange_Sonic);
Write(config.AggroSensitivityMultiplier);
Write(config.EntityRecognitionSpeedMultiplier);
Write(config.CombatTargetIdentificationSpeedMultiplier);
Write(config.DoesJointBreakKill_Head);
Write(config.DoesJointBreakKill_Upper);
Write(config.DoesJointBreakKill_Lower);
Write(config.DoesSeverKill_Head);
Write(config.DoesSeverKill_Upper);
Write(config.DoesSeverKill_Lower);
Write(config.DoesExplodeKill_Head);
Write(config.DoesExplodeKill_Upper);
Write(config.DoesExplodeKill_Lower);
Write(config.CrawlSpeed);
Write(config.SneakSpeed);
Write(config.WalkSpeed);
Write(config.RunSpeed);
Write(config.TurnSpeed);
Write(config.MovementRotMagnitude);
Write(config.DamMult_Projectile);
Write(config.DamMult_Explosive);
Write(config.DamMult_Melee);
Write(config.DamMult_Piercing);
Write(config.DamMult_Blunt);
Write(config.DamMult_Cutting);
Write(config.DamMult_Thermal);
Write(config.DamMult_Chilling);
Write(config.DamMult_EMP);
Write(config.CanBeSurpressed);
Write(config.SuppressionMult);
Write(config.CanBeGrabbed);
Write(config.CanBeSevered);
Write(config.CanBeStabbed);
Write(config.MaxJointLimit);
if (config.LinkDamageMultipliers == null || config.LinkDamageMultipliers.Count == 0)
{
Write((byte)0);
}
else
{
Write((byte)config.LinkDamageMultipliers.Count);
foreach (float linkDamageMultiplier in config.LinkDamageMultipliers)
{
Write(linkDamageMultiplier);
}
}
if (config.LinkStaggerMultipliers == null || config.LinkStaggerMultipliers.Count == 0)
{
Write((byte)0);
}
else
{
Write((byte)config.LinkStaggerMultipliers.Count);
foreach (float linkStaggerMultiplier in config.LinkStaggerMultipliers)
{
Write(linkStaggerMultiplier);
}
}
if (config.StartingLinkIntegrity == null || config.StartingLinkIntegrity.Count == 0)
{
Write((byte)0);
}
else
{
Write((byte)config.StartingLinkIntegrity.Count);
foreach (Vector2 item in config.StartingLinkIntegrity)
{
Write(item);
}
}
if (config.StartingChanceBrokenJoint == null || config.StartingChanceBrokenJoint.Count == 0)
{
Write((byte)0);
}
else
{
Write((byte)config.StartingChanceBrokenJoint.Count);
foreach (float item2 in config.StartingChanceBrokenJoint)
{
Write(item2);
}
}
if (config.LinkSpawnChance == null || config.LinkSpawnChance.Count == 0)
{
Write((byte)0);
}
else
{
Write((byte)config.LinkSpawnChance.Count);
foreach (float item3 in config.LinkSpawnChance)
{
Write(item3);
}
}
Write(config.TargetCapacity);
Write(config.TargetTrackingTime);
Write(config.NoFreshTargetTime);
Write(config.DoesAggroOnFriendlyFire);
Write(config.UsesLinkSpawns);
Write(config.TimeInSkirmishToAlert);
}
public byte ReadByte(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
byte result = readableBuffer[readPos];
if (_moveReadPos)
{
readPos++;
}
return result;
}
throw new Exception("Could not read value of type 'byte'!");
}
public byte[] ReadBytes(int _length, bool _moveReadPos = true)
{
if (_length == 0)
{
return null;
}
if (buffer.Count > readPos)
{
byte[] result = buffer.GetRange(readPos, _length).ToArray();
if (_moveReadPos)
{
readPos += _length;
}
return result;
}
throw new Exception("Could not read value of type 'byte[]'!");
}
public short ReadShort(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
short result = BitConverter.ToInt16(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 2;
}
return result;
}
throw new Exception("Could not read value of type 'short'!");
}
public ushort ReadUShort(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
ushort result = BitConverter.ToUInt16(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 2;
}
return result;
}
throw new Exception("Could not read value of type 'ushort'!");
}
public int ReadInt(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
int result = BitConverter.ToInt32(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 4;
}
return result;
}
throw new Exception("Could not read value of type 'int'!");
}
public uint ReadUInt(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
uint result = BitConverter.ToUInt32(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 4;
}
return result;
}
throw new Exception("Could not read value of type 'uint'!");
}
public long ReadLong(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
long result = BitConverter.ToInt64(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 8;
}
return result;
}
throw new Exception("Could not read value of type 'long'!");
}
public float ReadFloat(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
float result = BitConverter.ToSingle(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 4;
}
return result;
}
throw new Exception("Could not read value of type 'float'!");
}
public double ReadDouble(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
double result = BitConverter.ToDouble(readableBuffer, readPos);
if (_moveReadPos)
{
readPos += 8;
}
return result;
}
throw new Exception("Could not read value of type 'double'!");
}
public bool ReadBool(bool _moveReadPos = true)
{
if (buffer.Count > readPos)
{
bool result = BitConverter.ToBoolean(readableBuffer, readPos);
if (_moveReadPos)
{
readPos++;
}
return result;
}
throw new Exception("Could not read value of type 'bool'!");
}
public string ReadString(bool _moveReadPos = true)
{
try
{
int num = ReadInt();
string @string = Encoding.ASCII.GetString(readableBuffer, readPos, num);
if (_moveReadPos && @string.Length > 0)
{
readPos += num;
}
return @string;
}
catch
{
throw new Exception("Could not read value of type 'string'!");
}
}
public Vector3 ReadVector3(bool _moveReadPos = true)
{
//IL_0016: 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_001e: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
}
public Vector2 ReadVector2(bool _moveReadPos = true)
{
//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 new Vector2(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
}
public Quaternion ReadQuaternion(bool _moveReadPos = true)
{
//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_0025: Unknown result type (might be due to invalid IL or missing references)
return new Quaternion(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
}
public SosigConfigTemplate ReadSosigConfig(bool full = false, bool _moveReadPos = true)
{
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0414: Unknown result type (might be due to invalid IL or missing references)
SosigConfigTemplate val = ScriptableObject.CreateInstance<SosigConfigTemplate>();
val.AppliesDamageResistToIntegrityLoss = ReadBool();
val.DoesDropWeaponsOnBallistic = ReadBool();
val.TotalMustard = ReadFloat();
val.BleedDamageMult = ReadFloat();
val.BleedRateMultiplier = ReadFloat();
val.BleedVFXIntensity = ReadFloat();
val.SearchExtentsModifier = ReadFloat();
val.ShudderThreshold = ReadFloat();
val.ConfusionThreshold = ReadFloat();
val.ConfusionMultiplier = ReadFloat();
val.ConfusionTimeMax = ReadFloat();
val.StunThreshold = ReadFloat();
val.StunMultiplier = ReadFloat();
val.StunTimeMax = ReadFloat();
val.HasABrain = ReadBool();
val.HasNightVision = ReadBool();
val.RegistersPassiveThreats = ReadBool();
val.CanBeKnockedOut = ReadBool();
val.MaxUnconsciousTime = ReadFloat();
val.IgnoresNeedForWeapons = ReadBool();
val.AssaultPointOverridesSkirmishPointWhenFurtherThan = ReadFloat();
val.ViewDistance = ReadFloat();
val.HearingDistance = ReadFloat();
val.MaxFOV = ReadFloat();
val.StateSightRangeMults = ReadVector3();
val.StateHearingRangeMults = ReadVector3();
val.StateFOVMults = ReadVector3();
val.CanPickup_Ranged = ReadBool();
val.CanPickup_Melee = ReadBool();
val.CanPickup_Other = ReadBool();
val.MaxThreatingIFFReactionRange_Visual = ReadFloat();
val.MaxThreatingIFFReactionRange_Sonic = ReadFloat();
val.AggroSensitivityMultiplier = ReadFloat();
val.EntityRecognitionSpeedMultiplier = ReadFloat();
val.CombatTargetIdentificationSpeedMultiplier = ReadFloat();
val.DoesJointBreakKill_Head = ReadBool();
val.DoesJointBreakKill_Upper = ReadBool();
val.DoesJointBreakKill_Lower = ReadBool();
val.DoesSeverKill_Head = ReadBool();
val.DoesSeverKill_Upper = ReadBool();
val.DoesSeverKill_Lower = ReadBool();
val.DoesExplodeKill_Head = ReadBool();
val.DoesExplodeKill_Upper = ReadBool();
val.DoesExplodeKill_Lower = ReadBool();
val.CrawlSpeed = ReadFloat();
val.SneakSpeed = ReadFloat();
val.WalkSpeed = ReadFloat();
val.RunSpeed = ReadFloat();
val.TurnSpeed = ReadFloat();
val.MovementRotMagnitude = ReadFloat();
val.DamMult_Projectile = ReadFloat();
val.DamMult_Explosive = ReadFloat();
val.DamMult_Melee = ReadFloat();
val.DamMult_Piercing = ReadFloat();
val.DamMult_Blunt = ReadFloat();
val.DamMult_Cutting = ReadFloat();
val.DamMult_Thermal = ReadFloat();
val.DamMult_Chilling = ReadFloat();
val.DamMult_EMP = ReadFloat();
val.CanBeSurpressed = ReadBool();
val.SuppressionMult = ReadFloat();
val.CanBeGrabbed = ReadBool();
val.CanBeSevered = ReadBool();
val.CanBeStabbed = ReadBool();
val.MaxJointLimit = ReadFloat();
byte b = ReadByte();
if (b > 0)
{
val.LinkDamageMultipliers = new List<float>();
for (int i = 0; i < b; i++)
{
val.LinkDamageMultipliers.Add(ReadFloat());
}
}
byte b2 = ReadByte();
if (b2 > 0)
{
val.LinkStaggerMultipliers = new List<float>();
for (int j = 0; j < b2; j++)
{
val.LinkStaggerMultipliers.Add(ReadFloat());
}
}
byte b3 = ReadByte();
if (b3 > 0)
{
val.StartingLinkIntegrity = new List<Vector2>();
for (int k = 0; k < b3; k++)
{
val.StartingLinkIntegrity.Add(ReadVector2());
}
}
byte b4 = ReadByte();
if (b4 > 0)
{
val.StartingChanceBrokenJoint = new List<float>();
for (int l = 0; l < b4; l++)
{
val.StartingChanceBrokenJoint.Add(ReadFloat());
}
}
byte b5 = ReadByte();
if (b5 > 0)
{
val.LinkSpawnChance = new List<float>();
for (int m = 0; m < b5; m++)
{
val.LinkSpawnChance.Add(ReadFloat());
}
}
val.TargetCapacity = ReadInt();
val.TargetTrackingTime = ReadFloat();
val.NoFreshTargetTime = ReadFloat();
val.DoesAggroOnFriendlyFire = ReadBool();
val.UsesLinkSpawns = ReadBool();
val.TimeInSkirmishToAlert = ReadFloat();
return val;
}
public Damage ReadDamage(bool _moveReadPos = true)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//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_0024: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
Damage val = new Damage();
val.point = ReadVector3();
val.Source_IFF = ReadInt();
val.Source_Point = ReadVector3();
val.Dam_Blunt = ReadFloat();
val.Dam_Piercing = ReadFloat();
val.Dam_Cutting = ReadFloat();
val.Dam_TotalKinetic = ReadFloat();
val.Dam_Thermal = ReadFloat();
val.Dam_Chilling = ReadFloat();
val.Dam_EMP = ReadFloat();
val.Dam_TotalEnergetic = ReadFloat();
val.Dam_Stunning = ReadFloat();
val.Dam_Blinding = ReadFloat();
val.hitNormal = ReadVector3();
val.strikeDir = ReadVector3();
val.edgeNormal = ReadVector3();
val.damageSize = ReadFloat();
val.Class = (DamageClass)ReadByte();
return val;
}
protected virtual void Dispose(bool _disposing)
{
if (!disposed)
{
if (_disposing)
{
buffer = null;
readableBuffer = null;
readPos = 0;
}
disposed = true;
}
}
public void Dispose()
{
Dispose(_disposing: true);
GC.SuppressFinalize(this);
}
}
public class Tools
{
private static int enabled = 2;
public static List<CustomConnection> connections = new List<CustomConnection>();
public static bool H3MPEnabled
{
get
{
if (enabled == 2)
{
enabled = (byte)(Chainloader.PluginInfos.ContainsKey("VIP.TommySoucy.H3MP") ? 1 : 0);
}
return enabled == 1;
}
}
private static bool isServerRunning
{
get
{
if ((Object)(object)Mod.managerObject == (Object)null)
{
return false;
}
return true;
}
}
private static bool isHosting
{
get
{
if ((Object)(object)Mod.managerObject == (Object)null)
{
return false;
}
if (ThreadManager.host)
{
return true;
}
return false;
}
}
private static int[] playerIds
{
get
{
int[] array = new int[GameManager.players.Count];
int num = 0;
foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
{
array[num] = player.Key;
num++;
}
return array;
}
}
private static int getLocalPlayerID => GameManager.ID;
public static bool ServerRunning()
{
if (H3MPEnabled)
{
return isServerRunning;
}
return false;
}
public static bool IsClient()
{
if (ServerRunning())
{
return isClient();
}
return false;
}
private static bool isClient()
{
if ((Object)(object)Mod.managerObject == (Object)null)
{
return false;
}
if (!ThreadManager.host)
{
return true;
}
return false;
}
public static bool IsHost()
{
if (ServerRunning())
{
return isHosting;
}
return false;
}
public static void SetLocalPlayerIFF(int iff)
{
GM.CurrentPlayerBody.SetPlayerIFF(iff);
if (ServerRunning())
{
setLocalPlayerIFF(iff);
}
}
private static void setLocalPlayerIFF(int iff)
{
if (ThreadManager.host)
{
ServerSend.PlayerIFF(0, GM.CurrentPlayerBody.GetPlayerIFF());
}
else
{
ClientSend.PlayerIFF(GM.CurrentPlayerBody.GetPlayerIFF());
}
}
public static int GetPlayerCount()
{
if (H3MPEnabled)
{
return GetNetworkPlayerCount();
}
return 1;
}
private static int GetNetworkPlayerCount()
{
return GameManager.players.Count;
}
public static int[] GetPlayerIDs()
{
if (!H3MPEnabled)
{
return null;
}
return playerIds;
}
public static int GetLocalPlayerID()
{
if (!H3MPEnabled)
{
return -1;
}
return getLocalPlayerID;
}
public static PlayerData GetPlayerData(int clientID)
{
if (!H3MPEnabled)
{
return GetLocalPlayerData();
}
return getPlayerData(clientID);
}
private static PlayerData getPlayerData(int clientID)
{
if (clientID == GameManager.ID)
{
PlayerData localPlayerData = GetLocalPlayerData();
localPlayerData.username = ((object)Mod.config["Username"]).ToString();
return localPlayerData;
}
PlayerData playerData = new PlayerData();
playerData.head = GameManager.players[clientID].head;
playerData.username = GameManager.players[clientID].username;
playerData.handLeft = GameManager.players[clientID].leftHand;
playerData.handRight = GameManager.players[clientID].rightHand;
playerData.iff = GameManager.players[clientID].IFF;
playerData.health = GameManager.players[clientID].health;
playerData.ID = clientID;
return playerData;
}
private static PlayerData GetLocalPlayerData()
{
PlayerData playerData = new PlayerData();
playerData.username = "Player";
playerData.head = GM.CurrentPlayerBody.Head;
playerData.handLeft = GM.CurrentPlayerBody.LeftHand;
playerData.handRight = GM.CurrentPlayerBody.RightHand;
playerData.iff = GM.CurrentPlayerBody.GetPlayerIFF();
playerData.health = GM.CurrentPlayerBody.Health;
return playerData;
}
public static CustomConnection CreateCustomConnection(string connectionName)
{
CustomConnection customConnection = connections.FirstOrDefault((CustomConnection obj) => obj.Name == connectionName);
CustomConnection customConnection2;
if (customConnection != null)
{
customConnection2 = customConnection;
NetworkingToolsPlugin.Logger.LogMessage((object)("Found Existing connection " + connectionName));
}
else
{
customConnection2 = new CustomConnection(connectionName);
connections.Add(customConnection2);
NetworkingToolsPlugin.Logger.LogMessage((object)("Created new connection " + connectionName));
}
customConnection2.Setup();
return customConnection2;
}
}
[Serializable]
public class PlayerData
{
public Transform head;
public string username;
public Transform handLeft;
public Transform handRight;
public int ID;
public float health;
public int iff;
public static PlayerData GetPlayer(int clientID)
{
return new PlayerData
{
head = GameManager.players[clientID].head,
username = GameManager.players[clientID].username,
handLeft = GameManager.players[clientID].leftHand,
handRight = GameManager.players[clientID].rightHand,
ID = clientID,
health = GameManager.players[clientID].health,
iff = GameManager.players[clientID].IFF
};
}
}
internal static class PluginInfo
{
internal const string NAME = "Networking Tools";
internal const string GUID = "Packer.NetworkingTools";
internal const string VERSION = "0.9.0";
}
}
