using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FriendPatches.Callbacks;
using FriendPatches.Core;
using FriendPatches.Patches;
using FriendPatches.Tools;
using GameNetcodeStuff;
using HarmonyLib;
using Steamworks;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("FriendPatches")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FriendPatches")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("955504ed-4fb7-496c-856e-f65e5b63ca4b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace FriendPatches.Tools
{
public static class PatchHelper
{
public static HarmonyMethod Method(Expression<Action> action, bool debug = false)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
return new HarmonyMethod(SymbolExtensions.GetMethodInfo(action), -1, (string[])null, (string[])null, (bool?)debug)
{
priority = 10000
};
}
public static HarmonyMethod Method<A>(Expression<Action<A>> action, bool debug = false)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
return new HarmonyMethod(SymbolExtensions.GetMethodInfo<A>(action), -1, (string[])null, (string[])null, (bool?)debug)
{
priority = 10000
};
}
public static HarmonyMethod Method<A, B>(Expression<Action<A, B>> action, bool debug = false)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
return new HarmonyMethod(SymbolExtensions.GetMethodInfo((LambdaExpression)action), -1, (string[])null, (string[])null, (bool?)debug)
{
priority = 10000
};
}
}
public static class Reflection
{
public static Type Type(string type)
{
return AccessTools.TypeByName(type);
}
public static List<ConstructorInfo> Constructors(string type)
{
return AccessTools.GetDeclaredConstructors(Type(type), (bool?)null);
}
public static List<ConstructorInfo> Constructors(Type type)
{
return AccessTools.GetDeclaredConstructors(type, (bool?)null);
}
public static MethodBase Method(string type, string method, Type[] args = null, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredMethod(Type(type), method, args, (Type[])null);
}
return AccessTools.Method(Type(type), method, args, (Type[])null);
}
public static MethodBase Method(Type type, string method, Type[] args = null, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredMethod(type, method, args, (Type[])null);
}
return AccessTools.Method(type, method, args, (Type[])null);
}
public static FieldInfo Field(string type, string field, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredField(Type(type), field);
}
return AccessTools.Field(Type(type), field);
}
public static FieldInfo Field(Type type, string field, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredField(type, field);
}
return AccessTools.Field(type, field);
}
public static PropertyInfo Property(string type, string property, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredProperty(Type(type), property);
}
return AccessTools.Property(Type(type), property);
}
public static PropertyInfo Property(Type type, string property, bool declared = true)
{
if (declared)
{
return AccessTools.DeclaredProperty(type, property);
}
return AccessTools.Property(type, property);
}
}
}
namespace FriendPatches.Patches
{
public static class GameNetworkManager_Patches
{
public static void Apply(Harmony harmony)
{
if (FriendPatchesSettings.SetPlayedWithOnSteam)
{
harmony.Patch(Reflection.Method(typeof(GameNetworkManager), "SteamMatchmaking_OnLobbyMemberJoined"), (HarmonyMethod)null, (HarmonyMethod)null, PatchHelper.Method(() => PlayerJoined(null, null)), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
public static void HandleFriendJoin(List<SteamId> steamIdsInLobby, SteamId id)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
if (steamIdsInLobby == null || steamIdsInLobby.Contains(id))
{
return;
}
steamIdsInLobby.Add(id);
if ((Object)(object)StartOfRound.Instance != (Object)null && StartOfRound.Instance.localPlayerController.playerSteamId == SteamId.op_Implicit(id))
{
foreach (SteamId otherId in steamIdsInLobby)
{
if (SteamId.op_Implicit(otherId) != SteamId.op_Implicit(id))
{
Task.Run(delegate
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
SteamFriends.SetPlayedWith(otherId);
});
}
}
}
Task.Run(delegate
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
SteamFriends.SetPlayedWith(id);
});
}
private static IEnumerable<CodeInstruction> PlayerJoined(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Expected O, but got Unknown
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, generator);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[6]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "steamIdsInLobby"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldelema, (object)null, (string)null),
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "Id" && ((FieldInfo)i.operand).DeclaringType == typeof(Friend)), (string)null),
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "Add" && ((MethodInfo)i.operand).DeclaringType.Name.StartsWith("List")), (string)null)
});
if (!val.ReportFailure(MethodBase.GetCurrentMethod(), (Action<string>)FriendPatchesPlugin.Log.LogFatal))
{
val.SetInstruction(new CodeInstruction(OpCodes.Call, (object)Reflection.Method(typeof(GameNetworkManager_Patches), "HandleFriendJoin")));
}
return val.InstructionEnumeration();
}
}
}
namespace FriendPatches.Core
{
public static class FriendPatchesInfo
{
public const string GUID = "lauriichan.friendpatches";
public const string PrintName = "FriendPatches";
public const string Version = "1.0.4";
}
public static class FriendPatchesSettings
{
public static bool SetPlayedWithOnSteam { get; private set; }
public static bool UsernameFix { get; private set; }
internal static void SetupConfig(ConfigFile cfg)
{
UsernameFix = cfg.Bind<bool>("General", "Enable the username fix patches", true, "Enables patches that listen to Steam callbacks for username changes and updates the player names accordingly.").Value;
SetPlayedWithOnSteam = cfg.Bind<bool>("Steam", "Enable PlayedWith patches", true, "Enables patches that add players that joined your lobby to the 'Played With' list on Steam.").Value;
}
}
[BepInPlugin("lauriichan.friendpatches", "FriendPatches", "1.0.4")]
internal class FriendPatchesPlugin : BaseUnityPlugin
{
private Harmony harmony;
public static ManualLogSource Log { get; private set; }
public void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
FriendPatchesSettings.SetupConfig(((BaseUnityPlugin)this).Config);
SetupCallbacks();
SetupPatches();
}
private void SetupPatches()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
if (harmony == null)
{
harmony = new Harmony("lauriichan.friendpatches");
GameNetworkManager_Patches.Apply(harmony);
}
}
private void SetupCallbacks()
{
SteamFriendsCallback.Apply();
}
public void OnDestroy()
{
if (harmony != null)
{
harmony.UnpatchSelf();
harmony = null;
}
ShutdownCallbacks();
}
private void ShutdownCallbacks()
{
SteamFriendsCallback.Unapply();
}
}
}
namespace FriendPatches.Callbacks
{
public static class SteamFriendsCallback
{
private static bool applied;
public static void Apply()
{
if (FriendPatchesSettings.UsernameFix)
{
applied = true;
SteamFriends.OnPersonaStateChange += PersonaChanged;
}
}
public static void Unapply()
{
if (applied)
{
applied = false;
SteamFriends.OnPersonaStateChange -= PersonaChanged;
}
}
private static void PersonaChanged(Friend friend)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
if (!GameNetworkManager.Instance.currentLobby.HasValue || (Object)(object)StartOfRound.Instance == (Object)null)
{
return;
}
SteamId friendId = friend.Id;
if (GameNetworkManager.Instance.steamIdsInLobby.Contains(friendId))
{
Task.Run(delegate
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
DoNameUpdate(friendId, ((Friend)(ref friend)).Name, ((Friend)(ref friend)).IsMe);
});
}
}
private static void DoNameUpdate(SteamId friendId, string friendName, bool isMe)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
StartOfRound instance = StartOfRound.Instance;
FriendPatchesPlugin.Log.LogInfo((object)$"Updating friend ({friendId}): {friendName}");
PlayerControllerB val = instance.allPlayerScripts[instance.thisClientPlayerId];
ulong num = SteamId.op_Implicit(friendId);
for (int i = 0; i < instance.allPlayerScripts.Length; i++)
{
PlayerControllerB val2 = instance.allPlayerScripts[i];
if ((Object)(object)val2 == (Object)null || !val2.isPlayerControlled || val2.playerSteamId != num)
{
continue;
}
val2.playerUsername = friendName;
if ((Object)(object)val2.usernameBillboardText != (Object)null)
{
((TMP_Text)val2.usernameBillboardText).text = friendName;
}
string name = friendName;
int numberOfDuplicateNamesInLobby = instance.GetNumberOfDuplicateNamesInLobby(val);
if (numberOfDuplicateNamesInLobby > 0)
{
name = $"{friendName}{numberOfDuplicateNamesInLobby}";
}
if ((Object)(object)val.quickMenuManager != (Object)null)
{
PlayerListSlot val3 = val.quickMenuManager.playerListSlots[i];
if (val3 != null)
{
val3.playerSteamId = SteamId.op_Implicit(friendId);
((TMP_Text)val3.usernameHeader).text = friendName;
if ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
{
val3.volumeSliderContainer.SetActive(!isMe);
}
}
}
if ((Object)(object)instance.mapScreen == (Object)null)
{
TransformAndName val4 = instance.mapScreen.radarTargets[i];
if (val4 != null)
{
val4.name = name;
}
}
break;
}
}
private static int GetNumberOfDuplicateNamesInLobby(this StartOfRound round, PlayerControllerB self)
{
int num = 0;
for (int i = 0; i < round.allPlayerScripts.Length; i++)
{
PlayerControllerB val = round.allPlayerScripts[i];
if ((Object)(object)val != (Object)null && (val.isPlayerControlled || val.isPlayerDead) && !((Object)(object)val == (Object)(object)self) && val.playerUsername == self.playerUsername)
{
num++;
}
}
for (int j = 0; j < round.allPlayerScripts.Length; j++)
{
PlayerControllerB val = round.allPlayerScripts[j];
if ((Object)(object)val != (Object)null && (val.isPlayerControlled || val.isPlayerDead) && !((Object)(object)val == (Object)(object)self) && val.playerUsername == $"{val.playerUsername}{num}")
{
num++;
}
}
return num;
}
}
}
