Open Source valo instalock src

eLwtx · 16 Mar 2026

alın beyler hayrına

C++:

namespace negrumdaddy
{
    namespace insta_lock_agents
    {
        uobject* astra = nullptr;
        uobject* breach = nullptr;
        uobject* brimstone = nullptr;
        uobject* chamber = nullptr;
        uobject* cypher = nullptr;
        uobject* fade = nullptr;
        uobject* jett = nullptr;
        uobject* kayo = nullptr;
        uobject* killjoy = nullptr;
        uobject* neon = nullptr;
        uobject* omen = nullptr;
        uobject* phoenix = nullptr;
        uobject* raze = nullptr;
        uobject* reyna = nullptr;
        uobject* sage = nullptr;
        uobject* skye = nullptr;
        uobject* sova = nullptr;
        uobject* viper = nullptr;
        uobject* yoru = nullptr;
        uobject* gekko = nullptr;
 
        void run()
        {
            auto enc_astra = Encrypt(L"Default__Rift_PrimaryAsset_C");
            astra = uobject::find_object(enc_astra.decrypt(), reinterpret_cast<uobject*>(-1)), enc_astra.clear();
 
            auto enc_breach = Encrypt(L"Default__Breach_PrimaryAsset_C");
            breach = uobject::find_object(enc_breach.decrypt(), reinterpret_cast<uobject*>(-1)), enc_breach.clear();
 
            auto enc_brimstone = Encrypt(L"Default__Sarge_PrimaryAsset_C");
            brimstone = uobject::find_object(enc_brimstone.decrypt(), reinterpret_cast<uobject*>(-1)), enc_brimstone.clear();
 
            auto enc_chamber = Encrypt(L"Default__Deadeye_PrimaryAsset_C");
            chamber = uobject::find_object(enc_chamber.decrypt(), reinterpret_cast<uobject*>(-1)), enc_chamber.clear();
 
            auto enc_cypher = Encrypt(L"Default__Gumshoe_PrimaryAsset_C");
            cypher = uobject::find_object(enc_cypher.decrypt(), reinterpret_cast<uobject*>(-1)), enc_cypher.clear();
 
            auto enc_fade = Encrypt(L"Default__BountyHunter_PrimaryAsset_C");
            fade = uobject::find_object(enc_fade.decrypt(), reinterpret_cast<uobject*>(-1)), enc_fade.clear();
 
            auto enc_jett = Encrypt(L"Default__Wushu_PrimaryAsset_C");
            jett = uobject::find_object(enc_jett.decrypt(), reinterpret_cast<uobject*>(-1)), enc_jett.clear();
 
            auto enc_kayo = Encrypt(L"Default__Grenadier_PrimaryAsset_C");
            kayo = uobject::find_object(enc_kayo.decrypt(), reinterpret_cast<uobject*>(-1)), enc_kayo.clear();
 
            auto enc_killjoy = Encrypt(L"Default__Killjoy_PrimaryAsset_C");
            killjoy = uobject::find_object(enc_killjoy.decrypt(), reinterpret_cast<uobject*>(-1)), enc_killjoy.clear();
 
            auto enc_neon = Encrypt(L"Default__Sprinter_PrimaryAsset_C");
            neon = uobject::find_object(enc_neon.decrypt(), reinterpret_cast<uobject*>(-1)), enc_neon.clear();
 
            auto enc_omen = Encrypt(L"Default__Wraith_PrimaryAsset_C");
            omen = uobject::find_object(enc_omen.decrypt(), reinterpret_cast<uobject*>(-1)), enc_omen.clear();
 
            auto enc_phoenix = Encrypt(L"Default__Phoenix_PrimaryAsset_C");
            phoenix = uobject::find_object(enc_phoenix.decrypt(), reinterpret_cast<uobject*>(-1)), enc_phoenix.clear();
 
            auto enc_raze = Encrypt(L"Default__Clay_PrimaryAsset_C");
            raze = uobject::find_object(enc_raze.decrypt(), reinterpret_cast<uobject*>(-1)), enc_raze.clear();
 
            auto enc_reyna = Encrypt(L"Default__Vampire_PrimaryAsset_C");
            reyna = uobject::find_object(enc_reyna.decrypt(), reinterpret_cast<uobject*>(-1)), enc_reyna.clear();
 
            auto enc_sage = Encrypt(L"Default__Thorne_PrimaryAsset_C");
            sage = uobject::find_object(enc_sage.decrypt(), reinterpret_cast<uobject*>(-1)), enc_sage.clear();
 
            auto enc_skye = Encrypt(L"Default__guide_PrimaryAsset_C");
            skye = uobject::find_object(enc_skye.decrypt(), reinterpret_cast<uobject*>(-1)), enc_skye.clear();
 
            auto enc_sova = Encrypt(L"Default__Hunter_PrimaryAsset_C");
            sova = uobject::find_object(enc_sova.decrypt(), reinterpret_cast<uobject*>(-1)), enc_sova.clear();
 
            auto enc_viper = Encrypt(L"Default__Pandemic_PrimaryAsset_C");
            viper = uobject::find_object(enc_viper.decrypt(), reinterpret_cast<uobject*>(-1)), enc_viper.clear();
 
            auto enc_yoru = Encrypt(L"Default__Stealth_PrimaryAsset_C");
            yoru = uobject::find_object(enc_yoru.decrypt(), reinterpret_cast<uobject*>(-1)), enc_yoru.clear();
 
            auto enc_gekko = Encrypt(L"Default__AggroBot_PrimaryAsset_C");
            gekko = uobject::find_object(enc_gekko.decrypt(), reinterpret_cast<uobject*>(-1)), enc_gekko.clear();
        }
 
        uobject* get_agent_object(int id)
        {
            if (id == 0) return astra;
            else if (id == 1) return breach;
            else if (id == 2) return brimstone;
            else if (id == 3) return chamber;
            else if (id == 4) return cypher;
            else if (id == 5) return fade;
            else if (id == 6) return jett;
            else if (id == 7) return kayo;
            else if (id == 8) return killjoy;
            else if (id == 9) return neon;
            else if (id == 10) return omen;
            else if (id == 11) return phoenix;
            else if (id == 12) return raze;
            else if (id == 13) return reyna;
            else if (id == 14) return sage;
            else if (id == 15) return skye;
            else if (id == 16) return sova;
            else if (id == 17) return viper;
            else if (id == 18) return yoru;
            else if (id == 19) return gekko;
            else return nullptr;
        }
    }
 
    namespace insta_lock
    {
        int old_time = NULL;
        int agent_counter = 0;
 
        void agent_roulette(controller* controller) {
            auto _class = find_obj(L"ShooterGame.PregamePlayerController");
            if (math::class_is_child_of(controller->class_private, _class))
                if (pregame_view_controller* pregame_view_controller = controller->get_pregame_view_controller())
                    if (pregame_view_model* pregame_view_model = pregame_view_controller->get_pregame_view_model())
                        if (!pregame_view_model->is_local_player_locked_in())
                        {
                            if (!old_time) old_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
                            int current_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
 
                            if (current_time > old_time)
                            {
                                old_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() + 50;
                                pregame_view_controller->select_character(insta_lock_agents::get_agent_object(agent_counter));
 
                                agent_counter++;
                                if (agent_counter >= 20)
                                    agent_counter = 0;
 
                            }
                        }
                        else if (global::misc::config.bRandomAgent == true)
                            global::misc::config.bRandomAgent = false;
        }
 
        void run(controller* controller)
        {
            if (global::misc::config.bRandomAgent)
                agent_roulette(controller);
 
            if (global::misc::config.bInstaLock) {
                auto _class = find_obj(L"ShooterGame.PregamePlayerController");
                if (math::class_is_child_of(controller->class_private, _class))
                    if (pregame_view_controller* pregame_view_controller = controller->get_pregame_view_controller())
                        if (pregame_view_model* pregame_view_model = pregame_view_controller->get_pregame_view_model())
                            if (!pregame_view_model->is_local_player_locked_in())
                                if (insta_lock_agents::get_agent_object(global::misc::config.iInstaLockAgent))
                                {
                                    pregame_view_controller->lock_character(insta_lock_agents::get_agent_object(global::misc::config.iInstaLockAgent));
                                    global::misc::config.bInstaLock = false;
                                }
 
            }
        }
    }
}

sdk:

C++:

            class pregame_view_model : public uobject {
            public:
                bool is_local_player_locked_in()
                {
                    uobject* function = find_obj(L"ShooterGame.PregameViewModel.IsLocalPlayerLockedIn");
 
                    if (function == nullptr)
                        return false;
 
                    struct
                    {
                        bool return_value;
                    } params;
 
                    this->process_event(function, &params);
 
                    return params.return_value;
                }
            };
 
            class pregame_view_controller : public uobject {
            public:
                pregame_view_model* get_pregame_view_model() {
                    uobject* function = find_obj(L"ShooterGame.PregameViewController.GetViewModel");
 
                    if (function == nullptr)
                        return nullptr;
 
                    struct
                    {
                        pregame_view_model* return_value;
                    } params;
 
                    this->process_event(function, &params);
 
                    return params.return_value;
                }
 
                void lock_character(uobject* agent)
                {
                    uobject* function = find_obj(L"ShooterGame.PregameViewController.LockCharacter");
 
                    if (function == nullptr)
                        return;
 
                    struct
                    {
                        uobject* agent;
                    } params = { agent };
 
                    this->process_event(function, &params);
                }
 
                void select_character(uobject* agent)
                {
                    uobject* function = find_obj(L"ShooterGame.PregameViewController.SelectCharacter");
 
                    if (function == nullptr)
                        return;
 
                    struct
                    {
                        uobject* agent;
                    } params = { agent };
 
                    this->process_event(function, &params);
                }
            };

CloneEgiht · 16 Mar 2026

kodu yazan ellerin dert görmesin

eLwtx · 16 Mar 2026

CloneEgiht' Alıntı:
kodu yazan ellerin dert görmesin

DIABL0 · 16 Mar 2026

workmu wiewmodel lazım sasy

Fl3uur · 16 Mar 2026

Yaw bisey dicem amacim bos muhabbet yapıp kufur yemek degilde su profil fotoğrafını nasıl ayarlayacam yardimci olur musunuz bürodaydım denk geldi oyle yazdım lutfen yardımcı olun

eLwtx · 16 Mar 2026

SALVADO' Alıntı:
workmu wiewmodel lazım sasy

DIABL0 · 16 Mar 2026

eLwtx' Alıntı:

wide da olur

eLwtx · 16 Mar 2026

Fl3uur' Alıntı:
Yaw bisey dicem amacim bos muhabbet yapıp kufur yemek degilde su profil fotoğrafını nasıl ayarlayacam yardimci olur musunuz bürodaydım denk geldi oyle yazdım lutfen yardımcı olun

belirli bi mesaja ulaşıp hesabını yeni açılmışdan çıkarman lazım konu bile açamazsın şuan

zxro · 16 Mar 2026

SALVADO' Alıntı:
workmu wiewmodel lazım sasy

#pragma pack(push, 1)
union fp_flag_store {
unsigned char raw;
struct {
unsigned char f0 : 1;
unsigned char f1 : 1;
unsigned char f2 : 6;
} bits;
};
#pragma pack(pop)
struct ViewModelCache {
uskeletalmeshcomponent* mesh1p = nullptr;
uskeletalmeshcomponent* overlayMesh = nullptr;
uskeletalmeshcomponent* weaponMesh1P = nullptr;
uskeletalmeshcomponent* cosmeticMesh1P = nullptr;
uskeletalmeshcomponent* meleeMesh1P = nullptr;
uskeletalmeshcomponent* offHandMesh = nullptr;
currentequippable* lastWeapon = nullptr;
currentequippable* lastMelee = nullptr;
ULONGLONG lastCacheTime = 0;
void Clear() {
mesh1p = overlayMesh = weaponMesh1P = cosmeticMesh1P = nullptr;
meleeMesh1P = offHandMesh = nullptr;
lastWeapon = lastMelee = nullptr;
}
bool IsValid() const {
return mesh1p != nullptr && weaponMesh1P != nullptr;
}
};
inline bool IsValidViewModelPointer(uintptr_t ptr) {
if (ptr == 0 || ptr == (uintptr_t)-1 || ptr < 0x10000 || ptr > 0x7FFFFFFFFFFF) {
return false;
}
__try {
volatile unsigned char test = *(unsigned char*)ptr;
(void)test;
return true;
}
__except (EXCEPTION_EXECUTE_HANDLER) {
return false;
}
}
inline bool IsValidViewModelObject(void* obj) {
if (!obj) return false;
return IsValidViewModelPointer((uintptr_t)obj);
}
inline tarray<USceneComponent*> GetChildrenComponents(USceneComponent* component, bool bIncludeAllDescendants) {
tarray<USceneComponent*> result;
if (!component || !IsValidViewModelObject(component)) return result;
static uobject* Function = nullptr;
if (!Function) {
auto function_name = (L"Engine.SceneComponent.GetChildrenComponents");
Function = uobject::find_object<uobject*>(function_name);
}
if (!Function || !IsValidViewModelObject(Function)) return result;
struct {
bool bIncludeAllDescendants;
tarray<USceneComponent*> Children;
} Args;
Args.bIncludeAllDescendants = bIncludeAllDescendants;
Args.Children.data = nullptr;
Args.Children.count = 0;
Args.Children.maxCount = 0;
__try {
component->process_event(Function, &Args);
return Args.Children;
}
__except (EXCEPTION_EXECUTE_HANDLER) {
return result;
}
}
currentequippable* GetLocalMeleeWeapon() {
static currentequippable* CachedMelee = nullptr;
static ULONGLONG lastCacheTime = 0;
ULONGLONG currentTime = GetTickCount64();
if (CachedMelee && (currentTime - lastCacheTime) < 2000) {
return CachedMelee;
}
CachedMelee = nullptr;
if (!UWorldSave) return nullptr;
tarray<AGameObject*> Objects;
GameplayStatics::GetAllActorsOfClass2(UWorldSave, Class::Actors(), &Objects);
for (int i = 0; i < Objects.size(); ++i) {
AGameObject* Object = Objects;
[*] if (!Object) continue;
[*]
[*] auto name = system::get_object_name(Object);
[*] if (!name.is_valid()) continue;
[*]
[*] std::string name_str = name.ToString();
[*] if (name_str.find("Ability_Melee_Base_C") != std::string::npos) {
[*] CachedMelee = (currentequippable*)Object;
[*] lastCacheTime = currentTime;
[*] return CachedMelee;
[*] }
[*] }
[*]
[*] return nullptr;
[*] }
[*]
[*] template<typename T>
[*] inline bool SafeRead(uintptr_t address, T& value) {
[*] if (!IsValidViewModelPointer(address)) return false;
[*]
[*] __try {
[*] value = *reinterpret_cast<T*>(address);
[*] return true;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return false;
[*] }
[*] }
[*]
[*] template<typename T>
[*] inline bool SafeWrite(uintptr_t address, const T& value) {
[*] if (!IsValidViewModelPointer(address)) return false;
[*]
[*] __try {
[*] *reinterpret_cast<T*>(address) = value;
[*] return true;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return false;
[*] }
[*] }
[*]
[*] inline bool SafeProcessFlag(uskeletalmeshcomponent* mesh, uintptr_t flag_offset, bool clear_flag) {
[*] if (!mesh || !IsValidViewModelObject(mesh)) return false;
[*]
[*] uintptr_t flag_addr = (uintptr_t)mesh + flag_offset;
[*] if (!IsValidViewModelPointer(flag_addr)) return false;
[*]
[*] fp_flag_store state;
[*] if (!SafeRead(flag_addr, state.raw)) return false;
[*]
[*] if (clear_flag) {
[*] state.bits.f0 = 0;
[*] return SafeWrite(flag_addr, state.raw);
[*] }
[*]
[*] return true;
[*] }
[*]
[*] inline void SafeLockDescendants(USceneComponent* component) {
[*] if (!component || !IsValidViewModelObject(component)) return;
[*]
[*] tarray<USceneComponent*> allChildren;
[*] __try {
[*] allChildren = GetChildrenComponents(component, true);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] for (int i = 0; i < allChildren.Num(); i++) {
[*] USceneComponent* child = allChildren;
[*] if (child && IsValidViewModelObject(child)) {
[*] uintptr_t child_flag_addr = (uintptr_t)child + 0x364;
[*] SafeWrite(child_flag_addr, (unsigned char)0x00);
[*] }
[*] }
[*] }
[*]
[*] inline void process_fp_mode(ashootercharacter* shooter) {
[*] if (!shooter) return;
[*]
[*] uintptr_t shooter_ptr = (uintptr_t)shooter;
[*] if (shooter_ptr == 0 || shooter_ptr == (uintptr_t)-1 || shooter_ptr < 0x10000 || shooter_ptr > 0x7FFFFFFFFFFF) {
[*] return;
[*] }
[*]
[*] __try {
[*] volatile uintptr_t test = *(uintptr_t*)shooter_ptr;
[*] (void)test;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] bool isAlive = false;
[*] __try {
[*] isAlive = shooter->is_alive();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] static ViewModelCache cache;
[*]
[*] if (!isAlive) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] static bool last_force_key_state = false;
[*] ULONGLONG current_time = GetTickCount64();
[*] bool force_key_pressed = GetAsyncKeyState(VK_F8) & 0x8000;
[*] bool force_reapply = force_key_pressed && !last_force_key_state;
[*] last_force_key_state = force_key_pressed;
[*]
[*] uinventory* inventory = nullptr;
[*] __try {
[*] inventory = shooter->get_inventory();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!inventory || !IsValidViewModelObject(inventory)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] currentequippable* weapon = nullptr;
[*] __try {
[*] weapon = inventory->get_current_equippable();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!weapon || !IsValidViewModelObject(weapon)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] bool needs_refresh = false;
[*] if (!cache.IsValid() ||
[*] weapon != cache.lastWeapon ||
[*] (current_time - cache.lastCacheTime) >= 2000 ||
[*] force_reapply) {
[*] needs_refresh = true;
[*] }
[*]
[*] if (needs_refresh) {
[*] cache.Clear();
[*] cache.lastCacheTime = current_time;
[*] cache.lastWeapon = weapon;
[*]
[*] __try {
[*] cache.mesh1p = shooter->getmesh1p();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!cache.mesh1p || !IsValidViewModelObject(cache.mesh1p)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] __try {
[*] cache.overlayMesh = shooter->GetOverlayMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {}
[*]
[*] __try {
[*] cache.weaponMesh1P = weapon->GetMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!cache.weaponMesh1P || !IsValidViewModelObject(cache.weaponMesh1P)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] uintptr_t cosmetic_ptr = (uintptr_t)weapon + 0x1188;
[*] if (IsValidViewModelPointer(cosmetic_ptr)) {
[*] __try {
[*] cache.cosmeticMesh1P = memory::read<uskeletalmeshcomponent*>(cosmetic_ptr);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {}
[*] }
[*]
[*] auto meleeWeapon = GetLocalMeleeWeapon();
[*] if (meleeWeapon && IsValidViewModelObject(meleeWeapon)) {
[*] cache.lastMelee = meleeWeapon;
[*]
[*] __try {
[*] cache.meleeMesh1P = meleeWeapon->GetMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.meleeMesh1P = nullptr;
[*] }
[*]
[*] if (cache.meleeMesh1P) {
[*] uintptr_t offhand_ptr = (uintptr_t)meleeWeapon + 0x1220;
[*] if (IsValidViewModelPointer(offhand_ptr)) {
[*] __try {
[*] cache.offHandMesh = memory::read<uskeletalmeshcomponent*>(offhand_ptr);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.offHandMesh = nullptr;
[*] }
[*] }
[*] }
[*] }
[*] }
[*]
[*] if (!cache.IsValid() || !cache.mesh1p || !cache.weaponMesh1P) {
[*] return;
[*] }
[*]
[*] const uintptr_t flag_offset = 0x364;
[*]
[*] bool should_process_flags = false;
[*] fp_flag_store main_state;
[*]
[*] uintptr_t mesh_flag_addr = (uintptr_t)cache.mesh1p + flag_offset;
[*] if (SafeRead(mesh_flag_addr, main_state.raw)) {
[*] should_process_flags = (main_state.bits.f0 != 0) || force_reapply;
[*] }
[*]
[*] if (should_process_flags) {
[*] SafeProcessFlag(cache.mesh1p, flag_offset, true);
[*]
[*] if (cache.overlayMesh && IsValidViewModelObject(cache.overlayMesh)) {
[*] SafeProcessFlag(cache.overlayMesh, flag_offset, true);
[*] }
[*]
[*] if (cache.weaponMesh1P && IsValidViewModelObject(cache.weaponMesh1P)) {
[*] SafeProcessFlag(cache.weaponMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.cosmeticMesh1P && IsValidViewModelObject(cache.cosmeticMesh1P)) {
[*] SafeProcessFlag(cache.cosmeticMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.meleeMesh1P && IsValidViewModelObject(cache.meleeMesh1P)) {
[*] SafeProcessFlag(cache.meleeMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.offHandMesh && IsValidViewModelObject(cache.offHandMesh)) {
[*] SafeProcessFlag(cache.offHandMesh, flag_offset, true);
[*] }
[*] }
[*]
[*] if (cache.mesh1p && IsValidViewModelObject(cache.mesh1p)) {
[*] SafeLockDescendants((USceneComponent*)cache.mesh1p);
[*] }
[*]
[*] if (cache.weaponMesh1P && IsValidViewModelObject(cache.weaponMesh1P)) {
[*] SafeLockDescendants((USceneComponent*)cache.weaponMesh1P);
[*] }
[*]
[*] if (cache.meleeMesh1P && IsValidViewModelObject(cache.meleeMesh1P)) {
[*] SafeLockDescendants((USceneComponent*)cache.meleeMesh1P);
[*] }
[*] }

DIABL0 · 16 Mar 2026

zxro' Alıntı:
#pragma pack(push, 1)

union fp_flag_store {

unsigned char raw;

struct {

unsigned char f0 : 1;

unsigned char f1 : 1;

unsigned char f2 : 6;

} bits;

};

#pragma pack(pop)

struct ViewModelCache {

uskeletalmeshcomponent* mesh1p = nullptr;

uskeletalmeshcomponent* overlayMesh = nullptr;

uskeletalmeshcomponent* weaponMesh1P = nullptr;

uskeletalmeshcomponent* cosmeticMesh1P = nullptr;

uskeletalmeshcomponent* meleeMesh1P = nullptr;

uskeletalmeshcomponent* offHandMesh = nullptr;

currentequippable* lastWeapon = nullptr;

currentequippable* lastMelee = nullptr;

ULONGLONG lastCacheTime = 0;

void Clear() {

mesh1p = overlayMesh = weaponMesh1P = cosmeticMesh1P = nullptr;

meleeMesh1P = offHandMesh = nullptr;

lastWeapon = lastMelee = nullptr;

}

bool IsValid() const {

return mesh1p != nullptr && weaponMesh1P != nullptr;

}

};

inline bool IsValidViewModelPointer(uintptr_t ptr) {

if (ptr == 0 || ptr == (uintptr_t)-1 || ptr < 0x10000 || ptr > 0x7FFFFFFFFFFF) {

return false;

}

__try {

volatile unsigned char test = *(unsigned char*)ptr;

(void)test;

return true;

}

__except (EXCEPTION_EXECUTE_HANDLER) {

return false;

}

}

inline bool IsValidViewModelObject(void* obj) {

if (!obj) return false;

return IsValidViewModelPointer((uintptr_t)obj);

}

inline tarray<USceneComponent*> GetChildrenComponents(USceneComponent* component, bool bIncludeAllDescendants) {

tarray<USceneComponent*> result;

if (!component || !IsValidViewModelObject(component)) return result;

static uobject* Function = nullptr;

if (!Function) {

auto function_name = (L"Engine.SceneComponent.GetChildrenComponents");

Function = uobject::find_object<uobject*>(function_name);

}

if (!Function || !IsValidViewModelObject(Function)) return result;

struct {

bool bIncludeAllDescendants;

tarray<USceneComponent*> Children;

} Args;

Args.bIncludeAllDescendants = bIncludeAllDescendants;

Args.Children.data = nullptr;

Args.Children.count = 0;

Args.Children.maxCount = 0;

__try {

component->process_event(Function, &Args);

return Args.Children;

}

__except (EXCEPTION_EXECUTE_HANDLER) {

return result;

}

}

currentequippable* GetLocalMeleeWeapon() {

static currentequippable* CachedMelee = nullptr;

static ULONGLONG lastCacheTime = 0;

ULONGLONG currentTime = GetTickCount64();

if (CachedMelee && (currentTime - lastCacheTime) < 2000) {

return CachedMelee;

}

CachedMelee = nullptr;

if (!UWorldSave) return nullptr;

tarray<AGameObject*> Objects;

GameplayStatics::GetAllActorsOfClass2(UWorldSave, Class::Actors(), &Objects);

for (int i = 0; i < Objects.size(); ++i) {

AGameObject* Object = Objects;
[*] if (!Object) continue;
[*]
[*] auto name = system::get_object_name(Object);
[*] if (!name.is_valid()) continue;
[*]
[*] std::string name_str = name.ToString();
[*] if (name_str.find("Ability_Melee_Base_C") != std::string::npos) {
[*] CachedMelee = (currentequippable*)Object;
[*] lastCacheTime = currentTime;
[*] return CachedMelee;
[*] }
[*] }
[*]
[*] return nullptr;
[*] }
[*]
[*] template<typename T>
[*] inline bool SafeRead(uintptr_t address, T& value) {
[*] if (!IsValidViewModelPointer(address)) return false;
[*]
[*] __try {
[*] value = *reinterpret_cast<T*>(address);
[*] return true;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return false;
[*] }
[*] }
[*]
[*] template<typename T>
[*] inline bool SafeWrite(uintptr_t address, const T& value) {
[*] if (!IsValidViewModelPointer(address)) return false;
[*]
[*] __try {
[*] *reinterpret_cast<T*>(address) = value;
[*] return true;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return false;
[*] }
[*] }
[*]
[*] inline bool SafeProcessFlag(uskeletalmeshcomponent* mesh, uintptr_t flag_offset, bool clear_flag) {
[*] if (!mesh || !IsValidViewModelObject(mesh)) return false;
[*]
[*] uintptr_t flag_addr = (uintptr_t)mesh + flag_offset;
[*] if (!IsValidViewModelPointer(flag_addr)) return false;
[*]
[*] fp_flag_store state;
[*] if (!SafeRead(flag_addr, state.raw)) return false;
[*]
[*] if (clear_flag) {
[*] state.bits.f0 = 0;
[*] return SafeWrite(flag_addr, state.raw);
[*] }
[*]
[*] return true;
[*] }
[*]
[*] inline void SafeLockDescendants(USceneComponent* component) {
[*] if (!component || !IsValidViewModelObject(component)) return;
[*]
[*] tarray<USceneComponent*> allChildren;
[*] __try {
[*] allChildren = GetChildrenComponents(component, true);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] for (int i = 0; i < allChildren.Num(); i++) {
[*] USceneComponent* child = allChildren;
[*] if (child && IsValidViewModelObject(child)) {
[*] uintptr_t child_flag_addr = (uintptr_t)child + 0x364;
[*] SafeWrite(child_flag_addr, (unsigned char)0x00);
[*] }
[*] }
[*] }
[*]
[*] inline void process_fp_mode(ashootercharacter* shooter) {
[*] if (!shooter) return;
[*]
[*] uintptr_t shooter_ptr = (uintptr_t)shooter;
[*] if (shooter_ptr == 0 || shooter_ptr == (uintptr_t)-1 || shooter_ptr < 0x10000 || shooter_ptr > 0x7FFFFFFFFFFF) {
[*] return;
[*] }
[*]
[*] __try {
[*] volatile uintptr_t test = *(uintptr_t*)shooter_ptr;
[*] (void)test;
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] bool isAlive = false;
[*] __try {
[*] isAlive = shooter->is_alive();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] return;
[*] }
[*]
[*] static ViewModelCache cache;
[*]
[*] if (!isAlive) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] static bool last_force_key_state = false;
[*] ULONGLONG current_time = GetTickCount64();
[*] bool force_key_pressed = GetAsyncKeyState(VK_F8) & 0x8000;
[*] bool force_reapply = force_key_pressed && !last_force_key_state;
[*] last_force_key_state = force_key_pressed;
[*]
[*] uinventory* inventory = nullptr;
[*] __try {
[*] inventory = shooter->get_inventory();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!inventory || !IsValidViewModelObject(inventory)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] currentequippable* weapon = nullptr;
[*] __try {
[*] weapon = inventory->get_current_equippable();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!weapon || !IsValidViewModelObject(weapon)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] bool needs_refresh = false;
[*] if (!cache.IsValid() ||
[*] weapon != cache.lastWeapon ||
[*] (current_time - cache.lastCacheTime) >= 2000 ||
[*] force_reapply) {
[*] needs_refresh = true;
[*] }
[*]
[*] if (needs_refresh) {
[*] cache.Clear();
[*] cache.lastCacheTime = current_time;
[*] cache.lastWeapon = weapon;
[*]
[*] __try {
[*] cache.mesh1p = shooter->getmesh1p();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!cache.mesh1p || !IsValidViewModelObject(cache.mesh1p)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] __try {
[*] cache.overlayMesh = shooter->GetOverlayMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {}
[*]
[*] __try {
[*] cache.weaponMesh1P = weapon->GetMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] if (!cache.weaponMesh1P || !IsValidViewModelObject(cache.weaponMesh1P)) {
[*] cache.Clear();
[*] return;
[*] }
[*]
[*] uintptr_t cosmetic_ptr = (uintptr_t)weapon + 0x1188;
[*] if (IsValidViewModelPointer(cosmetic_ptr)) {
[*] __try {
[*] cache.cosmeticMesh1P = memory::read<uskeletalmeshcomponent*>(cosmetic_ptr);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {}
[*] }
[*]
[*] auto meleeWeapon = GetLocalMeleeWeapon();
[*] if (meleeWeapon && IsValidViewModelObject(meleeWeapon)) {
[*] cache.lastMelee = meleeWeapon;
[*]
[*] __try {
[*] cache.meleeMesh1P = meleeWeapon->GetMesh1P();
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.meleeMesh1P = nullptr;
[*] }
[*]
[*] if (cache.meleeMesh1P) {
[*] uintptr_t offhand_ptr = (uintptr_t)meleeWeapon + 0x1220;
[*] if (IsValidViewModelPointer(offhand_ptr)) {
[*] __try {
[*] cache.offHandMesh = memory::read<uskeletalmeshcomponent*>(offhand_ptr);
[*] }
[*] __except (EXCEPTION_EXECUTE_HANDLER) {
[*] cache.offHandMesh = nullptr;
[*] }
[*] }
[*] }
[*] }
[*] }
[*]
[*] if (!cache.IsValid() || !cache.mesh1p || !cache.weaponMesh1P) {
[*] return;
[*] }
[*]
[*] const uintptr_t flag_offset = 0x364;
[*]
[*] bool should_process_flags = false;
[*] fp_flag_store main_state;
[*]
[*] uintptr_t mesh_flag_addr = (uintptr_t)cache.mesh1p + flag_offset;
[*] if (SafeRead(mesh_flag_addr, main_state.raw)) {
[*] should_process_flags = (main_state.bits.f0 != 0) || force_reapply;
[*] }
[*]
[*] if (should_process_flags) {
[*] SafeProcessFlag(cache.mesh1p, flag_offset, true);
[*]
[*] if (cache.overlayMesh && IsValidViewModelObject(cache.overlayMesh)) {
[*] SafeProcessFlag(cache.overlayMesh, flag_offset, true);
[*] }
[*]
[*] if (cache.weaponMesh1P && IsValidViewModelObject(cache.weaponMesh1P)) {
[*] SafeProcessFlag(cache.weaponMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.cosmeticMesh1P && IsValidViewModelObject(cache.cosmeticMesh1P)) {
[*] SafeProcessFlag(cache.cosmeticMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.meleeMesh1P && IsValidViewModelObject(cache.meleeMesh1P)) {
[*] SafeProcessFlag(cache.meleeMesh1P, flag_offset, true);
[*] }
[*]
[*] if (cache.offHandMesh && IsValidViewModelObject(cache.offHandMesh)) {
[*] SafeProcessFlag(cache.offHandMesh, flag_offset, true);
[*] }
[*] }
[*]
[*] if (cache.mesh1p && IsValidViewModelObject(cache.mesh1p)) {
[*] SafeLockDescendants((USceneComponent*)cache.mesh1p);
[*] }
[*]
[*] if (cache.weaponMesh1P && IsValidViewModelObject(cache.weaponMesh1P)) {
[*] SafeLockDescendants((USceneComponent*)cache.weaponMesh1P);
[*] }
[*]
[*] if (cache.meleeMesh1P && IsValidViewModelObject(cache.meleeMesh1P)) {
[*] SafeLockDescendants((USceneComponent*)cache.meleeMesh1P);
[*] }
[*] }

calsımıyordur enson bitane denedim silah uzakta kadlı kayboldu silah fixledim animasyonu kayboldu

Open Source valo instalock src

eLwtx

CloneEgiht

eLwtx

DIABL0

Fl3uur

Guns n' Roses

eLwtx

DIABL0

eLwtx

zxro

DIABL0

Şuanda konuyu görüntüleyen kullanıcılar