using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
[assembly: AssemblyFileVersion("1.2.5")]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyProduct("AzuMiscPatches")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("AzuMiscPatches")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.5.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<c0066aff-893c-4bea-87d4-14151dc61393>Embedded]
internal sealed class <c0066aff-893c-4bea-87d4-14151dc61393>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[<c0066aff-893c-4bea-87d4-14151dc61393>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
internal sealed class <a9384ffa-8e10-4084-ad54-b73403024498>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <a9384ffa-8e10-4084-ad54-b73403024498>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <a9384ffa-8e10-4084-ad54-b73403024498>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
[<c0066aff-893c-4bea-87d4-14151dc61393>Embedded]
[CompilerGenerated]
internal sealed class <92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace AzuMiscPatches
{
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public static class Admin
{
public static IAdmin Instance = new DefaultAdmin();
public static bool Enabled
{
get
{
return Instance.Enabled;
}
set
{
Instance.Enabled = value;
}
}
public static bool Checking
{
get
{
return Instance.Checking;
}
set
{
Instance.Checking = value;
}
}
public static void ManualCheck()
{
Instance.ManualCheck();
}
public static void Verify(string text)
{
Instance.Verify(text);
}
public static void AutomaticCheck()
{
Instance.AutomaticCheck();
}
public static void Reset()
{
Instance.Reset();
}
}
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public interface IAdmin
{
bool Enabled { get; set; }
bool Checking { get; set; }
void ManualCheck();
void Verify(string text);
void AutomaticCheck();
void Reset();
}
public class DefaultAdmin : IAdmin
{
public virtual bool Enabled { get; set; }
public virtual bool Checking { get; set; }
protected void Check()
{
if (Object.op_Implicit((Object)(object)ZNet.instance))
{
Checking = true;
if (ZNet.instance.IsServer())
{
OnSuccess();
}
else
{
ZNet.instance.Unban("admintest");
}
}
}
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public void Verify(string text)
{
if (text == "Unbanning user admintest")
{
OnSuccess();
}
else
{
OnFail();
}
}
public virtual void AutomaticCheck()
{
Check();
}
protected virtual void OnSuccess()
{
AzuMiscPatchesPlugin.AzuMiscPatchesLogger.LogInfo((object)"Admin status verified.");
Checking = false;
Enabled = true;
}
protected virtual void OnFail()
{
Checking = false;
Enabled = false;
}
public virtual void ManualCheck()
{
Check();
}
public virtual void Reset()
{
Checking = false;
Enabled = false;
}
}
[HarmonyPatch(typeof(ZNet), "RPC_RemotePrint")]
public class ZNet_RPC_RemotePrint
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(string text)
{
if (!Admin.Checking)
{
return true;
}
Admin.Verify(text);
return false;
}
}
[HarmonyPatch(typeof(Game), "Awake")]
public class AdminReset
{
private static void Postfix()
{
Admin.Reset();
}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
public class AdminCheck
{
private static void Postfix()
{
if (!Admin.Checking)
{
Admin.AutomaticCheck();
}
}
}
[HarmonyPatch(typeof(Inventory), "TopFirst")]
public static class Inventory_TopFirst_Patch
{
public static bool Prefix(ref bool __result)
{
if (AzuMiscPatchesPlugin.FillTopToBottom.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return true;
}
__result = true;
return false;
}
}
[HarmonyPatch(typeof(Inventory), "IsTeleportable")]
public static class NoItemTeleportPrevention
{
private static void Postfix(ref bool __result)
{
if (AzuMiscPatchesPlugin.NoTeleportPrevention.Value == AzuMiscPatchesPlugin.Toggle.On)
{
__result = true;
}
}
}
[HarmonyPatch(typeof(ItemDrop), "Awake")]
public static class ItemDrop_Awake_Patch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Prefix(ref ItemDrop __instance)
{
if (AzuMiscPatchesPlugin.ItemStackMultiplier.Value > 0f)
{
__instance.m_itemData.m_shared.m_weight = ApplyModifierValue(__instance.m_itemData.m_shared.m_weight, AzuMiscPatchesPlugin.WeightReduction.Value);
if (__instance.m_itemData.m_shared.m_maxStackSize > 1 && AzuMiscPatchesPlugin.ItemStackMultiplier.Value >= 1f)
{
SharedData shared = __instance.m_itemData.m_shared;
shared.m_maxStackSize *= (int)AzuMiscPatchesPlugin.ItemStackMultiplier.Value;
}
}
}
public static float ApplyModifierValue(float targetValue, float value)
{
if (value <= -100f)
{
value = -100f;
}
if (value >= 0f)
{
return targetValue + targetValue / 100f * value;
}
return targetValue - targetValue / 100f * (value * -1f);
}
}
[HarmonyPatch(typeof(Inventory), "MoveAll")]
public static class InventoryMoveAllPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Prefix(ref Inventory __instance, ref Inventory fromInventory)
{
if (AzuMiscPatchesPlugin.MergeStacks.Value != AzuMiscPatchesPlugin.Toggle.On)
{
return;
}
foreach (ItemData item in new List<ItemData>(fromInventory.GetAllItems()).Where((ItemData otherItem) => otherItem.m_shared.m_maxStackSize > 1))
{
foreach (ItemData item2 in __instance.m_inventory)
{
if (item2.m_shared.m_name == item.m_shared.m_name && item2.m_quality == item.m_quality)
{
int num = Math.Min(item2.m_shared.m_maxStackSize - item2.m_stack, item.m_stack);
item2.m_stack += num;
if (item.m_stack == num)
{
fromInventory.RemoveItem(item);
break;
}
item.m_stack -= num;
}
}
}
}
}
[HarmonyPriority(0)]
[HarmonyPatch(typeof(Location), "IsInsideNoBuildLocation")]
public class LocationIsInsideNoBuildLocationPatch
{
public static bool Postfix(bool result)
{
return AzuMiscPatchesPlugin.BuildInsideProtectedLocations.Value != AzuMiscPatchesPlugin.Toggle.On && result;
}
}
[HarmonyPatch(typeof(Game), "SpawnPlayer")]
public class DisableStartShout
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(Game __instance)
{
if (AzuMiscPatchesPlugin.HaveArrivedOnSpawn.Value == AzuMiscPatchesPlugin.Toggle.On)
{
__instance.m_firstSpawn = false;
}
}
}
[HarmonyPatch(typeof(Player), "StartGuardianPower")]
public static class PlayerStartGuardianPowerPatch
{
[HarmonyBefore(new string[] { "org.bepinex.plugins.passivepowers" })]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(ref Player __instance, ref bool __result)
{
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
if (AzuMiscPatchesPlugin.DisableGuardianAnimation.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return true;
}
if ((Object)(object)__instance.m_guardianSE == (Object)null)
{
__result = false;
return false;
}
if (__instance.m_guardianPowerCooldown > 0f)
{
((Character)__instance).Message((MessageType)2, "$hud_powernotready", 0, (Sprite)null);
__result = false;
return false;
}
if (!((double)__instance.m_guardianPowerCooldown > 0.0) && (Object)(object)__instance.m_guardianSE != (Object)null)
{
List<Player> list = new List<Player>();
Player.GetPlayersInRange(((Component)__instance).transform.position, 10f, list);
foreach (Player item in list)
{
((Character)item).GetSEMan().AddStatusEffect(__instance.m_guardianSE.NameHash(), true, 0, 0f);
}
if (!Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.passivepowers"))
{
__instance.m_guardianPowerCooldown = __instance.m_guardianSE.m_cooldown;
}
__result = true;
return false;
}
return false;
}
}
[HarmonyPatch(typeof(Player), "HaveSeenTutorial")]
public static class PlayerHaveSeenTutorialPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Prefix(Player __instance, ref string name)
{
if (AzuMiscPatchesPlugin.SkipTuts.Value != 0 && !__instance.m_shownTutorials.Contains(name))
{
__instance.m_shownTutorials.Add(name);
}
}
}
[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
public static class HumanoidUpdateEquipmentPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(Humanoid __instance)
{
if (AzuMiscPatchesPlugin.ReequipItemsAfterSwimming.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return true;
}
if (!((Character)__instance).IsPlayer())
{
return true;
}
if (((Character)__instance).IsSwimming())
{
if (!((Character)__instance).IsOnGround() && (__instance.m_leftItem != null || __instance.m_rightItem != null))
{
UpdateEquipmentState.ShouldReequipItemsAfterSwimming = true;
}
}
else if (((Character)__instance).IsOnGround() && UpdateEquipmentState.ShouldReequipItemsAfterSwimming)
{
__instance.ShowHandItems(false, true);
UpdateEquipmentState.ShouldReequipItemsAfterSwimming = false;
}
return true;
}
}
public static class UpdateEquipmentState
{
public static bool ShouldReequipItemsAfterSwimming;
}
[HarmonyPatch(typeof(Beehive), "Awake")]
public static class BeehiveAwakePatch
{
private static bool Prefix(ref float ___m_secPerUnit, ref int ___m_maxHoney)
{
___m_secPerUnit = AzuMiscPatchesPlugin.HoneyProductionSpeed.Value;
___m_maxHoney = AzuMiscPatchesPlugin.MaximumHoneyPerBeehive.Value;
return true;
}
}
[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public static class PlayerGetTotalFoodValueTranspiler
{
private static readonly FieldInfo FieldFoodMHealth = AccessTools.Field(typeof(Food), "m_health");
private static readonly FieldInfo FieldFoodMStamina = AccessTools.Field(typeof(Food), "m_stamina");
private static readonly FieldInfo FieldFoodMEitr = AccessTools.Field(typeof(Food), "m_eitr");
private static readonly FieldInfo FieldFoodMItem = AccessTools.Field(typeof(Food), "m_item");
private static readonly FieldInfo FieldItemDataMShared = AccessTools.Field(typeof(ItemData), "m_shared");
private static readonly FieldInfo FieldSharedDataMFood = AccessTools.Field(typeof(SharedData), "m_food");
private static readonly FieldInfo FieldSharedDataMFoodStamina = AccessTools.Field(typeof(SharedData), "m_foodStamina");
private static readonly FieldInfo FieldSharedDataMFoodEitr = AccessTools.Field(typeof(SharedData), "m_foodEitr");
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Expected O, but got Unknown
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Expected O, but got Unknown
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Expected O, but got Unknown
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Expected O, but got Unknown
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Expected O, but got Unknown
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Expected O, but got Unknown
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Expected O, but got Unknown
if (AzuMiscPatchesPlugin.FoodModifications.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return instructions;
}
List<CodeInstruction> list = instructions.ToList();
if (AzuMiscPatchesPlugin.NoFoodDeg.Value != AzuMiscPatchesPlugin.Toggle.On)
{
return list.AsEnumerable();
}
for (int i = 0; i < list.Count; i++)
{
CodeInstruction val = list[i];
if (!(val.opcode != OpCodes.Ldfld))
{
FieldInfo fieldInfo = (FieldInfo)val.operand;
List<CodeInstruction> list2 = new List<CodeInstruction>();
if (fieldInfo == FieldFoodMHealth)
{
list2.AddRange((IEnumerable<CodeInstruction>)(object)new CodeInstruction[3]
{
new CodeInstruction(OpCodes.Ldfld, (object)FieldFoodMItem),
new CodeInstruction(OpCodes.Ldfld, (object)FieldItemDataMShared),
new CodeInstruction(OpCodes.Ldfld, (object)FieldSharedDataMFood)
});
}
else if (fieldInfo == FieldFoodMStamina)
{
list2.AddRange((IEnumerable<CodeInstruction>)(object)new CodeInstruction[3]
{
new CodeInstruction(OpCodes.Ldfld, (object)FieldFoodMItem),
new CodeInstruction(OpCodes.Ldfld, (object)FieldItemDataMShared),
new CodeInstruction(OpCodes.Ldfld, (object)FieldSharedDataMFoodStamina)
});
}
else if (fieldInfo == FieldFoodMEitr)
{
list2.AddRange((IEnumerable<CodeInstruction>)(object)new CodeInstruction[3]
{
new CodeInstruction(OpCodes.Ldfld, (object)FieldFoodMItem),
new CodeInstruction(OpCodes.Ldfld, (object)FieldItemDataMShared),
new CodeInstruction(OpCodes.Ldfld, (object)FieldSharedDataMFoodEitr)
});
}
if (list2.Any())
{
list[i] = list2[0];
list.InsertRange(i + 1, list2.Skip(1));
i += list2.Count - 1;
}
}
}
return list.AsEnumerable();
}
}
[HarmonyPatch(typeof(Player), "RemovePiece")]
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public static class PlayerRemovePieceTranspiler
{
private static readonly MethodInfo ModifyIsInsideMythicalZone = AccessTools.Method(typeof(PlayerRemovePieceTranspiler), "IsInsideNoBuildLocation", (Type[])null, (Type[])null);
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
if (AzuMiscPatchesPlugin.BuildInsideProtectedLocations.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return instructions;
}
List<CodeInstruction> list = instructions.ToList();
for (int i = 0; i < list.Count; i++)
{
if (list[i].operand != null && list[i].operand.ToString().Contains("IsInsideNoBuildLocation"))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)ModifyIsInsideMythicalZone);
}
}
return list.AsEnumerable();
}
private static bool IsInsideNoBuildLocation(Vector3 point)
{
return false;
}
}
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
internal static class PlayerUpdatePlacementGhostPatch
{
public static void Prefix(Player __instance)
{
if (Object.op_Implicit((Object)(object)__instance.m_placementGhost))
{
Piece component = __instance.m_placementGhost.GetComponent<Piece>();
if (AzuMiscPatchesPlugin.BuildInsideProtectedLocations.Value == AzuMiscPatchesPlugin.Toggle.On)
{
component.m_allowedInDungeons = true;
}
}
}
private static void Postfix(Player __instance, bool flashGuardStone)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Invalid comparison between Unknown and I4
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: 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_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Expected I4, but got Unknown
//IL_0058: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Player.m_localPlayer == (Object)null || !Object.op_Implicit((Object)(object)__instance.m_placementGhost) || !__instance.m_placementGhost.activeSelf)
{
return;
}
Piece component = __instance.m_placementGhost.GetComponent<Piece>();
if ((Object)(object)component == (Object)null)
{
return;
}
if (AzuMiscPatchesPlugin.MoreSpace.Value == AzuMiscPatchesPlugin.Toggle.On && (int)__instance.m_placementStatus == 5)
{
__instance.m_placementStatus = (PlacementStatus)0;
component.SetInvalidPlacementHeightlight(false);
}
if (AzuMiscPatchesPlugin.BuildInsideProtectedLocations.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return;
}
PlacementStatus placementStatus = __instance.m_placementStatus;
switch (placementStatus - 1)
{
case 0:
case 2:
case 4:
case 5:
case 10:
__instance.m_placementStatus = (PlacementStatus)0;
component.SetInvalidPlacementHeightlight(false);
break;
case 3:
if (Admin.Enabled)
{
__instance.m_placementStatus = (PlacementStatus)0;
component.SetInvalidPlacementHeightlight(false);
}
break;
case 7:
if (Admin.Enabled)
{
__instance.m_placementStatus = (PlacementStatus)0;
component.SetInvalidPlacementHeightlight(false);
}
break;
case 1:
case 6:
case 8:
case 9:
break;
}
}
}
[HarmonyPatch(typeof(TeleportWorld), "Interact")]
internal class InteractPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> source = new List<CodeInstruction>(instructions);
if (AzuMiscPatchesPlugin.CharacterLimit.Value == AzuMiscPatchesPlugin.Toggle.Off)
{
return source.AsEnumerable();
}
foreach (CodeInstruction item in source.Where((CodeInstruction t) => t.opcode == OpCodes.Ldc_I4_S))
{
item.operand = 127;
}
return source.AsEnumerable();
}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
public static class PlayerOnSpawnedPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Prefix(ref Player __instance, ref bool spawnValkyrie)
{
if (AzuMiscPatchesPlugin.SkipTuts.Value == AzuMiscPatchesPlugin.Toggle.On || AzuMiscPatchesPlugin.SkipIntro.Value == AzuMiscPatchesPlugin.Toggle.On)
{
spawnValkyrie = false;
}
}
}
[HarmonyPatch(typeof(EventSystem), "OnApplicationFocus")]
public static class EventSystemOnApplicationFocusPatch
{
private static void Postfix(bool hasFocus)
{
if (AzuMiscPatchesPlugin.MuteGameInBackground.Value == AzuMiscPatchesPlugin.Toggle.On)
{
AzuMiscPatchesPlugin.AzuMiscPatchesLogger.LogDebug((object)string.Format("MuteGameInBackground is enabled. The game has focus? {0} MasterVolume PlayerPref is: {1: 0f}", hasFocus, PlayerPrefs.GetFloat("MasterVolume", 1f)));
AudioListener.volume = (hasFocus ? PlayerPrefs.GetFloat("MasterVolume", 1f) : 0f);
}
}
}
[HarmonyPatch(typeof(FejdStartup), "Awake")]
public static class HookServerStart
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(ref FejdStartup __instance)
{
if (AzuMiscPatchesPlugin.MinPassLength.Value == AzuMiscPatchesPlugin.Toggle.On)
{
__instance.m_minimumPasswordLength = 0;
}
}
}
[HarmonyPatch(typeof(FejdStartup), "IsPublicPasswordValid")]
public static class ChangeServerPasswordBehavior
{
private static bool Prefix(ref bool __result)
{
__result = true;
return false;
}
}
[HarmonyPatch(typeof(FejdStartup), "GetPublicPasswordError")]
public static class RemovePublicPasswordError
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(ref string __result)
{
__result = "";
return false;
}
}
[HarmonyPatch(typeof(Hud), "SetupPieceInfo", new Type[] { typeof(Piece) })]
public static class Hud_Patch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(Piece piece, TMP_Text ___m_buildSelection)
{
if ((Object)(object)piece == (Object)null || string.IsNullOrEmpty(AzuMiscPatchesPlugin.CanBuildAmountFormat.Value) || Localization.instance == null || string.IsNullOrEmpty(piece.m_name) || piece.m_resources == null || (Object)(object)___m_buildSelection == (Object)null)
{
return;
}
string text = Localization.instance.Localize(piece.m_name);
if (piece.m_resources.Length == 0)
{
return;
}
int num = int.MaxValue;
Requirement[] resources = piece.m_resources;
foreach (Requirement val in resources)
{
if (val != null && !((Object)(object)val.m_resItem == (Object)null) && val.m_resItem.m_itemData != null && val.m_resItem.m_itemData.m_shared != null && !string.IsNullOrEmpty(val.m_resItem.m_itemData.m_shared.m_name))
{
int availableItems = AzuMiscPatchesPlugin.GetAvailableItems(val.m_resItem.m_itemData.m_shared.m_name);
num = Math.Min(num, availableItems / val.m_amount);
}
}
string text2 = string.Format(AzuMiscPatchesPlugin.CanBuildAmountFormat.Value, num);
if (!string.IsNullOrEmpty(AzuMiscPatchesPlugin.CanBuildAmountColor.Value))
{
text2 = "<color=" + AzuMiscPatchesPlugin.CanBuildAmountColor.Value + ">" + text2 + "</color>";
}
___m_buildSelection.text = text + " " + text2;
}
}
[HarmonyPatch(typeof(Aoe), "Setup")]
internal static class AoeSetupPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(ref DamageTypes ___m_damage, Character owner)
{
if (AzuMiscPatchesPlugin.PreventExploits.Value == AzuMiscPatchesPlugin.Toggle.On && AzuMiscPatchesPlugin.PreventExploitsTroll.Value == AzuMiscPatchesPlugin.Toggle.On && AzuMiscPatchesPlugin.IsTroll(owner))
{
___m_damage.m_pickaxe = 0f;
}
}
}
[HarmonyPatch(typeof(ItemDrop), "Awake")]
internal static class ItemDropAwakePatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(ref Rigidbody ___m_body, ref List<ItemDrop> ___s_instances)
{
if (AzuMiscPatchesPlugin.PreventExploits.Value != AzuMiscPatchesPlugin.Toggle.On || AzuMiscPatchesPlugin.PreventExploitsTroll.Value != AzuMiscPatchesPlugin.Toggle.On || !((Object)(object)___m_body != (Object)null) || !AzuMiscPatchesPlugin.IsTrollAction(((Object)((Component)___m_body).gameObject).name))
{
return;
}
foreach (ItemDrop ___s_instance in ___s_instances)
{
___s_instance.m_itemData.m_shared.m_damages.m_pickaxe = 0f;
}
}
}
[HarmonyPatch(typeof(MineRock5), "DamageArea")]
internal static class MineRock5DamageAreaPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(ref bool __result, ref int ___m_minToolTier, HitData hit)
{
if (AzuMiscPatchesPlugin.PreventExploits.Value == AzuMiscPatchesPlugin.Toggle.On && AzuMiscPatchesPlugin.PreventExploitsSilverVein.Value == AzuMiscPatchesPlugin.Toggle.On)
{
Character attacker = hit.GetAttacker();
if ((Object)(object)attacker != (Object)null && AzuMiscPatchesPlugin.IsHuman(attacker) && hit.m_damage.m_blunt > 0f && hit.m_toolTier <= ___m_minToolTier)
{
__result = false;
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(Destructible), "Damage")]
internal static class DestructibleDamageAreaPatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static bool Prefix(ref int ___m_minToolTier, HitData hit)
{
if (AzuMiscPatchesPlugin.PreventExploits.Value == AzuMiscPatchesPlugin.Toggle.On && AzuMiscPatchesPlugin.PreventExploitsSilverVein.Value == AzuMiscPatchesPlugin.Toggle.On)
{
Character attacker = hit.GetAttacker();
if ((Object)(object)attacker != (Object)null && AzuMiscPatchesPlugin.IsHuman(attacker) && hit.m_damage.m_blunt > 0f && hit.m_toolTier <= ___m_minToolTier)
{
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(Location), "Awake")]
internal static class LocationAwakePatch
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
private static void Postfix(ref List<Location> ___s_allLocations)
{
if (AzuMiscPatchesPlugin.PreventExploits.Value != AzuMiscPatchesPlugin.Toggle.On || AzuMiscPatchesPlugin.PreventExploitsBuild.Value != AzuMiscPatchesPlugin.Toggle.On)
{
return;
}
foreach (Location ___s_allLocation in ___s_allLocations)
{
if (AzuMiscPatchesPlugin.IsSunkenCrypt4(((Object)((Component)___s_allLocation).gameObject).name))
{
___s_allLocation.m_noBuild = true;
}
}
}
}
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
[BepInPlugin("Azumatt.AzuMiscPatches", "AzuMiscPatches", "1.2.5")]
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(1)]
public class AzuMiscPatchesPlugin : BaseUnityPlugin
{
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)]
public enum Toggle
{
Off,
On
}
[<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)]
private class ConfigurationManagerAttributes
{
[UsedImplicitly]
public int? Order;
[UsedImplicitly]
public bool? Browsable;
[UsedImplicitly]
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(2)]
public string Category;
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(new byte[] { 2, 1 })]
[UsedImplicitly]
public Action<ConfigEntryBase> CustomDrawer;
}
[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(0)]
private class AcceptableShortcuts : AcceptableValueBase
{
public AcceptableShortcuts()
: base(typeof(KeyboardShortcut))
{
}
public override object Clamp(object value)
{
return value;
}
public override bool IsValid(object value)
{
return true;
}
public override string ToDescriptionString()
{
return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
}
}
internal const string ModName = "AzuMiscPatches";
internal const string ModVersion = "1.2.5";
internal const string Author = "Azumatt";
private const string ModGUID = "Azumatt.AzuMiscPatches";
private static string ConfigFileName = "Azumatt.AzuMiscPatches.cfg";
private static string ConfigFileFullPath;
private readonly Harmony _harmony = new Harmony("Azumatt.AzuMiscPatches");
internal static readonly List<Container> ContainerList;
public static readonly ManualLogSource AzuMiscPatchesLogger;
private static readonly ConfigSync ConfigSync;
private static ConfigEntry<Toggle> _serverConfigLocked;
internal static ConfigEntry<Toggle> MinPassLength;
public static ConfigEntry<Toggle> MuteGameInBackground;
public static ConfigEntry<Toggle> DisableGuardianAnimation;
public static ConfigEntry<Toggle> SkipTuts;
public static ConfigEntry<Toggle> SkipIntro;
public static ConfigEntry<Toggle> PreventExploits;
public static ConfigEntry<Toggle> PreventExploitsTroll;
public static ConfigEntry<Toggle> PreventExploitsBuild;
public static ConfigEntry<Toggle> PreventExploitsSilverVein;
public static ConfigEntry<Toggle> CharacterLimit;
public static ConfigEntry<Toggle> ReequipItemsAfterSwimming;
public static ConfigEntry<int> HoneyProductionSpeed;
public static ConfigEntry<int> MaximumHoneyPerBeehive;
public static ConfigEntry<Toggle> BuildInsideProtectedLocations;
public static ConfigEntry<Toggle> MoreSpace;
public static ConfigEntry<Toggle> HaveArrivedOnSpawn;
public static ConfigEntry<Toggle> FoodModifications;
public static ConfigEntry<Toggle> NoFoodDeg;
public static ConfigEntry<Toggle> NoTeleportPrevention;
public static ConfigEntry<Toggle> FillTopToBottom;
public static ConfigEntry<Toggle> MergeStacks;
public static ConfigEntry<float> WeightReduction;
public static ConfigEntry<float> ItemStackMultiplier;
public static ConfigEntry<string> CanBuildAmountFormat;
public static ConfigEntry<string> CanBuildAmountColor;
private void Awake()
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Expected O, but got Unknown
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Expected O, but got Unknown
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Expected O, but got Unknown
//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
//IL_01c3: Expected O, but got Unknown
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Expected O, but got Unknown
//IL_0237: Unknown result type (might be due to invalid IL or missing references)
//IL_0242: Expected O, but got Unknown
//IL_0273: Unknown result type (might be due to invalid IL or missing references)
//IL_027e: Expected O, but got Unknown
//IL_029a: Unknown result type (might be due to invalid IL or missing references)
//IL_02a5: Expected O, but got Unknown
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02cc: Expected O, but got Unknown
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_02f3: Expected O, but got Unknown
//IL_0360: Unknown result type (might be due to invalid IL or missing references)
//IL_036b: Expected O, but got Unknown
//IL_039c: Unknown result type (might be due to invalid IL or missing references)
//IL_03a7: Expected O, but got Unknown
//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
//IL_03e3: Expected O, but got Unknown
//IL_0414: Unknown result type (might be due to invalid IL or missing references)
//IL_041f: Expected O, but got Unknown
//IL_043b: Unknown result type (might be due to invalid IL or missing references)
//IL_0446: Expected O, but got Unknown
_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
FoodModifications = config("2 - Player", "Modify food", Toggle.Off, new ConfigDescription("Ensuring the food lasts longer while maintaining the same rate of regeneration. Needed to be on for No Food Degrade to work", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 2
}
}));
NoFoodDeg = config("2 - Player", "No Food Degrade", Toggle.Off, "Disable food degradation over time (maintain full benefit for the whole duration).");
FoodModifications.SettingChanged += [<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)] (object sender, EventArgs args) =>
{
((BaseUnityPlugin)this).Config.Save();
};
NoFoodDeg.SettingChanged += [<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)] (object sender, EventArgs args) =>
{
((BaseUnityPlugin)this).Config.Save();
};
ReequipItemsAfterSwimming = config("2 - Player", "Re Equip after Swimming", Toggle.On, new ConfigDescription("Re-equip Items After Swimming", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
WeightReduction = config("3 - Inventory & Items", "Item Weight Increase", 1f, new ConfigDescription("Multiplier for your item weight. This is a modifier value. 50 will increase it by 50%, -50 will reduce it by 50%.", (AcceptableValueBase)null, Array.Empty<object>()));
ItemStackMultiplier = config("3 - Inventory & Items", "Item Stack Increase", 1f, new ConfigDescription("Multiplier for your item stacks. Directly multiplies stack of the item by this value. (Stack of 50 with value of 10 here would turn into a stack of 500). Multiplier must be higher than 0 to apply.", (AcceptableValueBase)null, Array.Empty<object>()));
NoTeleportPrevention = config("3 - Inventory & Items", "Disable Teleport check for items", Toggle.Off, new ConfigDescription("Disable Teleport check for items", (AcceptableValueBase)null, Array.Empty<object>()));
FillTopToBottom = config("3 - Inventory & Items", "Fill Top to Bottom", Toggle.Off, "Move your things top to bottom when changing from inv to chest", synchronizedSetting: false);
MergeStacks = config("3 - Inventory & Items", "Merge Stacks", Toggle.Off, "Merge stacks when moving items from inv to chest (or another inventory). Try to merge items with existing stacks.", synchronizedSetting: false);
MinPassLength = config("4 - Game", "No Minimum Password Length", Toggle.On, new ConfigDescription("No Minimum password length for server", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 3
}
}));
MuteGameInBackground = config("4 - Game", "Mute Game in Background", Toggle.On, "Mute the game when you alt tab out of it, or it loses focus.", synchronizedSetting: false);
HaveArrivedOnSpawn = config("4 - Game", "I have arrived disable", Toggle.On, new ConfigDescription("Disable the I have arrived message, in chat window.", (AcceptableValueBase)null, Array.Empty<object>()));
BuildInsideProtectedLocations = config("4 - Game", "BuildInProtectedLocations", Toggle.Off, new ConfigDescription("Allow Building Inside Protected Locations", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 2
}
}));
MoreSpace = config("4 - Game", "Ignore space restrictions", Toggle.Off, new ConfigDescription("Ignore space restrictions. This will allow you to build pieces close together.", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 1
}
}));
DisableGuardianAnimation = config("4 - Game", "Disable Guardian Animation", Toggle.Off, new ConfigDescription("Disable Guardian power animation for the players", (AcceptableValueBase)null, Array.Empty<object>()));
SkipTuts = config("4 - Game", "Skip Tuts", Toggle.Off, new ConfigDescription("Skip Tutorials", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
SkipIntro = config("4 - Game", "Skip Valkyrie Intro", Toggle.Off, new ConfigDescription("Skip Valkyrie Intro", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
HoneyProductionSpeed = config("4 - Game", "Honey Speed", 1200, "Honey Production Speed");
MaximumHoneyPerBeehive = config("4 - Game", "Honey Count Per Hive", 4, "Honey Count Per Hive");
PreventExploits = config("4 - Game", "Prevent Exploits", Toggle.Off, new ConfigDescription("Main toggle that Disables the ability for trolls to damage deposits, disable building near swamp crypts, disable easy finding of silver veins using a blunt weapon.", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 4
}
}));
PreventExploitsTroll = config("4 - Game", "Prevent Trolls to damage deposits", Toggle.Off, new ConfigDescription("Prevents the ability for trolls to damage deposits", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 3
}
}));
PreventExploitsBuild = config("4 - Game", "Prevent Build Near Crypt", Toggle.Off, new ConfigDescription("Prevents the ability to build near swamp crypts. Please note that this applies when the location is loaded. Meaning, it doesn't change live if they are already standing there.", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 2
}
}));
PreventExploitsSilverVein = config("4 - Game", "Prevent Easy Vein Finding", Toggle.Off, new ConfigDescription("Prevents the ability to find silver veins using a blunt weapon such as the stag breaker.", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 1
}
}));
CharacterLimit = config("4 - Game", "Portal Character Limit", Toggle.Off, new ConfigDescription("If on, it removes the character limit for portals. Default value of Vanilla is 10 characters", (AcceptableValueBase)null, Array.Empty<object>()));
CanBuildAmountFormat = config("5 - Building HUD", "Can Build Amount Format", "({0})", "Format for the amount of times you can build the currently selected item with your current inventory. Uses standard C# format rules. Leave empty to hide altogether.", synchronizedSetting: false);
CanBuildAmountColor = config("5 - Building HUD", "Can Build Amount Color", "white", "Color to set the can-build amount. Leave empty to set no color. You can use the #XXXXXX hex color format.", synchronizedSetting: false);
AutoDoc();
_harmony.PatchAll();
SetupWatcher();
}
internal void AutoDoc()
{
}
private void OnDestroy()
{
((BaseUnityPlugin)this).Config.Save();
}
private void SetupWatcher()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
}
private void ReadConfigValues(object sender, FileSystemEventArgs e)
{
if (!File.Exists(ConfigFileFullPath))
{
return;
}
try
{
AzuMiscPatchesLogger.LogDebug((object)"ReadConfigValues called");
((BaseUnityPlugin)this).Config.Reload();
}
catch
{
AzuMiscPatchesLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
AzuMiscPatchesLogger.LogError((object)"Please check your config entries for spelling and format!");
}
}
public static float ApplyModifierValue(float targetValue, float value)
{
if (value <= -100f)
{
value = -100f;
}
if (value >= 0f)
{
return targetValue + targetValue / 100f * value;
}
return targetValue - targetValue / 100f * (value * -1f);
}
public static int GetAvailableItems(string itemName)
{
Player localPlayer = Player.m_localPlayer;
if ((Object)(object)localPlayer == (Object)null)
{
return 0;
}
int num = ((Humanoid)localPlayer).GetInventory().CountItems(itemName, -1, true);
int num2 = ContainerList.Sum([<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)] (Container container) => container.GetInventory().CountItems(itemName, -1, true));
return num + num2;
}
internal static bool IsTroll(Character character)
{
return character.m_name == "$enemy_troll";
}
internal static bool IsTrollAction(string name)
{
return GenerateNameAndCloneArray("troll_groundslam", "troll_punch", "troll_throw", "troll_log_swing_h", "troll_log_swing_v").Contains(name);
}
internal static bool IsHuman(Character character)
{
return character.m_name == "Human";
}
internal static bool IsSunkenCrypt4(string name)
{
return GenerateNameAndCloneArray("SunkenCrypt4").Contains(name);
}
private static string[] GenerateNameAndCloneArray(params string[] names)
{
return names.SelectMany([<92b3658a-fafd-4a7e-94da-de392996b7d4>NullableContext(0)] (string name) => new string[2]
{
name,
name + "(Clone)"
}).ToArray();
}
private ConfigEntry<T> config<[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
return val2;
}
private ConfigEntry<T> config<[<a9384ffa-8e10-4084-ad54-b73403024498>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
}
static AzuMiscPatchesPlugin()
{
string configPath = Paths.ConfigPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
ContainerList = new List<Container>();
AzuMiscPatchesLogger = Logger.CreateLogSource("AzuMiscPatches");
ConfigSync = new ConfigSync("Azumatt.AzuMiscPatches")
{
DisplayName = "AzuMiscPatches",
CurrentVersion = "1.2.5",
MinimumRequiredVersion = "1.2.5"
};
_serverConfigLocked = null;
MinPassLength = null;
MuteGameInBackground = null;
DisableGuardianAnimation = null;
SkipTuts = null;
SkipIntro = null;
PreventExploits = null;
PreventExploitsTroll = null;
PreventExploitsBuild = null;
PreventExploitsSilverVein = null;
CharacterLimit = null;
ReequipItemsAfterSwimming = null;
HoneyProductionSpeed = null;
MaximumHoneyPerBeehive = null;
BuildInsideProtectedLocations = null;
MoreSpace = null;
HaveArrivedOnSpawn = null;
FoodModifications = null;
NoFoodDeg = null;
NoTeleportPrevention = null;
FillTopToBottom = null;
MergeStacks = null;
WeightReduction = null;
ItemStackMultiplier = null;
CanBuildAmountFormat = null;
CanBuildAmountColor = null;
}
}
}
namespace Microsoft.CodeAnalysis
{
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
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;
}
}
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
[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;
}
}
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ServerSync
{
[PublicAPI]
internal abstract class OwnConfigEntryBase
{
public object? LocalBaseValue;
public bool SynchronizedConfig = true;
public abstract ConfigEntryBase BaseConfig { get; }
}
[PublicAPI]
internal class SyncedConfigEntry<T> : OwnConfigEntryBase
{
public readonly ConfigEntry<T> SourceConfig;
public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;
public T Value
{
get
{
return SourceConfig.Value;
}
set
{
SourceConfig.Value = value;
}
}
public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
{
SourceConfig = sourceConfig;
}
public void AssignLocalValue(T value)
{
if (LocalBaseValue == null)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
internal abstract class CustomSyncedValueBase
{
public object? LocalBaseValue;
public readonly string Identifier;
public readonly Type Type;
private object? boxedValue;
protected bool localIsOwner;
public readonly int Priority;
public object? BoxedValue
{
get
{
return boxedValue;
}
set
{
boxedValue = value;
this.ValueChanged?.Invoke();
}
}
public event Action? ValueChanged;
protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
{
Priority = priority;
Identifier = identifier;
Type = type;
configSync.AddCustomValue(this);
localIsOwner = configSync.IsSourceOfTruth;
configSync.SourceOfTruthChanged += delegate(bool truth)
{
localIsOwner = truth;
};
}
}
[PublicAPI]
internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
{
public T Value
{
get
{
return (T)base.BoxedValue;
}
set
{
base.BoxedValue = value;
}
}
public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
: base(configSync, identifier, typeof(T), priority)
{
Value = value;
}
public void AssignLocalValue(T value)
{
if (localIsOwner)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
internal class ConfigurationManagerAttributes
{
[UsedImplicitly]
public bool? ReadOnly = false;
}
[PublicAPI]
internal class ConfigSync
{
[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
private static class SnatchCurrentlyHandlingRPC
{
public static ZRpc? currentRpc;
[HarmonyPrefix]
private static void Prefix(ZRpc __instance)
{
currentRpc = __instance;
}
}
[HarmonyPatch(typeof(ZNet), "Awake")]
internal static class RegisterRPCPatch
{
[HarmonyPostfix]
private static void Postfix(ZNet __instance)
{
isServer = __instance.IsServer();
foreach (ConfigSync configSync2 in configSyncs)
{
ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
if (isServer)
{
configSync2.InitialSyncDone = true;
Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
}
}
if (isServer)
{
((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
}
static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
{
ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
{
new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = isAdmin
}
});
ConfigSync configSync = configSyncs.First();
if (configSync != null)
{
((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
}
}
static IEnumerator WatchAdminListChanges()
{
MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
List<string> CurrentList = new List<string>(adminList.GetList());
while (true)
{
yield return (object)new WaitForSeconds(30f);
if (!adminList.GetList().SequenceEqual(CurrentList))
{
CurrentList = new List<string>(adminList.GetList());
List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
{
string hostName = p.m_rpc.GetSocket().GetHostName();
return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
}).ToList();
List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
SendAdmin(nonAdminPeer, isAdmin: false);
SendAdmin(adminPeer, isAdmin: true);
}
}
}
}
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static class RegisterClientRPCPatch
{
[HarmonyPostfix]
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
if (__instance.IsServer())
{
return;
}
foreach (ConfigSync configSync in configSyncs)
{
peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
}
}
}
private class ParsedConfigs
{
public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();
public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
}
[HarmonyPatch(typeof(ZNet), "Shutdown")]
private class ResetConfigsOnShutdown
{
[HarmonyPostfix]
private static void Postfix()
{
ProcessingServerUpdate = true;
foreach (ConfigSync configSync in configSyncs)
{
configSync.resetConfigsFromServer();
configSync.IsSourceOfTruth = true;
configSync.InitialSyncDone = false;
}
ProcessingServerUpdate = false;
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
private class SendConfigsAfterLogin
{
private class BufferingSocket : ISocket
{
public volatile bool finished = false;
public volatile int versionMatchQueued = -1;
public readonly List<ZPackage> Package = new List<ZPackage>();
public readonly ISocket Original;
public BufferingSocket(ISocket original)
{
Original = original;
}
public bool IsConnected()
{
return Original.IsConnected();
}
public ZPackage Recv()
{
return Original.Recv();
}
public int GetSendQueueSize()
{
return Original.GetSendQueueSize();
}
public int GetCurrentSendRate()
{
return Original.GetCurrentSendRate();
}
public bool IsHost()
{
return Original.IsHost();
}
public void Dispose()
{
Original.Dispose();
}
public bool GotNewData()
{
return Original.GotNewData();
}
public void Close()
{
Original.Close();
}
public string GetEndPointString()
{
return Original.GetEndPointString();
}
public void GetAndResetStats(out int totalSent, out int totalRecv)
{
Original.GetAndResetStats(ref totalSent, ref totalRecv);
}
public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
{
Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
}
public ISocket Accept()
{
return Original.Accept();
}
public int GetHostPort()
{
return Original.GetHostPort();
}
public bool Flush()
{
return Original.Flush();
}
public string GetHostName()
{
return Original.GetHostName();
}
public void VersionMatch()
{
if (finished)
{
Original.VersionMatch();
}
else
{
versionMatchQueued = Package.Count;
}
}
public void Send(ZPackage pkg)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
int pos = pkg.GetPos();
pkg.SetPos(0);
int num = pkg.ReadInt();
if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
{
ZPackage val = new ZPackage(pkg.GetArray());
val.SetPos(pos);
Package.Add(val);
}
else
{
pkg.SetPos(pos);
Original.Send(pkg);
}
}
}
[HarmonyPrefix]
[HarmonyPriority(800)]
private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Invalid comparison between Unknown and I4
if (__instance.IsServer())
{
BufferingSocket value = new BufferingSocket(rpc.GetSocket());
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (val != null && (int)ZNet.m_onlineBackend > 0)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
}
if (__state == null)
{
__state = new Dictionary<Assembly, BufferingSocket>();
}
__state[Assembly.GetExecutingAssembly()] = value;
}
}
[HarmonyPostfix]
private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
{
ZRpc rpc2 = rpc;
ZNet __instance2 = __instance;
Dictionary<Assembly, BufferingSocket> __state2 = __state;
ZNetPeer peer;
if (__instance2.IsServer())
{
object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
if (peer == null)
{
SendBufferedData();
}
else
{
((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
}
}
void SendBufferedData()
{
if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
{
AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
if (val != null)
{
AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
}
}
BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
bufferingSocket2.finished = true;
for (int i = 0; i < bufferingSocket2.Package.Count; i++)
{
if (i == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
}
if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
{
bufferingSocket2.Original.VersionMatch();
}
}
IEnumerator sendAsync()
{
foreach (ConfigSync configSync in configSyncs)
{
List<PackageEntry> entries = new List<PackageEntry>();
if (configSync.CurrentVersion != null)
{
entries.Add(new PackageEntry
{
section = "Internal",
key = "serverversion",
type = typeof(string),
value = configSync.CurrentVersion
});
}
MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
entries.Add(new PackageEntry
{
section = "Internal",
key = "lockexempt",
type = typeof(bool),
value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
{
adminList,
rpc2.GetSocket().GetHostName()
}))
});
ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
}
SendBufferedData();
}
}
}
private class PackageEntry
{
public string section = null;
public string key = null;
public Type type = null;
public object? value;
}
[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
private static class PreventSavingServerInfo
{
[HarmonyPrefix]
private static bool Prefix(ConfigEntryBase __instance, ref string __result)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
{
return true;
}
__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
return false;
}
}
[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
private static class PreventConfigRereadChangingValues
{
[HarmonyPrefix]
private static bool Prefix(ConfigEntryBase __instance, string value)
{
OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
{
return true;
}
try
{
ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
}
catch (Exception ex)
{
Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
}
return false;
}
}
private class InvalidDeserializationTypeException : Exception
{
public string expected = null;
public string received = null;
public string field = "";
}
public static bool ProcessingServerUpdate;
public readonly string Name;
public string? DisplayName;
public string? CurrentVersion;
public string? MinimumRequiredVersion;
public bool ModRequired = false;
private bool? forceConfigLocking;
private bool isSourceOfTruth = true;
private static readonly HashSet<ConfigSync> configSyncs;
private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();
private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();
private static bool isServer;
private static bool lockExempt;
private OwnConfigEntryBase? lockedConfig = null;
private const byte PARTIAL_CONFIGS = 1;
private const byte FRAGMENTED_CONFIG = 2;
private const byte COMPRESSED_CONFIG = 4;
private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();
private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();
private static long packageCounter;
public bool IsLocked
{
get
{
bool? flag = forceConfigLocking;
bool num;
if (!flag.HasValue)
{
if (lockedConfig == null)
{
goto IL_0052;
}
num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
}
else
{
num = flag.GetValueOrDefault();
}
if (!num)
{
goto IL_0052;
}
int result = ((!lockExempt) ? 1 : 0);
goto IL_0053;
IL_0053:
return (byte)result != 0;
IL_0052:
result = 0;
goto IL_0053;
}
set
{
forceConfigLocking = value;
}
}
public bool IsAdmin => lockExempt || isSourceOfTruth;
public bool IsSourceOfTruth
{
get
{
return isSourceOfTruth;
}
private set
{
if (value != isSourceOfTruth)
{
isSourceOfTruth = value;
this.SourceOfTruthChanged?.Invoke(value);
}
}
}
public bool InitialSyncDone { get; private set; } = false;
public event Action<bool>? SourceOfTruthChanged;
private event Action? lockedConfigChanged;
static ConfigSync()
{
ProcessingServerUpdate = false;
configSyncs = new HashSet<ConfigSync>();
lockExempt = false;
packageCounter = 0L;
RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
}
public ConfigSync(string name)
{
Name = name;
configSyncs.Add(this);
new VersionCheck(this);
}
public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
{
ConfigEntry<T> configEntry2 = configEntry;
OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
if (syncedEntry == null)
{
syncedEntry = new SyncedConfigEntry<T>(configEntry2);
AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
{
new ConfigurationManagerAttributes()
}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
configEntry2.SettingChanged += delegate
{
if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
{
Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
}
};
allConfigs.Add(syncedEntry);
}
return syncedEntry;
}
public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
{
if (lockedConfig != null)
{
throw new Exception("Cannot initialize locking ConfigEntry twice");
}
lockedConfig = AddConfigEntry<T>(lockingConfig);
lockingConfig.SettingChanged += delegate
{
this.lockedConfigChanged?.Invoke();
};
return (SyncedConfigEntry<T>)lockedConfig;
}
internal void AddCustomValue(CustomSyncedValueBase customValue)
{
CustomSyncedValueBase customValue2 = customValue;
if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
{
throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
}
allCustomValues.Add(customValue2);
allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
customValue2.ValueChanged += delegate
{
if (!ProcessingServerUpdate)
{
Broadcast(ZRoutedRpc.Everybody, customValue2);
}
};
}
private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
{
lockedConfigChanged += serverLockedSettingChanged;
IsSourceOfTruth = false;
if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
{
InitialSyncDone = true;
}
}
private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
{
HandleConfigSyncRPC(sender, package, clientUpdate: true);
}
private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: Expected O, but got Unknown
//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
//IL_01f1: Expected O, but got Unknown
try
{
if (isServer && IsLocked)
{
ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
object obj;
if (currentRpc == null)
{
obj = null;
}
else
{
ISocket socket = currentRpc.GetSocket();
obj = ((socket != null) ? socket.GetHostName() : null);
}
string text = (string)obj;
if (text != null)
{
MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
{
return false;
}
}
}
cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
{
if (kv.Key < DateTimeOffset.Now.Ticks)
{
configValueCache.Remove(kv.Value);
return true;
}
return false;
});
byte b = package.ReadByte();
if ((b & 2u) != 0)
{
long num = package.ReadLong();
string text2 = sender.ToString() + num;
if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
{
value = new SortedDictionary<int, byte[]>();
configValueCache[text2] = value;
cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
}
int key = package.ReadInt();
int num2 = package.ReadInt();
value.Add(key, package.ReadByteArray());
if (value.Count < num2)
{
return false;
}
configValueCache.Remove(text2);
package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
b = package.ReadByte();
}
ProcessingServerUpdate = true;
if ((b & 4u) != 0)
{
byte[] buffer = package.ReadByteArray();
MemoryStream stream = new MemoryStream(buffer);
MemoryStream memoryStream = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
{
deflateStream.CopyTo(memoryStream);
}
package = new ZPackage(memoryStream.ToArray());
b = package.ReadByte();
}
if ((b & 1) == 0)
{
resetConfigsFromServer();
}
ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
ConfigFile val2 = null;
bool saveOnConfigSet = false;
foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
{
if (!isServer && configValue.Key.LocalBaseValue == null)
{
configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
}
if (val2 == null)
{
val2 = configValue.Key.BaseConfig.ConfigFile;
saveOnConfigSet = val2.SaveOnConfigSet;
val2.SaveOnConfigSet = false;
}
configValue.Key.BaseConfig.BoxedValue = configValue.Value;
}
if (val2 != null)
{
val2.SaveOnConfigSet = saveOnConfigSet;
}
foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
{
if (!isServer)
{
CustomSyncedValueBase key2 = customValue.Key;
if (key2.LocalBaseValue == null)
{
key2.LocalBaseValue = customValue.Key.BoxedValue;
}
}
customValue.Key.BoxedValue = customValue.Value;
}
Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
if (!isServer)
{
serverLockedSettingChanged();
}
return true;
}
finally
{
ProcessingServerUpdate = false;
}
}
private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
{
ParsedConfigs parsedConfigs = new ParsedConfigs();
Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
int num = package.ReadInt();
for (int i = 0; i < num; i++)
{
string text = package.ReadString();
string text2 = package.ReadString();
string text3 = package.ReadString();
Type type = Type.GetType(text3);
if (text3 == "" || type != null)
{
object obj;
try
{
obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
}
catch (InvalidDeserializationTypeException ex)
{
Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
continue;
}
OwnConfigEntryBase value2;
if (text == "Internal")
{
CustomSyncedValueBase value;
if (text2 == "serverversion")
{
if (obj?.ToString() != CurrentVersion)
{
Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
}
}
else if (text2 == "lockexempt")
{
if (obj is bool flag)
{
lockExempt = flag;
}
}
else if (dictionary2.TryGetValue(text2, out value))
{
if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
{
parsedConfigs.customValues[value] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
}
}
else if (dictionary.TryGetValue(text + "_" + text2, out value2))
{
Type type2 = configType(value2.BaseConfig);
if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
{
parsedConfigs.configValues[value2] = obj;
continue;
}
Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
}
else
{
Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
}
continue;
}
Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
return new ParsedConfigs();
}
return parsedConfigs;
}
private static bool isWritableConfig(OwnConfigEntryBase config)
{
OwnConfigEntryBase config2 = config;
ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
if (configSync == null)
{
return true;
}
return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
}
private void serverLockedSettingChanged()
{
foreach (OwnConfigEntryBase allConfig in allConfigs)
{
configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
}
}
private void resetConfigsFromServer()
{
ConfigFile val = null;
bool saveOnConfigSet = false;
foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
{
if (val == null)
{
val = item.BaseConfig.ConfigFile;
saveOnConfigSet = val.SaveOnConfigSet;
val.SaveOnConfigSet = false;
}
item.BaseConfig.BoxedValue = item.LocalBaseValue;
item.LocalBaseValue = null;
}
if (val != null)
{
val.SaveOnConfigSet = saveOnConfigSet;
}
foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
{
item2.BoxedValue = item2.LocalBaseValue;
item2.LocalBaseValue = null;
}
lockedConfigChanged -= serverLockedSettingChanged;
serverLockedSettingChanged();
}
private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
{
ZNetPeer peer2 = peer;
ZRoutedRpc rpc = ZRoutedRpc.instance;
if (rpc == null)
{
yield break;
}
byte[] data = package.GetArray();
if (data != null && data.LongLength > 250000)
{
int fragments = (int)(1 + (data.LongLength - 1) / 250000);
long packageIdentifier = ++packageCounter;
int fragment = 0;
while (fragment < fragments)
{
foreach (bool item in waitForQueue())
{
yield return item;
}
if (peer2.m_socket.IsConnected())
{
ZPackage fragmentedPackage = new ZPackage();
fragmentedPackage.Write((byte)2);
fragmentedPackage.Write(packageIdentifier);
fragmentedPackage.Write(fragment);
fragmentedPackage.Write(fragments);
fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
SendPackage(fragmentedPackage);
if (fragment != fragments - 1)
{
yield return true;
}
int num = fragment + 1;
fragment = num;
continue;
}
break;
}
yield break;
}
foreach (bool item2 in waitForQueue())
{
yield return item2;
}
SendPackage(package);
void SendPackage(ZPackage pkg)
{
string text = Name + " ConfigSync";
if (isServer)
{
peer2.m_rpc.Invoke(text, new object[1] { pkg });
}
else
{
rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
}
}
IEnumerable<bool> waitForQueue()
{
float timeout = Time.time + 30f;
while (peer2.m_socket.GetSendQueueSize() > 20000)
{
if (Time.time > timeout)
{
Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
ZNet.instance.Disconnect(peer2);
break;
}
yield return false;
}
}
}
private IEnumerator sendZPackage(long target, ZPackage package)
{
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
return Enumerable.Empty<object>().GetEnumerator();
}
List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
if (target != ZRoutedRpc.Everybody)
{
list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
}
return sendZPackage(list, package);
}
private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
{
ZPackage package2 = package;
if (!Object.op_Implicit((Object)(object)ZNet.instance))
{
yield break;
}
byte[] rawData = package2.GetArray();
if (rawData != null && rawData.LongLength > 10000)
{
ZPackage compressedPackage = new ZPackage();
compressedPackage.Write((byte)4);
MemoryStream output = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
{
deflateStream.Write(rawData, 0, rawData.Length);
}
compressedPackage.Write(output.ToArray());
package2 = compressedPackage;
}
List<IEnumerator<bool>> writers = (from peer in peers
where peer.IsReady()
select peer into p
select distributeConfigToPeers(p, package2)).ToList();
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
while (writers.Count > 0)
{
yield return null;
writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
}
}
private void Broadcast(long target, params ConfigEntryBase[] configs)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(configs);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
{
if (!IsLocked || isServer)
{
ZPackage package = ConfigsToPackage(null, customValues);
ZNet instance = ZNet.instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
}
}
}
private static OwnConfigEntryBase? configData(ConfigEntryBase config)
{
return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
}
public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
{
return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
}
private static T configAttribute<T>(ConfigEntryBase config)
{
return config.Description.Tags.OfType<T>().First();
}
private static Type configType(ConfigEntryBase config)
{
return configType(config.SettingType);
}
private static Type configType(Type type)
{
return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
}
private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
ZPackage val = new ZPackage();
val.Write((byte)(partial ? 1 : 0));
val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
{
AddEntryToPackage(val, item);
}
foreach (CustomSyncedValueBase item2 in list2)
{
AddEntryToPackage(val, new PackageEntry
{
section = "Internal",
key = item2.Identifier,
type = item2.Type,
value = item2.BoxedValue
});
}
foreach (ConfigEntryBase item3 in list)
{
AddEntryToPackage(val, new PackageEntry
{
section = item3.Definition.Section,
key = item3.Definition.Key,
type = configType(item3),
value = item3.BoxedValue
});
}
return val;
}
private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
{
package.Write(entry.section);
package.Write(entry.key);
package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
AddValueToZPackage(package, entry.value);
}
private static string GetZPackageTypeString(Type type)
{
return type.AssemblyQualifiedName;
}
private static void AddValueToZPackage(ZPackage package, object? value)
{
Type type = value?.GetType();
if (value is Enum)
{
value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
}
else
{
if (value is ICollection collection)
{
package.Write(collection.Count);
{
foreach (object item in collection)
{
AddValueToZPackage(package, item);
}
return;
}
}
if ((object)type != null && type.IsValueType && !type.IsPrimitive)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
package.Write(fields.Length);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
package.Write(GetZPackageTypeString(fieldInfo.FieldType));
AddValueToZPackage(package, fieldInfo.GetValue(value));
}
return;
}
}
ZRpc.Serialize(new object[1] { value }, ref package);
}
private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
{
if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num = package.ReadInt();
if (num != fields.Length)
{
throw new InvalidDeserializationTypeException
{
received = $"(field count: {num})",
expected = $"(field count: {fields.Length})"
};
}
object uninitializedObject = FormatterServices.GetUninitializedObject(type);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = package.ReadString();
if (text != GetZPackageTypeString(fieldInfo.FieldType))
{
throw new InvalidDeserializationTypeException
{
received = text,
expected = GetZPackageTypeString(fieldInfo.FieldType),
field = fieldInfo.Name
};
}
fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
}
return uninitializedObject;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
{
int num2 = package.ReadInt();
IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
for (int j = 0; j < num2; j++)
{
object obj = ReadValueWithTypeFromZPackage(package, type2);
dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
}
return dictionary;
}
if (type != typeof(List<string>) && type.IsGenericType)
{
Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
if ((object)type3 != null && type3.IsAssignableFrom(type))
{
int num3 = package.ReadInt();
object obj2 = Activator.CreateInstance(type);
MethodInfo method = type3.GetMethod("Add");
for (int k = 0; k < num3; k++)
{
method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
}
return obj2;
}
}
ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
List<object> source = new List<object>();
ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
return source.First();
}
}
[PublicAPI]
[HarmonyPatch]
internal class VersionCheck
{
private static readonly HashSet<VersionCheck> versionChecks;
private static readonly Dictionary<string, string> notProcessedNames;
public string Name;
private string? displayName;
private string? currentVersion;
private string? minimumRequiredVersion;
public bool ModRequired = true;
private string? ReceivedCurrentVersion;
private string? ReceivedMinimumRequiredVersion;
private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();
private ConfigSync? ConfigSync;
public string DisplayName
{
get
{
return displayName ?? Name;
}
set
{
displayName = value;
}
}
public string CurrentVersion
{
get
{
return currentVersion ?? "0.0.0";
}
set
{
currentVersion = value;
}
}
public string MinimumRequiredVersion
{
get
{
return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
}
set
{
minimumRequiredVersion = value;
}
}
private static void PatchServerSync()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
{
return;
}
Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
where t.IsClass
select t)
{
val.PatchAll(item);
}
}
static VersionCheck()
{
versionChecks = new HashSet<VersionCheck>();
notProcessedNames = new Dictionary<string, string>();
typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
{
new Action(PatchServerSync)
});
}
public VersionCheck(string name)
{
Name = name;
ModRequired = true;
versionChecks.Add(this);
}
public VersionCheck(ConfigSync configSync)
{
ConfigSync = configSync;
Name = ConfigSync.Name;
versionChecks.Add(this);
}
public void Initialize()
{
ReceivedCurrentVersion = null;
ReceivedMinimumRequiredVersion = null;
if (ConfigSync != null)
{
Name = ConfigSync.Name;
DisplayName = ConfigSync.DisplayName;
CurrentVersion = ConfigSync.CurrentVersion;
MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
ModRequired = ConfigSync.ModRequired;
}
}
private bool IsVersionOk()
{
if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
{
return !ModRequired;
}
bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
return flag && flag2;
}
private string ErrorClient()
{
if (ReceivedMinimumRequiredVersion == null)
{
return DisplayName + " is not installed on the server.";
}
return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
}
private string ErrorServer(ZRpc rpc)
{
return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
}
private string Error(ZRpc? rpc = null)
{
return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
}
private static VersionCheck[] GetFailedClient()
{
return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
}
private static VersionCheck[] GetFailedServer(ZRpc rpc)
{
ZRpc rpc2 = rpc;
return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
}
private static void Logout()
{
Game.instance.Logout(true, true);
AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
}
private static void DisconnectClient(ZRpc rpc)
{
rpc.Invoke("Error", new object[1] { 3 });
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg)
{
CheckVersion(rpc, pkg, null);
}
private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
{
string text = pkg.ReadString();
string text2 = pkg.ReadString();
string text3 = pkg.ReadString();
bool flag = false;
foreach (VersionCheck versionCheck in versionChecks)
{
if (!(text != versionCheck.Name))
{
Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
versionCheck.ReceivedMinimumRequiredVersion = text2;
versionCheck.ReceivedCurrentVersion = text3;
if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
{
versionCheck.ValidatedClients.Add(rpc);
}
flag = true;
}
}
if (flag)
{
return;
}
pkg.SetPos(0);
if (original != null)
{
original(rpc, pkg);
if (pkg.GetPos() == 0)
{
notProcessedNames.Add(text, text3);
}
}
}
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
[HarmonyPrefix]
private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
{
VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
if (array.Length == 0)
{
return true;
}
VersionCheck[] array2 = array;
foreach (VersionCheck versionCheck in array2)
{
Debug.LogWarning((object)versionCheck.Error(rpc));
}
if (__instance.IsServer())
{
DisconnectClient(rpc);
}
else
{
Logout();
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
{
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Expected O, but got Unknown
notProcessedNames.Clear();
IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
{
object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
{
CheckVersion(rpc, pkg, action);
});
}
else
{
peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.Initialize();
if (versionCheck.ModRequired || __instance.IsServer())
{
Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
ZPackage val = new ZPackage();
val.Write(versionCheck.Name);
val.Write(versionCheck.MinimumRequiredVersion);
val.Write(versionCheck.CurrentVersion);
peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(ZNet), "Disconnect")]
private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
{
if (!__instance.IsServer())
{
return;
}
foreach (VersionCheck versionCheck in versionChecks)
{
versionCheck.ValidatedClients.Remove(peer.m_rpc);
}
}
[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
[HarmonyPostfix]
private static void ShowConnectionError(FejdStartup __instance)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Invalid comparison between Unknown and I4
//IL_0186: 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_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_021e: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
{
return;
}
bool flag = false;
VersionCheck[] failedClient = GetFailedClient();
if (failedClient.Length != 0)
{
string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
TMP_Text connectionFailedError = __instance.m_connectionFailedError;
connectionFailedError.text = connectionFailedError.text + "\n" + text;
flag = true;
}
foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
{
if (!__instance.m_connectionFailedError.text.Contains(item.Key))
{
TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
flag = true;
}
}
if (flag)
{
RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
Vector2 sizeDelta = component.sizeDelta;
sizeDelta.x = 675f;
component.sizeDelta = sizeDelta;
__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
float num = __instance.m_connectionFailedError.renderedHeight + 105f;
RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
sizeDelta = component.sizeDelta;
sizeDelta.y = num;
component.sizeDelta = sizeDelta;
}
}
}
}
