Weaponedit

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>

bool InfiniteAmmo = true;
bool EquipBrokenItems = true;
bool RemoveEquipmentLevel = true;

BYTE InfiniteAmmoSig[] = { 0x30, 0x54, 0x24, 0x52, 0x30, 0x54, 0x24, 0x53 };
BYTE EquipBrokenItemsSig[] = { 0x0F, 0x57, 0xC0, 0x0F, 0x2F, 0x40, 0x10, 0x40, 0x0F, 0x92, 0xC7 };
BYTE RemoveEquipmentLevelSig[] = { 0x48, 0x8B, 0xB8, 0x48, 0x04, 0x00, 0x00, 0x48, 0x8B, 0x86, 0xC8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x58, 0x08, 0x48, 0x8B, 0xCB };

#define WEAPON_LIST_OFFSET				0x055FAB40L//1.2.4.10
#define WEAPON_INVALID					0x00000001L//Default
#define WEAPON_PLAYABLE_ENABLED			0x00000002L//Ranged, melee
#define WEAPON_PLAYABLE_DISABLED		0x00000004L//Ranged, melee
#define WEAPON_PLAYABLE_AMMO_ENABLED	0x00000008L//Ranged
#define WEAPON_PLAYABLE_AMMO_DISABLED	0x00000010L//Ranged
#define WEAPON_SPEED_FAST				0x00000020L//Ranged, melee
#define WEAPON_SPEED_NORMAL				0x00000040L//Ranged, melee
#define WEAPON_RELOAD_SPEED_FAST		0x00000080L//Ranged
#define WEAPON_RELOAD_SPEED_NORMAL		0x00000100L//Ranged
#define WEAPON_AUTOMATIC_ENABLED		0x00000200L//Ranged, melee
#define WEAPON_AUTOMATIC_DISABLED		0x00000400L//Ranged, melee
#define WEAPON_CHARGING_ENABLED			0x00000800L//Ranged
#define WEAPON_CHARGING_DISABLED		0x00001000L//Ranged
#define WEAPON_HOLD_TO_FIRE_ENABLED		0x00002000L//Ranged
#define WEAPON_HOLD_TO_FIRE_DISABLED	0x00004000L//Ranged
#define WEAPON_DAMAGE_HIGH				0x00008000L//Ranged
#define WEAPON_DAMAGE_NORMAL			0x00010000L//Ranged
#define WEAPON_REACH_FAR				0x00020000L//Ranged, melee
#define WEAPON_REACH_NORMAL				0x00040000L//Ranged, melee
#define WEAPON_VATS_COST_ZERO			0x00080000L//Ranged, melee
#define WEAPON_CAPACITY_HIGH			0x00100000L//Ranged
#define WEAPON_RECOIL_ZERO				0x00200000L//Ranged
#define WEAPON_SPREAD_ZERO				0x00400000L//Ranged
#define WEAPON_SWAY_ZERO				0x00800000L//Ranged

CHAR sProcess[] = "Fallout76.exe";
bool Valid(DWORD64 ptr);
bool RPM(HANDLE sHandle, DWORD64 src, void *dst, size_t Size);
bool WPM(HANDLE sHandle, DWORD64 dst, void *src, size_t Size);
DWORD GetSigOffset(HANDLE sHandle, DWORD64 mBase, DWORD mSize, void *Sig, size_t Size);

LONG GetWeaponFlags(DWORD Formid)
{
	switch (Formid)//Add whitelisted weapons here
	{
	case 0x00113854://Handmade Rifle
		return LONG(WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED | WEAPON_DAMAGE_HIGH);
	case 0x0046D2A1://The Fixer
		return LONG(WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED | WEAPON_DAMAGE_HIGH);
	case 0x000FE268://Railway Rifle
		return LONG(WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED | WEAPON_DAMAGE_HIGH);
	case 0x0005C250://Board
		return LONG(WEAPON_PLAYABLE_ENABLED | WEAPON_SPEED_FAST | WEAPON_REACH_FAR | WEAPON_VATS_COST_ZERO | WEAPON_AUTOMATIC_ENABLED);
	case 0x000DF621://Fire Hydrant Bat
		return LONG(WEAPON_PLAYABLE_ENABLED | WEAPON_SPEED_FAST | WEAPON_REACH_FAR | WEAPON_VATS_COST_ZERO | WEAPON_AUTOMATIC_ENABLED);
	default:
		return LONG(WEAPON_INVALID);
	}
}

bool EditWeapon(DWORD64 WeaponPtr, HANDLE sHandle)
{
	class Weapon
	{
	public:
		char PaddingA[0x20];
		DWORD Formid;//0x20
		char PaddingB[0x19C];
		DWORD64 KeywordArrayPtr;//0x1C0
		DWORD KeywordArraySize;//0x1C8
		char PaddingC[0xC4];
		DWORD64 AmmoPtr;//0x290
		DWORD64 EquipTypePtr;//0x298
		char PaddingD[0x10];
		DWORD64 AimModelPtr;//0x2B0
		char PaddingE[0x44];
		float ReloadSpeed;//0x2FC
		char PaddingF[0x4];
		float Speed;//0x304
		float Reach;//0x308
		char PaddingG[0x2C];
		float ActionPointCost;//0x338
		float FullPowerSeconds;//0x33C
		float MinPowerPerShot;//0x340
		char PaddingH[0x1C];
		BYTE FlagA;//0x360
		BYTE FlagB;//0x361
		BYTE FlagC;//0x362
		BYTE FlagD;//0x363
		char PaddingI[0x1C];
		short Capacity;//0x380
	};

	class Ammo
	{
	public:
		char PaddingA[0x20];
		DWORD Formid;//0x20
		char PaddingB[0x1B0];
		BYTE FlagA;//0x1D4
		BYTE FlagB;//0x1D5
		BYTE FlagC;//0x1D6
		BYTE FlagD;//0x1D7
	};

	class AimModel
	{
	public:
		char PaddingA[0x20];
		DWORD Formid;//0x20
		char PaddingB[0x4];
		float Cone_of_Fire_MinAngle;//0x28
		float Cone_of_Fire_MaxAngle;//0x2C
		float Cone_of_Fire_IncreasePerShot;//0x30
		float Cone_of_Fire_DecreasePerShot;//0x34
		int Cone_of_Fire_DecreaseDelayMS;//0x38
		float Cone_of_Fire_SneakMult;//0x3C
		float Recoil_DiminishSpringForce;//0x40
		float Recoil_DiminishSightsMult;//0x44
		float Recoil_MaxPerShot;//0x48
		float Recoil_MinPerShot;//0x4C
		float Recoil_HipMult;//0x50
		int Runaway_RecoilShots;//0x54
		float Recoil_Arc;//0x58
		float Recoil_ArcRotate;//0x5C
		float Cone_of_Fire_IronSightsMult;//0x60
		float Stability_BaseStability;//0x64
	};

	Weapon WeaponData;
	if (!RPM(sHandle, WeaponPtr, &WeaponData, sizeof(WeaponData))) return false;

	LONG Result = GetWeaponFlags(WeaponData.Formid);

	if (Result & WEAPON_INVALID)
	{
		return false;
	}

	if (Result & WEAPON_PLAYABLE_ENABLED)
	{
		if (((WeaponData.FlagC >> 1) & 1) == 1) WeaponData.FlagC &= ~(1 << 1);
		if (((WeaponData.FlagC >> 4) & 1) == 1) WeaponData.FlagC &= ~(1 << 4);
	}

	if (Result & WEAPON_PLAYABLE_DISABLED)
	{
		if (((WeaponData.FlagC >> 1) & 1) == 0) WeaponData.FlagC |= 1 << 1;
		if (((WeaponData.FlagC >> 4) & 1) == 0) WeaponData.FlagC |= 1 << 4;
	}

	if (Result & WEAPON_PLAYABLE_AMMO_ENABLED)
	{
		if (Valid(WeaponData.AmmoPtr))
		{
			Ammo AmmoData;
			if (RPM(sHandle, WeaponData.AmmoPtr, &AmmoData, sizeof(AmmoData)))
			{
				if (((AmmoData.FlagA >> 1) & 1) == 1) AmmoData.FlagA &= ~(1 << 1);
				WPM(sHandle, WeaponData.AmmoPtr, &AmmoData, sizeof(AmmoData));
			}
		}
	}

	if (Result & WEAPON_PLAYABLE_AMMO_DISABLED)
	{
		if (Valid(WeaponData.AmmoPtr))
		{
			Ammo AmmoData;
			if (RPM(sHandle, WeaponData.AmmoPtr, &AmmoData, sizeof(AmmoData)))
			{
				if (((AmmoData.FlagA >> 1) & 1) == 0) AmmoData.FlagA |= 1 << 1;
				WPM(sHandle, WeaponData.AmmoPtr, &AmmoData, sizeof(AmmoData));
			}
		}
	}

	if (Result & WEAPON_SPEED_FAST)
	{
		if (WeaponData.Speed != 999.0f) WeaponData.Speed = 999.0f;
	}

	if (Result & WEAPON_SPEED_NORMAL)
	{
		if (WeaponData.Speed != 1.0f) WeaponData.Speed = 1.0f;
	}

	if (Result & WEAPON_RELOAD_SPEED_FAST)
	{
		if (WeaponData.ReloadSpeed != 999.0f) WeaponData.ReloadSpeed = 999.0f;
	}

	if (Result & WEAPON_RELOAD_SPEED_NORMAL)
	{
		if (WeaponData.ReloadSpeed != 1.0f) WeaponData.ReloadSpeed = 1.0f;
	}

	if (Result & WEAPON_AUTOMATIC_ENABLED)
	{
		if (((WeaponData.FlagB >> 7) & 1) == 0) WeaponData.FlagB |= 1 << 7;
	}

	if (Result & WEAPON_AUTOMATIC_DISABLED)
	{
		if (((WeaponData.FlagC >> 7) & 1) == 1) WeaponData.FlagC &= ~(1 << 7);
	}

	if (Result & WEAPON_CHARGING_ENABLED)
	{
		if (((WeaponData.FlagA >> 3) & 1) == 0) WeaponData.FlagA |= 1 << 3;
	}

	if (Result & WEAPON_CHARGING_DISABLED)
	{
		if (((WeaponData.FlagA >> 3) & 1) == 1) WeaponData.FlagA &= ~(1 << 3);
	}

	if (Result & WEAPON_HOLD_TO_FIRE_ENABLED)
	{
		if (((WeaponData.FlagB >> 3) & 1) == 0) WeaponData.FlagB |= 1 << 3;
	}

	if (Result & WEAPON_HOLD_TO_FIRE_DISABLED)
	{
		if (((WeaponData.FlagB >> 3) & 1) == 1) WeaponData.FlagB &= ~(1 << 3);
	}

	if (Result & WEAPON_DAMAGE_HIGH)
	{
		if (WeaponData.FullPowerSeconds != 1.0f) WeaponData.FullPowerSeconds = 1.0f;
		if (WeaponData.MinPowerPerShot != 9001.0f) WeaponData.MinPowerPerShot = 9001.0f;
	}

	if (Result & WEAPON_DAMAGE_NORMAL)
	{
		if (WeaponData.FullPowerSeconds != 0.0f) WeaponData.FullPowerSeconds = 0.0f;
		if (WeaponData.MinPowerPerShot != 0.0f) WeaponData.MinPowerPerShot = 0.0f;
	}

	if (Result & WEAPON_REACH_FAR)
	{
		if (WeaponData.Reach != 999.0f) WeaponData.Reach = 999.0f;
	}

	if (Result & WEAPON_REACH_NORMAL)
	{
		if (WeaponData.Reach != 1.0f) WeaponData.Reach = 1.0f;
	}

	if (Result & WEAPON_VATS_COST_ZERO)
	{
		if (WeaponData.ActionPointCost != 0.0f) WeaponData.ActionPointCost = 0.0f;
	}

	if (Result & WEAPON_CAPACITY_HIGH)
	{
		if (WeaponData.Capacity != 999) WeaponData.Capacity = 999;
	}

	if (Result & WEAPON_RECOIL_ZERO)
	{
		if (Valid(WeaponData.AimModelPtr))
		{
			AimModel AimModelData;
			if (RPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData)))
			{
				if (AimModelData.Recoil_DiminishSpringForce != 0.0f) AimModelData.Recoil_DiminishSpringForce = 0.0f;
				if (AimModelData.Recoil_DiminishSightsMult != 0.0f) AimModelData.Recoil_DiminishSightsMult = 0.0f;
				if (AimModelData.Recoil_MaxPerShot != 0.0f) AimModelData.Recoil_MaxPerShot = 0.0f;
				if (AimModelData.Recoil_MinPerShot != 0.0f) AimModelData.Recoil_MinPerShot = 0.0f;
				if (AimModelData.Recoil_HipMult != 0.0f) AimModelData.Recoil_HipMult = 0.0f;
				if (AimModelData.Runaway_RecoilShots != 0) AimModelData.Runaway_RecoilShots = 0;
				if (AimModelData.Recoil_Arc != 0.0f) AimModelData.Recoil_Arc = 0.0f;
				if (AimModelData.Recoil_ArcRotate != 0.0f) AimModelData.Recoil_ArcRotate = 0.0f;
				WPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData));
			}
		}
	}

	if (Result & WEAPON_SPREAD_ZERO)
	{
		if (Valid(WeaponData.AimModelPtr))
		{
			AimModel AimModelData;
			if (RPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData)))
			{
				if (AimModelData.Cone_of_Fire_MinAngle != 0.0f) AimModelData.Cone_of_Fire_MinAngle = 0.0f;
				if (AimModelData.Cone_of_Fire_MaxAngle != 0.0f) AimModelData.Cone_of_Fire_MaxAngle = 0.0f;
				if (AimModelData.Cone_of_Fire_IncreasePerShot != 0.0f) AimModelData.Cone_of_Fire_IncreasePerShot = 0.0f;
				if (AimModelData.Cone_of_Fire_DecreasePerShot != 0.0f) AimModelData.Cone_of_Fire_DecreasePerShot = 0.0f;
				if (AimModelData.Cone_of_Fire_DecreaseDelayMS != 0) AimModelData.Cone_of_Fire_DecreaseDelayMS = 0;
				if (AimModelData.Cone_of_Fire_SneakMult != 0.0f) AimModelData.Cone_of_Fire_SneakMult = 0.0f;
				if (AimModelData.Cone_of_Fire_IronSightsMult != 0.0f) AimModelData.Cone_of_Fire_IronSightsMult = 0.0f;
				WPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData));
			}
		}
	}

	if (Result & WEAPON_SWAY_ZERO)
	{
		if (Valid(WeaponData.AimModelPtr))
		{
			AimModel AimModelData;
			if (RPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData)))
			{
				if (AimModelData.Stability_BaseStability != 100.0f) AimModelData.Stability_BaseStability = 100.0f;
				WPM(sHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData));
			}
		}
	}

	return WPM(sHandle, WeaponPtr, &WeaponData, sizeof(WeaponData));
}

bool IterateWeapons(HANDLE sHandle, DWORD64 mBase)
{
	class WeaponList
	{
	public:
		DWORD64 List;
		DWORD Size;
	};

	WeaponList WeaponListData;
	if (!RPM(sHandle, mBase + WEAPON_LIST_OFFSET, &WeaponListData, sizeof(WeaponListData))) return false;
	if (!Valid(WeaponListData.List)) return false;
	if (!WeaponListData.Size) return false;

	DWORD64 *WeaponPtr = new DWORD64[WeaponListData.Size];
	if (!RPM(sHandle, WeaponListData.List, &*WeaponPtr, WeaponListData.Size * sizeof(DWORD64)))
	{
		delete[]WeaponPtr;
		return false;
	}

	for (DWORD i = 0; i < WeaponListData.Size; i++)
	{
		if (!Valid(WeaponPtr[i])) continue;
		EditWeapon(WeaponPtr[i], sHandle);
	}

	delete[]WeaponPtr;
	return true;
}

void PatchFunctions(HANDLE sHandle, DWORD64 mBase, DWORD mSize)
{
	DWORD AmmoOffset = GetSigOffset(sHandle, mBase, mSize, InfiniteAmmoSig, sizeof(InfiniteAmmoSig));
	if (AmmoOffset > 0)
	{
		BYTE AmmoOn[] = { 0x66, 0xBE, 0xE7, 0x03 };
		BYTE AmmoOff[] = { 0x8B, 0x74, 0x24, 0x50 };
		BYTE AmmoCheck[sizeof(AmmoOff)];
		DWORD64 AmmoAddress = mBase + AmmoOffset + 0x8;
		if (RPM(sHandle, AmmoAddress, &AmmoCheck, sizeof(AmmoCheck)))
		{
			if (InfiniteAmmo)
			{
				if (!memcmp(AmmoCheck, AmmoOff, sizeof(AmmoCheck)))
				{
					WPM(sHandle, AmmoAddress, &AmmoOn, sizeof(AmmoOn));
				}
			}
			else
			{
				if (!memcmp(AmmoCheck, AmmoOn, sizeof(AmmoOn)))
				{
					WPM(sHandle, AmmoAddress, &AmmoOff, sizeof(AmmoOff));
				}
			}
		}
	}

	DWORD BrokenOffset = GetSigOffset(sHandle, mBase, mSize, EquipBrokenItemsSig, sizeof(EquipBrokenItemsSig));
	if (BrokenOffset > 0)
	{
		BYTE BrokenOn[] = { 0x31, 0xFF };
		BYTE BrokenOff[] = { 0xFF, 0xC7 };
		BYTE BrokenCheck[sizeof(BrokenOff)];
		DWORD64 BrokenAddress = mBase + BrokenOffset + 0xB;
		if (RPM(sHandle, BrokenAddress, &BrokenCheck, sizeof(BrokenCheck)))
		{
			if (EquipBrokenItems)
			{
				if (!memcmp(BrokenCheck, BrokenOff, sizeof(BrokenCheck)))
				{
					WPM(sHandle, BrokenAddress, &BrokenOn, sizeof(BrokenOn));
				}
			}
			else
			{
				if (!memcmp(BrokenCheck, BrokenOn, sizeof(BrokenOn)))
				{
					WPM(sHandle, BrokenAddress, &BrokenOff, sizeof(BrokenOff));
				}
			}
		}
	}

	DWORD LevelOffset = GetSigOffset(sHandle, mBase, mSize, RemoveEquipmentLevelSig, sizeof(RemoveEquipmentLevelSig));
	if (LevelOffset > 0)
	{
		BYTE LevelOn[] = { 0xB8, 0x32, 0x00, 0x00, 0x00 };
		BYTE LevelOff[] = { 0xF3, 0x48, 0x0F, 0x2C, 0xC0 };
		BYTE LevelCheck[sizeof(LevelOff)];
		DWORD64 LevelAddress = mBase + LevelOffset + 0x31;
		if (RPM(sHandle, LevelAddress, &LevelCheck, sizeof(LevelCheck)))
		{
			if (RemoveEquipmentLevel)
			{
				if (!memcmp(LevelCheck, LevelOff, sizeof(LevelCheck)))
				{
					WPM(sHandle, LevelAddress, &LevelOn, sizeof(LevelOn));
				}
			}
			else
			{
				if (!memcmp(LevelCheck, LevelOn, sizeof(LevelOn)))
				{
					WPM(sHandle, LevelAddress, &LevelOff, sizeof(LevelOff));
				}
			}
		}
	}
}

bool RPM(HANDLE sHandle, DWORD64 src, void *dst, size_t Size)
{
	return ReadProcessMemory(sHandle, (void*)(src), dst, Size, NULL);
}

bool WPM(HANDLE sHandle, DWORD64 dst, void *src, size_t Size)
{
	return WriteProcessMemory(sHandle, (void*)(dst), src, Size, NULL);
}

bool Valid(DWORD64 ptr)
{
	if (ptr < 0x7FFF || ptr > 0x7FFFFFFFFFFF) return false;
	else return true;
}

DWORD GetSigOffset(HANDLE sHandle, DWORD64 mBase, DWORD mSize, void *Sig, size_t Size)
{
	DWORD SigOffset = 0;
	unsigned char *ModuleArray = new unsigned char[mSize];

	if (RPM(sHandle, mBase, &*ModuleArray, mSize))
	{
		for (DWORD i = 0; i < mSize; i++)
		{
			if (i + Size >= mSize) break;
			if (!memcmp(&ModuleArray[i], Sig, Size))
			{
				SigOffset = i;
				break;
			}
		}
	}

	delete[]ModuleArray;
	return SigOffset;
}

class ModuleData
{
public:
	CHAR *mName;
	BYTE *mBase;
	DWORD mSize;
	DWORD mPid;
};

bool GetModuleData(ModuleData &mData)
{
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, mData.mPid);
	if (hSnapshot == INVALID_HANDLE_VALUE) return false;

	MODULEENTRY32 lpme;
	lpme.dwSize = sizeof(lpme);

	while (Module32Next(hSnapshot, &lpme))
	{
		if (!strcmp(lpme.szModule, mData.mName))
		{
			mData.mBase = lpme.modBaseAddr;
			mData.mSize = lpme.modBaseSize;
			CloseHandle(hSnapshot);
			return true;
		}
	}

	CloseHandle(hSnapshot);
	return false;
}

int main()
{
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	if (hSnapshot == INVALID_HANDLE_VALUE) return 1;

	PROCESSENTRY32 lppe;
	lppe.dwSize = sizeof(lppe);

	while (Process32Next(hSnapshot, &lppe))
	{
		if (!strcmp(lppe.szExeFile, sProcess))
		{
			ModuleData mData;
			mData.mName = lppe.szExeFile;
			mData.mPid = lppe.th32ProcessID;
			if (!GetModuleData(mData)) continue;

			HANDLE sHandle = OpenProcess(PROCESS_ALL_ACCESS, false, mData.mPid);
			IterateWeapons(sHandle, DWORD64(mData.mBase));
			PatchFunctions(sHandle, DWORD64(mData.mBase), mData.mSize);
			CloseHandle(sHandle);
		}
	}

	CloseHandle(hSnapshot);
	return 0;
}