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()
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()
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 __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()
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 __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()
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 __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()
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 + 0x38E0ACC,
features_check.check.fake_lag_value / 2)
except:
pass
pm.close_process()
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()
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 __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 __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 __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 + 0x8,
float(allies_color[0])) # R
pm.write_float(glow_manager +
entity_glow * 0x38 + 0xC,
float(allies_color[1])) # G
pm.write_float(glow_manager +
entity_glow * 0x38 + 0x10,
float(allies_color[2])) # B
pm.write_float(glow_manager +
entity_glow * 0x38 + 0x14,
float(allies_color[3])) # Alpha
pm.write_int(glow_manager +
entity_glow * 0x38 + 0x28,
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 + 0x8,
float(ennemies_color[0])) # R
pm.write_float(glow_manager +
entity_glow * 0x38 + 0xC,
float(ennemies_color[1])) # G
pm.write_float(glow_manager +
entity_glow * 0x38 + 0x10,
float(ennemies_color[2])) # B
pm.write_float(
glow_manager + entity_glow * 0x38 + 0x14,
float(ennemies_color[3])) # Alpha
pm.write_int(glow_manager +
entity_glow * 0x38 + 0x28,
1) # Enable glow
time.sleep(0.002)
except:
pass
pm.close_process()
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 is_running(self):
glow_switch = False
chams_switch = False
chams_reset_switch = False
aimbot_switch = False
rcs_switch = False
triggerbot_switch = False
rapidfire_switch = False
silent_aim_switch = False
crosshair_switch = False
thirdperson_switch = False
fov_switch = False
fov_reset_switch = False
hitsound_switch = False
soundesp_switch = False
noflash_switch = False
noflash_reset_switch = False
bhop_rage_switch = False
bhop_legit_switch = False
show_money_switch = False
show_money_reset_switch = False
radar_switch = False
radar_reset_switch = False
fake_lag_switch = False
multiprocessing.freeze_support()
t_skinchanger = Process(target=skinchanger_func)
t_skinchanger.start()
multiprocessing.freeze_support()
t_knifechanger = Process(target=knifechanger_func)
t_knifechanger.start()
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
while True:
try:
time.sleep(0.3)
engine_state = pm.read_int(engine + dwClientState)
if pm.read_int(engine_state + dwClientState_State
) != 6 and t_knifechanger.is_alive(
) and t_skinchanger.is_alive():
t_skinchanger.terminate()
t_knifechanger.terminate()
elif pm.read_int(engine_state + dwClientState_State
) == 6 and not t_knifechanger.is_alive(
) and not t_skinchanger.is_alive():
multiprocessing.freeze_support()
t_skinchanger = Process(target=skinchanger_func)
t_skinchanger.start()
multiprocessing.freeze_support()
t_knifechanger = Process(target=knifechanger_func)
t_knifechanger.start()
read()
if check.glow_active and glow_switch == False:
multiprocessing.freeze_support()
t_glow = Process(target=glow)
t_glow.start()
glow_switch = True
elif not check.glow_active and glow_switch == True:
t_glow.terminate()
glow_switch = False
if check.chams_active and chams_switch == False:
if chams_reset_switch == True:
t_chams_reset.terminate()
chams_reset_switch = False
multiprocessing.freeze_support()
t_chams = Process(target=chams)
t_chams.start()
chams_switch = True
elif not check.chams_active and chams_switch == True:
t_chams.terminate()
multiprocessing.freeze_support()
t_chams_reset = Process(target=chams_reset)
t_chams_reset.start()
chams_reset_switch = True
chams_switch = False
if check.aimbot and aimbot_switch == False:
multiprocessing.freeze_support()
t_aimbot = Process(target=aimbot)
t_aimbot.start()
aimbot_switch = True
elif not check.aimbot and aimbot_switch == True:
t_aimbot.terminate()
aimbot_switch = False
if check.rcs and rcs_switch == False:
multiprocessing.freeze_support()
t_rcs = Process(target=rcs)
t_rcs.start()
rcs_switch = True
elif not check.rcs and rcs_switch == True:
t_rcs.terminate()
rcs_switch = False
if check.triggerbot and triggerbot_switch == False:
multiprocessing.freeze_support()
t_triggerbot = Process(target=triggerbot)
t_triggerbot.start()
triggerbot_switch = True
elif not check.triggerbot and triggerbot_switch == True:
t_triggerbot.terminate()
triggerbot_switch = False
if check.rapid_fire and rapidfire_switch == False:
multiprocessing.freeze_support()
t_rapid_fire = Process(target=rapidfire)
t_rapid_fire.start()
rapidfire_switch = True
elif not check.rapid_fire and rapidfire_switch == True:
t_rapid_fire.terminate()
rapidfire_switch = False
if check.silent_aim and silent_aim_switch == False:
multiprocessing.freeze_support()
t_silent_aim = Process(target=silent)
t_silent_aim.start()
silent_aim_switch = True
elif not check.silent_aim and silent_aim_switch == True:
t_silent_aim.terminate()
silent_aim_switch = False
if check.crosshair and crosshair_switch == False:
multiprocessing.freeze_support()
t_crosshair = Process(target=crosshair_hack)
t_crosshair.start()
crosshair_switch = True
elif not check.crosshair and crosshair_switch == True:
t_crosshair.terminate()
crosshair_switch = False
if check.third_person and thirdperson_switch == False:
multiprocessing.freeze_support()
t_thirdperson = Process(target=thirdperson)
t_thirdperson.start()
thirdperson_switch = True
elif not check.third_person and thirdperson_switch == True:
t_thirdperson.terminate()
thirdperson_switch = False
if check.fov and fov_switch == False:
if fov_reset_switch == True:
t_fov_reset.terminate()
fov_reset_switch = False
multiprocessing.freeze_support()
t_fov = Process(target=fov)
t_fov.start()
fov_switch = True
elif not check.fov and fov_switch == True:
t_fov.terminate()
multiprocessing.freeze_support()
t_fov_reset = Process(target=fov_reset)
t_fov_reset.start()
fov_reset_switch = True
fov_switch = False
if check.hitsound and hitsound_switch == False:
multiprocessing.freeze_support()
t_hitsound = Process(target=hitsound)
t_hitsound.start()
hitsound_switch = True
elif not check.hitsound and hitsound_switch == True:
t_hitsound.terminate()
hitsound_switch = False
if check.sound_esp and soundesp_switch == False:
multiprocessing.freeze_support()
t_soundesp = Process(target=sound_esp)
t_soundesp.start()
soundesp_switch = True
elif not check.sound_esp and soundesp_switch == True:
t_soundesp.terminate()
soundesp_switch = False
if check.no_flash and noflash_switch == False:
if noflash_reset_switch == True:
t_noflash_reset.terminate()
noflash_reset_switch = False
multiprocessing.freeze_support()
t_noflash = Process(target=noflash)
t_noflash.start()
noflash_switch = True
elif not check.no_flash and noflash_switch == True:
t_noflash.terminate()
multiprocessing.freeze_support()
t_noflash_reset = Process(target=noflash_reset)
t_noflash_reset.start()
noflash_reset_switch = True
noflash_switch = False
if check.bhop_rage and bhop_rage_switch == False:
multiprocessing.freeze_support()
t_bhop_rage = Process(target=bhop_rage)
t_bhop_rage.start()
bhop_rage_switch = True
elif not check.bhop_rage and bhop_rage_switch == True:
t_bhop_rage.terminate()
bhop_rage_switch = False
if check.bhop_legit and bhop_legit_switch == False:
multiprocessing.freeze_support()
t_bhop_legit = Process(target=bhop_legit)
t_bhop_legit.start()
bhop_legit_switch = True
elif not check.bhop_legit and bhop_legit_switch == True:
t_bhop_legit.terminate()
bhop_legit_switch = False
if check.show_money and show_money_switch == False:
if show_money_reset_switch == True:
t_show_money_reset.terminate()
show_money_reset_switch = False
multiprocessing.freeze_support()
t_show_money = Process(target=money)
t_show_money.start()
show_money_switch = True
elif not check.show_money and show_money_switch == True:
t_show_money.terminate()
multiprocessing.freeze_support()
t_show_money_reset = Process(target=money_reset)
t_show_money_reset.start()
show_money_reset_switch = True
show_money_switch = False
if check.radar and radar_switch == False:
if radar_reset_switch == True:
t_radar_reset.terminate()
radar_reset_switch = False
multiprocessing.freeze_support()
t_radar = Process(target=radar)
t_radar.start()
radar_switch = True
elif not check.radar and radar_switch == True:
t_radar.terminate()
multiprocessing.freeze_support()
t_radar_reset = Process(target=radar_reset)
t_radar_reset.start()
radar_reset_switch = True
radar_switch = False
if check.fake_lag and fake_lag_switch == False:
multiprocessing.freeze_support()
t_fake_lag = Process(target=fake_lag)
t_fake_lag.start()
fake_lag_switch = True
elif not check.fake_lag and fake_lag_switch == True:
t_fake_lag.terminate()
fake_lag_switch = False
except Exception as e:
print(e)
