using System;
using System.Collections;
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 BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using Mono.Collections.Generic;
using MonoMod.Cil;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PEAKERRpcInfo")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PEAKERRpcInfo")]
[assembly: AssemblyTitle("PEAKERRpcInfo")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[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 PEAKERRpcInfo
{
public static class PEAKERRpcInfo
{
private record struct PatchedMethod(string OriginalFullName, MethodDefinition Method);
private static readonly ManualLogSource logger = Logger.CreateLogSource("PEAKERRpcInfo");
public static IEnumerable<string> TargetDLLs { get; } = new <>z__ReadOnlySingleElementList<string>("Assembly-CSharp.dll");
public static void Patch(AssemblyDefinition assembly)
{
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Expected O, but got Unknown
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0203: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Expected O, but got Unknown
TypeReference photonMessageInfoTypeRef = default(TypeReference);
if (!assembly.MainModule.TryGetTypeReference("Photon.Pun.PhotonMessageInfo", ref photonMessageInfoTypeRef))
{
logger.LogFatal((object)"Photon.Pun.PhotonMessageInfo type not found.");
return;
}
List<PatchedMethod> patchedMethods = new List<PatchedMethod>();
PatchAssemblyRpcParams(assembly, photonMessageInfoTypeRef, ref patchedMethods);
PatchAssemblyRpcInvokes(assembly, photonMessageInfoTypeRef, importTypeRef: false, patchedMethods, out var _);
foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "*.dll", SearchOption.AllDirectories))
{
if (Path.GetFileName(item).Contains("Assembly-CSharp"))
{
continue;
}
try
{
DefaultAssemblyResolver val = new DefaultAssemblyResolver();
try
{
((BaseAssemblyResolver)val).AddSearchDirectory(Path.GetDirectoryName(item));
((BaseAssemblyResolver)val).AddSearchDirectory(Paths.ManagedPath);
ReaderParameters val2 = new ReaderParameters
{
AssemblyResolver = (IAssemblyResolver)(object)val,
ReadWrite = false,
ReadSymbols = false
};
using MemoryStream memoryStream = new MemoryStream(File.ReadAllBytes(item));
AssemblyDefinition val3 = AssemblyDefinition.ReadAssembly((Stream)memoryStream, val2);
if (!((IEnumerable<AssemblyNameReference>)val3.MainModule.AssemblyReferences).Any((AssemblyNameReference pluginName) => pluginName.FullName == assembly.FullName))
{
logger.LogDebug((object)("No Assembly-CSharp reference in " + item));
continue;
}
if (!val3.MainModule.GetMemberReferences().Any((MemberReference memberRef) => patchedMethods.Any((PatchedMethod patchedMethod) => memberRef.FullName == patchedMethod.OriginalFullName)))
{
logger.LogDebug((object)("No patched method references in " + item));
continue;
}
logger.LogDebug((object)("Patching " + item + "..."));
PatchAssemblyRpcInvokes(val3, photonMessageInfoTypeRef, importTypeRef: true, patchedMethods, out var patched2);
if (patched2)
{
if (File.Exists(item + "-unrpcpatched.old"))
{
File.Delete(item + "-unrpcpatched.old");
}
File.Move(item, item + "-unrpcpatched.old");
WriterParameters val4 = new WriterParameters
{
WriteSymbols = false
};
val3.Write(item, val4);
logger.LogInfo((object)("Patched " + item));
}
else
{
logger.LogDebug((object)("Nothing to patch in " + item));
}
}
finally
{
((IDisposable)val)?.Dispose();
}
}
catch (Exception arg)
{
logger.LogError((object)$"Failed to patch {item}: {arg}");
}
}
}
private static void PatchAssemblyRpcParams(AssemblyDefinition assembly, TypeReference photonMessageInfoTypeRef, ref List<PatchedMethod> patchedMethods)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Expected O, but got Unknown
foreach (TypeDefinition type in assembly.MainModule.GetTypes())
{
Enumerator<MethodDefinition> enumerator2 = type.Methods.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
MethodDefinition current = enumerator2.Current;
try
{
if (current.HasBody && current.HasCustomAttributes && ((IEnumerable<CustomAttribute>)current.CustomAttributes).Any((CustomAttribute attribute) => ((object)attribute.AttributeType).ToString() == "Photon.Pun.PunRPC") && !((IEnumerable<ParameterDefinition>)((MethodReference)current).Parameters).Any((ParameterDefinition parameter) => ((object)((ParameterReference)parameter).ParameterType).ToString() == "Photon.Pun.PhotonMessageInfo"))
{
string fullName = ((MemberReference)current).FullName;
((MethodReference)current).Parameters.Add(new ParameterDefinition("info", (ParameterAttributes)16, photonMessageInfoTypeRef));
logger.LogDebug((object)("Added Photon.Pun.PhotonMessageInfo info parameter onto " + ((MemberReference)current).FullName));
patchedMethods.Add(new PatchedMethod(fullName, current));
}
}
catch (Exception arg)
{
logger.LogError((object)$"An exception occured adding to the parameters of {((MemberReference)current).FullName}:\n{arg}");
}
}
}
finally
{
((IDisposable)enumerator2).Dispose();
}
}
}
private static void PatchAssemblyRpcInvokes(AssemblyDefinition assembly, TypeReference photonMessageInfoTypeRef, bool importTypeRef, List<PatchedMethod> methodsToPatch, out bool patched)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Expected O, but got Unknown
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0210: Unknown result type (might be due to invalid IL or missing references)
patched = false;
foreach (TypeDefinition type in assembly.MainModule.GetTypes())
{
Enumerator<MethodDefinition> enumerator2 = type.Methods.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
MethodDefinition current = enumerator2.Current;
if (((current != null) ? current.Body : null) == null)
{
continue;
}
List<Instruction> list = new List<Instruction>();
try
{
Enumerator<Instruction> enumerator3 = current.Body.Instructions.GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
Instruction current2 = enumerator3.Current;
foreach (PatchedMethod item in methodsToPatch)
{
if (ILPatternMatchingExt.MatchCallOrCallvirt(current2, (MethodReference)(object)item.Method) || ((current2.OpCode == OpCodes.Call || current2.OpCode == OpCodes.Callvirt) && ((MemberReference)/*isinst with value type is only supported in some contexts*/).FullName == item.OriginalFullName))
{
list.Add(current2);
current2.Operand = assembly.MainModule.ImportReference((MethodReference)(object)item.Method);
break;
}
}
}
}
finally
{
((IDisposable)enumerator3).Dispose();
}
if (list.Count == 0)
{
continue;
}
if (!patched)
{
patched = true;
if (importTypeRef)
{
photonMessageInfoTypeRef = assembly.MainModule.ImportReference(photonMessageInfoTypeRef);
}
}
VariableDefinition val = new VariableDefinition(photonMessageInfoTypeRef);
current.Body.Variables.Add(val);
logger.LogDebug((object)("Added Photon.Pun.PhotonMessageInfo variable to " + ((MemberReference)current).FullName));
MethodBodyRocks.SimplifyMacros(current.Body);
ILProcessor iLProcessor = current.Body.GetILProcessor();
foreach (Instruction item2 in list)
{
iLProcessor.InsertBefore(item2, iLProcessor.Create(OpCodes.Ldloca_S, val));
iLProcessor.InsertBefore(item2, iLProcessor.Create(OpCodes.Initobj, photonMessageInfoTypeRef));
iLProcessor.InsertBefore(item2, iLProcessor.Create(OpCodes.Ldloc_S, val));
logger.LogDebug((object)("Inserted default(Photon.Pun.PhotonMessageInfo) before call to " + ((MemberReference)(MethodReference)item2.Operand).FullName));
}
}
catch (Exception arg)
{
logger.LogError((object)$"An exception occured inserting default(Photon.Pun.PhotonMessageInfo) into {((MemberReference)current).FullName}:\n{arg}");
}
finally
{
if (list.Count != 0)
{
MethodBodyRocks.OptimizeMacros(current.Body);
}
}
}
}
finally
{
((IDisposable)enumerator2).Dispose();
}
}
}
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
{
object IEnumerator.Current => _item;
T IEnumerator<T>.Current => _item;
public Enumerator(T item)
{
_item = item;
}
bool IEnumerator.MoveNext()
{
if (!_moveNextCalled)
{
return _moveNextCalled = true;
}
return false;
}
void IEnumerator.Reset()
{
_moveNextCalled = false;
}
void IDisposable.Dispose()
{
}
}
int ICollection.Count => 1;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => 1;
T IReadOnlyList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
}
int ICollection<T>.Count => 1;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlySingleElementList(T item)
{
_item = item;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection.CopyTo(Array array, int index)
{
array.SetValue(_item, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return EqualityComparer<T>.Default.Equals(_item, (T)value);
}
int IList.IndexOf(object value)
{
if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
{
return -1;
}
return 0;
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return EqualityComparer<T>.Default.Equals(_item, item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
array[arrayIndex] = _item;
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
if (!EqualityComparer<T>.Default.Equals(_item, item))
{
return -1;
}
return 0;
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
