|
а я уже походу в глаза еб*сь
Новичок
Pyckyn
[CITA = "lagasy, post: 88743, member: 3813"] na verdade C + P todos sabem como, aproveite
[SPOILER = "SDK.h"]
[/ SPOILER]
[SPOILER = "SDK.cpp"]
#include "stdafx.h"
#include <unordered_map>
// ------------------------------------------------ ------------
// Classes para ajudar a analisar os netvars
// ------------------------------------------------ ------------
#cragma region Aulas auxiliares
typedef unordered_map <string, unique_ptr <NetvarTable >> TableMap;
typedef unordered_map <string, uint32_t> PropMap;
typedef unordered_map <string, unique_ptr <NetvarTable >> :: iterator Iter;
struct NetvarTable {
TableMap m_ChildTables;
PropMap m_ChildProps;
uint32_t m_uOffset = 0;
bool is_empty () {
Retorna m_ChildTables.size () == 0 && m_ChildProps.size () == 0;
}
void insert_table (string && nome, unique_ptr <NetvarTable> && pTable) {
m_ChildTables.emplace (name, std :: move (pTable));
}
void insert_prop (string && name, uint32_t offset) {
m_ChildProps.emplace (nome, offset);
}
};}};
classe NetvarDatabase {
público:
TableMap m_Tables;
inserir vazio (string && nome, unique_ptr <NetvarTable> && pTable) {
m_Tables.emplace (name, std :: move (pTable));
}
Iter find (const string & key) {
retornar m_Tables.find (chave);
}
Iter begin () {return m_Tables.begin (); }
Iter end () {return m_Tables.end (); }
};}};
#pragma endregion
// ------------------------------------------------ ------------
// Netvar Manager
// ------------------------------------------------ ------------
CNetvarManager * CNetvarManager :: instance = nullptr;
CNetvarManager :: CNetvarManager () {
}
CNetvarManager :: ~ CNetvarManager () {
}
vazio CNetvarManager :: CreateDatabase () {
m_pDatabase = make_unique <NetvarDatabase> ();
auto pClient = Interfaces.pClient;
se (pClient) {
para (pClass automático = pClient-> GetAllClasses (); pClass; pClass = pClass-> m_pNext) {
se (pClass-> m_pRecvTable) {
// Insira nova entrada no banco de dados
m_pDatabase-> insert (
pClass-> m_pRecvTable-> m_pNetTableName,
InternalLoadTable (pClass-> m_pRecvTable, 0));
m_tableCount ++;
}
}
}
}
vazio CNetvarManager :: Dump (std :: ostream & output) {
para (auto & entry: * m_pDatabase) {
Auto & pTable = entry.second;
se (pTable-> is_empty ())
continuar;
saída << entry.first << std :: endl;
Dump (saída, * pTable, 1);
saída << "============================================== ================ "<< std :: endl;
}
}
anular CNetvarManager :: Dump (const std :: string & file) {
std :: output de saída (arquivo);
Dump (saída);
}
// ------------------------------------------------ ------------
// Métodos internos abaixo. Este é o lugar onde o trabalho real é feito
// ------------------------------------------------ ------------
unique_ptr <NetvarTable> CNetvarManager :: InternalLoadTable (RecvTable * pRecvTable, uint32_t offset) {
auto pTable = make_unique <NetvarTable> ();
pTable-> m_uOffset = offset;
para (auto i = 0; i <pRecvTable-> m_nProps; ++ i) {
auto pProp = & pRecvTable-> m_pProps ;
// Salte os itens da lixeira
se (! pProp || isdigit (pProp-> m_pVarName [0])) continue;
// Nós não nos preocupamos com a classe base
se (strcmp (pProp-> m_pVarName, "baseclass") == 0) continue;
// Se este suporte é uma tabela
se (pProp-> m_RecvType == SendPropType :: DPT_DataTable && // Se é uma tabela AND
pProp-> m_pDataTable! = NULL && // O DataTable não é nulo AND
pProp-> m_pDataTable-> m_pNetTableName [0] == 'D') {// O nome da tabela começa com D (isto é porque existem algumas merda aninhadas
// tabelas que queremos ignorar, e aqueles que não começam com D)
// Carrega a tabela apontada por pProp-> m_pDataTable e insira-a
pTable-> insert_table (pProp-> m_pVarName, InternalLoadTable (pProp-> m_pDataTable, pProp-> m_Offset));
}
else {
pTable-> insert_prop (pProp-> m_pVarName, pProp-> m_Offset);
}
m_netvarCount ++;
}
retornar pTable;
}
void CNetvarManager :: Dump (std :: ostream & output, NetvarTable & table, int level) {
linha de caracteres [512] = "";
char fmt [512] = "";
sprintf (fmt, "%% -% ds: 0x %% 08X \ n", 50 - nível * 4);
para (auto & prop: table.m_ChildProps) {
para (int i = 0; i <level; i ++) {
se (i! = level - 1) {
saída << "";
}
else {
saída << "| ___";
}
}
sprintf (linha, fmt, prop.first.c_str (), prop.second + table.m_uOffset);
saída << linha;
}
para (auto & child: table.m_ChildTables) {
para (int i = 0; i <level; i ++) {
se (i! = level - 1) {
saída << "";
}
else {
saída << "| ___";
}
}
sprintf (linha, fmt, child.first.c_str (), child.second-> m_uOffset);
saída << linha;
Dump (saída, * child.second, level + 1);
}
}
uint32_t CNetvarManager :: GetOffset (const std :: string & szTableName, const std :: initializer_list <std :: string> & props) {
tabela automática = m_pDatabase-> find (szTableName);
se (tabela == m_pDatabase-> end ()) return -1;
int tableOffset = table-> second-> m_uOffset;
se (props.size () == 0) return tableOffset;
int totalOffset = tableOffset;
NetvarTable * curTable = table-> second.get ();
para (auto i = 0; i <props.size (); i ++) {
std :: string propName = * (props.begin () + i);
se (i + 1 <props.size ()) {// Este índice não é o último
auto childTable = curTable-> m_ChildTables.find (propName);
se (childTable == curTable-> m_ChildTables.end ()) {
lance std :: runtime_error ("Prop not found");
}
totalOffset + = childTable-> second-> m_uOffset;
curTable = childTable-> second.get ();
}
else {// Último índice, recuperar suporte em vez de tabela
auto childProp = curTable-> m_ChildProps.find (propName);
se (childProp == curTable-> m_ChildProps.end ()) {
lance std :: runtime_error ("Prop not found");
}
totalOffset + = childProp-> segundo;
}
}
retornar totalOffset;
}
vazio UTIL_TraceLine (Vector & vecAbsStart, Vector & vecAbsEnd, máscara int não assinada, const IHandleEntity * ignore, int collisionGroup, trace_t * ptr)
{
Ray_t ray;
ray.Init (vecAbsStart, vecAbsEnd);
CTraceFilter traceFilter;
traceFilter.pSkip = (void *) ignore;
Interfaces.pTrace-> TraceRay (ray, mask, & traceFilter, ptr);
}
vazio UTIL_TracePos (Ray_t & ray, máscara int não assinada, const IHandleEntity * ignore, int collisionGroup, trace_t * ptr)
{
CTraceFilter traceFilter;
traceFilter.pSkip = (void *) ignore;
Interfaces.pTrace-> TraceRay (ray, mask, & traceFilter, ptr);
}
Float DistanceToRay (const Vector & pos, const Vector & rayStart, const Vector & rayEnd, float * along = NULL, Vector * pointOnRay = NULL)
{
Vector to = pos - rayStart;
Vector dir = rayEnd - rayStart;
comprimento do flutuador = dir.NormalizeInPlace ();
Float RangeAlong = g_Math.DotProduct (dir, to);
se (ao longo)
{
* along = rangeAlong;
}
intervalo de flutuação;
se (rangeAlong <0.0f)
{
// ponto de partida
range = - (pos-rayStart) .Length ();
se (pointOnRay)
{
* pointOnRay = rayStart;
}
}
senão se (rangeAlong> length)
{
// ponto final
range = - (pos-rayEnd) .Length ();
se (pointOnRay)
{
* pointOnRay = rayEnd;
}
}
else // dentro dos limites do raio
{
Vector onRay = rayStart + (dir.operator * (rangeAlong));
range = (pos-onRay) .Length ();
se (pointOnRay)
{
* pointOnRay = onRay;
}
}
intervalo de retorno;
}
vazio UTIL_ClipTraceToPlayers (Vector & vecAbsStart, Vector & vecAbsEnd, máscara int não assinada, ITraceFilter * filter, trace_t * tr)
{
trace_t playerTrace;
Ray_t ray;
flutuar a menorFração = tr-> fração;
const float maxRange = 60.0f;
ray.Init (vecAbsStart, vecAbsEnd);
para (int k = 1; k <= Interfaces.pGlobalVars-> maxClients; ++ k)
{
CBaseEntity * player = Interfaces.pEntList-> GetClientEntity (k);
se (! player ||! player-> isAlive ())
continuar;
se (jogador-> IsDormant ())
continuar;
se (filter && filter-> ShouldHitEntity (player, mask) == false)
continuar;
gama flutuador = DistanceToRay (player-> WorldSpaceCenter (), vecAbsStart, vecAbsEnd);
se (intervalo <0.0f | range> maxRange)
continuar;
Interfaces.pTrace-> ClipRayToEntity (ray, máscara | CONTENTS_HITBOX, jogador, & playerTrace);
se (playerTrace.fraction <smallestFraction)
{
// reduzimos o raio - salve o traço
* tr = playerTrace;
menor executado = playerTrace.fraction;
}
}
}
bool TraceToExit (Vector & fim, trace_t & tr, Vector início, Vector vend, trace_t * traço)
{
bool typedef (__ fastcall * TraceToExitFn) (Vector &, trace_t &, float, float, float, float, float, float, trace_t *);
DWORD estática TraceToExit = Utils.PatternSearch ( "client.dll", (BYTE *) "\ x55 \ x8B \ Xec \ x83 \ Xec \ x30 \ XF3 \ x0F \ x10 \ x75", "xxxxxxxxxx", NULL, NULL);
se (! TraceToExit)
retornar falso;
float start_y = start.y, start_z = start.z, start_x = start.x, dir_y = vEnd.y, dir_x = vEnd.x, dir_z = vEnd.z;
_asm
{
empurrar rastreamento
pressione dir_z
pressione dir_y
push dir_x
pressione start_z
pressione start_y
pressione start_x
mov edx, tr
mov ecx, fim
chame TraceToExit
adicionar esp, 0x1C
}
}
CBaseCombatWeapon * CBaseEntity :: GetActiveBaseCombatWeapon () {
static int m_hActiveWeapon = GET_NETVAR ("DT_BaseCombatCharacter", "m_hActiveWeapon");
DWORD weaponHandle = * (DWORD *) ((DWORD) this + (DWORD) m_hActiveWeapon);
retorno (CBaseCombatWeapon *) (Interfaces.pEntList-> GetClientEntity (weaponHandle & 0xFFF));
}
const char * ConVar :: GetName ()
{
typedef char * (__ thiscall * GetNameFn) (void *);
retornar getvfunc <GetNameFn> (isto, ConVar_GetName) (this);
}
const char * ConVar :: GetBaseName ()
{
typedef char * (__ thiscall * GetNameFn) (void *);
retornar getvfunc <GetNameFn> (este, ConVar_GetBaseName) (este);
}
void ConVar :: SetValue (const char * value)
{
typedef void (__ thiscall * SetValueFn) (void *, const char *);
retornar getvfunc <SetValueFn> (isto, ConVar_SetString) (este, valor);
}
vazio ConVar :: SetValue (valor flutuante)
{
typedef void (__ thiscall * SetValueFn) (void *, float);
retornar getvfunc <SetValueFn> (isto, ConVar_SetFloat) (este, valor);
}
vazio ConVar :: SetValue (valor int)
{
typedef void (__ thiscall * SetValueFn) (void *, int);
retornar getvfunc <SetValueFn> (este, ConVar_SetInt) (este, valor);
}
[/ SPOILER]
[SPOILER = "Entitys.h"]
CBaseCombatWeapon * GetActiveBaseCombatWeapon ();
bool SetupBones (matrix3x4 * pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime) {
static DWORD m_nWritableBones = GET_NETVAR ("DT_BaseAnimating", "m_nForceBone");
estática DWORD m_dwOcclusionArray = * (uintptr_t *) (Utils.PatternSearch ( "client.dll", (PBYTE) "\ xA1 \ x00 \ x00 \ x00 \ x00 \ x8B \ xB7 \ x00 \ x00 \ x00 \ x00 \ x89 \ x75 \ xF8 "," x "xx" xxx ", 0, 0) + 0x1);
estática DWORD m_bDidCheckForOcclusion = * (uintptr_t *) (Utils.PatternSearch ( "client.dll", (PBYTE) "\ xA1 \ x00 \ x00 \ x00 \ x00 \ x8B \ xB7 \ x00 \ x00 \ x00 \ x00 \ x89 \ x75 \ xF8 "," x "xx" xxx ", 0, 0) + 0x7);
* (int *) ((uintptr_t) this + m_nWritableBones) = 0;
* (int *) ((uintptr_t) this + m_bDidCheckForOcclusion) = reinterpret_cast <int *> (m_dwOcclusionArray) [1];
__asm
{
mov edi, isso
lea ecx, dword ptr ds: [edi + 0x4]
mov edx, dword ptr ds: [ecx]
Pressione CurrentTime
push boneMask
empurre nMaxBones
pressione pBoneToWorldOut
Ligue dword ptr ds: [edx + 0x34]
}
}
anular CBaseCombatWeapon :: UpdateAccuracyPenalty () {
typedef void (__ thiscall * OriginalFn) (void *);
getvfunc <OriginalFn> (isto, 485) (este);
}
float & CBaseCombatWeapon :: GetAccuracyPenalty () {
static int m_fAccuracyPenalty = GET_NETVAR (("DT_WeaponCSBase"), ("m_fAccuracyPenalty")));
retorno * (float *) ((DWORD) this + m_fAccuracyPenalty);
}
float CBaseCombatWeapon :: GetInaccuracy () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 483) (este);
}
flutuar CBaseCombatWeapon :: GetSpread () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 484) (este); // 479
}
float CBaseCombatWeapon :: GetWeaponCone () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 482) (este);
}
CCSWeaponInfo * GetCSWpnData ()
{
se (! this) retornar nullptr;
typedef CCSWeaponInfo * (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 456) (este);
}
[/ SPOILER]
[SPOILER = "XD Surprises"] [/ SPOILER]
VirusTotal não é necessário para surtsy [/ QUOTE]
THAX MY BRO
[SPOILER = "SDK.h"]
[/ SPOILER]
[SPOILER = "SDK.cpp"]
#include "stdafx.h"
#include <unordered_map>
// ------------------------------------------------ ------------
// Classes para ajudar a analisar os netvars
// ------------------------------------------------ ------------
#cragma region Aulas auxiliares
typedef unordered_map <string, unique_ptr <NetvarTable >> TableMap;
typedef unordered_map <string, uint32_t> PropMap;
typedef unordered_map <string, unique_ptr <NetvarTable >> :: iterator Iter;
struct NetvarTable {
TableMap m_ChildTables;
PropMap m_ChildProps;
uint32_t m_uOffset = 0;
bool is_empty () {
Retorna m_ChildTables.size () == 0 && m_ChildProps.size () == 0;
}
void insert_table (string && nome, unique_ptr <NetvarTable> && pTable) {
m_ChildTables.emplace (name, std :: move (pTable));
}
void insert_prop (string && name, uint32_t offset) {
m_ChildProps.emplace (nome, offset);
}
};}};
classe NetvarDatabase {
público:
TableMap m_Tables;
inserir vazio (string && nome, unique_ptr <NetvarTable> && pTable) {
m_Tables.emplace (name, std :: move (pTable));
}
Iter find (const string & key) {
retornar m_Tables.find (chave);
}
Iter begin () {return m_Tables.begin (); }
Iter end () {return m_Tables.end (); }
};}};
#pragma endregion
// ------------------------------------------------ ------------
// Netvar Manager
// ------------------------------------------------ ------------
CNetvarManager * CNetvarManager :: instance = nullptr;
CNetvarManager :: CNetvarManager () {
}
CNetvarManager :: ~ CNetvarManager () {
}
vazio CNetvarManager :: CreateDatabase () {
m_pDatabase = make_unique <NetvarDatabase> ();
auto pClient = Interfaces.pClient;
se (pClient) {
para (pClass automático = pClient-> GetAllClasses (); pClass; pClass = pClass-> m_pNext) {
se (pClass-> m_pRecvTable) {
// Insira nova entrada no banco de dados
m_pDatabase-> insert (
pClass-> m_pRecvTable-> m_pNetTableName,
InternalLoadTable (pClass-> m_pRecvTable, 0));
m_tableCount ++;
}
}
}
}
vazio CNetvarManager :: Dump (std :: ostream & output) {
para (auto & entry: * m_pDatabase) {
Auto & pTable = entry.second;
se (pTable-> is_empty ())
continuar;
saída << entry.first << std :: endl;
Dump (saída, * pTable, 1);
saída << "============================================== ================ "<< std :: endl;
}
}
anular CNetvarManager :: Dump (const std :: string & file) {
std :: output de saída (arquivo);
Dump (saída);
}
// ------------------------------------------------ ------------
// Métodos internos abaixo. Este é o lugar onde o trabalho real é feito
// ------------------------------------------------ ------------
unique_ptr <NetvarTable> CNetvarManager :: InternalLoadTable (RecvTable * pRecvTable, uint32_t offset) {
auto pTable = make_unique <NetvarTable> ();
pTable-> m_uOffset = offset;
para (auto i = 0; i <pRecvTable-> m_nProps; ++ i) {
auto pProp = & pRecvTable-> m_pProps ;
// Salte os itens da lixeira
se (! pProp || isdigit (pProp-> m_pVarName [0])) continue;
// Nós não nos preocupamos com a classe base
se (strcmp (pProp-> m_pVarName, "baseclass") == 0) continue;
// Se este suporte é uma tabela
se (pProp-> m_RecvType == SendPropType :: DPT_DataTable && // Se é uma tabela AND
pProp-> m_pDataTable! = NULL && // O DataTable não é nulo AND
pProp-> m_pDataTable-> m_pNetTableName [0] == 'D') {// O nome da tabela começa com D (isto é porque existem algumas merda aninhadas
// tabelas que queremos ignorar, e aqueles que não começam com D)
// Carrega a tabela apontada por pProp-> m_pDataTable e insira-a
pTable-> insert_table (pProp-> m_pVarName, InternalLoadTable (pProp-> m_pDataTable, pProp-> m_Offset));
}
else {
pTable-> insert_prop (pProp-> m_pVarName, pProp-> m_Offset);
}
m_netvarCount ++;
}
retornar pTable;
}
void CNetvarManager :: Dump (std :: ostream & output, NetvarTable & table, int level) {
linha de caracteres [512] = "";
char fmt [512] = "";
sprintf (fmt, "%% -% ds: 0x %% 08X \ n", 50 - nível * 4);
para (auto & prop: table.m_ChildProps) {
para (int i = 0; i <level; i ++) {
se (i! = level - 1) {
saída << "";
}
else {
saída << "| ___";
}
}
sprintf (linha, fmt, prop.first.c_str (), prop.second + table.m_uOffset);
saída << linha;
}
para (auto & child: table.m_ChildTables) {
para (int i = 0; i <level; i ++) {
se (i! = level - 1) {
saída << "";
}
else {
saída << "| ___";
}
}
sprintf (linha, fmt, child.first.c_str (), child.second-> m_uOffset);
saída << linha;
Dump (saída, * child.second, level + 1);
}
}
uint32_t CNetvarManager :: GetOffset (const std :: string & szTableName, const std :: initializer_list <std :: string> & props) {
tabela automática = m_pDatabase-> find (szTableName);
se (tabela == m_pDatabase-> end ()) return -1;
int tableOffset = table-> second-> m_uOffset;
se (props.size () == 0) return tableOffset;
int totalOffset = tableOffset;
NetvarTable * curTable = table-> second.get ();
para (auto i = 0; i <props.size (); i ++) {
std :: string propName = * (props.begin () + i);
se (i + 1 <props.size ()) {// Este índice não é o último
auto childTable = curTable-> m_ChildTables.find (propName);
se (childTable == curTable-> m_ChildTables.end ()) {
lance std :: runtime_error ("Prop not found");
}
totalOffset + = childTable-> second-> m_uOffset;
curTable = childTable-> second.get ();
}
else {// Último índice, recuperar suporte em vez de tabela
auto childProp = curTable-> m_ChildProps.find (propName);
se (childProp == curTable-> m_ChildProps.end ()) {
lance std :: runtime_error ("Prop not found");
}
totalOffset + = childProp-> segundo;
}
}
retornar totalOffset;
}
vazio UTIL_TraceLine (Vector & vecAbsStart, Vector & vecAbsEnd, máscara int não assinada, const IHandleEntity * ignore, int collisionGroup, trace_t * ptr)
{
Ray_t ray;
ray.Init (vecAbsStart, vecAbsEnd);
CTraceFilter traceFilter;
traceFilter.pSkip = (void *) ignore;
Interfaces.pTrace-> TraceRay (ray, mask, & traceFilter, ptr);
}
vazio UTIL_TracePos (Ray_t & ray, máscara int não assinada, const IHandleEntity * ignore, int collisionGroup, trace_t * ptr)
{
CTraceFilter traceFilter;
traceFilter.pSkip = (void *) ignore;
Interfaces.pTrace-> TraceRay (ray, mask, & traceFilter, ptr);
}
Float DistanceToRay (const Vector & pos, const Vector & rayStart, const Vector & rayEnd, float * along = NULL, Vector * pointOnRay = NULL)
{
Vector to = pos - rayStart;
Vector dir = rayEnd - rayStart;
comprimento do flutuador = dir.NormalizeInPlace ();
Float RangeAlong = g_Math.DotProduct (dir, to);
se (ao longo)
{
* along = rangeAlong;
}
intervalo de flutuação;
se (rangeAlong <0.0f)
{
// ponto de partida
range = - (pos-rayStart) .Length ();
se (pointOnRay)
{
* pointOnRay = rayStart;
}
}
senão se (rangeAlong> length)
{
// ponto final
range = - (pos-rayEnd) .Length ();
se (pointOnRay)
{
* pointOnRay = rayEnd;
}
}
else // dentro dos limites do raio
{
Vector onRay = rayStart + (dir.operator * (rangeAlong));
range = (pos-onRay) .Length ();
se (pointOnRay)
{
* pointOnRay = onRay;
}
}
intervalo de retorno;
}
vazio UTIL_ClipTraceToPlayers (Vector & vecAbsStart, Vector & vecAbsEnd, máscara int não assinada, ITraceFilter * filter, trace_t * tr)
{
trace_t playerTrace;
Ray_t ray;
flutuar a menorFração = tr-> fração;
const float maxRange = 60.0f;
ray.Init (vecAbsStart, vecAbsEnd);
para (int k = 1; k <= Interfaces.pGlobalVars-> maxClients; ++ k)
{
CBaseEntity * player = Interfaces.pEntList-> GetClientEntity (k);
se (! player ||! player-> isAlive ())
continuar;
se (jogador-> IsDormant ())
continuar;
se (filter && filter-> ShouldHitEntity (player, mask) == false)
continuar;
gama flutuador = DistanceToRay (player-> WorldSpaceCenter (), vecAbsStart, vecAbsEnd);
se (intervalo <0.0f | range> maxRange)
continuar;
Interfaces.pTrace-> ClipRayToEntity (ray, máscara | CONTENTS_HITBOX, jogador, & playerTrace);
se (playerTrace.fraction <smallestFraction)
{
// reduzimos o raio - salve o traço
* tr = playerTrace;
menor executado = playerTrace.fraction;
}
}
}
bool TraceToExit (Vector & fim, trace_t & tr, Vector início, Vector vend, trace_t * traço)
{
bool typedef (__ fastcall * TraceToExitFn) (Vector &, trace_t &, float, float, float, float, float, float, trace_t *);
DWORD estática TraceToExit = Utils.PatternSearch ( "client.dll", (BYTE *) "\ x55 \ x8B \ Xec \ x83 \ Xec \ x30 \ XF3 \ x0F \ x10 \ x75", "xxxxxxxxxx", NULL, NULL);
se (! TraceToExit)
retornar falso;
float start_y = start.y, start_z = start.z, start_x = start.x, dir_y = vEnd.y, dir_x = vEnd.x, dir_z = vEnd.z;
_asm
{
empurrar rastreamento
pressione dir_z
pressione dir_y
push dir_x
pressione start_z
pressione start_y
pressione start_x
mov edx, tr
mov ecx, fim
chame TraceToExit
adicionar esp, 0x1C
}
}
CBaseCombatWeapon * CBaseEntity :: GetActiveBaseCombatWeapon () {
static int m_hActiveWeapon = GET_NETVAR ("DT_BaseCombatCharacter", "m_hActiveWeapon");
DWORD weaponHandle = * (DWORD *) ((DWORD) this + (DWORD) m_hActiveWeapon);
retorno (CBaseCombatWeapon *) (Interfaces.pEntList-> GetClientEntity (weaponHandle & 0xFFF));
}
const char * ConVar :: GetName ()
{
typedef char * (__ thiscall * GetNameFn) (void *);
retornar getvfunc <GetNameFn> (isto, ConVar_GetName) (this);
}
const char * ConVar :: GetBaseName ()
{
typedef char * (__ thiscall * GetNameFn) (void *);
retornar getvfunc <GetNameFn> (este, ConVar_GetBaseName) (este);
}
void ConVar :: SetValue (const char * value)
{
typedef void (__ thiscall * SetValueFn) (void *, const char *);
retornar getvfunc <SetValueFn> (isto, ConVar_SetString) (este, valor);
}
vazio ConVar :: SetValue (valor flutuante)
{
typedef void (__ thiscall * SetValueFn) (void *, float);
retornar getvfunc <SetValueFn> (isto, ConVar_SetFloat) (este, valor);
}
vazio ConVar :: SetValue (valor int)
{
typedef void (__ thiscall * SetValueFn) (void *, int);
retornar getvfunc <SetValueFn> (este, ConVar_SetInt) (este, valor);
}
[/ SPOILER]
[SPOILER = "Entitys.h"]
CBaseCombatWeapon * GetActiveBaseCombatWeapon ();
bool SetupBones (matrix3x4 * pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime) {
static DWORD m_nWritableBones = GET_NETVAR ("DT_BaseAnimating", "m_nForceBone");
estática DWORD m_dwOcclusionArray = * (uintptr_t *) (Utils.PatternSearch ( "client.dll", (PBYTE) "\ xA1 \ x00 \ x00 \ x00 \ x00 \ x8B \ xB7 \ x00 \ x00 \ x00 \ x00 \ x89 \ x75 \ xF8 "," x "xx" xxx ", 0, 0) + 0x1);
estática DWORD m_bDidCheckForOcclusion = * (uintptr_t *) (Utils.PatternSearch ( "client.dll", (PBYTE) "\ xA1 \ x00 \ x00 \ x00 \ x00 \ x8B \ xB7 \ x00 \ x00 \ x00 \ x00 \ x89 \ x75 \ xF8 "," x "xx" xxx ", 0, 0) + 0x7);
* (int *) ((uintptr_t) this + m_nWritableBones) = 0;
* (int *) ((uintptr_t) this + m_bDidCheckForOcclusion) = reinterpret_cast <int *> (m_dwOcclusionArray) [1];
__asm
{
mov edi, isso
lea ecx, dword ptr ds: [edi + 0x4]
mov edx, dword ptr ds: [ecx]
Pressione CurrentTime
push boneMask
empurre nMaxBones
pressione pBoneToWorldOut
Ligue dword ptr ds: [edx + 0x34]
}
}
anular CBaseCombatWeapon :: UpdateAccuracyPenalty () {
typedef void (__ thiscall * OriginalFn) (void *);
getvfunc <OriginalFn> (isto, 485) (este);
}
float & CBaseCombatWeapon :: GetAccuracyPenalty () {
static int m_fAccuracyPenalty = GET_NETVAR (("DT_WeaponCSBase"), ("m_fAccuracyPenalty")));
retorno * (float *) ((DWORD) this + m_fAccuracyPenalty);
}
float CBaseCombatWeapon :: GetInaccuracy () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 483) (este);
}
flutuar CBaseCombatWeapon :: GetSpread () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 484) (este); // 479
}
float CBaseCombatWeapon :: GetWeaponCone () {
se (! isto)
retornar 0.f;
typedef flutuador (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 482) (este);
}
CCSWeaponInfo * GetCSWpnData ()
{
se (! this) retornar nullptr;
typedef CCSWeaponInfo * (__ thiscall * OriginalFn) (void *);
retornar getvfunc <OriginalFn> (isto, 456) (este);
}
[/ SPOILER]
[SPOILER = "XD Surprises"] [/ SPOILER]
VirusTotal não é necessário para surtsy [/ QUOTE]
THAX MY BRO