WELCOME TO INFOCHEATS.NET

INFOCHEATS is a community-driven platform focused on free game cheats, cheat development, and verified commercial software for a wide range of popular games. We provide a large collection of free cheats shared by the community. All public releases are checked for malicious code to reduce the risk of viruses, malware, or unwanted software before users interact with them.

Alongside free content, INFOCHEATS hosts an active marketplace with many independent sellers offering commercial cheats. Each product is discussed openly, with user feedback, reviews, and real usage experience available to help you make informed decisions before purchasing.

Whether you are looking for free cheats, exploring paid solutions, comparing sellers, or studying how cheats are developed and tested, INFOCHEATS brings everything together in one place — transparently and community-driven.

exi

Well-known member
Administrator

exi

Well-known member
Administrator
Status
Offline
Joined
Oct 22, 2024
Messages
1,089
Reaction score
152
In this topic I provide external auto offset finder for pubg mobile. Author of parser: pooya7831.

8FVmVZv.jpeg

What is the game Pubg Mobile?

Pubg Mobile is the mobile version of one of the most popular battle royales. Here like on PC you need to jump out of the plane, loot with 3 helmet and backpack, take two slots with attachments and take TOP-1. And for those who want to get the cherished inscription "winner-winner chicken dinner!" this article is written, because here I publish software helping writing cheat for Playerunknown Battlegrounds Mobile.


What do cheats do on Pubg?

Like in most other online games, cheats on pubg have more or less the same functionality, consisting of aimbot, vch and misk functions. In aimbot mostly you can set the radius of aiming, its speed and the part of body to aim at, also enable recoil control. In valhack distance, showing names, health are set. In other settings you can find disabling recoil and spread and other exploits, but I do not recommend using them, because they often get banned.


What are offsets and what are they needed for?

Offsets are needed so that cheat, created for mobile, works with every update. This software helps quickly and without external help update offsets and continue playing with the latest update.


How to use?
  1. Compile the application (build the build in x64 release);
  2. Go to the release folder;
  3. Open SDK in the application (using cmd or drag the SDK file into the application);
  4. Enter the name;
  5. Done.

C++ source code (source):
C++:
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <string>
#include <regex>

using namespace std;


void FindSdkOffset(const string& SdkPath, const string& ClassName, const string& SearchString, vector<string>& results, string VarName) {
    ifstream file(SdkPath, ios::binary);
    if (!file) {
        cout << "Error opening file: " << SdkPath << endl;
        return;
    }

    bool ClassNameFound = false;

    string line;
    while (getline(file, line)) {

        if (!ClassNameFound && line.find(ClassName) != string::npos) {
            ClassNameFound = true;
            continue;
        }

        if (ClassNameFound && line.find(SearchString) != string::npos) {
            std::regex offsetRegex("Offset: (0x[0-9a-fA-F]+),");
            std::smatch offsetMatch;

            if (std::regex_search(line, offsetMatch, offsetRegex)) {
                if (offsetMatch.size() == 2) {
                    std::string offsetValue = "const uintptr_t " + VarName + " = " + offsetMatch[1].str() + ";";
                    results.push_back(offsetValue);
                }
                else {
                    std::cout << "Invalid offset match." << std::endl;
                }
            }
            else {
                std::cout << "Offset not found in the input string." << std::endl;
            }

            break;
        }
    }

    file.close();
}
int main(int argc, const char* argv[]) {
    string SdkPath = argv[1];
    string ClassName_1 = "Class: StaticMeshComponent.MeshComponent.PrimitiveComponent.SceneComponent.ActorComponent.Object";
    string SearchString_1 = "int NoneAIGameTime;//[Offset:";
    vector<string> results_1;
    FindSdkOffset(SdkPath, ClassName_1, SearchString_1, results_1, "MinLOD");


    std::vector<std::tuple<std::string, std::string, std::string>> formats = {
        {"Class: World.Object", "GameStateBase* GameState;//[Offset:", "GameState"},
        {"Class: STExtraGameStateBase.UAEGameState.LuaGameState.GameState.GameStateBase.Info.Actor.Object", "int AlivePlayerNum;//[Offset:", "AlivePlayerNum"},
        {"Class: GameState.GameStateBase.Info.Actor.Object", "int ElapsedTime;//[Offset:", "ElapsedTime"},
        {"", "int NoneAIGameTime;//[Offset: ", "NoneAIGameTime"},
        {"", "int PlayerNum;//[Offset:", "PlayerNum"},
        {"", "int PlayerNum;//[Offset:", "RealPlayerNum"},
        {"", "int AliveTeamNum;//[Offset:", "AliveTeamNum"},
        {"Class: STExtraGameStateBase.UAEGameState.LuaGameState.GameState.GameStateBase.Info.Actor.Object", "int PlayerNumPerTeam;//[Offset:", "PlayerNumPerTeam"},
        {"Class: STExtraGameStateBase.UAEGameState.LuaGameState.GameState.GameStateBase.Info.Actor.Object", "FString GameModeID;//[Offset: ", "GameModeID"},
        {"", "int CurCircleWave;//[Offset: ", "CurCircleWave"},
        {"", "int GameReplayType;//[Offset:", "GameReplayType"},

        {"lass: Pawn.Actor.Object", "PlayerState* PlayerState;//[Offset:", "PlayerState"},
        {"Class: UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "int Kills;//[Offset:", "PlayerKills"},
        {"Class: UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "FString Nation;//[Offset:", "PlayerNation"},
        {"Class: UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "int TeamID;//[Offset:", "PlayerTeamID"},
        {"Class: UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "int PlayerLevel;//[Offset:", "PlayerLevel"},
        {"Class: UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "FString PlayerUID;//[Offset:", "PlayerPlayerUID"},

        {"Class: PlayerState.Info.Actor.Object", "FString PlayerName;//[Offset:", "PlayerName"},
        {"Class: STExtraPlayerState.UAEPlayerState.LuaPlayerState.PlayerState.Info.Actor.Object", "float PlayerHealth;//[Offset:", "PlayerHealth"},



        {"Class: World.Object", "Level* PersistentLevel;//[Offset:", "PersistentLevel"},
        {"Class: World.Object", "NetDriver* NetDriver;//[Offset:", "NetDriver"},
        {"", "NetConnection* ServerConnection;//[Offset:", "ServerConnection"},
        {"Class: Player.Object", "PlayerController* PlayerController;//[Offset", "PlayerController"},
        {"", "Pawn* AcknowledgedPawn;//[Offset:", "AcknowledgedPawn"},
        {"", "SceneComponent* RootComponent;//[Offset:", "RootComponent"},

        {"Class: STExtraCharacter.UAECharacter.Character.Pawn.Actor.Object", "uint64 CurrentStates;//[Offset:", "CurrentStates"},
        {"Class: CharacterMovementComponent.PawnMovementComponent.NavMovementComponent.MovementComponent.ActorComponent.Object", "Vector LastUpdateVelocity;//[Offset:", "LastUpdateVelocity"},
        {"Class: UAECharacter.Character.Pawn.Actor.Object", "int TeamID;//[Offset: ", "TeamId"},
        {"Class: UAECharacter.Character.Pawn.Actor.Object", "bool bEnsure;", "IsBot"},
        {"Class: UAECharacter.Character.Pawn.Actor.Object", "FString PlayerName;//[Offset:", "Name"},
        {"Class: UAECharacter.Character.Pawn.Actor.Object", "FString Nation;//[Offset: ", "Nation"},
        {"STExtraCharacter.UAECharacter.Character.Pawn.Actor.Object", "bool bDead;//(ByteOffset: 0, ByteMask: 1, FieldMask: 1)[Offset:", "IsDead"},
        {"", "FString PlayerUID;//[Offset:", "PlayerUID"},
        {"Class: STExtraCharacter.UAECharacter.Character.Pawn.Actor.Object", "float Health;//[Offset:", "Health"},
        {"Class: STExtraCharacter.UAECharacter.Character.Pawn.Actor.Object", "float HealthMax;//[Offset:", "HealthMax"},
        {"", "float NearDeathBreath;//[Offset: ", "NearDeathBreath"},
        {"", "STCharacterNearDeathComp* NearDeatchComponent;//[Offset:", "NearDeatchComponent"},
        {"", "float BreathMax;//[Offset:", "BreathMax"},

        {"Class: Controller.Actor.Object", "Rotator ControlRotation;//[Offset: ", "ControlRotation"},
        {"Class: SceneComponent.ActorComponent.Object", "Vector ComponentVelocity;//[Offset:", "ComponentVelocity"},
        {"Class: STExtraCharacter.UAECharacter.Character", "STExtraVehicleBase* CurrentVehicle;//[Offset:", "CurrentVehicle"},
        {"Class: Actor.Object", "RepMovement ReplicatedMovement;//[Offset:", "ReplicatedMovement"},

        {"Class: SceneComponent.ActorComponent.Object", "Vector RelativeLocation;//[Offset:", "RelativeLocation"},
        {"Class: SceneComponent.ActorComponent.Object", "Rotator RelativeRotation;//[Offset:", "RelativeRotation"},

        {"Character.Pawn.Actor.Object", "SkeletalMeshComponent* Mesh;//[Offset:", "Mesh"},
        {"Class: WeaponMeshCfg", "enum meshType;//[Offset", "BodyAddv"},
        {"Class: StaticMeshComponent.MeshComponent.PrimitiveComponent.SceneComponent.ActorComponent.Object", "int MinLOD;//[Offset: ", "MinLOD"},

        {"", "STExtraWeapon* CurrentWeaponReplicated;//[Offset:", "CurrentWeaponReplicated"},
        {"", "CharacterWeaponManagerComponent* WeaponManagerComponent;", "WeaponManagerComponent"},

        {"", "STExtraWeapon* CurrentReloadWeapon;//[Offset:", "CurrentReloadWeapon"},
        // {"", "", "CurrentWeapon"},
        {"", "STExtraShootWeaponComponent* ShootWeaponComponent;//[Offset: ", "ShootWeaponComponent"},
        {"Class: STExtraShootWeaponComponent.WeaponLogicBaseComponent.ActorComponent.Object", "STExtraShootWeapon* OwnerShootWeapon;//[Offset: ", "OwnerShootWeapon"},
        {"Class: STExtraShootWeapon.STExtraWeapon.LuaActor.Actor.Object", "int CurBulletNumInClip;//[Offset:", "CurBulletNumInClip"},
        {"Class: STExtraShootWeapon.STExtraWeapon.LuaActor.Actor.Object", "int CurMaxBulletNumInOneClip;//[Offset:", "CurMaxBulletNumInOneClip"},
        {"", "ShootWeaponEntity* ShootWeaponEntityComp;//[Offset:", "ShootWeaponEntity"},
        {"", "ShootWeaponEffectComponent* ShootWeaponEffectComp;//[Offset:", "ShootWeaponEffectComp"},

        {"Class: ShootWeaponEffectComponent.WeaponEffectComponent.WeaponLogicBaseComponent.ActorComponent.Object", "float CameraShakeInnerRadius", "CameraShakeInnerRadius"},
        {"", "float CameraShakeOuterRadius;//[Offset: ", "CameraShakeOuterRadius"},
        {"", "float CameraShakFalloff;//[Offset:", "CameraShakFalloff"},
        {"", "CharacterOverrideAttrData[] CharacterOverrideAttrs;//[Offset:", "CharacterOverrideAttrs"},

        {"", "float BulletFireSpeed;//[Offset:", "BulletFireSpeed"},
        {"", "float BulletMomentum;//[Offset: ", "BulletMomentum"},
        {"", "float BulletRange;//[Offset:", "BulletRange"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float BaseImpactDamage;//[Offset:", "BaseImpactDamage"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float VehicleDamageScale;//[Offset:", "VehicleDamageScale"},
        {"Class: STExtraFlareGunBullet.Actor.Object", "float LaunchGravityScale;//[Offset: ", "LaunchGravityScale"},

        {"", "loat ShootInterval;//[Offset: ", "ShootInterval"},
        {"", "bool bHasSingleFireMode;//(ByteOffset: 0, ByteMask: 1, FieldMask: 255)[Offset:", "bHasSingleFireMode"},
        {"", "bool bHasAutoFireMode;//(ByteOffset: 0, ByteMask: 1, FieldMask: 255)[Offset:", "bHasAutoFireMode"},
        {"", "bool bHasBurstFireMode;//(ByteOffset: 0, ByteMask: 1, FieldMask: 255)[Offset:", "bHasBurstFireMode"},
        {"", "float BurstShootInterval;//[Offset:", "BurstShootInterval"},
        {"", "float ReloadRate;//[Offset:", "ReloadRate"},

        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float AccessoriesVRecoilFactor;//[Offset:", "AccessoriesVRecoilFactor"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float AccessoriesHRecoilFactor;//[Offset:", "AccessoriesHRecoilFactor"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float AccessoriesRecoveryFactor;//[Offset:", "AccessoriesRecoveryFactor"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float ShotGunCenterPerc;//[Offset:", "ShotGunCenterPerc"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float ShotGunVerticalSpread;//[Offset:", "ShotGunVerticalSpread"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float ShotGunHorizontalSpread;//[Offset:", "ShotGunHorizontalSpread"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float GameDeviationFactor;//[Offset:", "GameDeviationFactor"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float GameDeviationAccuracy;//[Offset:", "GameDeviationAccuracy"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float AccessoriesDeviationFactor;//[Offset:", "AccessoriesDeviationFactor"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float VehicleWeaponDeviationAngle;//[Offset:", "VehicleWeaponDeviationAngle"},
        {"Class: ShootWeaponEntity.WeaponEntity.WeaponLogicBaseComponent.ActorComponent.Object", "float RecoilKickADS;//[Offset:", "RecoilKickADS"},

        {"Class: VehicleCommonComponent.VehicleComponent.LuaActorComponent.ActorComponent.Object", "float HP;//[Offset:", "HP"},
        {"Class: VehicleCommonComponent.VehicleComponent.LuaActorComponent.ActorComponent.Object", "float HPMax;//[Offset: ", "HPMax"},
        {"Class: VehicleCommonComponent.VehicleComponent.LuaActorComponent.ActorComponent.Object", "float Fuel;//[Offset:", "Fuel"},
        {"Class: VehicleCommonComponent.VehicleComponent.LuaActorComponent.ActorComponent.Object", "float FuelMax;//[Offset:", "FuelMax"},
        {"Class: STExtraWheeledVehicle.STExtraVehicleBase.Pawn.Actor.Object", "STExtraVehicleMovementComponent4W* VehicleMovement;//[Offset: ", "VehicleMovement"},
        {"Class: STExtraVehicleBase.Pawn.Actor.Object", "VehicleCommonComponent* VehicleCommon;//[Offset:", "VehicleCommon"},
        {"Class: STExtraVehicleBase.Pawn.Actor.Object", "float lastForwardSpeed;//[Offset:", "lastForwardSpeed"},

        {"Class: PickUpListWrapperActor.PickUpWrapperActor.UAENetActor.LuaActor.Actor.Object", "PickUpItemData[] PickUpDataList;//[Offset:", "PickUpDataList"}, /////

        {"", "STExtraPlayerController* STPlayerController;//[Offset", "STPlayerController"},

        {"", "PlayerCameraManager* PlayerCameraManager;//[Offset:", "PlayerCameraManager"},
        {"", "HUD* MyHUD;//[Offset:", "MyHUD"},

        {"", "CameraCacheEntry CameraCache;//[Offset:", "CameraCache"},

        {"", "float ScopeFov;//[Offset: ", "ScopeFov"},
        {"", "CameraComponent* ScopeCameraComp;//[Offset:", "ScopeCameraComp"},
        {"", "bool IsFPPGameMode;//(ByteOffset: 0, ByteMask: 1, FieldMask: 255)[Offset:", "IsFPPGameMode"},
        {"", "HitPerformData HitPerform;//[Offset:", "HitPerform"},
        {"", "float SwitchWeaponSpeedScale;//[Offset:", "SwitchWeaponSpeedScale"},
        {"", "CharacterParachuteComponent* ParachuteComponent", "CharacterParachuteComponent"},
        {"", "CurrentFallSpeed;//[Offset:", "CurrentFallSpeed"},

    };



    if (!results_1.empty()) {
        string XXSDK_OUT;
        cout << "Enter the output file name: ";
        cin >> XXSDK_OUT;
        XXSDK_OUT =XXSDK_OUT + ".h";

        ofstream output(XXSDK_OUT);
        if (!output) {
            cerr << "Error creating output file." << endl;
            return 1;
        }


        for (const auto& format : formats) {
            vector<string> results_2;
            FindSdkOffset(SdkPath, std::get<0>(format), std::get<1>(format), results_2, std::get<2>(format));

            for (const string& result : results_2) {
                //output <<"//" << std::get<0>(format) << "\t -> \t" << std::get<1>(format) << endl;
                output << result  << endl /*<< endl*/;
            }
        }

        output.close();

        cout << "Results saved to: " << XXSDK_OUT << endl;
    }
    else {
        cout << "No results found" << endl;
    }
    system("pause");
}
 
Top