using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AdvancedREPO.Config.Patches;
using AdvancedREPO.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AdvancedREPO.Config")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Synchronizing configurations for REPO")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+91089561413fedaed7f28d429c4a3c83beb72026")]
[assembly: AssemblyProduct("AdvancedREPO.Config")]
[assembly: AssemblyTitle("AdvancedREPO.Config")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace AdvancedREPO.Config
{
public static class ConfigBuilderStatic
{
public static ConfigField<T> Sync<T>(this ConfigEntry<T> entry)
{
return ConfigBuilder<T>.Sync(entry, Assembly.GetCallingAssembly().GetName().Name);
}
}
public class ConfigBuilder<T>
{
private static Dictionary<string, ConfigFile> AssignedFiles = new Dictionary<string, ConfigFile>(StringComparer.OrdinalIgnoreCase);
private ConfigFile? _File;
private bool _Sync = false;
private string? _Description;
private string? _Section;
private string? _Key;
private T[]? _Acceptable;
private T? _Min;
private T? _Max;
private T? _Default;
private ConfigEntry<T>? _Entry;
private string _ModName;
public ConfigBuilder()
{
_ModName = Assembly.GetCallingAssembly().GetName().Name;
}
public ConfigBuilder(string modName)
{
_ModName = modName;
}
public static ConfigField<T> Sync(ConfigEntry<T> entry, string modName = null)
{
return new ConfigBuilder<T>((modName != null) ? modName : Assembly.GetCallingAssembly().GetName().Name).Entry(entry).Sync().Build();
}
public static ConfigBuilder<T> FromConfigEntry(ConfigEntry<T> entry)
{
return new ConfigBuilder<T>(Assembly.GetCallingAssembly().GetName().Name).Entry(entry);
}
public ConfigBuilder<T> Entry(ConfigEntry<T> entry)
{
_Entry = entry;
return this;
}
private static ConfigFile FindFile(string modName, string fileName)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
string text = Path.Combine(Paths.ConfigPath, modName, fileName);
if (!AssignedFiles.ContainsKey(text))
{
AssignedFiles.Add(text, new ConfigFile(text, true));
}
return AssignedFiles[text];
}
public ConfigBuilder<T> Description(string description)
{
_Description = description;
return this;
}
public ConfigBuilder<T> Section(string section)
{
_Section = section;
return this;
}
public ConfigBuilder<T> Key(string key)
{
_Key = key;
return this;
}
public ConfigBuilder<T> Range(T min, T max)
{
_Min = min;
_Max = max;
return this;
}
public ConfigBuilder<T> Default(T @default)
{
_Default = @default;
return this;
}
public ConfigBuilder<T> Acceptable(T[] values)
{
_Acceptable = values;
return this;
}
public ConfigBuilder<T> Sync(bool val = true)
{
_Sync = val;
return this;
}
public ConfigBuilder<T> File(ConfigFile file)
{
_File = file;
return this;
}
public ConfigBuilder<T> File(string fileName)
{
_File = FindFile(_ModName, fileName);
return this;
}
public ConfigField<T> Build()
{
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Expected O, but got Unknown
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Expected O, but got Unknown
//IL_0182: Expected O, but got Unknown
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Expected O, but got Unknown
ConfigField<T> ret = new ConfigField<T>();
ret.Sync = _Sync;
if (_Entry != null)
{
ret.Entry = _Entry;
}
else if (_File != null)
{
AcceptableValueBase val = null;
if (_Min != null && _Max != null && default(T) is IComparable<T>)
{
val = (AcceptableValueBase)Activator.CreateInstance(typeof(AcceptableValueRange<>).MakeGenericType(typeof(T)), _Min, _Max);
}
else if (_Acceptable != null && default(T) is IEquatable<T>)
{
val = (AcceptableValueBase)Activator.CreateInstance(typeof(AcceptableValueList<>).MakeGenericType(typeof(T)), _Acceptable);
}
ret.Entry = _File.Bind<T>(new ConfigDefinition(_Section, _Key), _Default, new ConfigDescription(_Description, val, Array.Empty<object>()));
}
ret.Key = _ModName;
if (((ConfigEntryBase)ret.Entry).Definition.Section != null)
{
ConfigField<T> configField = ret;
configField.Key = configField.Key + ":" + ((ConfigEntryBase)ret.Entry).Definition.Section;
}
ConfigField<T> configField2 = ret;
configField2.Key = configField2.Key + ":" + ((ConfigEntryBase)ret.Entry).Definition.Key;
if (ret.Sync)
{
ret.Entry.SettingChanged += delegate
{
if (!ret.SyncedValue.Equals(ret.Entry.Value))
{
ret.SyncWithClients();
}
};
ret.AddToSync();
}
return ret;
}
private void Entry_SettingChanged(object sender, EventArgs e)
{
throw new NotImplementedException();
}
}
public class ConfigField
{
internal bool Sync = false;
internal string Key = null;
public virtual void AddToSync()
{
AdvancedREPO.Config.Sync.Configs.Add(Key, this);
}
internal virtual void SyncWithClients()
{
}
}
public class ConfigField<T> : ConfigField
{
public delegate void SettingChangedHandler(object sender, EventArgs e);
public delegate void ValueChangedHandler(object sender, EventArgs e);
private bool ReceivedSynced = false;
private ConfigEntry<T> _Entry;
private T OldValue;
private T? _SyncedValue;
public ConfigEntry<T> Entry
{
get
{
return _Entry;
}
set
{
if (_Entry != null)
{
_Entry.SettingChanged -= SettingChangedListener;
}
_Entry = value;
OldValue = _Entry.Value;
_Entry.SettingChanged += SettingChangedListener;
}
}
internal T? SyncedValue
{
get
{
return _SyncedValue;
}
set
{
ReceivedSynced = true;
bool flag = false;
if (value != null)
{
ref T reference = ref value;
T val = default(T);
if (val == null)
{
val = reference;
reference = ref val;
}
if (!reference.Equals(Value))
{
goto IL_0064;
}
}
if (value == null && Value != null)
{
goto IL_0064;
}
goto IL_0068;
IL_0068:
_SyncedValue = value;
if (flag)
{
this.ValueChanged?.Invoke(this, new EventArgs());
}
return;
IL_0064:
flag = true;
goto IL_0068;
}
}
public T? Value
{
get
{
if (Sync && ReceivedSynced)
{
return SyncedValue;
}
if (_Entry != null)
{
return _Entry.Value;
}
return default(T);
}
set
{
if (_Entry != null)
{
_Entry.Value = value;
}
}
}
public event SettingChangedHandler SettingChanged;
public event ValueChangedHandler ValueChanged;
private void SettingChangedListener(object sender, EventArgs e)
{
T val;
if (OldValue != null)
{
ref T reference = ref OldValue;
val = default(T);
if (val == null)
{
val = reference;
reference = ref val;
}
if (!reference.Equals(Entry.Value))
{
goto IL_0073;
}
}
if (OldValue == null && Entry.Value != null)
{
goto IL_0073;
}
goto IL_00da;
IL_00da:
if (!Sync)
{
return;
}
if (SyncedValue != null)
{
val = SyncedValue;
if (!val.Equals(Entry.Value))
{
goto IL_0144;
}
}
if (SyncedValue != null || Entry.Value == null)
{
return;
}
goto IL_0144;
IL_0144:
SyncWithClients();
return;
IL_0073:
OldValue = Entry.Value;
T value = Value;
this.SettingChanged?.Invoke(sender, e);
val = Value;
if (!val.Equals(value))
{
this.ValueChanged?.Invoke(this, new EventArgs());
}
goto IL_00da;
}
internal override void SyncWithClients()
{
PunManager instance = PunManager.instance;
if ((Object)(object)instance != (Object)null && (!SemiFunc.IsMultiplayer() || PhotonNetwork.IsMasterClient))
{
if (typeof(T) == typeof(bool))
{
PunManagerPatches.SyncConfigBool(instance, Key, (bool)(object)Entry.Value);
}
else if (typeof(T) == typeof(byte))
{
PunManagerPatches.SyncConfigByte(instance, Key, (byte)(object)Entry.Value);
}
else if (typeof(T) == typeof(sbyte))
{
PunManagerPatches.SyncConfigSByte(instance, Key, (sbyte)(object)Entry.Value);
}
else if (typeof(T) == typeof(short))
{
PunManagerPatches.SyncConfigShort(instance, Key, (short)(object)Entry.Value);
}
else if (typeof(T) == typeof(ushort))
{
PunManagerPatches.SyncConfigUShort(instance, Key, (ushort)(object)Entry.Value);
}
else if (typeof(T) == typeof(int))
{
PunManagerPatches.SyncConfigInt(instance, Key, (int)(object)Entry.Value);
}
else if (typeof(T) == typeof(uint))
{
PunManagerPatches.SyncConfigUInt(instance, Key, (uint)(object)Entry.Value);
}
else if (typeof(T) == typeof(long))
{
PunManagerPatches.SyncConfigLong(instance, Key, (long)(object)Entry.Value);
}
else if (typeof(T) == typeof(ulong))
{
PunManagerPatches.SyncConfigULong(instance, Key, (ulong)(object)Entry.Value);
}
else if (typeof(T) == typeof(float))
{
PunManagerPatches.SyncConfigFloat(instance, Key, (float)(object)Entry.Value);
}
else if (typeof(T) == typeof(double))
{
PunManagerPatches.SyncConfigDouble(instance, Key, (double)(object)Entry.Value);
}
else if (typeof(T) == typeof(string))
{
PunManagerPatches.SyncConfigString(instance, Key, (string)(object)Entry.Value);
}
}
}
}
[BepInPlugin("potatoepet.advancedrepo.config", "AdvancedREPO.Config", "1.0.2")]
public class Plugin : BaseUnityPlugin
{
public static ManualLogSource? Log;
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"Applying AdvancedREPO.Config...");
PunManagerPatches.ApplyPatches();
Log.LogInfo((object)"AdvancedREPO.Config applied!");
}
}
internal class Sync
{
public static Dictionary<string, ConfigField> Configs = new Dictionary<string, ConfigField>();
private static ConfigField<T>? GetConfig<T>(string propertyName)
{
if (Configs.ContainsKey(propertyName) && Configs[propertyName] is ConfigField<T> result)
{
return result;
}
return null;
}
internal static void ApplyLocal()
{
foreach (KeyValuePair<string, ConfigField> config in Configs)
{
if (config.Value is ConfigField<bool> field)
{
ApplyLocal(field);
}
else if (config.Value is ConfigField<byte> field2)
{
ApplyLocal(field2);
}
else if (config.Value is ConfigField<sbyte> field3)
{
ApplyLocal(field3);
}
else if (config.Value is ConfigField<short> field4)
{
ApplyLocal(field4);
}
else if (config.Value is ConfigField<ushort> field5)
{
ApplyLocal(field5);
}
else if (config.Value is ConfigField<int> field6)
{
ApplyLocal(field6);
}
else if (config.Value is ConfigField<uint> field7)
{
ApplyLocal(field7);
}
else if (config.Value is ConfigField<long> field8)
{
ApplyLocal(field8);
}
else if (config.Value is ConfigField<ulong> field9)
{
ApplyLocal(field9);
}
else if (config.Value is ConfigField<float> field10)
{
ApplyLocal(field10);
}
else if (config.Value is ConfigField<double> field11)
{
ApplyLocal(field11);
}
else if (config.Value is ConfigField<string> field12)
{
ApplyLocal(field12);
}
}
}
internal static void ApplyLocal<T>(ConfigField<T> field)
{
if (field.Entry != null)
{
ManualLogSource? log = Plugin.Log;
if (log != null)
{
log.LogDebug((object)$"Applying local configuration for {field.Key}: {field.Entry.Value}");
}
field.SyncedValue = field.Entry.Value;
}
}
internal static void SyncSet<T>(string propertyName, T val)
{
ManualLogSource? log = Plugin.Log;
if (log != null)
{
log.LogDebug((object)$"Received configuration for {propertyName}: {val}");
}
ConfigField<T> config = GetConfig<T>(propertyName);
if (config != null)
{
config.SyncedValue = val;
}
}
}
}
namespace AdvancedREPO.Config.Patches
{
public class PunManagerPatches
{
private static PunManager _Instance;
private static Field<PunManager, PhotonView>? PhotonViewField;
public static PunManager Instance
{
get
{
if ((Object)(object)_Instance == (Object)null)
{
_Instance = Object.FindFirstObjectByType<PunManager>();
}
return _Instance;
}
set
{
if ((Object)(object)value != (Object)null)
{
_Instance = value;
}
}
}
public static void ApplyPatches()
{
PhotonViewField = new Field<PunManager, PhotonView>((from e in typeof(PunManager).GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
where e.Name == "photonView"
select e).First());
ManualLogSource? log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"Patching PunManager...");
}
Harmony.CreateAndPatchAll(typeof(PunManagerPatches), (string)null);
ManualLogSource? log2 = Plugin.Log;
if (log2 != null)
{
log2.LogInfo((object)"PunManager patched!");
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigBool")]
[HarmonyPrefix]
public static void SyncConfigBool(PunManager __instance, string propertyName, bool value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigBoolRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigBoolRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigByte")]
[HarmonyPrefix]
public static void SyncConfigByte(PunManager __instance, string propertyName, byte value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigByteRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigByteRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigSByte")]
[HarmonyPrefix]
public static void SyncConfigSByte(PunManager __instance, string propertyName, sbyte value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigSByteRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigSByteRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigShort")]
[HarmonyPrefix]
public static void SyncConfigShort(PunManager __instance, string propertyName, short value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigShortRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigShortRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigUShort")]
[HarmonyPrefix]
public static void SyncConfigUShort(PunManager __instance, string propertyName, ushort value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigUShortRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigUShortRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigInt")]
[HarmonyPrefix]
public static void SyncConfigInt(PunManager __instance, string propertyName, int value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigIntRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigIntRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigUInt")]
[HarmonyPrefix]
public static void SyncConfigUInt(PunManager __instance, string propertyName, uint value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigUIntRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigUIntRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigLong")]
[HarmonyPrefix]
public static void SyncConfigLong(PunManager __instance, string propertyName, long value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer() || !SemiFunc.IsMultiplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigLongRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigLongRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigULong")]
[HarmonyPrefix]
public static void SyncConfigULong(PunManager __instance, string propertyName, ulong value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigULongRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigULongRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigFloat")]
[HarmonyPrefix]
public static void SyncConfigFloat(PunManager __instance, string propertyName, float value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigFloatRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigFloatRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigDouble")]
[HarmonyPrefix]
public static void SyncConfigDouble(PunManager __instance, string propertyName, double value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigDoubleRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigDoubleRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigString")]
[HarmonyPrefix]
public static void SyncConfigString(PunManager __instance, string propertyName, string value)
{
if (!SemiFunc.IsMasterClientOrSingleplayer() || !SemiFunc.IsMultiplayer())
{
return;
}
if (SemiFunc.IsMultiplayer())
{
PhotonView val = PhotonViewField?.GetValue(__instance) ?? null;
if (val != null)
{
val.RPC("SyncConfigStringRPC", (RpcTarget)0, new object[2] { propertyName, value });
}
}
else
{
SyncConfigStringRPC(__instance, propertyName, value);
}
}
[HarmonyPatch(typeof(PunManager), "SyncConfigBoolRPC")]
[HarmonyPrefix]
public static void SyncConfigBoolRPC(PunManager __instance, string propertyName, bool value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigByteRPC")]
[HarmonyPrefix]
public static void SyncConfigByteRPC(PunManager __instance, string propertyName, byte value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigSByteRPC")]
[HarmonyPrefix]
public static void SyncConfigSByteRPC(PunManager __instance, string propertyName, sbyte value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigShortRPC")]
[HarmonyPrefix]
public static void SyncConfigShortRPC(PunManager __instance, string propertyName, short value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigUShortRPC")]
[HarmonyPrefix]
public static void SyncConfigUShortRPC(PunManager __instance, string propertyName, ushort value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigIntRPC")]
[HarmonyPrefix]
public static void SyncConfigIntRPC(PunManager __instance, string propertyName, int value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigUIntRPC")]
[HarmonyPrefix]
public static void SyncConfigUIntRPC(PunManager __instance, string propertyName, uint value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigLongRPC")]
[HarmonyPrefix]
public static void SyncConfigLongRPC(PunManager __instance, string propertyName, long value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigULongRPC")]
[HarmonyPrefix]
public static void SyncConfigULongRPC(PunManager __instance, string propertyName, ulong value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigFloatRPC")]
[HarmonyPrefix]
public static void SyncConfigFloatRPC(PunManager __instance, string propertyName, float value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigDoubleRPC")]
[HarmonyPrefix]
public static void SyncConfigDoubleRPC(PunManager __instance, string propertyName, double value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncConfigStringRPC")]
[HarmonyPrefix]
public static void SyncConfigStringRPC(PunManager __instance, string propertyName, string value)
{
Sync.SyncSet(propertyName, value);
}
[HarmonyPatch(typeof(PunManager), "SyncAllDictionaries")]
[HarmonyPrefix]
public static void InitiateSync(PunManager __instance)
{
if (SemiFunc.IsMultiplayer() && !PhotonNetwork.IsMasterClient)
{
return;
}
ManualLogSource? log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)"Synchronizing configuration with clients...");
}
foreach (KeyValuePair<string, ConfigField> config in Sync.Configs)
{
config.Value.SyncWithClients();
}
}
}
}
