-
Автор темы
- #1
Да-да это плагин для ОБС с читом.. Нашёл я сие чудо на одном зарубежном форуме (хз можно ли оставлять название его). Лично мне он показался неудобным, потому что инжектится раза так с 8 (до обновления данного плагина всё было нормально). Я не знаю детект он или нет, я побегал с ним наверное минут 10 и просто закрыл. Так-то плагин 2019 года, но хуй знает детект оно или нет, по крайней мере работает и уже хорошо 
Функции:
- 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
Как запустить:
- Посмотреть гайд: (
)
- Проверить последняя ли у вас версия (я не знаю есть ли смысл обновлять это)
Функции:
- 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
Как запустить:
- Посмотреть гайд: (
- Проверить последняя ли у вас версия (я не знаю есть ли смысл обновлять это)
Пожалуйста, авторизуйтесь для просмотра ссылки.
VT:
Пожалуйста, авторизуйтесь для просмотра ссылки.
- Added radar
- Fixed bug in Aimbot
- Fixed bug in GLOW/Bhop
- Improved key list
- 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
- 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")