using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HG.Reflection;
using IL.RoR2.Projectile;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using On.RoR2.Projectile;
using PizzaClientLagFix.ModCompat;
using PizzaClientLagFix.Networking;
using RoR2;
using RoR2.Projectile;
using UnityEngine;
using UnityEngine.Networking;
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyInformationalVersion("1.0.0+60b82f78f634befdbb358c629fdc65a45661368d")]
[assembly: AssemblyProduct("PizzaClientLagFix")]
[assembly: AssemblyTitle("PizzaClientLagFix")]
[assembly: AssemblyCompany("PizzaClientLagFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace PizzaClientLagFix
{
internal static class Log
{
private static readonly StringBuilder _sharedStringBuilder;
private static readonly int _cachedCallerPathPrefixLength;
private static ManualLogSource _logSource;
static Log()
{
_sharedStringBuilder = new StringBuilder(256);
_cachedCallerPathPrefixLength = getCallerPathPrefixLength("D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\Log.cs");
static int getCallerPathPrefixLength([CallerFilePath] string callerPath = null)
{
int num = callerPath.LastIndexOf("PizzaClientLagFix\\");
if (num >= 0)
{
return num + "PizzaClientLagFix\\".Length;
}
Debug.LogError((object)"[PizzaClientLagFix] Logger failed to determine caller path prefix length");
return 0;
}
}
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
private static StringBuilder AppendCallerPrefix(this StringBuilder stringBuilder, string callerPath, string callerMemberName, int callerLineNumber)
{
return stringBuilder.Append(callerPath, _cachedCallerPathPrefixLength, callerPath.Length - _cachedCallerPathPrefixLength).Append(':').Append(callerLineNumber)
.Append(" (")
.Append(callerMemberName)
.Append("):");
}
private static StringBuilder buildCallerLogString(string callerPath, string callerMemberName, int callerLineNumber, object data)
{
return _sharedStringBuilder.Clear().AppendCallerPrefix(callerPath, callerMemberName, callerLineNumber).Append(' ')
.Append(data);
}
[Conditional("DEBUG")]
internal static void Debug(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogDebug((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Conditional("DEBUG")]
internal static void Debug_NoCallerPrefix(object data)
{
_logSource.LogDebug(data);
}
internal static void Error(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogError((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Error_NoCallerPrefix(object data)
{
_logSource.LogError(data);
}
internal static void Fatal(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogFatal((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Fatal_NoCallerPrefix(object data)
{
_logSource.LogFatal(data);
}
internal static void Info(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogInfo((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Info_NoCallerPrefix(object data)
{
_logSource.LogInfo(data);
}
internal static void Message(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogMessage((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Message_NoCallerPrefix(object data)
{
_logSource.LogMessage(data);
}
internal static void Warning(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
_logSource.LogWarning((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Warning_NoCallerPrefix(object data)
{
_logSource.LogWarning(data);
}
internal static void LogType(LogLevel level, object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
if ((level & 0x20) == 0)
{
_logSource.Log(level, (object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void LogType_NoCallerPrefix(LogLevel level, object data)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
if ((level & 0x20) == 0)
{
_logSource.Log(level, data);
}
}
}
[BepInPlugin("Gorakh.PizzaClientLagFix", "PizzaClientLagFix", "1.3.2")]
public class Main : BaseUnityPlugin
{
public const string PluginGUID = "Gorakh.PizzaClientLagFix";
public const string PluginAuthor = "Gorakh";
public const string PluginName = "PizzaClientLagFix";
public const string PluginVersion = "1.3.2";
internal static Main Instance { get; private set; }
private void Awake()
{
Stopwatch stopwatch = Stopwatch.StartNew();
Log.Init(((BaseUnityPlugin)this).Logger);
Instance = SingletonHelper.Assign<Main>(Instance, this);
stopwatch.Stop();
Log.Info_NoCallerPrefix($"Initialized in {stopwatch.Elapsed.TotalSeconds:F2} seconds");
}
private void OnDestroy()
{
Instance = SingletonHelper.Unassign<Main>(Instance, this);
}
}
public static class OverlapAttackIgnoreNonAuthorityHitsPatch
{
[CompilerGenerated]
private static class <>O
{
public static hook_ProcessHits <0>__OverlapAttack_ProcessHits;
}
public static bool Enabled;
[SystemInitializer(new Type[] { })]
private static void Init()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
object obj = <>O.<0>__OverlapAttack_ProcessHits;
if (obj == null)
{
hook_ProcessHits val = OverlapAttack_ProcessHits;
<>O.<0>__OverlapAttack_ProcessHits = val;
obj = (object)val;
}
OverlapAttack.ProcessHits += (hook_ProcessHits)obj;
}
private static void OverlapAttack_ProcessHits(orig_ProcessHits orig, OverlapAttack self, object boxedHitList)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
if (!Enabled)
{
orig.Invoke(self, boxedHitList);
return;
}
try
{
List<OverlapInfo> list = (List<OverlapInfo>)boxedHitList;
_ = list.Count;
_ = 0;
for (int num = list.Count - 1; num >= 0; num--)
{
HurtBox hurtBox = list[num].hurtBox;
if (Object.op_Implicit((Object)(object)hurtBox))
{
HealthComponent healthComponent = hurtBox.healthComponent;
if (Object.op_Implicit((Object)(object)healthComponent) && !Util.HasEffectiveAuthority(((Component)healthComponent).gameObject))
{
list.RemoveAt(num);
}
}
}
orig.Invoke(self, (object)list);
}
catch (Exception data)
{
Log.Error_NoCallerPrefix(data);
orig.Invoke(self, boxedHitList);
}
}
}
internal static class ProjectileOverlapAttackClientPredictionHooks
{
[CompilerGenerated]
private static class <>O
{
public static hook_MyFixedUpdate <0>__ProjectileOverlapAttack_MyFixedUpdate_EnsurePatchDisabled;
public static Manipulator <1>__ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction;
public static Func<ProjectileOverlapAttack, ProjectileOverlapAttackClientPrediction> <2>__getClientPrediction;
public static Func<bool, ProjectileOverlapAttackClientPrediction, bool> <3>__overrideShouldProcessAttack;
public static Action<ProjectileOverlapAttackClientPrediction> <4>__preFire;
public static Action <5>__postFire;
}
[SystemInitializer(new Type[] { typeof(ProjectileCatalog) })]
private static void Init()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
object obj = <>O.<0>__ProjectileOverlapAttack_MyFixedUpdate_EnsurePatchDisabled;
if (obj == null)
{
hook_MyFixedUpdate val = ProjectileOverlapAttack_MyFixedUpdate_EnsurePatchDisabled;
<>O.<0>__ProjectileOverlapAttack_MyFixedUpdate_EnsurePatchDisabled = val;
obj = (object)val;
}
ProjectileOverlapAttack.MyFixedUpdate += (hook_MyFixedUpdate)obj;
object obj2 = <>O.<1>__ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction;
if (obj2 == null)
{
Manipulator val2 = ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction;
<>O.<1>__ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction = val2;
obj2 = (object)val2;
}
ProjectileOverlapAttack.MyFixedUpdate += (Manipulator)obj2;
addPredictionToProjectile("BrotherUltLineProjectileRotateLeft");
addPredictionToProjectile("BrotherUltLineProjectileRotateRight");
addPredictionToProjectile("BrotherUltLineProjectileStatic");
addPredictionToProjectile("BrotherSunderWave");
if (!UmbralMithrixCompat.Enabled)
{
return;
}
bool flag = !tryAddPredictionToProjectile("P4UltLineLeft");
bool flag2 = !tryAddPredictionToProjectile("P4UltLineRight");
bool flag3 = !tryAddPredictionToProjectile("StaticUltLine");
if (!(flag || flag2 || flag3))
{
return;
}
PluginInfo value = UmbralMithrixCompat.UmbralPluginInfo.Value;
if (value == null)
{
return;
}
BaseUnityPlugin umbralPluginInstance = value.Instance;
Type umbralPluginType;
if (Object.op_Implicit((Object)(object)umbralPluginInstance))
{
umbralPluginType = ((object)umbralPluginInstance).GetType();
if (flag)
{
tryAddPredictionToUmbralField("leftP4Line");
}
if (flag2)
{
tryAddPredictionToUmbralField("rightP4Line");
}
if (flag3)
{
tryAddPredictionToUmbralField("staticUltLine");
}
}
static void addPredictionToPrefab(GameObject prefab)
{
prefab.AddComponent<ProjectileOverlapAttackValueNetworker>();
prefab.AddComponent<ProjectileOverlapAttackClientPrediction>();
}
static void addPredictionToProjectile(string projectileName)
{
if (!tryAddPredictionToProjectile(projectileName))
{
Log.Error("Failed to find projectile '" + projectileName + "'", "D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\ProjectileOverlapAttackClientPredictionHooks.cs", "Init", 85);
}
}
static bool tryAddPredictionToProjectile(string projectileName)
{
int num = ProjectileCatalog.FindProjectileIndex(projectileName);
if (num < 0)
{
return false;
}
addPredictionToPrefab(ProjectileCatalog.GetProjectilePrefab(num));
return true;
}
void tryAddPredictionToUmbralField(string fieldName)
{
FieldInfo field = umbralPluginType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (field == null)
{
Log.Error("Failed to find umbral field '" + fieldName + "'", "D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\ProjectileOverlapAttackClientPredictionHooks.cs", "Init", 57);
}
else
{
object value2 = field.GetValue(umbralPluginInstance);
GameObject val3 = (GameObject)((value2 is GameObject) ? value2 : null);
if (val3 == null)
{
string text = "null";
if (value2 != null)
{
text = value2.GetType().FullName;
}
Log.Error("Unexpected type " + text + " of umbral field '" + field.Name + "'", "D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\ProjectileOverlapAttackClientPredictionHooks.cs", "Init", 70);
}
else
{
addPredictionToPrefab(val3);
}
}
}
}
private static void ProjectileOverlapAttack_MyFixedUpdate_EnsurePatchDisabled(orig_MyFixedUpdate orig, ProjectileOverlapAttack self, float deltaTime)
{
try
{
orig.Invoke(self, deltaTime);
}
finally
{
OverlapAttackIgnoreNonAuthorityHitsPatch.Enabled = false;
}
}
private static void ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_003a: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: 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_0183: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
VariableDefinition val2 = new VariableDefinition(il.Import(typeof(ProjectileOverlapAttackClientPrediction)));
il.Method.Body.Variables.Add(val2);
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Func<ProjectileOverlapAttack, ProjectileOverlapAttackClientPrediction>>((Func<ProjectileOverlapAttack, ProjectileOverlapAttackClientPrediction>)getClientPrediction);
val.Emit(OpCodes.Stloc, val2);
int shouldProccessAttacksVar = -1;
ILLabel afterCanProcessCheckLabel = null;
if (!val.TryGotoNext(new Func<Instruction, bool>[3]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<ProjectileController>(x, "CanProcessCollisionEvents"),
(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref shouldProccessAttacksVar),
(Instruction x) => ILPatternMatchingExt.MatchBr(x, ref afterCanProcessCheckLabel)
}))
{
Log.Error("Failed to find initial patch location", "D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\ProjectileOverlapAttackClientPredictionHooks.cs", "ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction", 143);
return;
}
val.Goto(afterCanProcessCheckLabel.Target, (MoveType)1, false);
val.Emit(OpCodes.Ldloc, shouldProccessAttacksVar);
val.Emit(OpCodes.Ldloc, val2);
val.EmitDelegate<Func<bool, ProjectileOverlapAttackClientPrediction, bool>>((Func<bool, ProjectileOverlapAttackClientPrediction, bool>)overrideShouldProcessAttack);
val.Emit(OpCodes.Stloc, shouldProccessAttacksVar);
if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<OverlapAttack>(x, "Fire")
}))
{
val.Emit(OpCodes.Ldloc, val2);
val.EmitDelegate<Action<ProjectileOverlapAttackClientPrediction>>((Action<ProjectileOverlapAttackClientPrediction>)preFire);
int index = val.Index;
val.Index = index + 1;
val.EmitDelegate<Action>((Action)postFire);
}
else
{
Log.Error("Failed to find fire patch location", "D:\\Git\\RoR2\\PizzaClientLagFix\\PizzaClientLagFix\\ProjectileOverlapAttackClientPredictionHooks.cs", "ProjectileOverlapAttack_MyFixedUpdate_AllowClientPrediction", 179);
}
static ProjectileOverlapAttackClientPrediction getClientPrediction(ProjectileOverlapAttack projectileOverlapAttack)
{
return ((Component)projectileOverlapAttack).GetComponent<ProjectileOverlapAttackClientPrediction>();
}
static bool overrideShouldProcessAttack(bool shouldProccessAttacks, ProjectileOverlapAttackClientPrediction clientPrediction)
{
if (!shouldProccessAttacks)
{
return Object.op_Implicit((Object)(object)clientPrediction);
}
return true;
}
static void postFire()
{
OverlapAttackIgnoreNonAuthorityHitsPatch.Enabled = false;
}
static void preFire(ProjectileOverlapAttackClientPrediction clientPrediction)
{
OverlapAttackIgnoreNonAuthorityHitsPatch.Enabled = Object.op_Implicit((Object)(object)clientPrediction);
}
}
}
}
namespace PizzaClientLagFix.Networking
{
public class ProjectileOverlapAttackClientPrediction : MonoBehaviour
{
}
public class ProjectileOverlapAttackValueNetworker : NetworkBehaviour
{
private ProjectileController _projectileController;
private ProjectileDamage _projectileDamage;
private const uint PROC_CHAIN_MASK_DIRTY_BIT = 1u;
private ProcChainMask _procChainMask;
private const uint PROC_COEFFICIENT_DIRTY_BIT = 2u;
private float _procCoefficient = 1f;
private const uint DAMAGE_DIRTY_BIT = 4u;
private float _damage;
private const uint FORCE_DIRTY_BIT = 8u;
private float _force;
private const uint CRIT_DIRTY_BIT = 16u;
private bool _crit;
private const uint DAMAGE_COLOR_INDEX_DIRTY_BIT = 32u;
private DamageColorIndex _damageColorIndex;
private const uint DAMAGE_TYPE_DIRTY_BIT = 64u;
private DamageTypeCombo _damageType = DamageTypeCombo.Generic;
private void Awake()
{
_projectileController = ((Component)this).GetComponent<ProjectileController>();
_projectileDamage = ((Component)this).GetComponent<ProjectileDamage>();
_projectileController.onInitialized += onProjectileInitialized;
}
public override void OnStartClient()
{
((NetworkBehaviour)this).OnStartClient();
refreshValues();
}
private void FixedUpdate()
{
refreshValues();
}
private void onProjectileInitialized(ProjectileController projectileController)
{
refreshValues();
}
private void refreshValues()
{
//IL_001a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
_ = ((NetworkBehaviour)this).syncVarDirtyBits;
if (Object.op_Implicit((Object)(object)_projectileController))
{
ProcChainMask currentValue2 = _projectileController.procChainMask;
checkValueEquatable<ProcChainMask>(ref _procChainMask, ref currentValue2, 1u);
_projectileController.procChainMask = currentValue2;
checkValueEquatable<float>(ref _procCoefficient, ref _projectileController.procCoefficient, 2u);
}
if (Object.op_Implicit((Object)(object)_projectileDamage))
{
checkValueEquatable<float>(ref _damage, ref _projectileDamage.damage, 4u);
checkValueEquatable<float>(ref _force, ref _projectileDamage.force, 8u);
checkValueEquatable<bool>(ref _crit, ref _projectileDamage.crit, 16u);
checkValue<DamageColorIndex>(ref _damageColorIndex, ref _projectileDamage.damageColorIndex, 32u, (DamageColorIndex a, DamageColorIndex b) => a == b);
checkValue<DamageTypeCombo>(ref _damageType, ref _projectileDamage.damageType, 64u, (DamageTypeCombo a, DamageTypeCombo b) => ((object)(DamageTypeCombo)(ref a)).Equals((object?)b));
}
bool checkValue<T>(ref T authorityValue, ref T currentValue, uint dirtyBit, Func<T, T, bool> comparison)
{
if (comparison(authorityValue, currentValue))
{
return false;
}
if (NetworkServer.active)
{
authorityValue = currentValue;
((NetworkBehaviour)this).SetDirtyBit(dirtyBit);
}
else
{
currentValue = authorityValue;
}
return true;
}
bool checkValueEquatable<T>(ref T authorityValue, ref T currentValue, uint dirtyBit) where T : IEquatable<T>
{
return checkValue<T>(ref authorityValue, ref currentValue, dirtyBit, (T a, T b) => a.Equals(b));
}
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
//IL_001e: 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_0093: Unknown result type (might be due to invalid IL or missing references)
uint num;
if (initialState)
{
num = uint.MaxValue;
}
else
{
num = ((NetworkBehaviour)this).syncVarDirtyBits;
writer.WritePackedUInt32(num);
}
bool flag = false;
if ((num & (true ? 1u : 0u)) != 0)
{
NetworkExtensions.Write(writer, _procChainMask);
flag = true;
}
if ((num & 2u) != 0)
{
writer.Write(_procCoefficient);
flag = true;
}
if ((num & 4u) != 0)
{
writer.Write(_damage);
flag = true;
}
if ((num & 8u) != 0)
{
writer.Write(_force);
flag = true;
}
if ((num & 0x10u) != 0)
{
writer.Write(_crit);
flag = true;
}
if ((num & 0x20u) != 0)
{
NetworkExtensions.Write(writer, _damageColorIndex);
flag = true;
}
if ((num & 0x40u) != 0)
{
NetworkExtensions.WriteDamageType(writer, _damageType);
flag = true;
}
return flag || initialState;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
//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_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: 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)
int num = (initialState ? (-1) : ((int)reader.ReadPackedUInt32()));
if (((uint)num & (true ? 1u : 0u)) != 0)
{
_procChainMask = NetworkExtensions.ReadProcChainMask(reader);
}
if (((uint)num & 2u) != 0)
{
_procCoefficient = reader.ReadSingle();
}
if (((uint)num & 4u) != 0)
{
_damage = reader.ReadSingle();
}
if (((uint)num & 8u) != 0)
{
_force = reader.ReadSingle();
}
if (((uint)num & 0x10u) != 0)
{
_crit = reader.ReadBoolean();
}
if (((uint)num & 0x20u) != 0)
{
_damageColorIndex = NetworkExtensions.ReadDamageColorIndex(reader);
}
if (((uint)num & 0x40u) != 0)
{
_damageType = NetworkExtensions.ReadDamageType(reader);
}
refreshValues();
}
private void UNetVersion()
{
}
}
}
namespace PizzaClientLagFix.ModCompat
{
internal static class UmbralMithrixCompat
{
private const string UMBRAL_GUID = "com.Nuxlar.UmbralMithrix";
public static readonly Lazy<PluginInfo> UmbralPluginInfo = new Lazy<PluginInfo>((Func<PluginInfo>)(() => (!Chainloader.PluginInfos.TryGetValue("com.Nuxlar.UmbralMithrix", out var value)) ? null : value));
public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.Nuxlar.UmbralMithrix");
}
}
