Outdated OBS плагин-чит для CS:GO (G37OBS) + source

Статус
В этой теме нельзя размещать новые ответы.
Начинающий
Статус
Оффлайн
Регистрация
5 Фев 2019
Сообщения
65
Реакции[?]
4
Поинты[?]
0

В данном разделе софт не проверяется модераторами, даже популярные пользователи могут в очередном обновлении вшить вирус в чит, поэтому любое использование исключительно на свой страх и риск. В разделе "Проверенные читы для CS:GO" вы можете скачать софт, который был одобрен нашими модераторами. Ссылка: https://yougame.biz/forums/843/

Да-да это плагин для ОБС с читом.. Нашёл я сие чудо на одном зарубежном форуме (хз можно ли оставлять название его). Лично мне он показался неудобным, потому что инжектится раза так с 8 (до обновления данного плагина всё было нормально). Я не знаю детект он или нет, я побегал с ним наверное минут 10 и просто закрыл. Так-то плагин 2019 года, но хуй знает детект оно или нет, по крайней мере работает и уже хорошо :LUL:


Функции:

- Recoil Control System
- Aimbot
- Triggerbot
- Glow ESP
- Radar
- Interfaces/Virtual Tables
- NetVars/Offsets
- ConVars
- obs-studio game handle
- silent load


Что требуется для работы:

- Windows 7 64bit или выше
- OBS Studio


Как запустить:

- Посмотреть гайд: (
)
- Проверить последняя ли у вас версия (я не знаю есть ли смысл обновлять это)

1592652385664.png
1592652419434.png

Пожалуйста, авторизуйтесь для просмотра ссылки.

VT:
Пожалуйста, авторизуйтесь для просмотра ссылки.

- Added radar
- Fixed bug in Aimbot
- Fixed bug in GLOW/Bhop
- Improved key list
- mem_scan_pattern accepts string now.
- get_int/get_float functions much simplier
- project is now using lua math libraries, as some one had problem:
"cannot resolve symbol 'atan2': The specified procedure could not be found" with some operating system

Python:
import obspython as obs
from ctypes import *
import os
import math
import random
nt = windll.ntdll
k32 = windll.kernel32
u32 = windll.user32


class Vector3(Structure):
    _fields_ = [("x", c_float), ("y", c_float), ("z", c_float)]


class GlobalVars:
    def __init__(self):
        self.running = False
        self.mem = 0
        self.client_panorama = 0
        self.vt = 0
        self.nv = 0
        self.sensitivity = 0
        self.mp_teammates_are_enemies = 0
        self.target = 0
        self.target_bone = 0
        self.current_tick = 0
        self.previous_tick = 0
        self.old_punch = 0
        self.bone_list = [5, 4, 3, 0, 7, 8]
        self.glow = False
        self.rcs = False
        self.aimbot = True
        self.aimbot_rcs = True
        self.aimbot_key = 107
        self.aimbot_smooth = 5
        self.aimbot_fov = 1.0 / 180.0
        self.aimbot_headonly = False
        self.triggerbot_key = 111


g_vars = GlobalVars()


def array_to_data(address):
    r = 0
    for j in bytearray(reversed(address)):
        r = (r << 8) + j
    return r


class HandleList:
    def __init__(self):
        length = c_uint32()
        self.snap = create_string_buffer(0x188)
        nt.NtQuerySystemInformation(16, self.snap, 0x188, pointer(length))
        self.snap = create_string_buffer(length.value + 8192)
        nt.NtQuerySystemInformation(16, self.snap, length.value + 8192, 0)
        self.count = array_to_data(self.snap[0:4])
        self.pos = 8

    def next(self):
        if self.count > 0:
            self.count = self.count - 1
            self.pos = self.pos + 24
            return True
        return False

    def pid(self):
        return int(array_to_data(self.snap[self.pos:self.pos + 4]))

    def handle(self):
        return c_uint64(array_to_data(self.snap[self.pos + 6:self.pos + 8]))


def get_process_handle(process_name):
    name_length = process_name.__len__() + 1
    handle_list = HandleList()
    while handle_list.next():
        if handle_list.pid() == os.getpid():
            name = create_string_buffer(name_length)
            if k32.K32GetModuleBaseNameA(handle_list.handle(), 0, name, name_length):
                if name.value == process_name.encode("ascii", "ignore"):
                    return handle_list.handle()
    return 0


def get_process_info(process_handle):
    buffer = create_string_buffer(48)
    if nt.NtQueryInformationProcess(process_handle, 26, buffer, 8, 0) == 0:
        return [array_to_data(buffer[0:4]), True]
    nt.NtQueryInformationProcess(process_handle, 0, buffer, 48, 0)
    return [array_to_data(buffer[8:16]), False]


class Process:
    def __init__(self, name):
        self.process_name = name
        self.mem = 0
        self.peb = 0
        self.wow64 = 0

    def attach(self):
        self.mem = get_process_handle("csgo.exe")
        if self.mem == 0:
            return False
        info = get_process_info(self.mem)
        self.peb = info[0]
        self.wow64 = info[1]
        return True

    def is_running(self):
        buffer = c_uint32()
        k32.GetExitCodeProcess(self.mem, pointer(buffer))
        return buffer.value == 0x103

    def read_vec3(self, address):
        buffer = Vector3()
        nt.NtReadVirtualMemory(self.mem, c_long(address), pointer(buffer), 12, 0)
        return buffer

    def read_string(self, address, length=120):
        buffer = create_string_buffer(length)
        nt.NtReadVirtualMemory(self.mem, address, buffer, length, 0)
        return buffer.value

    def read_unicode(self, address, length=120):
        buffer = create_unicode_buffer(length)
        nt.NtReadVirtualMemory(self.mem, address, pointer(buffer), length, 0)
        return buffer.value

    def read_float(self, address, length=4):
        buffer = c_float()
        nt.NtReadVirtualMemory(self.mem, c_long(address), pointer(buffer), length, 0)
        return buffer.value

    def read_i8(self, address, length=1):
        buffer = c_uint8()
        nt.NtReadVirtualMemory(self.mem, address, pointer(buffer), length, 0)
        return buffer.value

    def read_i16(self, address, length=2):
        buffer = c_uint16()
        nt.NtReadVirtualMemory(self.mem, address, pointer(buffer), length, 0)
        return buffer.value

    def read_i32(self, address, length=4):
        buffer = c_uint32()
        nt.NtReadVirtualMemory(self.mem, address, pointer(buffer), length, 0)
        return buffer.value

    def read_i64(self, address, length=8):
        buffer = c_uint64()
        nt.NtReadVirtualMemory(self.mem, c_uint64(address), pointer(buffer), length, 0)
        return buffer.value

    def write_float(self, address, value):
        buffer = c_float(value)
        return nt.NtWriteVirtualMemory(self.mem, address, pointer(buffer), 4, 0) == 0

    def write_i8(self, address, value):
        buffer = c_uint8(value)
        return nt.NtWriteVirtualMemory(self.mem, address, pointer(buffer), 1, 0) == 0

    def write_i16(self, address, value):
        buffer = c_uint16(value)
        return nt.NtWriteVirtualMemory(self.mem, address, pointer(buffer), 2, 0) == 0

    def write_i32(self, address, value):
        buffer = c_uint32(value)
        return nt.NtWriteVirtualMemory(self.mem, address, pointer(buffer), 4, 0) == 0

    def write_i64(self, address, value):
        buffer = c_uint64(value)
        return nt.NtWriteVirtualMemory(self.mem, address, pointer(buffer), 8, 0) == 0

    def get_module_handle(self, name, wow64):
        count = c_uint32()
        buffer = create_string_buffer(1024)
        k32.K32EnumProcessModulesEx(self.mem, buffer, 1024, pointer(count), 0x01 if wow64 else 0x02)
        modules = cast(buffer, POINTER(c_uint64))
        for i in range(0, count.value):
            module_name = create_string_buffer(260)
            if k32.K32GetModuleBaseNameA(self.mem, c_uint64(modules[i]), module_name, 260) != 0:
                if name.encode('ascii', 'ignore').lower() == module_name.value.lower():
                    return c_uint64(modules[i])
        return 0

    def get_module(self, name):
        if self.wow64:
            a0 = [0x04, 0x0C, 0x14, 0x28, 0x10]
        else:
            a0 = [0x08, 0x18, 0x20, 0x50, 0x20]
        a1 = self.read_i64(self.read_i64(self.peb + a0[1], a0[0]) + a0[2], a0[0])
        a2 = self.read_i64(a1 + a0[0], a0[0])
        while a1 != a2:
            val = self.read_unicode(self.read_i64(a1 + a0[3], a0[0]), 260)
            if val.lower() == name.lower():
                return self.read_i64(a1 + a0[4], a0[0])
            a1 = self.read_i64(a1, a0[0])
        raise Exception("[!]Process::get_module")

    def get_export(self, module, name):
        if module == 0:
            return 0
        a0 = self.read_i32(module + self.read_i16(module + 0x3C) + (0x88 - self.wow64 * 0x10)) + module
        a1 = [self.read_i32(a0 + 0x18), self.read_i32(a0 + 0x1c), self.read_i32(a0 + 0x20), self.read_i32(a0 + 0x24)]
        while a1[0] > 0:
            a1[0] -= 1
            export_name = self.read_string(module + self.read_i32(module + a1[2] + (a1[0] * 4)), 120)
            if name.encode("ascii", "ignore") == export_name:
                a2 = self.read_i16(module + a1[3] + (a1[0] * 2))
                a3 = self.read_i32(module + a1[1] + (a2 * 4))
                return module + a3
        raise Exception("[!]Process::get_export")
  
    def find_pattern(self, module_name, pattern, mask):
        a0 = self.get_module(module_name)
        a1 = self.read_i32(a0 + 0x03C) + a0
        a2 = self.read_i32(a1 + 0x01C)
        a3 = self.read_i32(a1 + 0x02C)
        a4 = cast(create_string_buffer(a2), POINTER(c_uint8))
        nt.NtReadVirtualMemory(self.mem, a0 + a3, a4, a2, 0)
        for a5 in range(0, a2):
            a6 = 0
            for a7 in range(0, pattern.__len__()):
                if mask[a7] == 'x' and a4[a5 + a7] != pattern[a7]:
                    break
                a6 = a6 + 1
            if a6 == pattern.__len__():
                return a0 + a3 + a5
        return 0


class VirtualTable:
    def __init__(self, table):
        self.table = table

    def function(self, index):
        return g_vars.mem.read_i32(g_vars.mem.read_i32(self.table) + index * 4)


class InterfaceTable:
    def __init__(self, name):
        self.table_list = g_vars.mem.read_i32(g_vars.mem.read_i32(g_vars.mem.get_export(g_vars.mem.get_module(name), "CreateInterface") - 0x6A))

    def get_interface(self, name):
        a0 = self.table_list
        while a0 != 0:
            if name.encode("ascii", "ignore") == g_vars.mem.read_string(g_vars.mem.read_i32(a0 + 0x4), 120)[0:-3]:
                return VirtualTable(g_vars.mem.read_i32(g_vars.mem.read_i32(a0) + 1))
            a0 = g_vars.mem.read_i32(a0 + 0x8)
        raise Exception("[!]InterfaceTable::get_interface")


class NetVarTable:
    def __init__(self, name):
        self.table = 0
        a0 = g_vars.mem.read_i32(g_vars.mem.read_i32(g_vars.vt.client.function(8) + 1))
        while a0 != 0:
            a1 = g_vars.mem.read_i32(a0 + 0x0C)
            if name.encode("ascii", "ignore") == g_vars.mem.read_string(g_vars.mem.read_i32(a1 + 0x0C), 120):
                self.table = a1
            a0 = g_vars.mem.read_i32(a0 + 0x10)
        if self.table == 0:
            raise Exception("[!]NetVarTable::__init__")

    def get_offset(self, name):
        offset = self.__get_offset(self.table, name)
        if offset == 0:
            raise Exception("[!]NetVarTable::get_offset")
        return offset

    def __get_offset(self, address, name):
        a0 = 0
        for a1 in range(0, g_vars.mem.read_i32(address + 0x4)):
            a2 = a1 * 60 + g_vars.mem.read_i32(address)
            a3 = g_vars.mem.read_i32(a2 + 0x2C)
            a4 = g_vars.mem.read_i32(a2 + 0x28)
            if a4 != 0 and g_vars.mem.read_i32(a4 + 0x4) != 0:
                a5 = self.__get_offset(a4, name)
                if a5 != 0:
                    a0 += a3 + a5
            if name.encode("ascii", "ignore") == g_vars.mem.read_string(g_vars.mem.read_i32(a2), 120):
                return a3 + a0
        return a0


class ConVar:
    def __init__(self, name):
        self.address = 0
        a0 = g_vars.mem.read_i32(g_vars.mem.read_i32(g_vars.mem.read_i32(g_vars.vt.cvar.table + 0x34)) + 0x4)
        while a0 != 0:
            if name.encode("ascii", "ignore") == g_vars.mem.read_string(g_vars.mem.read_i32(a0 + 0x0C)):
                self.address = a0
                break
            a0 = g_vars.mem.read_i32(a0 + 0x4)
        if self.address == 0:
            raise Exception("[!]ConVar not found!")

    def get_int(self):
        a0 = c_int32()
        a1 = g_vars.mem.read_i32(self.address + 0x30) ^ self.address
        nt.memcpy(pointer(a0), pointer(c_int32(a1)), 4)
        return a0.value

    def get_float(self):
        a0 = c_float()
        a1 = g_vars.mem.read_i32(self.address + 0x2C) ^ self.address
        nt.memcpy(pointer(a0), pointer(c_int32(a1)), 4)
        return a0.value


class InterfaceList:
    def __init__(self):
        g_vars.client_panorama = g_vars.mem.get_module("client_panorama.dll")
        table = InterfaceTable("client_panorama.dll")
        self.client = table.get_interface("VClient")
        self.entity = table.get_interface("VClientEntityList")
        table = InterfaceTable("engine.dll")
        self.engine = table.get_interface("VEngineClient")
        table = InterfaceTable("vstdlib.dll")
        self.cvar = table.get_interface("VEngineCvar")
        table = InterfaceTable("inputsystem.dll")
        self.input = table.get_interface("InputSystemVersion")


class NetVarList:
    def __init__(self):
        table = NetVarTable("DT_BasePlayer")
        self.m_iHealth = table.get_offset("m_iHealth")
        self.m_vecViewOffset = table.get_offset("m_vecViewOffset[0]")
        self.m_lifeState = table.get_offset("m_lifeState")
        self.m_nTickBase = table.get_offset("m_nTickBase")
        self.m_vecPunch = table.get_offset("m_Local") + 0x70

        table = NetVarTable("DT_BaseEntity")
        self.m_iTeamNum = table.get_offset("m_iTeamNum")
        self.m_vecOrigin = table.get_offset("m_vecOrigin")

        table = NetVarTable("DT_CSPlayer")
        self.m_hActiveWeapon = table.get_offset("m_hActiveWeapon")
        self.m_iShotsFired = table.get_offset("m_iShotsFired")
        self.m_iCrossHairID = table.get_offset("m_bHasDefuser") + 0x5C
        self.m_iGlowIndex = table.get_offset("m_flFlashDuration") + 0x18

        table = NetVarTable("DT_BaseAnimating")
        self.m_dwBoneMatrix = table.get_offset("m_nForceBone") + 0x1C

        table = NetVarTable("DT_BaseAttributableItem")
        self.m_iItemDefinitionIndex = table.get_offset("m_iItemDefinitionIndex")

        self.dwEntityList = g_vars.vt.entity.table - (g_vars.mem.read_i32(g_vars.vt.entity.function(5) + 0x22) - 0x38)
        self.dwClientState = g_vars.mem.read_i32(g_vars.mem.read_i32(g_vars.vt.engine.function(18) + 0x16))
        self.dwGetLocalPlayer = g_vars.mem.read_i32(g_vars.vt.engine.function(12) + 0x16)
        self.dwViewAngles = g_vars.mem.read_i32(g_vars.vt.engine.function(19) + 0xB2)
        self.dwMaxClients = g_vars.mem.read_i32(g_vars.vt.engine.function(20) + 0x07)
        self.dwState = g_vars.mem.read_i32(g_vars.vt.engine.function(26) + 0x07)
        self.dwButton = g_vars.mem.read_i32(g_vars.vt.input.function(15) + 0x21D)
        self.dwGlowObjectManager = g_vars.mem.find_pattern("client_panorama.dll",
                                                           b'\xA1\x00\x00\x00\x00\xA8\x01\x75\x4B', "x????xxxx")
        self.dwGlowObjectManager = g_vars.mem.read_i32(self.dwGlowObjectManager + 1) + 4


class Player:
    def __init__(self, address):
        self.address = address

    def get_team_num(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_iTeamNum)

    def get_health(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_iHealth)

    def get_life_state(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_lifeState)

    def get_tick_count(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_nTickBase)

    def get_shots_fired(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_iShotsFired)

    def get_cross_index(self):
        return g_vars.mem.read_i32(self.address + g_vars.nv.m_iCrossHairID)

    def get_weapon(self):
        a0 = g_vars.mem.read_i32(self.address + g_vars.nv.m_hActiveWeapon)
        return g_vars.mem.read_i32(g_vars.nv.dwEntityList + ((a0 & 0xFFF) - 1) * 0x10)

    def get_weapon_id(self):
        return g_vars.mem.read_i32(self.get_weapon() + g_vars.nv.m_iItemDefinitionIndex)

    def get_origin(self):
        return g_vars.mem.read_vec3(self.address + g_vars.nv.m_vecOrigin)

    def get_vec_view(self):
        return g_vars.mem.read_vec3(self.address + g_vars.nv.m_vecViewOffset)

    def get_eye_pos(self):
        v = self.get_vec_view()
        o = self.get_origin()
        return Vector3(v.x + o.x, v.y + o.y, v.z + o.z)

    def get_vec_punch(self):
        return g_vars.mem.read_vec3(self.address + g_vars.nv.m_vecPunch)

    def get_bone_pos(self, index):
        a0 = 0x30 * index
        a1 = g_vars.mem.read_i32(self.address + g_vars.nv.m_dwBoneMatrix)
        return Vector3(
            g_vars.mem.read_float(a1 + a0 + 0x0C),
            g_vars.mem.read_float(a1 + a0 + 0x1C),
            g_vars.mem.read_float(a1 + a0 + 0x2C)
        )

    def is_valid(self):
        health = self.get_health()
        return self.address != 0 and self.get_life_state() == 0 and 0 < health < 1338


g_vars.target = Player(0)


class Engine:
       @staticmethod
    def get_local_player():
        return g_vars.mem.read_i32(g_vars.nv.dwClientState + g_vars.nv.dwGetLocalPlayer)

       @staticmethod
    def get_view_angles():
        return g_vars.mem.read_vec3(g_vars.nv.dwClientState + g_vars.nv.dwViewAngles)

       @staticmethod
    def get_max_clients():
        return g_vars.mem.read_i32(g_vars.nv.dwClientState + g_vars.nv.dwMaxClients)

       @staticmethod
    def is_in_game():
        return g_vars.mem.read_i8(g_vars.nv.dwClientState + g_vars.nv.dwState) >> 2


class Entity:
       @staticmethod
    def get_client_entity(index):
        return Player(g_vars.mem.read_i32(g_vars.nv.dwEntityList + index * 0x10))


class InputSystem:
       @staticmethod
    def is_button_down(button):
        a0 = g_vars.mem.read_i32(g_vars.vt.input.table + ((button >> 5) * 4) + g_vars.nv.dwButton)
        return (a0 >> (button & 31)) & 1


class Math:
       @staticmethod
    def sin_cos(radians):
        return [math.sin(radians), math.cos(radians)]

       @staticmethod
    def rad2deg(x):
        return x * 3.141592654

       @staticmethod
    def deg2rad(x):
        return x * 0.017453293

       @staticmethod
    def angle_vec(angles):
        s = Math.sin_cos(Math.deg2rad(angles.x))
        y = Math.sin_cos(Math.deg2rad(angles.y))
        return Vector3(s[1] * y[1], s[1] * y[0], -s[0])

       @staticmethod
    def vec_normalize(vec):
        radius = 1.0 / (math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z) + 1.192092896e-07)
        vec.x *= radius
        vec.y *= radius
        vec.z *= radius
        return vec

       @staticmethod
    def vec_angles(forward):
        if forward.y == 0.00 and forward.x == 0.00:
            yaw = 0
            pitch = 270.0 if forward.z > 0.00 else 90.0
        else:
            yaw = math.atan2(forward.y, forward.x) * 57.295779513
            if yaw < 0.00:
                yaw += 360.0
            tmp = math.sqrt(forward.x * forward.x + forward.y * forward.y)
            pitch = math.atan2(-forward.z, tmp) * 57.295779513
            if pitch < 0.00:
                pitch += 360.0
        return Vector3(pitch, yaw, 0.00)

       @staticmethod
    def vec_clamp(v):
        if 89.0 < v.x <= 180.0:
            v.x = 89.0
        if v.x > 180.0:
            v.x -= 360.0
        if v.x < -89.0:
            v.x = -89.0
        v.y = math.fmod(v.y + 180.0, 360.0) - 180.0
        v.z = 0.00
        return v

       @staticmethod
    def vec_dot(v0, v1):
        return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z

       @staticmethod
    def vec_length(v):
        return v.x * v.x + v.y * v.y + v.z * v.z

       @staticmethod
    def get_fov(va, angle):
        a0 = Math.angle_vec(va)
        a1 = Math.angle_vec(angle)
        return Math.rad2deg(math.acos(Math.vec_dot(a0, a1) / Math.vec_length(a0)))


def get_target_angle(local_p, target, bone_id):
    m = target.get_bone_pos(bone_id)
    c = local_p.get_eye_pos()
    c.x = m.x - c.x
    c.y = m.y - c.y
    c.z = m.z - c.z
    c = Math.vec_angles(Math.vec_normalize(c))
    if g_vars.aimbot_rcs and local_p.get_shots_fired() > 1:
        p = local_p.get_vec_punch()
        c.x -= p.x * 2.0
        c.y -= p.y * 2.0
        c.z -= p.z * 2.0
    return Math.vec_clamp(c)


def get_best_target(va, local_p):
    a0 = 9999.9
    for i in range(1, Engine.get_max_clients()):
        entity = Entity.get_client_entity(i)
        if not entity.is_valid():
            continue
        if not g_vars.mp_teammates_are_enemies.get_int() and local_p.get_team_num() == entity.get_team_num():
            continue
        if g_vars.aimbot_headonly:
            fov = Math.get_fov(va, get_target_angle(local_p, entity, 8))
            if fov < a0:
                a0 = fov
                g_vars.target = entity
                g_vars.target_bone = 8
        else:
            for j in range(0, g_vars.bone_list.__len__()):
                fov = Math.get_fov(va, get_target_angle(local_p, entity, g_vars.bone_list[j]))
                if fov < a0:
                    a0 = fov
                    g_vars.target = entity
                    g_vars.target_bone = g_vars.bone_list[j]
    return a0 != 9999


def aim_at_target(sensitivity, va, angle):
    y = va.x - angle.x
    x = va.y - angle.y
    if y > 89.0:
        y = 89.0
    elif y < -89.0:
        y = -89.0
    if x > 180.0:
        x -= 360.0
    elif x < -180.0:
        x += 360.0
    if math.fabs(x) / 180.0 >= g_vars.aimbot_fov:
        g_vars.target = Player(0)
        return
    if math.fabs(y) / 89.0 >= g_vars.aimbot_fov:
        g_vars.target = Player(0)
        return
    x = (x / sensitivity) / 0.022
    y = (y / sensitivity) / -0.022
    if g_vars.aimbot_smooth != 0.00:
        sx = 0.00
        sy = 0.00
        if sx < x:
            sx += 1.0 + (x / g_vars.aimbot_smooth)
        elif sx > x:
            sx -= 1.0 - (x / g_vars.aimbot_smooth)
        if sy < y:
            sy += 1.0 + (y / g_vars.aimbot_smooth)
        elif sy > y:
            sy -= 1.0 - (y / g_vars.aimbot_smooth)
    else:
        sx = x
        sy = y
    if g_vars.current_tick - g_vars.previous_tick > 0:
        g_vars.previous_tick = g_vars.current_tick
        u32.mouse_event(0x0001, int(sx), int(sy), 0, 0)


def aim_assist():
    try:
        if Engine.is_in_game():
            self = Entity.get_client_entity(Engine.get_local_player())
            view_angle = Engine.get_view_angles()
            sensitivity = g_vars.sensitivity.get_float()
            if g_vars.glow:
                glow_pointer = g_vars.mem.read_i32(g_vars.nv.dwGlowObjectManager)
                for i in range(0, 32):
                    entity = Entity.get_client_entity(i)
                    if not entity.is_valid():
                        continue
                    if not g_vars.mp_teammates_are_enemies.get_int() and self.get_team_num() == entity.get_team_num():
                        continue
                    entity_health = entity.get_health() / 100.0
                    index = (g_vars.mem.read_i32(entity.address + g_vars.nv.m_iGlowIndex) * 0x38)
                    g_vars.mem.write_float(glow_pointer + index + 0x04, 1.0 - entity_health)  # r
                    g_vars.mem.write_float(glow_pointer + index + 0x08, entity_health)        # g
                    g_vars.mem.write_float(glow_pointer + index + 0x0C, 0.0)                  # b
                    g_vars.mem.write_float(glow_pointer + index + 0x10, 0.8)                  # a
                    g_vars.mem.write_i8(glow_pointer + index + 0x24, 1)
                    g_vars.mem.write_i8(glow_pointer + index + 0x25, 0)
            if InputSystem.is_button_down(g_vars.triggerbot_key):
                cross_id = self.get_cross_index()
                if cross_id == 0:
                    return
                cross_target = Entity.get_client_entity(cross_id - 1)
                if self.get_team_num() != cross_target.get_team_num() and cross_target.get_health() > 0:
                    u32.mouse_event(0x0002, 0, 0, 0, 0)
                    u32.mouse_event(0x0004, 0, 0, 0, 0)
            if g_vars.aimbot and InputSystem.is_button_down(g_vars.aimbot_key):
                weapon_id = self.get_weapon_id()
                if weapon_id == 42 or weapon_id == 49:
                    return
                g_vars.current_tick = self.get_tick_count()
                if not g_vars.target.is_valid() and not get_best_target(view_angle, self):
                    return
                aim_at_target(sensitivity, view_angle, get_target_angle(self, g_vars.target, g_vars.target_bone))
            else:
                g_vars.target = Player(0)
            if g_vars.rcs:
                current_punch = self.get_vec_punch()
                if self.get_shots_fired() > 1:
                    new_punch = Vector3(current_punch.x - g_vars.old_punch.x,
                                        current_punch.y - g_vars.old_punch.y, 0)
                    new_angle = Vector3(view_angle.x - new_punch.x * 2.0, view_angle.y - new_punch.y * 2.0, 0)
                    u32.mouse_event(0x0001,
                                    int(((new_angle.y - view_angle.y) / sensitivity) / -0.022),
                                    int(((new_angle.x - view_angle.x) / sensitivity) / 0.022),
                                    0, 0)
                g_vars.old_punch = current_punch
    except ValueError:
        return


# fuck you obs:
# https://github.com/obsproject/obs-st...ca5db04f5fd70c
def patch_process_handle(desired_access):
    base = windll.LoadLibrary("win-capture.dll")
    addr = c_uint64(base._handle + 0x58AE)
    return k32.WriteProcessMemory(-1, addr, pointer(c_uint32(desired_access)), 4, 0)


def start_button_callback(props, prop):
    if g_vars.running:
        return
    if not g_vars.mem.attach():
        print("[!]target is not running")
        return
    try:
        g_vars.vt = InterfaceList()
        g_vars.nv = NetVarList()
        g_vars.sensitivity = ConVar("sensitivity")
        g_vars.mp_teammates_are_enemies = ConVar("mp_teammates_are_enemies")
    except Exception as e:
        print(e)
        return
    g_vars.running = True
    print("[*]started!")


def stop_button_callback(props, prop):
    if g_vars.running:
        g_vars.running = False
        g_vars.mem = Process("csgo.exe")
        print("[*]stopped!")


def script_properties():
    props = obs.obs_properties_create()
    obs.obs_properties_add_bool(props, "glow_esp", "glow_esp")
    obs.obs_properties_add_bool(props, "rcs", "rcs")
    obs.obs_properties_add_bool(props, "aimbot", "aimbot")
    obs.obs_properties_add_bool(props, "aimbot_rcs", "aimbot_rcs")
    obs.obs_properties_add_bool(props, "aimbot_headonly", "aimbot_headonly")
    obs.obs_properties_add_int(props, "aimbot_key", "aimbot_key", 0, 123, 1)
    obs.obs_properties_add_float_slider(props, "aimbot_fov", "aimbot_fov", 0.0, 360.0, 0.25)
    obs.obs_properties_add_float_slider(props, "aimbot_smooth", "aimbot_smooth", 0.0, 1000.0, 0.25)
    obs.obs_properties_add_int(props, "triggerbot_key", "triggerbot_key", 0, 123, 1)
    obs.obs_properties_add_button(props, "start_button", "Start", start_button_callback)
    obs.obs_properties_add_button(props, "stop_button", "Stop", stop_button_callback)
    return props


def script_defaults(settings):
    obs.obs_data_set_default_bool(settings, "glow_esp", False)
    obs.obs_data_set_default_bool(settings, "rcs", False)
    obs.obs_data_set_default_bool(settings, "aimbot", True)
    obs.obs_data_set_default_bool(settings, "aimbot_rcs", True)
    obs.obs_data_set_default_bool(settings, "aimbot_headonly", False)
    obs.obs_data_set_default_double(settings, "aimbot_smooth", 3.0)
    obs.obs_data_set_default_double(settings, "aimbot_fov", 1.0)
    obs.obs_data_set_default_int(settings, "aimbot_key", 107)
    obs.obs_data_set_default_int(settings, "triggerbot_key", 111)


def script_description():
    return "<b>CU@LAN</b>" + "<hr>" + \
     '"Puutyöt kiinnosti niin pirusti, mä olin siellä ihan ihmeissäni että miten nää kiinnostaa niin saatanasti"' + \
     "<hr>" + '"Sanotaan 3/5,5 ja vielä puoli pistettä päälle"' + \
     "<hr>" + '"Se on VOI VOI"' "<br/><br/>" + "ekknod@2019"


def script_load(settings):
    # 0x1fffff = PROCESS_ALL_ACCESS
    # 0x000410 = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
    patch_process_handle(0x000430)
    g_vars.mem = Process("csgo.exe")


def script_tick(seconds):
    if g_vars.running:
        g_vars.running = g_vars.mem.is_running()
        aim_assist()


def script_update(settings):
    g_vars.glow = obs.obs_data_get_bool(settings, "glow_esp")
    g_vars.rcs = obs.obs_data_get_bool(settings, "rcs")
    g_vars.aimbot = obs.obs_data_get_bool(settings, "aimbot")
    g_vars.aimbot_rcs = obs.obs_data_get_bool(settings, "aimbot_rcs")
    g_vars.aimbot_key = obs.obs_data_get_int(settings, "aimbot_key")
    g_vars.aimbot_smooth = obs.obs_data_get_double(settings, "aimbot_smooth")
    g_vars.aimbot_fov = obs.obs_data_get_double(settings, "aimbot_fov") / 180.0
    g_vars.aimbot_headonly = obs.obs_data_get_bool(settings, "aimbot_headonly")
    g_vars.triggerbot_key = obs.obs_data_get_int(settings, "triggerbot_key")
 
Пользователь
Статус
Оффлайн
Регистрация
22 Сен 2019
Сообщения
210
Реакции[?]
33
Поинты[?]
0
он вроде уд должен быть, т.к. экстернал, но я могу и ошибаться
 
Статус
В этой теме нельзя размещать новые ответы.
Сверху Снизу