Fake Shotgun Reload

[D1GQ]

I made a patch that allows you to reload the Shotgun at any time, to make it less suspicious of you having infinite ammo.

FakeReloadPatch.cs

#pragma warning disable IDE1006

using HarmonyLib;
using System.Collections;
using UnityEngine;

[HarmonyPatch(typeof(ShotgunItem))]
class FakeReloadPatch {
    [HarmonyPatch("FindAmmoInInventory")]
    [HarmonyPrefix]
    static bool Prefix(ShotgunItem __instance, ref int __result) {

        __result = 0;
        return false;
    }

    [HarmonyPatch("reloadGunAnimation")]
    [HarmonyPrefix]
    static bool PrefixReloadGunAnimation(ShotgunItem __instance) {
        __instance.isReloading = true;
        if (__instance.shellsLoaded <= 0) {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", true);
            __instance.shotgunShellLeft.enabled = false;
            __instance.shotgunShellRight.enabled = false;
        }
        else {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", true);
            __instance.shotgunShellRight.enabled = false;
        }

        __instance.StartCoroutine(CustomReloadCoroutine(__instance));

        return false;
    }

    static IEnumerator CustomReloadCoroutine(ShotgunItem instance) {
        yield return new WaitForSeconds(0.3f);
        instance.gunAudio.PlayOneShot(instance.gunReloadSFX);
        instance.gunAnimator.SetBool("Reloading", true);
        instance.ReloadGunEffectsServerRpc(true);
        yield return new WaitForSeconds(0.95f);
        instance.shotgunShellInHand.enabled = true;
        instance.shotgunShellInHandTransform.SetParent(instance.playerHeldBy.leftHandItemTarget);
        instance.shotgunShellInHandTransform.localPosition = new Vector3(-0.0555f, 0.1469f, -0.0655f);
        instance.shotgunShellInHandTransform.localEulerAngles = new Vector3(-1.956f, 143.856f, -16.427f);
        yield return new WaitForSeconds(0.95f);
        // instance.playerHeldBy.DestroyItemInSlotAndSync(instance.ammoSlotToUse);
        // instance.ammoSlotToUse = -1;
        instance.shellsLoaded = Mathf.Clamp(instance.shellsLoaded + 1, 0, 2);
        if (instance.shellsLoaded >= 2) { //New
            instance.StartCoroutine(SetLoadedShells(instance));
        }
        instance.shotgunShellLeft.enabled = true;
        if (instance.shellsLoaded == 2) {
            instance.shotgunShellRight.enabled = true;
        }
        instance.shotgunShellInHand.enabled = false;
        instance.shotgunShellInHandTransform.SetParent(instance.transform);
        yield return new WaitForSeconds(0.45f);
        instance.gunAudio.PlayOneShot(instance.gunReloadFinishSFX);
        instance.gunAnimator.SetBool("Reloading", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", false);
        instance.isReloading = false;
        instance.ReloadGunEffectsServerRpc(false);
    }

    static IEnumerator SetLoadedShells(ShotgunItem instance) {
        yield return new WaitForSeconds(0.5f);
        instance.shellsLoaded = 0;
    }
}

InfiniteAmmoPatch.cs

#pragma warning disable IDE1006

using HarmonyLib;

[HarmonyPatch(typeof(ShotgunItem), nameof(ShotgunItem.ItemActivate))]
class InfiniteShotgunAmmoPatch {
    static void Prefix(EnemyAI? ___heldByEnemy, ref int ___shellsLoaded) {
        if (___heldByEnemy is not null) return;
        ___shellsLoaded = 2;
    }
}

[winstxnhdw]

Goddamn, why isit so complicated.

[D1GQ]

Because I had to completely patch a void because it was originally deleting the shotgun shell, which would completely break the shotgun without the shell being in the inventory. And the where no conditions to delete the shell, so I couldn't set any value to prevent it.

[D1GQ]

If you can find a better way to simplify it, go right ahead lol.

[D1GQ]

I refined the code a bit

#pragma warning disable IDE1006

using HarmonyLib;
using System.Collections;
using UnityEngine;

[HarmonyPatch(typeof(ShotgunItem))]
class FakeReloadPatch {
    [HarmonyPatch("FindAmmoInInventory")]
    [HarmonyPrefix]
    static bool Prefix(ShotgunItem __instance, ref int __result) {

        __result = 0;
        return false;
    }

    [HarmonyPatch("ItemInteractLeftRight")]
    [HarmonyPrefix]
    static bool PrefixItemInteractLeftRight(ShotgunItem __instance, ref int ___shellsLoaded) {

        if (___shellsLoaded >= 2) {
            ___shellsLoaded = 0;
        }
        return true;
    }

    [HarmonyPatch("reloadGunAnimation")]
    [HarmonyPrefix]
    static bool PrefixReloadGunAnimation(ShotgunItem __instance) {
        __instance.isReloading = true;
        if (__instance.shellsLoaded <= 0) {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", true);
            __instance.shotgunShellLeft.enabled = false;
            __instance.shotgunShellRight.enabled = false;
        }
        else {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", true);
            __instance.shotgunShellRight.enabled = false;
        }

        __instance.StartCoroutine(CustomReloadCoroutine(__instance));

        return false;
    }

    static IEnumerator CustomReloadCoroutine(ShotgunItem instance) {
        yield return new WaitForSeconds(0.3f);
        instance.gunAudio.PlayOneShot(instance.gunReloadSFX);
        instance.gunAnimator.SetBool("Reloading", true);
        instance.ReloadGunEffectsServerRpc(true);
        yield return new WaitForSeconds(0.95f);
        instance.shotgunShellInHand.enabled = true;
        instance.shotgunShellInHandTransform.SetParent(instance.playerHeldBy.leftHandItemTarget);
        instance.shotgunShellInHandTransform.localPosition = new Vector3(-0.0555f, 0.1469f, -0.0655f);
        instance.shotgunShellInHandTransform.localEulerAngles = new Vector3(-1.956f, 143.856f, -16.427f);
        yield return new WaitForSeconds(0.95f);
        // instance.playerHeldBy.DestroyItemInSlotAndSync(instance.ammoSlotToUse);
        // instance.ammoSlotToUse = -1;
        instance.shellsLoaded = Mathf.Clamp(instance.shellsLoaded + 1, 0, 2);
        instance.shotgunShellLeft.enabled = true;
        if (instance.shellsLoaded == 2) {
            instance.shotgunShellRight.enabled = true;
        }
        instance.shotgunShellInHand.enabled = false;
        instance.shotgunShellInHandTransform.SetParent(instance.transform);
        yield return new WaitForSeconds(0.45f);
        instance.gunAudio.PlayOneShot(instance.gunReloadFinishSFX);
        instance.gunAnimator.SetBool("Reloading", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", false);
        instance.isReloading = false;
        instance.ReloadGunEffectsServerRpc(false);
    }
}

[D1GQ]

@winstxnhdw This is the final patch I got!

FakeReloadPatch.cs

#pragma warning disable IDE1006

using HarmonyLib;
using System.Collections;
using UnityEngine;

[HarmonyPatch(typeof(ShotgunItem))]
class FakeReloadPatch {
    [HarmonyPatch("FindAmmoInInventory")] // Always allow reload without shotgun shell.
    [HarmonyPrefix]
    static bool PrefixFindAmmoInInventory(ShotgunItem __instance, ref int __result) {

        __result = 0;
        return false;
    }

    [HarmonyPatch("ItemInteractLeftRight")] // If shotgun is full empty to allow reload.
    [HarmonyPrefix]
    static bool PrefixItemInteractLeftRight(ShotgunItem __instance, ref int ___shellsLoaded) {

        if (___shellsLoaded >= 2) {
            ___shellsLoaded = 0;
        }
        return true;
    }

    [HarmonyPatch("reloadGunAnimation")] // Repatch reloadGunAnimation() to do not delete item on reload.
    [HarmonyPrefix]
    static bool PrefixReloadGunAnimation(ShotgunItem __instance) {
        __instance.isReloading = true;
        if (__instance.shellsLoaded <= 0) {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", true);
            __instance.shotgunShellLeft.enabled = false;
            __instance.shotgunShellRight.enabled = false;
        }
        else {
            __instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", true);
            __instance.shotgunShellRight.enabled = false;
        }

        __instance.StartCoroutine(CustomReloadCoroutine(__instance));

        return false;
    }

    static IEnumerator CustomReloadCoroutine(ShotgunItem instance) {
        yield return new WaitForSeconds(0.3f);
        instance.gunAudio.PlayOneShot(instance.gunReloadSFX);
        instance.gunAnimator.SetBool("Reloading", true);
        instance.ReloadGunEffectsServerRpc(true);
        yield return new WaitForSeconds(0.95f);
        instance.shotgunShellInHand.enabled = true;
        instance.shotgunShellInHandTransform.SetParent(instance.playerHeldBy.leftHandItemTarget);
        instance.shotgunShellInHandTransform.localPosition = new Vector3(-0.0555f, 0.1469f, -0.0655f);
        instance.shotgunShellInHandTransform.localEulerAngles = new Vector3(-1.956f, 143.856f, -16.427f);
        yield return new WaitForSeconds(0.95f);
        // instance.playerHeldBy.DestroyItemInSlotAndSync(instance.ammoSlotToUse);
        // instance.ammoSlotToUse = -1;
        instance.shellsLoaded = Mathf.Clamp(instance.shellsLoaded + 1, 0, 2);
        instance.shotgunShellLeft.enabled = true;
        if (instance.shellsLoaded == 2) {
            instance.shotgunShellRight.enabled = true;
        }
        instance.shotgunShellInHand.enabled = false;
        instance.shotgunShellInHandTransform.SetParent(instance.transform);
        yield return new WaitForSeconds(0.45f);
        instance.gunAudio.PlayOneShot(instance.gunReloadFinishSFX);
        instance.gunAnimator.SetBool("Reloading", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun", false);
        instance.playerHeldBy.playerBodyAnimator.SetBool("ReloadShotgun2", false);
        instance.isReloading = false;
        instance.ReloadGunEffectsServerRpc(false);
    }
}

InfiniteAmmoPatch.cs

#pragma warning disable IDE1006

using HarmonyLib;

[HarmonyPatch(typeof(ShotgunItem), nameof(ShotgunItem.ItemActivate))] // Load shell if empty on fire.
class InfiniteShotgunAmmoPatch {
    static void Prefix(EnemyAI? ___heldByEnemy, ref int ___shellsLoaded, ref bool ___isReloading) {
        if (___heldByEnemy is not null || ___isReloading) return;
        if (___shellsLoaded <= 0) {
            ___shellsLoaded = 1;
        }
    }
}

[o777l]

Just tried it and it won't compile. Trying to get a screen of the error message that momentarily flashes by

Edit:

Edit 2: Nevermind, got it. Turns out I did a bad copy paste of the reload patch, then had two InfiniteAmmoPatch.cs in the folder. Working as expected now

Thanks!

[winstxnhdw]

Is there no way to achieve the same thing without patching the entire coroutine? We could probably reuse the original patch but just make the game think we have ammo in our inventory. That way we don't have to patch everything.

The less custom code we write, the better.

[D1GQ]

@winstxnhdw that's the first thing I tried, the issue is the game absolutely freaks out because there's no ammo in your inventory and the game tries to destroy an item that doesn't exist, either the shotgun gets destroyed or you get stuck in the middle of the reload animation.

[o777l]

@D1GQ Can I DM you on here somehow

[D1GQ]

Just msg me on Discord, is the same as my github name.

[Dexteriority]

This is Lit.
Im testing it out

[D1GQ]

How did it go?

[Dexteriority]

Its amazing!!
I forgot i had InfiniteAmmoPatch turned off but my shotgun keep reloading whenever it needs ammo.
So basically i had infinite ammo added to my shotgun but with reload animation.
Great work!!

[D1GQ]

@winstxnhdw I found a way better way pulling off the Fake Shotgun Reload, without patching the entire coroutine! it's pretty simple I don't know why I didn't think about it, all I did was make it where if the shotgun is Reloading it forcibly interrupts the DestroyItemInSlotAndSync until IsReloading Is false;

FakeReloadPatch

using GameNetcodeStuff;
using HarmonyLib;

class FakeReloadPatch {

    static bool InterruptDestroyItem { get; set; }

    [HarmonyPatch(typeof(ShotgunItem))]
    class ShotGun {
        [HarmonyPatch("FindAmmoInInventory"), HarmonyPrefix] // This makes the shotgun look for a item slot that has a Shotgun Shell. Patch makes FindAmmoInInventory always result to 0 so it's not null.
        static bool PrefixFindAmmoInInventory(ShotgunItem __instance, ref int __result) {
            __result = 0;
            return false;
        }

        [HarmonyPatch("ItemInteractLeftRight"), HarmonyPrefix]
        static bool PrefixItemInteractLeftRight(ShotgunItem __instance, ref int ___shellsLoaded) { // This checks if the shotgun is already loaded. Patch makes it where if it's full it unloads it so you can reload again.
            if (___shellsLoaded >= 2) {
                ___shellsLoaded = 0;
                return false;
            }
            return true;
        }

        [HarmonyPatch("Update"), HarmonyPrefix]
        static void PrefixUpdate(ref bool ___isReloading) {
            FakeReloadPatch.InterruptDestroyItem = ___isReloading; // Constantly sets InterruptDestroyItem to the same value of ShotgunItem.isReloading.
        }
    }

    [HarmonyPatch(typeof(PlayerControllerB))]
    class DestroyItem {
        [HarmonyPatch("DestroyItemInSlotAndSync"), HarmonyPrefix] // if InterruptDestroyItem it's true it immediately returns DestroyItemInSlotAndSync to prevent ShotgunItem.reloadGunAnimation to call it.
        static bool Prefix() => !FakeReloadPatch.InterruptDestroyItem;
    }
}

Also don't forget to update the InfiniteAmmoPatch.cs

InfiniteAmmoPatch.cs

#pragma warning disable IDE1006

using HarmonyLib;

[HarmonyPatch(typeof(ShotgunItem), nameof(ShotgunItem.ItemActivate))] // Load shell if empty on fire
class InfiniteShotgunAmmoPatch {
    static void Prefix(EnemyAI? ___heldByEnemy, ref int ___shellsLoaded, ref bool ___isReloading) {
        if (___heldByEnemy is not null || ___isReloading) return;
        if (___shellsLoaded <= 0) {
            ___shellsLoaded = 1;
        }
    }
}

[winstxnhdw]

Yeap. It’s usually this case.

[D1GQ]

@winstxnhdw Fixed it!

Replace

        [HarmonyPatch("Update"), HarmonyPrefix]
        static void PrefixUpdate(ref bool ___isReloading) {
            FakeReloadPatch.InterruptDestroyItem = ___isReloading; // Constantly sets InterruptDestroyItem to the same value of ShotgunItem.isReloading.
        }

With

        [HarmonyPatch("reloadGunAnimation"), HarmonyPrefix] // Sets InterruptDestroyItem to true if Reload Starts.
        static void PrefixReloadGunAnimation() {
            FakeReloadPatch.InterruptDestroyItem = true;
        }
        [HarmonyPatch("StopUsingGun"), HarmonyPrefix] // Sets InterruptDestroyItem to false if Shotgun is Dropped or Pocketed.
        static void PrefixStopUsingGun() {
            FakeReloadPatch.InterruptDestroyItem = false;
        }

[D1GQ]

Hey winstxnhdw do you mind checking out AntiFlash & EarRinging Patch and LookDownPatch it's some other patches I've made.

[winstxnhdw]

Sure but could you send them in as PRs. I am a bit stretched for time here.

[D1GQ]

Here #441 (comment)