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

DWORD GetSigOffset(HANDLE pHandle, DWORD64 mBase, DWORD mSize, BYTE *Sig, const char *Mask, int Len);
bool RPM(HANDLE pHandle, DWORD64 src, void *dst, size_t Size);
bool WPM(HANDLE pHandle, DWORD64 dst, void *src, size_t Size);
DWORD64 AllocEx(HANDLE pHandle, size_t Size);
bool FreeEx(HANDLE pHandle, DWORD64 src);
bool Valid(DWORD64 ptr);

class ProcessData
{
public:
    CHAR* pName;
    CHAR* mName;
    BYTE *mBase;
    DWORD mSize;
    DWORD pPid;
    HANDLE pHandle;
};

#define WEAPON_LIST_OFFSET              0x055AB800L//1.2.5.11
#define WEAPON_INVALID                  0x00000001L//Default
#define WEAPON_VORPAL                   0x00000002L//Vorpal
#define WEAPON_PLAYABLE_DEFAULT         0x00000004L//Ranged, melee
#define WEAPON_PLAYABLE_RANGED          0x00000008L//Ranged
#define WEAPON_SPEED_FAST               0x00000010L//Ranged, melee
#define WEAPON_SPEED_NORMAL             0x00000020L//Ranged, melee
#define WEAPON_RELOAD_SPEED_FAST        0x00000040L//Ranged
#define WEAPON_RELOAD_SPEED_NORMAL      0x00000080L//Ranged
#define WEAPON_AUTOMATIC_ENABLED        0x00000100L//Ranged, melee
#define WEAPON_AUTOMATIC_DISABLED       0x00000200L//Ranged, melee
#define WEAPON_CHARGING_ENABLED         0x00000400L//Ranged
#define WEAPON_CHARGING_DISABLED        0x00000800L//Ranged
#define WEAPON_HOLD_TO_FIRE_ENABLED     0x00001000L//Ranged
#define WEAPON_HOLD_TO_FIRE_DISABLED    0x00002000L//Ranged
#define WEAPON_REACH_FAR                0x00004000L//Ranged, melee
#define WEAPON_REACH_NORMAL             0x00008000L//Ranged, melee
#define WEAPON_VATS_COST_ZERO           0x00010000L//Ranged, melee
#define WEAPON_PROJECTILES_ONE          0x00020000L//Ranged, grenades
#define WEAPON_PROJECTILES_TEN          0x00040000L//Ranged, greandes
#define WEAPON_PROJECTILES_MAX          0x00080000L//Ranged, grenades
#define WEAPON_CAPACITY_HIGH            0x00100000L//Ranged
#define WEAPON_RECOIL_ZERO              0x00200000L//Ranged
#define WEAPON_SPREAD_ZERO              0x00400000L//Ranged
#define WEAPON_SWAY_ZERO                0x00800000L//Ranged

LONG GetWeaponFlags(DWORD Formid)
{
    switch (Formid)//Add whitelisted weapons here
    {
    case 0x0010CC9E://Scorchbeast Strafe Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x00019951://Grafton Oil Bomb
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0039CCB0://Grafton Oil Bomb Salvo
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0012A1F2://Snallygaster Spit Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x000FC3EC://Sonic Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0009F24D://Spit Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x003B7F70://Wendigo Scream Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0003226A://MegaslothDirtThrow
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0052193E://Megasloth Area Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x004F4A84://Honey Beast Bee Swarm Spawn (Does not spawn bees, additional edits might be required)
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x00107BD6://Baseball Grenade
        return WEAPON_PROJECTILES_MAX;
    case 0x00113849://Fragmentation Grenade MIRV
        return WEAPON_PROJECTILES_MAX;
    case 0x0010A340://Nuke Mine
        return WEAPON_PROJECTILES_MAX;
    case 0x000EEBED://Fragmentation Grenade
        return WEAPON_PROJECTILES_MAX;
    case 0x004E5566://Mothman AoE Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x00001BA1://Sonic Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_PROJECTILES_TEN;
    case 0x0052EEF8://Scorchbeast Sonic Attack
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_PROJECTILES_TEN;
    case 0x0010D80A://Liberator Laser
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x00004117://Flatwoods Monster Laser
        return WEAPON_PLAYABLE_RANGED | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO;
    case 0x0014245D://Bomb
        return WEAPON_PLAYABLE_DEFAULT | WEAPON_SPEED_FAST | WEAPON_REACH_FAR | WEAPON_VATS_COST_ZERO | WEAPON_AUTOMATIC_ENABLED;
    case 0x000DF621://Fire Hydrant Bat
        return WEAPON_PLAYABLE_DEFAULT | WEAPON_SPEED_FAST | WEAPON_REACH_FAR | WEAPON_VATS_COST_ZERO | WEAPON_AUTOMATIC_ENABLED;
    case 0x000D1EB0://Gauss Rifle
        WEAPON_HOLD_TO_FIRE_DISABLED | WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0010FAA7://Salvaged Assaultron Head
        WEAPON_CHARGING_DISABLED | WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST;
    case 0x0012DBB3://Pump Action Shotgun
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x001025AC://Flare Gun
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x00004822://10mm Pistol
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x00113854://Handmade Rifle
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x000BD56F://Fat Man
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x0046D2A1://The Fixer
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x000FE268://Railway Rifle
        return WEAPON_SWAY_ZERO | WEAPON_RECOIL_ZERO | WEAPON_SPREAD_ZERO | WEAPON_RELOAD_SPEED_FAST | WEAPON_VATS_COST_ZERO | WEAPON_SPEED_FAST | WEAPON_AUTOMATIC_ENABLED;
    case 0x0005C250://Board
        return WEAPON_SPEED_FAST | WEAPON_REACH_FAR | WEAPON_VATS_COST_ZERO | WEAPON_AUTOMATIC_ENABLED;
    case 0x0030CB79://Vorpal (Do not remove or edit)
        return WEAPON_VORPAL;
    default:
        return WEAPON_INVALID;
    }
}

bool EditWeapon(HANDLE pHandle, DWORD64 WeaponPtr, DWORD64 *EquipTypePtr, DWORD64 *KeywordPtr, bool Vorpal)
{
    class Weapon
    {
    public:
        char PaddingA[0x20];
        DWORD Formid;//0x20
        char PaddingB[0x12C];
        DWORD64 EquipTypePtrA;//0x150
        char PaddingC[0x68];
        DWORD64 KeywordArrayPtr;//0x1C0
        DWORD KeywordArraySize;//0x1C8
        char PaddingD[0xC4];
        DWORD64 AmmoPtr;//0x290
        DWORD64 EquipTypePtrB;//0x298
        char PaddingE[0x10];
        DWORD64 AimModelPtr;//0x2B0
        char PaddingF[0x10];
        DWORD64 WeaponMiscPtr;//0x2C8
        char PaddingG[0x2C];
        float ReloadSpeed;//0x2FC
        char PaddingH[0x4];
        float Speed;//0x304
        float Reach;//0x308
        char PaddingI[0x2C];
        float ActionPointCost;//0x338
        float FullPowerSeconds;//0x33C
        float MinPowerPerShot;//0x340
        char PaddingJ[0x1C];
        BYTE FlagA;//0x360
        BYTE FlagB;//0x361
        BYTE FlagC;//0x362
        BYTE FlagD;//0x363
        char PaddingK[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
    };

    class WeaponMisc
    {
    public:
        char PaddingA[0x34];
        BYTE ProjectileCount;
    };

    class Keyword
    {
    public:
        char PaddingA[0x20];
        DWORD Formid;//0x20
    };

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

    LONG Result = GetWeaponFlags(WeaponData.Formid);

    if (Result & WEAPON_INVALID)
    {
        return false;
    }

    if (Vorpal)
    {
        if (Result & WEAPON_VORPAL)
        {
            *EquipTypePtr = WeaponData.EquipTypePtrA;
            if (!Valid(WeaponData.KeywordArrayPtr) || WeaponData.KeywordArraySize == 0) return true;

            DWORD64 *KeywordArray = new DWORD64[WeaponData.KeywordArraySize];
            if (!RPM(pHandle, WeaponData.KeywordArrayPtr, &*KeywordArray, WeaponData.KeywordArraySize * sizeof(DWORD64)))
            {
                delete[]KeywordArray;
                return true;
            }

            for (DWORD i = 0; i < WeaponData.KeywordArraySize; i++)
            {
                Keyword KeywordData;
                if (!RPM(pHandle, KeywordArray[i], &KeywordData, sizeof(KeywordData))) continue;
                if (KeywordData.Formid != 0x0004C7EA) continue;
                *KeywordPtr = KeywordArray[i];
                break;
            }

            delete[]KeywordArray;
            return true;
        }
        else return false;
    }

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

    if (Result & WEAPON_PLAYABLE_RANGED)
    {
        if (Valid(*EquipTypePtr))
        {
            WeaponData.EquipTypePtrA = *EquipTypePtr;
            WeaponData.EquipTypePtrB = *EquipTypePtr;
        }

        if (!Valid(WeaponData.KeywordArrayPtr) && WeaponData.KeywordArraySize == 0)
        {
            WeaponData.KeywordArrayPtr = AllocEx(pHandle, 0x1000);
            if (Valid(WeaponData.KeywordArrayPtr)) WeaponData.KeywordArraySize = 1;
        }

        if (Valid(*KeywordPtr) && Valid(WeaponData.KeywordArrayPtr) && WeaponData.KeywordArraySize > 0)
        {
            DWORD64 *KeywordArray = new DWORD64[WeaponData.KeywordArraySize];
            for (DWORD i = 0; i < WeaponData.KeywordArraySize; i++) KeywordArray[i] = 0;
            KeywordArray[0] = *KeywordPtr;

            if (WPM(pHandle, WeaponData.KeywordArrayPtr, &*KeywordArray, WeaponData.KeywordArraySize * sizeof(DWORD64)))
            {
                WeaponData.KeywordArraySize = 1;
            }

            delete[]KeywordArray;
        }

        if (((WeaponData.FlagC >> 1) & 1) == 1) WeaponData.FlagC &= ~(1 << 1);
        if (((WeaponData.FlagC >> 4) & 1) == 1) WeaponData.FlagC &= ~(1 << 4);

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

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

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

    if (Result & WEAPON_RELOAD_SPEED_FAST)
    {
        if (WeaponData.ReloadSpeed != 100.0f) WeaponData.ReloadSpeed = 100.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_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_PROJECTILES_ONE)
    {
        if (Valid(WeaponData.WeaponMiscPtr))
        {
            WeaponMisc WeaponMiscData;
            if (RPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData)))
            {
                if (WeaponMiscData.ProjectileCount != 1) WeaponMiscData.ProjectileCount = 1;
                WPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData));
            }
        }
    }

    if (Result & WEAPON_PROJECTILES_TEN)
    {
        if (Valid(WeaponData.WeaponMiscPtr))
        {
            WeaponMisc WeaponMiscData;
            if (RPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData)))
            {
                if (WeaponMiscData.ProjectileCount != 10) WeaponMiscData.ProjectileCount = 10;
                WPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData));
            }
        }
    }

    if (Result & WEAPON_PROJECTILES_MAX)
    {
        if (Valid(WeaponData.WeaponMiscPtr))
        {
            WeaponMisc WeaponMiscData;
            if (RPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData)))
            {
                if (WeaponMiscData.ProjectileCount != MAXBYTE) WeaponMiscData.ProjectileCount = MAXBYTE;
                WPM(pHandle, WeaponData.WeaponMiscPtr, &WeaponMiscData, sizeof(WeaponMiscData));
            }
        }
    }

    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(pHandle, 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(pHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData));
            }
        }
    }

    if (Result & WEAPON_SPREAD_ZERO)
    {
        if (Valid(WeaponData.AimModelPtr))
        {
            AimModel AimModelData;
            if (RPM(pHandle, 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(pHandle, WeaponData.AimModelPtr, &AimModelData, sizeof(AimModelData));
            }
        }
    }

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

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

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

    WeaponList WeaponListData;
    if (!RPM(pHandle, 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(pHandle, WeaponListData.List, &*WeaponPtr, WeaponListData.Size * sizeof(DWORD64)))
    {
        delete[]WeaponPtr;
        return false;
    }

    DWORD64 EquipTypePtr = 0;
    DWORD64 KeywordPtr = 0;

    for (DWORD i = 0; i < WeaponListData.Size; i++)
    {
        if (!Valid(WeaponPtr[i])) continue;
        if (EditWeapon(pHandle, WeaponPtr[i], &EquipTypePtr, &KeywordPtr, true)) break;
    }

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

    delete[]WeaponPtr;
    return true;
}

void ProcessMain(ProcessData pData)
{
    IterateWeapons(pData.pHandle, DWORD64(pData.mBase));
}

DWORD GetSigOffset(HANDLE pHandle, DWORD64 mBase, DWORD mSize, BYTE *Sig, const char *Mask, int Len)
{
    DWORD SigOffset = 0;
    BYTE *ModuleArray = new BYTE[mSize];

    if (ReadProcessMemory(pHandle, (void*)(mBase), &*ModuleArray, mSize, NULL))
    {
        for (DWORD i = 0; i < mSize; i++)
        {
            if (i + Len >= mSize) break;
            for (int c = 0; c < Len; c++)
            {
                if (ModuleArray[i + c] != Sig[c] && Mask[c] != '?') break;
                if (c == Len - 1)
                {
                    delete[]ModuleArray;
                    return i;
                }
            }
        }
    }

    delete[]ModuleArray;
    return SigOffset;
}

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

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

DWORD64 AllocEx(HANDLE pHandle, size_t Size)
{
    return DWORD64(VirtualAllocEx(pHandle, NULL, Size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE));
}

bool FreeEx(HANDLE pHandle, DWORD64 src)
{
    return VirtualFreeEx(pHandle, LPVOID(src), 0, MEM_RELEASE);
}

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

bool GetModuleData(ProcessData *pData)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pData->pPid);
    if (hSnapshot == INVALID_HANDLE_VALUE) return false;

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

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

    CloseHandle(hSnapshot);
    return false;
}

int GetProcessData(ProcessData *BaseData, ProcessData *pData = nullptr, int pCount = 0)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    if (hSnapshot == INVALID_HANDLE_VALUE) return 0;

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

    int ProcessCount = 0;
    while (Process32Next(hSnapshot, &lppe))
    {
        if (!strcmp(lppe.szExeFile, BaseData->pName))
        {
            if (pData != nullptr && pCount > 0 && ProcessCount < pCount)
            {
                pData[ProcessCount].pPid = lppe.th32ProcessID;
            }

            ProcessCount++;
        }
    }

    CloseHandle(hSnapshot);
    return ProcessCount;
}

int main()
{
    ProcessData BaseData;
    BaseData.pName = (CHAR*)("Fallout76.exe");//Process
    BaseData.mName = (CHAR*)("Fallout76.exe");//Module

    int pCount = GetProcessData(&BaseData);
    if (pCount == 0) return 1;

    ProcessData *pData = new ProcessData[pCount];
    for (int i = 0; i < pCount; i++) memcpy(&pData[i], &BaseData, sizeof(ProcessData));

    if (GetProcessData(&BaseData, pData, pCount) != pCount)
    {
        delete[]pData;
        return 2;
    }

    int Index = 0;
    if (pCount > 1)
    {
        for (int i = 0; i < pCount; i++)
        {
            printf("%08lX - %s - Index: %d\n", pData[i].pPid, pData[i].pName, i + 1);
        }

        printf("Enter target process index: ");
        std::cin >> Index;
        printf("--------------------------------\n");

        if (Index == 0 || Index > pCount)
        {
            delete[]pData;
            return 3;
        }
        else
        {
            Index--;
        }
    }

    if (!GetModuleData(&pData[Index]))
    {
        delete[]pData;
        return 4;
    }

    pData[Index].pHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pData[Index].pPid);
    if (pData[Index].pHandle == NULL)
    {
        delete[]pData;
        return 5;
    }

    ProcessMain(pData[Index]);

    CloseHandle(pData[Index].pHandle);
    delete[]pData;
    return 0;
}