patate/Rainbow-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add files via upload

Browse Source
This commit is contained in:
ALittlePatate
2021-02-24 12:54:38 +01:00
committed by GitHub
parent df32dae200
commit 5ed12e4c21
25 changed files with 1864 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
utils/Offsets.py Normal file
View File

@@ -0,0 +1,155 @@
import requests, json, sys
n = open("classes/netvars.json", "r")
response = json.load(n)
m_totalHitsOnServer = int(response["DT_CSPlayer"]["m_totalHitsOnServer"])
url = 'https://raw.githubusercontent.com/frk1/hazedumper/master/csgo.json'
response = requests.get(url).json()
cs_gamerules_data = int(response["netvars"]["cs_gamerules_data"])
m_ArmorValue = int(response["netvars"]["m_ArmorValue"])
m_Collision = int(response["netvars"]["m_Collision"])
m_CollisionGroup = int(response["netvars"]["m_CollisionGroup"])
m_Local = int(response["netvars"]["m_Local"])
m_MoveType = int(response["netvars"]["m_MoveType"])
m_OriginalOwnerXuidHigh = int(response["netvars"]["m_OriginalOwnerXuidHigh"])
m_OriginalOwnerXuidLow = int(response["netvars"]["m_OriginalOwnerXuidLow"])
m_SurvivalGameRuleDecisionTypes = int(response["netvars"]["m_SurvivalGameRuleDecisionTypes"])
m_SurvivalRules = int(response["netvars"]["m_SurvivalRules"])
m_aimPunchAngleVel = int(response["netvars"]["m_aimPunchAngleVel"])
m_aimPunchAngle = int(response["netvars"]["m_aimPunchAngle"])
m_angEyeAnglesX = int(response["netvars"]["m_angEyeAnglesX"])
m_angEyeAnglesY = int(response["netvars"]["m_angEyeAnglesY"])
m_bBombPlanted = int(response["netvars"]["m_bBombPlanted"])
m_bFreezePeriod = int(response["netvars"]["m_bFreezePeriod"])
m_bGunGameImmunity = int(response["netvars"]["m_bGunGameImmunity"])
m_bHasDefuser = int(response["netvars"]["m_bHasDefuser"])
m_bHasHelmet = int(response["netvars"]["m_bHasHelmet"])
m_bInReload = int(response["netvars"]["m_bInReload"])
m_bIsDefusing = int(response["netvars"]["m_bIsDefusing"])
m_bIsQueuedMatchmaking = int(response["netvars"]["m_bIsQueuedMatchmaking"])
m_bIsScoped = int(response["netvars"]["m_bIsScoped"])
m_bIsValveDS = int(response["netvars"]["m_bIsValveDS"])
m_bSpotted = int(response["netvars"]["m_bSpotted"])
m_bSpottedByMask = int(response["netvars"]["m_bSpottedByMask"])
m_bStartedArming = int(response["netvars"]["m_bStartedArming"])
m_bUseCustomAutoExposureMax = int(response["netvars"]["m_bUseCustomAutoExposureMax"])
m_bUseCustomAutoExposureMin = int(response["netvars"]["m_bUseCustomAutoExposureMin"])
m_bUseCustomBloomScale = int(response["netvars"]["m_bUseCustomBloomScale"])
m_clrRender = int(response["netvars"]["m_clrRender"])
m_dwBoneMatrix = int(response["netvars"]["m_dwBoneMatrix"])
m_fAccuracyPenalty = int(response["netvars"]["m_fAccuracyPenalty"])
m_fFlags = int(response["netvars"]["m_fFlags"])
m_flC4Blow = int(response["netvars"]["m_flC4Blow"])
m_flCustomAutoExposureMax = int(response["netvars"]["m_flCustomAutoExposureMax"])
m_flCustomAutoExposureMin = int(response["netvars"]["m_flCustomAutoExposureMin"])
m_flCustomBloomScale = int(response["netvars"]["m_flCustomBloomScale"])
m_flDefuseCountDown = int(response["netvars"]["m_flDefuseCountDown"])
m_flDefuseLength = int(response["netvars"]["m_flDefuseLength"])
m_flFallbackWear = int(response["netvars"]["m_flFallbackWear"])
m_flFlashDuration = int(response["netvars"]["m_flFlashDuration"])
m_flFlashMaxAlpha = int(response["netvars"]["m_flFlashMaxAlpha"])
m_flLastBoneSetupTime = int(response["netvars"]["m_flLastBoneSetupTime"])
m_flLowerBodyYawTarget = int(response["netvars"]["m_flLowerBodyYawTarget"])
m_flNextAttack = int(response["netvars"]["m_flNextAttack"])
m_flNextPrimaryAttack = int(response["netvars"]["m_flNextPrimaryAttack"])
m_flSimulationTime = int(response["netvars"]["m_flSimulationTime"])
m_flTimerLength = int(response["netvars"]["m_flTimerLength"])
m_hActiveWeapon = int(response["netvars"]["m_hActiveWeapon"])
m_hMyWeapons = int(response["netvars"]["m_hMyWeapons"])
m_hObserverTarget = int(response["netvars"]["m_hObserverTarget"])
m_hOwner = int(response["netvars"]["m_hOwner"])
m_hOwnerEntity = int(response["netvars"]["m_hOwnerEntity"])
m_iAccountID = int(response["netvars"]["m_iAccountID"])
m_iClip1 = int(response["netvars"]["m_iClip1"])
m_iCompetitiveRanking = int(response["netvars"]["m_iCompetitiveRanking"])
m_iCompetitiveWins = int(response["netvars"]["m_iCompetitiveWins"])
m_iCrosshairId = int(response["netvars"]["m_iCrosshairId"])
m_iEntityQuality = int(response["netvars"]["m_iEntityQuality"])
m_iFOV = int(response["netvars"]["m_iDefaultFOV"])
m_iFOVStart = int(response["netvars"]["m_iFOVStart"])
m_iGlowIndex = int(response["netvars"]["m_iGlowIndex"])
m_iHealth = int(response["netvars"]["m_iHealth"])
m_iItemDefinitionIndex = int(response["netvars"]["m_iItemDefinitionIndex"])
m_iItemIDHigh = int(response["netvars"]["m_iItemIDHigh"])
m_iMostRecentModelBoneCounter = int(response["netvars"]["m_iMostRecentModelBoneCounter"])
m_iObserverMode = int(response["netvars"]["m_iObserverMode"])
m_iShotsFired = int(response["netvars"]["m_iShotsFired"])
m_iState = int(response["netvars"]["m_iState"])
m_iTeamNum = int(response["netvars"]["m_iTeamNum"])
m_lifeState = int(response["netvars"]["m_lifeState"])
m_nFallbackPaintKit = int(response["netvars"]["m_nFallbackPaintKit"])
m_nFallbackSeed = int(response["netvars"]["m_nFallbackSeed"])
m_nFallbackStatTrak = int(response["netvars"]["m_nFallbackStatTrak"])
m_nForceBone = int(response["netvars"]["m_nForceBone"])
m_nTickBase = int(response["netvars"]["m_nTickBase"])
m_rgflCoordinateFrame = int(response["netvars"]["m_rgflCoordinateFrame"])
m_szCustomName = int(response["netvars"]["m_szCustomName"])
m_szLastPlaceName = int(response["netvars"]["m_szLastPlaceName"])
m_thirdPersonViewAngles = int(response["netvars"]["m_thirdPersonViewAngles"])
m_vecOrigin = int(response["netvars"]["m_vecOrigin"])
m_vecVelocity = int(response["netvars"]["m_vecVelocity"])
m_vecViewOffset = int(response["netvars"]["m_vecViewOffset"])
m_viewPunchAngle = int(response["netvars"]["m_viewPunchAngle"])
anim_overlays = int(response["signatures"]["anim_overlays"])
clientstate_choked_commands = int(response["signatures"]["clientstate_choked_commands"])
clientstate_delta_ticks = int(response["signatures"]["clientstate_delta_ticks"])
clientstate_last_outgoing_command = int(response["signatures"]["clientstate_last_outgoing_command"])
clientstate_net_channel = int(response["signatures"]["clientstate_net_channel"])
convar_name_hash_table = int(response["signatures"]["convar_name_hash_table"])
dwLocalPlayer = int(response["signatures"]["dwLocalPlayer"])
dwClientState = int(response["signatures"]["dwClientState"])
dwClientState_GetLocalPlayer = int(response["signatures"]["dwClientState_GetLocalPlayer"])
dwClientState_IsHLTV = int(response["signatures"]["dwClientState_IsHLTV"])
dwClientState_Map = int(response["signatures"]["dwClientState_Map"])
dwClientState_MapDirectory = int(response["signatures"]["dwClientState_MapDirectory"])
dwClientState_MaxPlayer = int(response["signatures"]["dwClientState_MaxPlayer"])
dwClientState_PlayerInfo = int(response["signatures"]["dwClientState_PlayerInfo"])
dwClientState_State = int(response["signatures"]["dwClientState_State"])
dwClientState_ViewAngles = int(response["signatures"]["dwClientState_ViewAngles"])
dwEntityList = int(response["signatures"]["dwEntityList"])
dwForceAttack = int(response["signatures"]["dwForceAttack"])
dwForceAttack2 = int(response["signatures"]["dwForceAttack2"])
dwForceBackward = int(response["signatures"]["dwForceBackward"])
dwForceForward = int(response["signatures"]["dwForceForward"])
dwForceJump = int(response["signatures"]["dwForceJump"])
dwForceLeft = int(response["signatures"]["dwForceLeft"])
dwForceRight = int(response["signatures"]["dwForceRight"])
dwGameDir = int(response["signatures"]["dwGameDir"])
dwGameRulesProxy = int(response["signatures"]["dwGameRulesProxy"])
dwGetAllClasses = int(response["signatures"]["dwGetAllClasses"])
dwGlobalVars = int(response["signatures"]["dwGlobalVars"])
dwGlowObjectManager = int(response["signatures"]["dwGlowObjectManager"])
dwInput = int(response["signatures"]["dwInput"])
dwInterfaceLinkList = int(response["signatures"]["dwInterfaceLinkList"])
dwMouseEnable = int(response["signatures"]["dwMouseEnable"])
dwMouseEnablePtr = int(response["signatures"]["dwMouseEnablePtr"])
dwPlayerResource = int(response["signatures"]["dwPlayerResource"])
dwSensitivity = int(response["signatures"]["dwSensitivity"])
dwSensitivityPtr = int(response["signatures"]["dwSensitivityPtr"])
dwRadarBase = int(response["signatures"]["dwRadarBase"])
dwSetClanTag = int(response["signatures"]["dwSetClanTag"])
dwViewMatrix = int(response["signatures"]["dwViewMatrix"])
dwWeaponTable = int(response["signatures"]["dwWeaponTable"])
dwWeaponTableIndex = int(response["signatures"]["dwWeaponTableIndex"])
dwYawPtr = int(response["signatures"]["dwYawPtr"])
dwZoomSensitivityRatioPtr = int(response["signatures"]["dwZoomSensitivityRatioPtr"])
dwbSendPackets = int(response["signatures"]["dwbSendPackets"])
dwppDirect3DDevice9 = int(response["signatures"]["dwppDirect3DDevice9"])
find_hud_element = int(response["signatures"]["find_hud_element"])
force_update_spectator_glow = int(response["signatures"]["force_update_spectator_glow"])
interface_engine_cvar = int(response["signatures"]["interface_engine_cvar"])
is_c4_owner = int(response["signatures"]["is_c4_owner"])
m_bDormant = int(response["signatures"]["m_bDormant"])
m_flSpawnTime = int(response["signatures"]["m_flSpawnTime"])
m_pStudioHdr = int(response["signatures"]["m_pStudioHdr"])
m_pitchClassPtr = int(response["signatures"]["m_pitchClassPtr"])
m_yawClassPtr = int(response["signatures"]["m_yawClassPtr"])
model_ambient_min = int(response["signatures"]["model_ambient_min"])
set_abs_angles = int(response["signatures"]["set_abs_angles"])
set_abs_origin = int(response["signatures"]["set_abs_origin"])

255
utils/aimbot.py Normal file
View File

@@ -0,0 +1,255 @@
import pymem
import pymem.process
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
from math import *
import features_check
import keyboard
import win32api
class aimbot() :
def __init__(self):
try :
self.pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll
self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll
self.enginepointer = self.pm.read_int(self.engine + dwClientState)
read("aim")
while features_check.check.aimbot :
read("aim")
key = self.get_key()
time.sleep(0.002)
try :
while key :
key = self.get_key()
aimlocalplayer = self.pm.read_int(self.client + dwLocalPlayer)
aimflag = self.pm.read_int(aimlocalplayer + m_fFlags)
aimteam = self.pm.read_int(aimlocalplayer + m_iTeamNum)
for y in range(1):
if self.pm.read_int(self.client + dwEntityList + y * 0x10):
aimplayer = self.GetBestTarget(aimlocalplayer)
aimplayerbone = self.pm.read_int(aimplayer + m_dwBoneMatrix)
gungameimmunity = self.pm.read_int(aimplayer + m_bGunGameImmunity)
aimplayerteam = self.pm.read_int(aimplayer + m_iTeamNum)
aimplayerhealth = self.pm.read_int(aimplayer + m_iHealth)
if aimplayerteam != aimteam and aimplayerhealth > 0 and gungameimmunity != 1:
localpos1 = self.pm.read_float(aimlocalplayer + m_vecOrigin)
localpos2 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 4)
if aimflag == 263:
localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 45
elif aimflag == 257:
localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 62
elif aimflag == 256:
localpos3 = self.pm.read_float(aimlocalplayer + m_vecOrigin + 8) + 64
bone = 8 #head
enemypos1 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0xC)
enemypos2 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0x1C)
enemypos3 = self.pm.read_float(aimplayerbone + 0x30 * bone + 0x2C)
targetline1 = enemypos1 - localpos1
targetline2 = enemypos2 - localpos2
targetline3 = enemypos3 - localpos3
viewanglex = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles)
viewangley = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x4)
if targetline2 == 0 and targetline1 == 0:
yaw = 0
if targetline3 > 0:
pitch = 270
else:
pitch = 90
else:
yaw = (atan2(targetline2, targetline1) * 180 / pi)
if yaw < 0:
yaw += 360
hypo = sqrt(
(targetline1 * targetline1) + (targetline2 * targetline2) + (targetline3 * targetline3))
pitch = (atan2(-targetline3, hypo) * 180 / pi)
if pitch < 0:
pitch += 360
pitch, yaw = self.normalizeAngles(pitch, yaw)
if self.checkangles(pitch, yaw):
distance_x, distance_y = self.calc_distance(viewanglex, viewangley, pitch, yaw)
if distance_x < 900 and distance_y < 900:
if self.nanchecker(pitch, yaw):
key = self.get_key()
if key :
self.pm.write_float(self.enginepointer + dwClientState_ViewAngles, pitch)
self.pm.write_float(self.enginepointer + dwClientState_ViewAngles + 0x4, yaw)
except :
pass
self.pm.close_process()
def get_key(self) :
if "Button.right" in features_check.check.aimbot_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.aimbot_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.aimbot_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.aimbot_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key
def checkindex(self) :
localplayer = self.pm.read_int(self.client + dwLocalPlayer)
for y in range(64):
if self.pm.read_int(self.client + dwEntityList + y * 0x10):
entity = self.pm.read_int(self.client + dwEntityList + y * 0x10)
if localplayer == entity and y:
return y
def nanchecker(self, first, second):
if isnan(first) or isnan(second):
return False
else:
return True
def calc_distance(self, current_x, current_y, new_x, new_y):
distancex = new_x - current_x
if distancex < -89:
distancex += 360
elif distancex > 89:
distancex -= 360
if distancex < 0.0:
distancex = -distancex
distancey = new_y - current_y
if distancey < -180:
distancey += 360
elif distancey > 180:
distancey -= 360
if distancey < 0.0:
distancey = -distancey
return distancex, distancey
def checkangles(self, x, y):
if x > 89:
return False
elif x < -89:
return False
elif y > 360:
return False
elif y < -360:
return False
else:
return True
def normalizeAngles(self, viewAngleX, viewAngleY):
if viewAngleX > 89:
viewAngleX -= 360
if viewAngleX < -89:
viewAngleX += 360
if viewAngleY > 180:
viewAngleY -= 360
if viewAngleY < -180:
viewAngleY += 360
return viewAngleX, viewAngleY
def Magnitude(self, vec_x, vec_y, vec_z):
return sqrt(vec_x * vec_x + vec_y * vec_y + vec_z * vec_z)
def Subtract(self, src_x, src_y, src_z, dst_x, dst_y, dst_z):
diff_x = src_x - dst_x
diff_y = src_y - dst_y
diff_z = src_z - dst_z
return (diff_x, diff_y, diff_z)
def Distance(self, src_x, src_y, src_z, dst_x, dst_y, dst_z):
diff_x, diff_y, diff_z = self.Subtract(src_x, src_y, src_z, dst_x, dst_y, dst_z)
src_x += diff_x
src_y += diff_y
return self.Magnitude(diff_x, diff_y, diff_z)
def calcangle(self, src_x, src_y, src_z, dst_x, dst_y, dst_z):
x = -atan2(dst_x - src_x, dst_y - src_y) / pi * 180.0 + 180.0
y = asin((dst_z - src_z) / self.Distance(src_x, src_y, src_z, dst_x, dst_y, dst_z)) * 180.0 / pi
return x, y
def GetBestTarget(self, local):
while True:
olddist = 1.7976931348623157e+308
newdist = None
target = None
if local :
localplayer_team = self.pm.read_int(local + m_iTeamNum)
for x in range(1):
entity_id = self.pm.read_int(local + m_iCrosshairId)
entity = self.pm.read_int(self.client + dwEntityList + (entity_id - 1) * 0x10)
if self.pm.read_int(self.client + dwEntityList + x * 0x10):
spotted = self.pm.read_int(entity + m_bSpottedByMask)
index = self.checkindex()
entity_health = self.pm.read_int(entity + m_iHealth)
entity_team = self.pm.read_int(entity + m_iTeamNum)
if localplayer_team != entity_team and entity_health > 0 :# and spotted == 1 << index:
entity_bones = self.pm.read_int(entity + m_dwBoneMatrix)
localpos_x = self.pm.read_float(local + m_vecOrigin)
localpos_y = self.pm.read_float(local + m_vecOrigin + 4)
localpos_z = self.pm.read_float(local + m_vecOrigin + 8)
localpos_x_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles)
localpos_y_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x4)
localpos_z_angles = self.pm.read_float(self.enginepointer + dwClientState_ViewAngles + 0x8)
bone = 8 #head
entitypos_x = self.pm.read_float(entity_bones + 0x30 * bone + 0xC)
entitypos_y = self.pm.read_float(entity_bones + 0x30 * bone + 0x1C)
entitypos_z = self.pm.read_float(entity_bones + 0x30 * bone + 0x2C) + 64
X, Y = self.calcangle(entitypos_x, entitypos_y, entitypos_z, localpos_x, localpos_y, localpos_z)
newdist = self.Distance(localpos_x_angles, localpos_y_angles, localpos_z_angles, entitypos_x,
entitypos_y, entitypos_z)
olddist = newdist
target = entity
if target:
return target

50
utils/bhop_legit.py Normal file
View File

@@ -0,0 +1,50 @@
import keyboard
import pymem
import pymem.process
import time
import ctypes, sys
from random import *
from Offsets import *
from win32gui import GetWindowText, GetForegroundWindow
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class bhop_legit() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
read("misc")
while features_check.check.bhop_legit:
try :
read("misc")
if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive":
continue
if keyboard.is_pressed("space"):
force_jump = client + dwForceJump
player = pm.read_int(client + dwLocalPlayer)
if player:
on_ground = pm.read_int(player + m_fFlags)
if on_ground and on_ground == 257:
a = randint(0,5)
time.sleep(a/100)
pm.write_int(force_jump, 5)
time.sleep(0.08)
pm.write_int(force_jump, 4)
time.sleep(0.002)
except :
pass
pm.close_process()

47
utils/bhop_rage.py Normal file
View File

@@ -0,0 +1,47 @@
import keyboard
import pymem
import pymem.process
import time
import ctypes, sys
from Offsets import *
from win32gui import GetWindowText, GetForegroundWindow
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class bhop_rage() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
read("misc")
while features_check.check.bhop_rage:
try :
read("misc")
if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive":
continue
if keyboard.is_pressed("space"):
force_jump = client + dwForceJump
player = pm.read_int(client + dwLocalPlayer)
if player:
on_ground = pm.read_int(player + m_fFlags)
if on_ground and on_ground == 257:
pm.write_int(force_jump, 5)
time.sleep(0.08)
pm.write_int(force_jump, 4)
time.sleep(0.002)
except :
pass
pm.close_process()

124
utils/chams.py Normal file
View File

@@ -0,0 +1,124 @@
import pymem
import pymem.process
import keyboard
import time
import re, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class chams() :
def __init__(self) :
self.pm = pymem.Pymem("csgo.exe")
self.base_client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll
self.base_engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll
self.dye_em()
def get_class_id(self, entity):
buffer = self.pm.read_int(entity + 8)
buffer = self.pm.read_int(buffer + 2 * 4)
buffer = self.pm.read_int(buffer + 1)
return self.pm.read_int(buffer + 20)
def get_entity_team(self, entity):
return self.pm.read_int(entity + m_iTeamNum)
def dye_em(self):
glowmax = self.pm.read_int(self.base_client + dwGlowObjectManager + 4)
glow_object = self.pm.read_int(self.base_client + dwGlowObjectManager)
local_player = self.pm.read_int(self.base_client + dwLocalPlayer)
read("chams")
first = True
while features_check.check.chams_active :
read("chams")
local_player_team = self.get_entity_team(local_player)
allies_color_rgba = self.rgba(features_check.check.allies_chams_color)
ennemies_color_rgba = self.rgba(features_check.check.ennemies_chams_color)
for i in range(glowmax):
try:
entity = self.pm.read_int(glow_object + 56 * i)
if entity != 0 :
if self.get_class_id(entity) == 40:
entity_team = self.get_entity_team(entity)
entity_hp = self.pm.read_int(entity + m_iHealth)
if features_check.check.chams_health_based :
if entity_hp == 100 :
allies_color_rgba = self.rgba("[0, 1, 0, 1]")
ennemies_color_rgba = self.rgba("[0, 1, 0, 1]")
if entity_hp < 100 :
if entity_hp > 75:
ennemies_color_rgba = self.rgba("[0.30, 1, 0, 1]")
allies_color_rgba = self.rgba("[0.30, 1, 0, 1]")
if entity_hp < 75:
ennemies_color_rgba = self.rgba("[0.70, 0.30, 0, 1]")
allies_color_rgba = self.rgba("[0.70, 0.30, 0, 1]")
if entity_hp < 50 :
ennemies_color_rgba = self.rgba("[1, 0.10, 0, 1]")
allies_color_rgba = self.rgba("[1, 0.10, 0, 1]")
if entity_hp < 25 :
ennemies_color_rgba = self.rgba("[1, 0, 0, 1]")
allies_color_rgba = self.rgba("[1, 0, 0, 1]")
if entity_hp == 1 :
ennemies_color_rgba = self.rgba("[1, 1, 1, 1]")
allies_color_rgba = self.rgba("[1, 1, 1, 1]")
if features_check.check.chams_allies :
if entity_team == local_player_team and entity_team != 0 and entity != local_player:
self.pm.write_uchar(entity + 112, allies_color_rgba[0])
self.pm.write_uchar(entity + 113, allies_color_rgba[1])
self.pm.write_uchar(entity + 114, allies_color_rgba[2])
if not features_check.check.chams_allies :
if entity_team == local_player_team and entity_team != 0 and entity != local_player:
self.pm.write_uchar(entity + 112, 255)
self.pm.write_uchar(entity + 113, 255)
self.pm.write_uchar(entity + 114, 255)
if features_check.check.chams_ennemies :
if entity_team != local_player_team and entity_team != 0 and entity != local_player:
self.pm.write_uchar(entity + 112, ennemies_color_rgba[0])
self.pm.write_uchar(entity + 113, ennemies_color_rgba[1])
self.pm.write_uchar(entity + 114, ennemies_color_rgba[2])
if not features_check.check.chams_ennemies :
if entity_team != local_player_team and entity_team != 0 and entity != local_player:
self.pm.write_uchar(entity + 112, 255)
self.pm.write_uchar(entity + 113, 255)
self.pm.write_uchar(entity + 114, 255)
if first == True :
b = 1084227584
pointer = self.pm.read_int(self.base_engine + model_ambient_min - 44)
xored = b ^ pointer
self.pm.write_int(self.base_engine + model_ambient_min, xored)
first = False
time.sleep(0.002)
except Exception as e :
pass
self.pm.close_process()
def rgba(self, string) :
string = str(string)
string = string.strip('][').split(', ')
string[0] = int(round((float(string[0])*255.0)/1.0, 0))
string[1] = int(round((float(string[1])*255.0)/1.0, 0))
string[2] = int(round((float(string[2])*255.0)/1.0, 0))
return string

61
utils/chams_reset.py Normal file
View File

@@ -0,0 +1,61 @@
import pymem
import pymem.process
import keyboard
import time
import re, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class chams_reset() :
def __init__(self) :
self.pm = pymem.Pymem("csgo.exe")
self.base_client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll
self.base_engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll
self.dye_em()
def get_class_id(self, entity):
buffer = self.pm.read_int(entity + 8)
buffer = self.pm.read_int(buffer + 2 * 4)
buffer = self.pm.read_int(buffer + 1)
return self.pm.read_int(buffer + 20)
def get_entity_team(self, entity):
return self.pm.read_int(entity + m_iTeamNum)
def dye_em(self):
glowmax = self.pm.read_int(self.base_client + dwGlowObjectManager + 4)
glow_object = self.pm.read_int(self.base_client + dwGlowObjectManager)
local_player = self.pm.read_int(self.base_client + dwLocalPlayer)
read("chams")
while not features_check.check.chams_active :
read("chams")
for i in range(glowmax):
try:
entity = self.pm.read_int(glow_object + 56 * i)
if self.get_class_id(entity) == 40:
entity_team = self.get_entity_team(entity)
if entity_team != 0 and entity != local_player:
self.pm.write_uchar(entity + 112, 255)
self.pm.write_uchar(entity + 113, 255)
self.pm.write_uchar(entity + 114, 255)
b = 0
pointer = self.pm.read_int(self.base_engine + model_ambient_min - 44)
xored = b ^ pointer
self.pm.write_int(self.base_engine + model_ambient_min, xored)
except :
pass
return
self.pm.close_process()

82
utils/crosshair_hack.py Normal file
View File

@@ -0,0 +1,82 @@
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
import ctypes
import pymem
import pymem.process
import time
sys.path.insert(1, "classes/")
from features_reads import read
from Offsets import *
import features_check
class Crosshair(QtWidgets.QWidget):
def __init__(self, parent=None, windowSize=24, penWidth=2):
QtWidgets.QWidget.__init__(self, parent)
self.ws = windowSize
self.resize(windowSize+1, windowSize+1)
self.pen = QtGui.QPen(QtGui.QColor(0,255,0,255))
self.pen.setWidth(penWidth)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint | QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.WindowTransparentForInput)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.move(QtWidgets.QApplication.desktop().screen().rect().center() - self.rect().center() + QtCore.QPoint(1,1))
def paintEvent(self, event):
ws = self.ws
d = 6
painter = QtGui.QPainter(self)
painter.setPen(self.pen)
# painter.drawLine( x1,y1, x2,y2 )
painter.drawLine( ws/2, 0, ws/2, ws/2 - ws/d ) # Top
painter.drawLine( ws/2, ws/2 + ws/d, ws/2, ws ) # Bottom
painter.drawLine( 0, ws/2, ws/2 - ws/d, ws/2 ) # Left
painter.drawLine( ws/2 + ws/d, ws/2, ws, ws/2 ) # Right
class crosshair_hack() :
def __init__(self) :
app = QtWidgets.QApplication(sys.argv)
widget = Crosshair(windowSize=24, penWidth=1)
widget.show()
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
awp = 9
ssg = 40
scar = 38
g3sg1 = 11
snipers = [awp, ssg, scar, g3sg1]
read("aim")
while features_check.check.crosshair :
try :
read("aim")
app.processEvents()
player = pm.read_int(client + dwLocalPlayer)
scoped = pm.read_int(player + m_bIsScoped)
weapon = pm.read_int(player + m_hActiveWeapon)
weapon_entity = pm.read_int(client + dwEntityList + ((weapon & 0xFFF) - 1) * 0x10)
weapon_id = str(pm.read_short(weapon_entity + m_iItemDefinitionIndex))
if weapon:
if int(weapon_id) in snipers and scoped == 0 :
widget.show()
else :
widget.hide()
time.sleep(0.2)
except :
pass
pm.close_process()

32
utils/fake_lag.py Normal file
View File

@@ -0,0 +1,32 @@
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
from features_reads import read
import features_check
class fake_lag() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll
read("misc")
while features_check.check.fake_lag :
try :
read("misc")
pm.write_float(engine + 0x38E6AC4, features_check.check.fake_lag_value/2)
except :
pass
pm.close_process()

33
utils/fov.py Normal file
View File

@@ -0,0 +1,33 @@
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
from features_reads import read
import features_check
class fov() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
read("misc")
inputFOV = int(round(features_check.check.fov_value, 0))
player = pm.read_int(client + dwLocalPlayer)
while features_check.check.fov :
read("misc")
inputFOV = int(round(features_check.check.fov_value, 0))
fov = player + m_iFOV
pm.write_int(fov, inputFOV)
pm.close_process()

22
utils/fov_reset.py Normal file
View File

@@ -0,0 +1,22 @@
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
class fov_reset() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
player = pm.read_int(client + dwLocalPlayer)
fov = player + m_iFOV
pm.write_int(fov, 90)
pm.close_process()

96
utils/glow.py Normal file
View File

@@ -0,0 +1,96 @@
import pymem
import pymem.process
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class glow() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except Exception as e:
print(e)
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
glow_manager = pm.read_int(client + dwGlowObjectManager)
read("glow")
while features_check.check.glow_active :
try :
read("glow")
for i in range(1, 32): # Entities 1-32 are reserved for players.
entity = pm.read_int(client + dwEntityList + i * 0x10)
if entity:
entity_team_id = pm.read_int(entity + m_iTeamNum)
player = pm.read_int(client + dwLocalPlayer)
player_team = pm.read_int(player + m_iTeamNum)
entity_hp = pm.read_int(entity + m_iHealth)
entity_glow = pm.read_int(entity + m_iGlowIndex)
if features_check.check.glow_health_based :
if entity_hp == 100 :
ennemies_color = [0, 1, 0, 1]
allies_color = [0, 1, 0, 1]
if entity_hp < 100 :
if entity_hp > 75:
ennemies_color = [0.30, 1, 0, 1]
allies_color = [0.30, 1, 0, 1]
if entity_hp < 75:
ennemies_color = [0.70, 0.30, 0, 1]
allies_color = [0.70, 0.30, 0, 1]
if entity_hp < 50 :
ennemies_color = [1, 0.10, 0, 1]
allies_color = [1, 0.10, 0, 1]
if entity_hp < 25 :
ennemies_color = [1, 0, 0, 1]
allies_color = [1, 0, 0, 1]
if entity_hp == 1 :
ennemies_color = [1, 1, 1, 1]
allies_color = [1, 1, 1, 1]
if not features_check.check.glow_health_based :
ennemies_color = self.rgba(features_check.check.ennemies_glow_color)
allies_color = self.rgba(features_check.check.allies_glow_color)
if features_check.check.glow_allies :
if entity_team_id == player_team: # Terrorist
pm.write_float(glow_manager + entity_glow * 0x38 + 0x4, float(allies_color[0])) # R
pm.write_float(glow_manager + entity_glow * 0x38 + 0x8, float(allies_color[1])) # G
pm.write_float(glow_manager + entity_glow * 0x38 + 0xC, float(allies_color[2])) # B
pm.write_float(glow_manager + entity_glow * 0x38 + 0x10, float(allies_color[3])) # Alpha
pm.write_int(glow_manager + entity_glow * 0x38 + 0x24, 1) # Enable glow
if features_check.check.glow_ennemies :
if entity_team_id != player_team: # Counter-terrorist
pm.write_float(glow_manager + entity_glow * 0x38 + 0x4, float(ennemies_color[0])) # R
pm.write_float(glow_manager + entity_glow * 0x38 + 0x8, float(ennemies_color[1])) # G
pm.write_float(glow_manager + entity_glow * 0x38 + 0xC, float(ennemies_color[2])) # B
pm.write_float(glow_manager + entity_glow * 0x38 + 0x10, float(ennemies_color[3])) # Alpha
pm.write_int(glow_manager + entity_glow * 0x38 + 0x24, 1) # Enable glow
time.sleep(0.002)
except :
pass
pm.close_process()
def rgba(self, string) :
string = str(string)
return string.strip('][').split(', ')

42
utils/hitsound.py Normal file
View File

@@ -0,0 +1,42 @@
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
import pymem
import pymem.process
import winsound
class hitsound() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
read("misc")
while features_check.check.hitsound :
try :
read("misc")
player = pm.read_int(client + dwLocalPlayer)
hitsound = pm.read_int(player + m_totalHitsOnServer)
if hitsound > 0:
pm.write_int(player + m_totalHitsOnServer, 0)
winsound.PlaySound("sounds/"+features_check.check.sound, winsound.SND_FILENAME)
time.sleep(0.1)
except :
pass
pm.close_process()

29
utils/money.py Normal file
View File

@@ -0,0 +1,29 @@
import pymem
import pymem.process
import re
import time
import ctypes, sys
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class money() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle,
'client.dll')
clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage)
address = client.lpBaseOfDll + re.search(rb'.\x0C\x5B\x5F\xB8\xFB\xFF\xFF\xFF',
clientModule).start()
pm.write_uchar(address, 0xEB)
pm.close_process()

29
utils/money_reset.py Normal file
View File

@@ -0,0 +1,29 @@
import pymem
import pymem.process
import re
import time
import ctypes, sys
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class money_reset() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle,
'client.dll')
clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage)
address = client.lpBaseOfDll + re.search(rb'.\x0C\x5B\x5F\xB8\xFB\xFF\xFF\xFF',
clientModule).start()
pm.write_uchar(address, 0x75)
pm.close_process()

35
utils/noflash.py Normal file
View File

@@ -0,0 +1,35 @@
import pymem
import pymem.process
import time
import ctypes, sys
import warnings
warnings.simplefilter("ignore")
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class noflash() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
player = pm.read_int(client + dwLocalPlayer)
flash_value = player + m_flFlashMaxAlpha
read("misc")
while features_check.check.no_flash :
try :
read("misc")
pm.write_float(flash_value, float(0))
time.sleep(0.2)
except :
pass
pm.close_process()

35
utils/noflash_reset.py Normal file
View File

@@ -0,0 +1,35 @@
import pymem
import pymem.process
import time
import ctypes, sys
import warnings
warnings.simplefilter("ignore")
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class noflash_reset() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
player = pm.read_int(client + dwLocalPlayer)
flash_value = player + m_flFlashMaxAlpha
read("misc")
while not features_check.check.no_flash :
try :
read("misc")
pm.write_float(flash_value, float(255))
time.sleep(0.2)
except :
pass
pm.close_process()

26
utils/radar.py Normal file
View File

@@ -0,0 +1,26 @@
import pymem
import pymem.process
import re
import ctypes, sys
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class radar() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle,
'client.dll')
clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage)
address = client.lpBaseOfDll + re.search(rb'\x80\xB9.{5}\x74\x12\x8B\x41\x08',
clientModule).start() + 6
pm.write_uchar(address, 2)
pm.close_process()

26
utils/radar_reset.py Normal file
View File

@@ -0,0 +1,26 @@
import pymem
import pymem.process
import re
import ctypes, sys
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class radar_reset() :
def __init__(self) :
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle,
'client.dll')
clientModule = pm.read_bytes(client.lpBaseOfDll, client.SizeOfImage)
address = client.lpBaseOfDll + re.search(rb'\x80\xB9.{5}\x74\x12\x8B\x41\x08',
clientModule).start() + 6
pm.write_uchar(address, 0)
pm.close_process()

79
utils/rank_reveal.py Normal file
View File

@@ -0,0 +1,79 @@
import pymem
import pymem.process
import time
import ctypes
from tkinter import *
from Offsets import *
class rank_reveal() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
top = Tk()
w = 320
h = 300
ws = top.winfo_screenwidth()
hs = top.winfo_screenheight()
x = (ws/2) - (w/2)
y = (hs/2) - (h/2)
top.geometry('%dx%d+%d+%d' % (w, h, x, y))
top.title('Rank Reveal')
top.iconbitmap("images/re.ico")
top.config(background='#f0f0f0')
scrollbar = Scrollbar(top)
scrollbar.pack(side=RIGHT, fill=Y)
listbox = Listbox(top)
listbox.pack(expand=1, fill=BOTH)
listbox.config(yscrollcommand=scrollbar.set)
scrollbar.config(command=listbox.yview)
client = pymem.process.module_from_name(pm.process_handle, "client.dll")
engine = pymem.process.module_from_name(pm.process_handle, "engine.dll")
ranks = ["Unranked" ,
"Silver I",
"Silver II",
"Silver III",
"Silver IV",
"Silver Elite",
"Silver Elite Master",
"Gold Nova I",
"Gold Nova II",
"Gold Nova III",
"Gold Nova Master",
"Master Guardian I",
"Master Guardian II",
"Master Guardian Elite",
"Distinguished Master Guardian",
"Legendary Eagle",
"Legendary Eagle Master",
"Supreme Master First Class",
"The Global Elite"]
for i in range(0, 32):
entity = pm.read_int(client.lpBaseOfDll + dwEntityList + i * 0x10)
if entity:
entity_team_id = pm.read_int(entity + m_iTeamNum)
entity_i = pm.read_int(client.lpBaseOfDll + dwLocalPlayer)
if entity_team_id != pm.read_int(entity_i + m_iTeamNum):
player_info = pm.read_int(
(pm.read_int(engine.lpBaseOfDll + dwClientState)) + dwClientState_PlayerInfo)
player_info_items = pm.read_int(pm.read_int(player_info + 0x40) + 0xC)
info = pm.read_int(player_info_items + 0x28 + (i * 0x34))
playerres = pm.read_int(client.lpBaseOfDll + dwPlayerResource)
rank = pm.read_int(playerres + m_iCompetitiveRanking + i * 4)
if pm.read_string(info + 0x10) != 'GOTV':
try :
listbox.insert(END, pm.read_string(info + 0x10) + " --> " + ranks[rank])
except :
listbox.insert(END, pm.read_string(info + 0x10).encode('iso-8859-1').decode() + " --> " + ranks[rank])
top.mainloop()
pm.close_process()

63
utils/rapidfire.py Normal file
View File

@@ -0,0 +1,63 @@
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
from features_reads import read
import features_check
import keyboard
import win32api
class rapidfire():
def __init__(self) :
read("rapid fire")
key = self.get_key()
while features_check.check.rapid_fire :
try :
read("rapid fire")
key = self.get_key()
if key :
while True :
ctypes.windll.user32.mouse_event(0x0002, 0, 0, 0, 0)
time.sleep(0.01)
ctypes.windll.user32.mouse_event(0x0004, 0, 0, 0, 0)
time.sleep(0.01)
key = self.get_key()
if not key :
break
except :
pass
def get_key(self) :
if "Button.right" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.rapid_fire_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key

94
utils/rcs.py Normal file
View File

@@ -0,0 +1,94 @@
import pymem
import pymem.process
import time
import ctypes, sys, time
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
from math import *
import math
import features_check
class rcs() :
def __init__(self):
try :
self.pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll
self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll
read("rcs")
perfect_percentage = features_check.check.rcs_perfect
oldpunchx = 0.0
oldpunchy = 0.0
while features_check.check.rcs :
read("rcs")
perfect_percentage = features_check.check.rcs_perfect
try :
time.sleep(0.01)
rcslocalplayer = self.pm.read_int(self.client + dwLocalPlayer)
rcsengine = self.pm.read_int(self.engine + dwClientState)
if self.pm.read_int(rcslocalplayer + m_iShotsFired) > 2:
rcs_x = self.pm.read_float(rcsengine + dwClientState_ViewAngles)
rcs_y = self.pm.read_float(rcsengine + dwClientState_ViewAngles + 0x4)
punchx = self.pm.read_float(rcslocalplayer + m_aimPunchAngle)
punchy = self.pm.read_float(rcslocalplayer + m_aimPunchAngle + 0x4)
newrcsx = rcs_x - (punchx - oldpunchx) * (perfect_percentage * 0.02)
newrcsy = rcs_y - (punchy - oldpunchy) * (perfect_percentage * 0.02)
newrcs, newrcy = self.normalizeAngles(newrcsx, newrcsy)
oldpunchx = punchx
oldpunchy = punchy
if self.nanchecker(newrcsx, newrcsy) and self.checkangles(newrcsx, newrcsy):
self.pm.write_float(rcsengine + dwClientState_ViewAngles, newrcsx)
self.pm.write_float(rcsengine + dwClientState_ViewAngles + 0x4, newrcsy)
else:
oldpunchx = 0.0
oldpunchy = 0.0
newrcsx = 0.0
newrcsy = 0.0
except :
pass
self.pm.close_process()
def normalizeAngles(self, viewAngleX, viewAngleY):
if viewAngleX > 89:
viewAngleX -= 360
if viewAngleX < -89:
viewAngleX += 360
if viewAngleY > 180:
viewAngleY -= 360
if viewAngleY < -180:
viewAngleY += 360
return viewAngleX, viewAngleY
def checkangles(self, x, y):
if x > 89:
return False
elif x < -89:
return False
elif y > 360:
return False
elif y < -360:
return False
else:
return True
def nanchecker(self, first, second):
if math.isnan(first) or math.isnan(second):
return False
else:
return True

207
utils/silent.py Normal file
View File

@@ -0,0 +1,207 @@
import pymem
import pymem.process
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
from math import *
import features_check
import keyboard
import win32api
class silent() :
def __init__(self):
try :
self.pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
self.client = pymem.process.module_from_name(self.pm.process_handle, "client.dll").lpBaseOfDll
self.engine = pymem.process.module_from_name(self.pm.process_handle, "engine.dll").lpBaseOfDll
self.engine_pointer = self.pm.read_int(self.engine + dwClientState)
read("aim")
while features_check.check.silent_aim :
read("aim")
key = self.get_key()
while key :
try :
key = self.get_key()
target = None
olddistx = 111111111111
olddisty = 111111111111
if self.client and self.engine and self.pm:
try:
player = self.pm.read_int(self.client + dwLocalPlayer)
localTeam = self.pm.read_int(player + m_iTeamNum)
except :
continue
for i in range(1,32):
key = self.get_key()
entity = self.pm.read_int(self.client + dwEntityList + i * 0x10)
if entity:
try:
entity_team_id = self.pm.read_int(entity + m_iTeamNum)
entity_hp = self.pm.read_int(entity + m_iHealth)
entity_dormant = self.pm.read_int(entity + m_bDormant)
except :
continue
if localTeam != entity_team_id and entity_hp > 0:
entity_bones = self.pm.read_int(entity + m_dwBoneMatrix)
localpos_x_angles = self.pm.read_float(self.engine_pointer + dwClientState_ViewAngles)
localpos_y_angles = self.pm.read_float(self.engine_pointer + dwClientState_ViewAngles + 0x4)
localpos1 = self.pm.read_float(player + m_vecOrigin)
localpos2 = self.pm.read_float(player + m_vecOrigin + 4)
localpos_z_angles = self.pm.read_float(player + m_vecViewOffset + 0x8)
localpos3 = self.pm.read_float(player + m_vecOrigin + 8) + localpos_z_angles
try:
entitypos_x = self.pm.read_float(entity_bones + 0x30 * 8 + 0xC)
entitypos_y = self.pm.read_float(entity_bones + 0x30 * 8 + 0x1C)
entitypos_z = self.pm.read_float(entity_bones + 0x30 * 8 + 0x2C)
except:
continue
try :
X, Y = self.calcangle(localpos1, localpos2, localpos3, entitypos_x, entitypos_y, entitypos_z)
except :
pass
newdist_x, newdist_y = self.calc_distance(localpos_x_angles, localpos_y_angles, X, Y)
if newdist_x < olddistx and newdist_y < olddisty and newdist_x <= 90 and newdist_y <= 90:
olddistx, olddisty = newdist_x, newdist_y
target, target_hp, target_dormant = entity, entity_hp, entity_dormant
target_x, target_y, target_z = entitypos_x, entitypos_y, entitypos_z
if key and player:
if target and target_hp > 0 and not target_dormant:
x, y = self.calcangle(localpos1, localpos2, localpos3, target_x, target_y, target_z)
normalize_x, normalize_y = self.normalizeAngles(x, y)
if key :
#print(dwbSendPackets) #1993604684 #880218
self.pm.write_uchar(self.engine + dwbSendPackets, 0)
Commands = self.pm.read_int(self.client + dwInput + 0xF4)
VerifedCommands = self.pm.read_int(self.client + dwInput + 0xF8)
Desired = self.pm.read_int(self.engine_pointer + clientstate_last_outgoing_command) + 2
OldUser = Commands + ((Desired - 1) % 150) * 100
VerifedOldUser = VerifedCommands + ((Desired - 1) % 150) * 0x68
m_buttons = self.pm.read_int(OldUser + 0x30)
Net_Channel = self.pm.read_uint(self.engine_pointer + clientstate_net_channel)
if self.pm.read_int(Net_Channel + 0x18) >= Desired:
self.pm.write_float(OldUser + 0x0C, normalize_x)
self.pm.write_float(OldUser + 0x10, normalize_y)
self.pm.write_int(OldUser + 0x30, m_buttons | (1 << 0))
self.pm.write_float(VerifedOldUser + 0x0C, normalize_x)
self.pm.write_float(VerifedOldUser + 0x10, normalize_y)
self.pm.write_int(VerifedOldUser + 0x30, m_buttons | (1 << 0))
self.pm.write_uchar(self.engine + dwbSendPackets, 1)
else :
self.pm.write_uchar(self.engine + dwbSendPackets, 1)
else:
self.pm.write_float(self.engine_pointer + dwClientState_ViewAngles, normalize_x)
self.pm.write_float(self.engine_pointer + dwClientState_ViewAngles + 0x4, normalize_y)
time.sleep(0.2)
except :
pass
self.pm.close_process()
def get_key(self) :
if "Button.right" in features_check.check.silent_aim_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.silent_aim_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.silent_aim_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.silent_aim_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key
def normalizeAngles(self, viewAngleX, viewAngleY):
if viewAngleX > 89:
viewAngleX -= 360
if viewAngleX < -89:
viewAngleX += 360
if viewAngleY > 180:
viewAngleY -= 360
if viewAngleY < -180:
viewAngleY += 360
return viewAngleX, viewAngleY
def checkangles(self, x, y):
if x > 89:
return False
elif x < -89:
return False
elif y > 360:
return False
elif y < -360:
return False
else:
return True
def nanchecker(self, first, second):
if math.isnan(first) or math.isnan(second):
return False
else:
return True
def calc_distance(self, current_x, current_y, new_x, new_y):
distancex = new_x - current_x
if distancex < -89:
distancex += 360
elif distancex > 89:
distancex -= 360
if distancex < 0.0:
distancex = -distancex
distancey = new_y - current_y
if distancey < -180:
distancey += 360
elif distancey > 180:
distancey -= 360
if distancey < 0.0:
distancey = -distancey
return distancex, distancey
def calcangle(self, localpos1, localpos2, localpos3, enemypos1, enemypos2, enemypos3):
try:
delta_x = localpos1 - enemypos1
delta_y = localpos2 - enemypos2
delta_z = localpos3 - enemypos3
hyp = sqrt(delta_x * delta_x + delta_y * delta_y + delta_z * delta_z)
x = atan(delta_z / hyp) * 180 / pi
y = atan(delta_y / delta_x) * 180 / pi
if delta_x >= 0.0:
y += 180.0
return x, y
except Exception as e:
print(e)
pass

71
utils/soundesp.py Normal file
View File

@@ -0,0 +1,71 @@
from Offsets import *
from ctypes import *
import ctypes
import pymem
import pymem.process
import time
import win32api
import random
import win32gui
import math
import winsound
sys.path.insert(1, "classes/")
from features_reads import read
import features_check
class sound_esp() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll
localPlayer = pm.read_int(client + dwLocalPlayer) # Get localPlayer pointer
maxSoundESPDistance = 780 # Default: 780, decent distance tbh
read("misc")
while features_check.check.sound_esp :
try :
read("misc")
closestPlayer = 99999.0
for i in range(0, 32):
read("misc")
ent = pm.read_int(client + dwEntityList + i * 0x10) # Get current entity based on for-loop variable i
if ent is 0x0:
break
entDormant = pm.read_int(ent + m_bDormant) # Get boolean that states whether glowCurrentPlayer entity is dormant or not
myTeamID = pm.read_int(localPlayer + m_iTeamNum) # Get the team ID of the localPlayer
entityBaseTeamID = pm.read_int(ent + m_iTeamNum) # Get the team ID of the ent entity-
localPlayerX = pm.read_float(localPlayer + m_vecOrigin) # Get the X coordinate of the vecOrigin of the localPlayer
localPlayerY = pm.read_float(localPlayer + m_vecOrigin + 0x4) # Get the Y coordinate of the vecOrigin of the localPlayer
localPlayerZ = pm.read_float(localPlayer + m_vecOrigin + 0x8) # Get the Z coordinate of the vecOrigin of the localPlayer
entityX = pm.read_float(ent + m_vecOrigin) # Get the X coordinate of the vecOrigin of the ent
entityY = pm.read_float(ent + m_vecOrigin + 0x4) # Get the Y coordinate of the vecOrigin of the ent
entityZ = pm.read_float(ent + m_vecOrigin + 0x8) # Get the Z coordinate of the vecOrigin of the ent
distance = math.sqrt((pow((entityX - localPlayerX), 2) + pow((entityY - localPlayerY), 2) + pow((entityZ - localPlayerZ), 2))) # Get the distance between localPlayer and ent
if myTeamID != entityBaseTeamID and closestPlayer > distance: # If not on localPlayer team and team is either 2 or 3 and distance isnt 0 and distance is less than closestPlayer
closestPlayer = distance
if closestPlayer < maxSoundESPDistance: # If closestPlayer isnt default value and closestPlayer is closer than maxSoundESPDistance
durMath = 1.000/maxSoundESPDistance # Generate baseline mathematical thingy - use ur brain
#winsound.Beep(2500, 2)
winsound.Beep(500, int((durMath * closestPlayer) * 1000))
except :
pass
pm.close_process()

80
utils/thirdperson.py Normal file
View File

@@ -0,0 +1,80 @@
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
from features_reads import read
import features_check
import keyboard
import win32api
class thirdperson() :
def __init__(self):
try :
pm_memory = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm_memory.process_handle, "client.dll").lpBaseOfDll
lcbase = pm_memory.read_int(client + dwLocalPlayer)
fov = lcbase + m_iFOV
read("misc")
key = self.get_key()
third_toggle = False
while features_check.check.third_person :
read("misc")
key = self.get_key()
if key :
try :
if not third_toggle :
pm_memory.write_int(lcbase + m_iObserverMode, 1)
pm_memory.write_int(fov, 130)
third_toggle = True
elif third_toggle :
pm_memory.write_int(lcbase + m_iObserverMode, 0)
pm_memory.write_int(fov, 90)
third_toggle = False
time.sleep(0.2)
except :
pass
pm.close_process()
def get_key(self) :
if "Button.right" in features_check.check.thirdperson_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.thirdperson_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.thirdperson_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.thirdperson_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key

91
utils/triggerbot.py Normal file
View File

@@ -0,0 +1,91 @@
import pymem
import pymem.process
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
from features_reads import read
from math import *
import features_check
import keyboard
import win32api
from win32gui import GetWindowText, GetForegroundWindow
class triggerbot() :
def __init__(self):
try :
pm = pymem.Pymem("csgo.exe")
except :
MessageBox = ctypes.windll.user32.MessageBoxW
MessageBox(None, 'Could not find the csgo.exe process !', 'Error', 16)
return
client = pymem.process.module_from_name(pm.process_handle, "client.dll").lpBaseOfDll
engine = pymem.process.module_from_name(pm.process_handle, "engine.dll").lpBaseOfDll
read("triggerbot")
delay = features_check.check.t_delay
key = self.get_key()
while features_check.check.triggerbot :
read("triggerbot")
delay = features_check.check.t_delay
key = self.get_key()
if not GetWindowText(GetForegroundWindow()) == "Counter-Strike: Global Offensive":
continue
if key :
try :
key = self.get_key()
player = pm.read_int(client + dwLocalPlayer)
entity_id = pm.read_int(player + m_iCrosshairId)
entity = pm.read_int(client + dwEntityList + (entity_id - 1) * 0x10)
entity_team = pm.read_int(entity + m_iTeamNum)
player_team = pm.read_int(player + m_iTeamNum)
if entity_id > 0 and entity_id <= 64 and player_team != entity_team:
if delay == 0 :
time.sleep(0)
else :
time.sleep(delay/1000)
pm.write_int(client + dwForceAttack, 6)
time.sleep(0.006)
except :
pass
pm.close_process()
def get_key(self) :
if "Button.right" in features_check.check.triggerbot_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.triggerbot_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.triggerbot_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.triggerbot_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key