Anti-Kick improvement

[ChunkyMonkey00]

Heyo! so if you really dont care about the ability to see other player's names
i have found a way to make it so you simply CANNOT kick someone. Your clientID is never sent to the host, so they can never kick you.

How it works:
sets actualClientId to 0 (which is interpreted as the last person in the lobby)
removes all instances of your client ID even in local player.

Code:
(no i wont be catering and doing it for you. But heres the patches)

    [HarmonyPatch]
    public class AntiKick : MonoBehaviour
    {
        public static object CallMethod(object instance, string methodName, BindingFlags bindingFlags, params object[] parameters)
        {
            MethodInfo method = instance.GetType().GetMethod(methodName, bindingFlags);
            if (method != null)
            {
                return method.Invoke(instance, parameters);
            }
            return null;
        }

        [HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesServerRpc")]
        class AntiKickPatch
        {
            static bool Prefix(PlayerControllerB __instance)
            {
                if (!Settings.Instance.settingsData.b_antiKick) return true;

                ulong[] playerSteamIds = new ulong[__instance.playersManager.allPlayerScripts.Length];

                for (int i = 0; i < __instance.playersManager.allPlayerScripts.Length; i++)
                {
                    playerSteamIds[i] = __instance.playersManager.allPlayerScripts[0].playerSteamId;
                }

                playerSteamIds[__instance.playerClientId] = __instance.playersManager.allPlayerScripts[0].playerSteamId;

                CallMethod(__instance, "SendNewPlayerValuesClientRpc", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, playerSteamIds);

                return false;
            }
        }

        [HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
        class AntiKickClientPatch
        {
            static bool Prefix(ref ulong clientId)
            {
                if (Settings.Instance.settingsData.b_antiKick)
                {
                    clientId = 0;
                    return true;
                }
                return true;
            }

         }

        [HarmonyTranspiler]
        [HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
        public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
        {
            var codes = new List<CodeInstruction>(instructions);

            for (int i = 0; i < codes.Count; i++)
            {
                if (Settings.Instance.settingsData.b_antiKick)
                {
                    // Look for the instruction that sets this.actualClientId
                    if (codes[i].opcode == OpCodes.Call && codes[i].operand is MethodInfo methodInfo &&
                        methodInfo.Name == "get_LocalClientId" && methodInfo.DeclaringType.Name == "NetworkManager")
                    {
                        // Replace the instruction to set this.actualClientId with a constant value of  0
                        codes[i - 1] = new CodeInstruction(OpCodes.Ldc_I4_0); // Load constant  0 onto the stack
                        codes[i] = new CodeInstruction(OpCodes.Stfld, typeof(PlayerControllerB).GetField("actualClientId", BindingFlags.NonPublic | BindingFlags.Instance));
                        break;
                    }
                }
            }

            return codes.AsEnumerable();
        }

    }

[winstxnhdw]

Cool, nice job for finding this. It must’ve been painful.

[joep26020]

wait winston can you add this to main?

[winstxnhdw]

Soon.

[Totoqoe]

Yall are so talented! I swear yall deserve donations!

[joep26020]

i said that to winston once but he never replied lol

[winstxnhdw]

I have no plans to take donations but if you guys really want to help out, I do need another copy of Lethal Company which I can use to automatically refresh the DLLs on new game updates even if I were to pass away one day. This will ensure that lc-hax will be around for a long long time.

Currently, we are using my DLLs from my install of Lethal Company, which I think is a security risk for you guys, even though I am setting them as Private.

So if anyone is interested, you guys can pool together money and purchase Lethal Company as a gift and send one over to me.

[joep26020]

hey how do i do this i wanna test it out real quick

[winstxnhdw]

Adding this after my lunch.

[winstxnhdw]

@ChunkyMonkey00

Looked promising at first, but after testing with a friend, it seems that the same issues remain. Once a new player joins, you can still be kicked.

[winstxnhdw]

For those who want to give it a try yourselves,

using GameNetcodeStuff;
using HarmonyLib;
using Hax;
using System.Collections.Generic;
using System.Reflection.Emit;
using System.Reflection;
using System.Linq;

[HarmonyPatch]
class AntiKickPatch {
    [HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesServerRpc")]
    static bool Prefix(PlayerControllerB __instance) {
        if (!Setting.EnableAntiKick) return true;

        ulong[] playerSteamIds = new ulong[__instance.playersManager.allPlayerScripts.Length];

        for (int i = 0; i < __instance.playersManager.allPlayerScripts.Length; i++) {
            playerSteamIds[i] = __instance.playersManager.allPlayerScripts[0].playerSteamId;
        }

        playerSteamIds[__instance.playerClientId] = __instance.playersManager.allPlayerScripts[0].playerSteamId;

        _ = __instance.Reflect().InvokeInternalMethod("SendNewPlayerValuesClientRpc", playerSteamIds);

        return false;
    }

    [HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
    static void Prefix(ref ulong clientId) {
        if (Setting.EnableAntiKick) {
            clientId = 0;
        }
    }

    [HarmonyTranspiler]
    [HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
    public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) {
        List<CodeInstruction> codes = new(instructions);

        for (int i = 0; i < codes.Count; i++) {
            if (Setting.EnableAntiKick) {
                // Look for the instruction that sets this.actualClientId
                if (codes[i].opcode == OpCodes.Call && codes[i].operand is MethodInfo methodInfo &&
                    methodInfo.Name == "get_LocalClientId" && methodInfo.DeclaringType.Name == "NetworkManager") {
                    // Replace the instruction to set this.actualClientId with a constant value of  0
                    codes[i - 1] = new CodeInstruction(OpCodes.Ldc_I4_0); // Load constant  0 onto the stack
                    codes[i] = new CodeInstruction(OpCodes.Stfld, typeof(PlayerControllerB).GetField("actualClientId", BindingFlags.NonPublic | BindingFlags.Instance));
                    break;
                }
            }
        }

        return codes.AsEnumerable();
    }
}

[ChunkyMonkey00]

starting to realize that the issue is indeed people joining after you. I will work on this for a bit more. BUT as of right now if you join as the last person youre unkickable

[winstxnhdw]

Yeap but if that’s the case, the previous method would already work.

[Totoqoe]

Maybe this new one would work better against tools such as lethal admin?

[winstxnhdw]

Fundamentally, there's no difference because both methods are only ever run on the client.