diff options
| author | boris <wzn@moneybot.cc> | 2018-11-28 16:00:02 +1300 |
|---|---|---|
| committer | boris <wzn@moneybot.cc> | 2018-11-28 16:00:02 +1300 |
| commit | 3d412a4b30a9f7c7f51ea6562e694315948bd3da (patch) | |
| tree | 26d67dfd1f3e5fd12903ad13e85d0cb8bcf8f21c /cheat/internal_rewrite/util.cpp | |
| parent | e4729e4393d90271a3814c7a79950a660c48325a (diff) | |
cleaned up
in short, the cheat and loader are now separate solutions. unused stuff was moved into the legacy solution in case anyone wants to compile it or whatever.
i can change this back if you want to. also, i configured the loader to compile in x64, and have separate build types for linux and win64
Diffstat (limited to 'cheat/internal_rewrite/util.cpp')
| -rw-r--r-- | cheat/internal_rewrite/util.cpp | 575 |
1 files changed, 575 insertions, 0 deletions
diff --git a/cheat/internal_rewrite/util.cpp b/cheat/internal_rewrite/util.cpp new file mode 100644 index 0000000..1d19f9a --- /dev/null +++ b/cheat/internal_rewrite/util.cpp @@ -0,0 +1,575 @@ +#include "util.hpp"
+
+#include "interface.hpp"
+#include "c_base_player.hpp"
+#include "pattern.hpp"
+#include "context.hpp"
+#include "settings.hpp"
+#include "math.hpp"
+#include "base_cheat.hpp"
+
+float TICK_INTERVAL( ) {
+ return g_csgo.m_globals->m_interval_per_tick;
+}
+
+int TIME_TO_TICKS( float dt ) {
+ return static_cast< int >( 0.5f + dt / TICK_INTERVAL( ) );
+}
+
+float TICKS_TO_TIME( int tick ) {
+ return tick * TICK_INTERVAL( );
+}
+
+bool util::is_low_fps( ) {
+ return g_csgo.m_globals->m_frametime > g_csgo.m_globals->m_interval_per_tick;
+}
+
+int util::get_closest_player( bool dist ) {
+ float cur_fov = FLT_MAX;
+ int ret{ -1 };
+ vec3_t viewangles{ };
+ vec3_t local_pos{ };
+
+ bool friendlies = g_settings.rage.active ?
+ g_settings.rage.friendlies : g_settings.legit.friendlies;
+
+ local_pos = g_ctx.m_local->get_eye_pos( );
+ g_csgo.m_engine( )->GetViewAngles( viewangles );
+
+ for( int i{ 1 }; i < g_csgo.m_globals->m_maxclients; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent ) continue;
+ if( ent == g_ctx.m_local ) continue;
+ if( !ent->is_valid( ) ) continue;
+ int team = ent->m_iTeamNum( );
+ if( team == g_ctx.m_local->m_iTeamNum( ) && !friendlies ) {
+ continue;
+ }
+
+ float distance = 0.f;
+ if( dist ) {
+ distance = g_ctx.m_local->m_vecOrigin( ).dist_to( ent->m_vecOrigin( ) );
+ }
+ else {
+ auto ang = math::vector_angles( local_pos, ent->get_hitbox_pos( 0 ) );
+ ang.clamp( );
+ distance = ( viewangles - ang ).clamp( ).length2d( );
+ }
+
+ if( distance < cur_fov ) {
+ ret = i;
+ cur_fov = distance;
+ }
+ }
+
+ return ret;
+}
+
+void util::clip_trace_to_player( IClientEntity* player, const vec3_t& src, const vec3_t& end,
+ unsigned mask, CTraceFilter* filter, CGameTrace* tr ) {
+ CGameTrace player_trace;
+ Ray_t ray;
+ float smallest_fraction = tr->fraction;
+
+ ray.Init( src, end );
+
+ if ( !filter->ShouldHitEntity( player, mask ) ) {
+ return;
+ }
+
+ g_csgo.m_trace( )->ClipRayToEntity( ray, mask | CONTENTS_HITBOX, player, &player_trace );
+
+ if ( player_trace.fraction < smallest_fraction ) {
+ *tr = player_trace;
+ smallest_fraction = player_trace.fraction;
+ }
+}
+
+std::string util::hitgroup_to_string( int hitgroup ) {
+ switch( hitgroup ) {
+ case HITGROUP_CHEST:
+ return xors( "chest" );
+ case HITGROUP_HEAD:
+ return xors( "head" );
+ case HITGROUP_LEFTARM:
+ return xors( "left arm" );
+ case HITGROUP_LEFTLEG:
+ return xors( "left leg" );
+ case HITGROUP_RIGHTARM:
+ return xors( "right arm" );
+ case HITGROUP_RIGHTLEG:
+ return xors( "right leg" );
+ case HITGROUP_STOMACH:
+ return xors( "stomach" );
+ default:
+ return xors( "generic" );
+ }
+}
+
+bool util::trace_ray( const vec3_t& start, const vec3_t& end, IClientEntity* a, IClientEntity* b ) {
+ CGameTrace tr;
+ Ray_t ray;
+ CTraceFilter filter;
+
+ filter.pSkip = a;
+
+ ray.Init( start, end );
+
+ g_csgo.m_trace( )->TraceRay( ray, 0x46004003 | CONTENTS_HITBOX, &filter, &tr );
+ clip_trace_to_player( b, start, end, ( unsigned )0x46004003, &filter, &tr );
+
+ return tr.m_pEnt == b || tr.fraction > 0.98f;
+}
+
+void util::set_random_seed( int seed ) {
+ using fn = int( __cdecl* )( int );
+ fn fn_ptr = ( fn )( GetProcAddress(
+ GetModuleHandleA( xors( "vstdlib.dll" ) ),
+ xors( "RandomSeed" ) ) );
+
+ fn_ptr( seed );
+}
+
+float util::get_random_float( float min, float max ) {
+ using fn = float( *)( float, float );
+ fn fn_ptr = ( fn )( GetProcAddress(
+ GetModuleHandleA( xors( "vstdlib.dll" ) ),
+ xors( "RandomFloat" ) ) );
+
+ return fn_ptr( min, max );
+}
+
+std::array< util::hitchance_data_t, 256 > hitchance_data;
+void util::calculate_spread_runtime( ) {
+ constexpr float pi_2 = 2.0f * ( float ) M_PI;
+
+ for ( size_t n { }; n < 256; ++n ) {
+ set_random_seed( n );
+
+ const float rand_a = get_random_float( 0.0f, 1.0f );
+ const float rand_pi_a = get_random_float( 0.0f, pi_2 );
+ const float rand_b = get_random_float( 0.0f, 1.0f );
+ const float rand_pi_b = get_random_float( 0.0f, pi_2 );
+
+ hitchance_data [ n ] = {
+ { rand_a, rand_b },
+ { std::cos( rand_pi_a ), std::sin( rand_pi_a ) },
+ { std::cos( rand_pi_b ), std::sin( rand_pi_b ) }
+ };
+ }
+}
+
+// This is gay, I didn't want to fuck up the project.
+vec3_t util::get_spread_dir( void *weapon, float inaccuracy, float spread, vec3_t angles, int seed ) {
+ const int rnsd = ( seed & 0xFF );
+ const auto *data = &hitchance_data [ rnsd ];
+ auto *wpn = ( c_base_weapon * ) weapon;
+
+ if ( !wpn )
+ return vec3_t{ };
+
+ float rand_a = data->m_random[ 0 ];
+ float rand_b = data->m_random[ 1 ];
+
+ const uint16_t item_def = wpn->m_iItemDefinitionIndex( );
+
+ // Because fuck you.
+ if ( item_def == WEAPON_NEGEV ) {
+ const int recoil_seed = wpn->get_wpn_info( )->recoil_seed;
+
+ if ( recoil_seed < 3 ) {
+ // Shoutouts to toast for the epic simplified math :^)
+ rand_a = 1.0f - std::powf( rand_a, ( 3 - recoil_seed ) + 1 );
+ rand_b = 1.0f - std::powf( rand_b, ( 3 - recoil_seed ) + 1 );
+ }
+ }
+
+ // Calculate spread.
+ const float rand_inacc = rand_a * g_ctx.m_weapon_inaccuracy;
+ const float rand_spread = rand_b * g_ctx.m_weapon_spread;
+
+ const float spread_x = data->m_inaccuracy [ 0 ] * rand_inacc + data->m_spread [ 0 ] * rand_spread;
+ const float spread_y = data->m_inaccuracy [ 1 ] * rand_inacc + data->m_spread [ 1 ] * rand_spread;
+
+ // Transform angle to direction.
+ vec3_t forward, right, up;
+ math::angle_vectors( angles, &forward, &right, &up );
+
+ return forward + right * spread_x + up * spread_y;
+}
+
+bool __vectorcall util::intersects_hitbox( vec3_t eye_pos, vec3_t end_pos, vec3_t min, vec3_t max, float radius ) {
+ auto dist = math::dist_segment_to_segment( eye_pos, end_pos, min, max );
+
+ return ( dist < radius );
+}
+
+// Note: abuse this as much as you can to achieve the full potential it offers.
+bool util::hitchance( int target, const vec3_t& angles, int percentage, int hitbox ) {
+ if( g_settings.rage.compensate_spread )
+ return true;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( target );
+
+ if ( !ent ) return false;
+ if ( percentage <= 1 ) return true;
+
+ int hits_needed = percentage * 256 / 100;
+ int hits = 0;
+
+ auto wep = g_ctx.m_local->get_weapon( );
+ if ( !wep ) return false;
+
+ vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
+ auto wpn_info = wep->get_wpn_info( );
+ if( !wpn_info ) return false;
+
+ float length = wpn_info->range;
+
+ float inaccuracy = g_ctx.m_weapon_inaccuracy;
+ float spread = g_ctx.m_weapon_spread;
+
+ if( g_settings.rage.active->m_spread_limit( ) ) {
+ bool crouched = g_ctx.m_local->m_vecViewOffset( ).z < 50.f;
+ bool alt_inaccuracy = wep->is_sniper( ) || wep->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER;
+ float min_accuracy = crouched ? ( alt_inaccuracy ? wpn_info->inaccuracy_crouch_alt : wpn_info->inaccuracy_crouch )
+ : ( alt_inaccuracy ? wpn_info->inaccuracy_stand_alt : wpn_info->inaccuracy_stand );
+
+ float max_accuracy = alt_inaccuracy ? wpn_info->inaccuracy_move_alt : wpn_info->inaccuracy_move;
+ min_accuracy += 0.0005f;
+
+ float spread_accuracy_fraction = -( g_settings.rage.active->m_spread_limit_min( ) * 0.01f - 1.0f );
+ float spread_accuracy_tolerance = max_accuracy * spread_accuracy_fraction;
+ min_accuracy += spread_accuracy_tolerance;
+
+ if( wep->m_iItemDefinitionIndex( ) == WEAPON_SSG08 && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) {
+ min_accuracy = 0.008750f;
+ }
+
+ if( min_accuracy >= inaccuracy )
+ return true;
+ }
+
+ struct hitbox_data_t {
+ hitbox_data_t( const vec3_t& min, const vec3_t& max, float radius ) {
+ m_min = min;
+ m_max = max;
+ m_radius = radius;
+ }
+
+ vec3_t m_min{ };
+ vec3_t m_max{ };
+ float m_radius{ };
+ };
+
+ std::vector< hitbox_data_t > m_hitbox_data;
+
+ auto model = ent->ce( )->GetModel( );
+ if( !model ) return false;
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !hdr ) return false;
+
+ matrix3x4 bone_matrix[ 128 ];
+ memcpy( bone_matrix,
+ ent->m_CachedBoneData( ).GetElements( ),
+ ent->m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) );
+
+ auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) );
+ if( !set ) return false;
+
+ if( hitbox == -1 ) {
+ for( int hitbox{ }; hitbox < set->numhitboxes; ++hitbox ) {
+ auto box = set->pHitbox( hitbox );
+ if( !box ) continue;
+
+ auto min = math::vector_transform( box->bbmin, bone_matrix[ box->bone ] );
+ auto max = math::vector_transform( box->bbmax, bone_matrix[ box->bone ] );
+ auto radius = box->m_flRadius;
+
+ if( radius == -1.f ) {
+ radius = min.dist_to( max );
+ }
+
+ m_hitbox_data.push_back( hitbox_data_t( min, max, radius ) );
+ }
+ }
+ else {
+ auto box = set->pHitbox( hitbox );
+ if( !box ) return false;
+
+ auto min = math::vector_transform( box->bbmin, bone_matrix[ box->bone ] );
+ auto max = math::vector_transform( box->bbmax, bone_matrix[ box->bone ] );
+ auto radius = box->m_flRadius;
+
+ if( radius == -1.f ) {
+ radius = min.dist_to( max );
+ }
+
+ m_hitbox_data.push_back( hitbox_data_t( min, max, radius ) );
+ }
+
+ if( m_hitbox_data.empty( ) )
+ return false;
+
+ for ( int i{ }; i < 256; i ++ ) {
+ vec3_t spread_dir = get_spread_dir( wep, inaccuracy, spread, angles, i );
+
+ //Ray_t ray;
+ //vec3_t end_pos = eye_pos + spread_dir * length;
+ //ray.Init( eye_pos, end_pos );
+ //
+ //
+ //CGameTrace tr;
+ //g_csgo.m_trace( )->ClipRayToEntity( ray, 0x46004003, ent->ce( ), &tr );
+
+ vec3_t end_pos = eye_pos + ( spread_dir * length );
+
+ for( const auto& hitbox : m_hitbox_data ) {
+ if( intersects_hitbox( eye_pos, end_pos, hitbox.m_min, hitbox.m_max, hitbox.m_radius ) ) {
+ hits++;
+ break; // cannot hit more than one hitbox
+ }
+ }
+
+ if ( hits >= hits_needed )
+ return true;
+ }
+
+ return false;
+}
+
+
+float util::get_total_latency( ) {
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+
+ if ( nci ) {
+ float latency = nci->GetLatency( 0 ) + nci->GetLatency( 1 );
+ return latency;
+ }
+
+ return 0.f;
+}
+
+float util::get_lerptime( ) {
+ static cvar_t* cl_interpolate = g_csgo.m_cvar( )->FindVar( xors( "cl_interpolate" ) );
+ static cvar_t* cl_interp = g_csgo.m_cvar( )->FindVar( xors( "cl_interp" ) );
+ static cvar_t* cl_updaterate = g_csgo.m_cvar( )->FindVar( xors( "cl_updaterate" ) );
+ static cvar_t* cl_interp_ratio = g_csgo.m_cvar( )->FindVar( xors( "cl_interp_ratio" ) );
+
+ if( cl_interp && cl_interpolate && cl_updaterate && cl_interp_ratio ) {
+ bool interpolate = cl_interpolate->get_int( );
+ if( interpolate ) {
+ float interp = cl_interp->get_float( );
+ float interp_ratio = cl_interp_ratio->get_float( );
+ float updaterate = cl_updaterate->get_float( );
+
+ return std::max< float >( interp, interp_ratio / updaterate );
+ }
+ }
+
+ return 0.f;
+}
+
+bool util::is_tick_valid( int tickcount ) {
+
+ float latency = get_total_latency( );
+ float correct = std::clamp( latency + get_lerptime( ), 0.f, *( bool* )( c_base_player::get_game_rules( ) + 0x75 ) ? 0.2f : 1.0f );
+ float delta = correct - ( g_ctx.pred_time( ) - TICKS_TO_TIME( tickcount ) );
+
+ if( g_settings.rage.enabled ) {
+ return delta > -0.2f + TICK_INTERVAL( ) * 2.f && delta < 0.2f;
+ }
+
+ return std::abs( delta ) < 0.2f;
+}
+
+void util::disable_pvs( ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || !ent->is_valid( ) )
+ continue;
+
+ if( ent == g_ctx.m_local )
+ continue;
+
+ *( int* )( uintptr_t( ent ) + 0xa30 ) = g_csgo.m_globals->m_framecount;
+ *( int* )( uintptr_t( ent ) + 0xa28 ) = 0;
+ }
+}
+
+vec2_t util::screen_transform( vec3_t world ) {
+ vec2_t screen;
+ auto w2s = [ &world, &screen ]( ) -> bool {
+ static uintptr_t view_matrix = 0;
+ if( !view_matrix ) {
+ view_matrix = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "0F 10 05 ? ? ? ? 8D 85 ? ? ? ? B9" ) );
+
+ view_matrix = *reinterpret_cast< uintptr_t* >( view_matrix + 0x3 ) + 176;
+ }
+
+ const matrix3x4& matrix = *( matrix3x4* )view_matrix;
+ screen.x = matrix[ 0 ][ 0 ] * world[ 0 ] + matrix[ 0 ][ 1 ] * world[ 1 ] + matrix[ 0 ][ 2 ] * world[ 2 ] + matrix[ 0 ][ 3 ];
+ screen.y = matrix[ 1 ][ 0 ] * world[ 0 ] + matrix[ 1 ][ 1 ] * world[ 1 ] + matrix[ 1 ][ 2 ] * world[ 2 ] + matrix[ 1 ][ 3 ];
+
+ float w = matrix[ 3 ][ 0 ] * world[ 0 ] + matrix[ 3 ][ 1 ] * world[ 1 ] + matrix[ 3 ][ 2 ] * world[ 2 ] + matrix[ 3 ][ 3 ];
+
+ if( w < 0.001f ) {
+ //screen.x *= 100000.f;
+ //screen.y *= 100000.f;
+ return true;
+ }
+
+ float invw = 1.0f / w;
+ screen.x *= invw;
+ screen.y *= invw;
+
+ return false;
+ };
+
+ w2s( );
+ //if ( !w2s( ) ) {
+ int w, h;
+ g_csgo.m_engine( )->GetScreenSize( w, h );
+
+ screen.x = ( w * .5f ) + ( screen.x * w ) * .5f;
+ screen.y = ( h * .5f ) - ( screen.y * h ) * .5f;
+
+ return screen;
+ //}
+
+ return vec2_t{ };
+}
+
+int util::hitbox_to_hitgroup( int hitbox ) {
+ switch( hitbox ) {
+ case HITBOX_HEAD:
+ case HITBOX_NECK:
+ return HITGROUP_HEAD;
+ case HITBOX_BODY:
+ case HITBOX_CHEST:
+ case HITBOX_THORAX:
+ case HITBOX_PELVIS:
+ return HITGROUP_STOMACH;
+ case HITBOX_LEFT_CALF:
+ case HITBOX_LEFT_THIGH:
+ case HITBOX_LEFT_FOOT:
+ return HITGROUP_RIGHTLEG;
+ case HITBOX_RIGHT_CALF:
+ case HITBOX_RIGHT_THIGH:
+ case HITBOX_RIGHT_FOOT:
+ return HITGROUP_LEFTLEG;
+ case HITBOX_LEFT_HAND:
+ case HITBOX_LEFT_FOREARM:
+ case HITBOX_LEFT_UPPER_ARM:
+ return HITGROUP_LEFTARM;
+ case HITBOX_RIGHT_HAND:
+ case HITBOX_RIGHT_FOREARM:
+ case HITBOX_RIGHT_UPPER_ARM:
+ return HITGROUP_RIGHTARM;
+ default:
+ return HITGROUP_GENERIC;
+ }
+}
+
+const char* util::definition_index_to_name( int index ) {
+ index = std::clamp( index, 0, 65 );
+
+ switch( index ) {
+ case 0:
+ return xors( "knife" );
+ case WEAPON_DEAGLE:
+ return xors( "deagle" );
+ case WEAPON_ELITE:
+ return xors( "elite" );
+ case WEAPON_FIVESEVEN:
+ return xors( "five seven" );
+ case WEAPON_GLOCK:
+ return xors( "glock" );
+ case WEAPON_AK47:
+ return xors( "ak47" );
+ case WEAPON_AUG:
+ return xors( "aug" );
+ case WEAPON_AWP:
+ return xors( "awp" );
+ case WEAPON_FAMAS:
+ return xors( "famas" );
+ case WEAPON_G3SG1:
+ return xors( "g3sg1" );
+ case WEAPON_GALILAR:
+ return xors( "galil" );
+ case WEAPON_M249:
+ return xors( "m249" );
+ case WEAPON_M4A1:
+ return xors( "m4a4" );
+ case WEAPON_MAC10:
+ return xors( "mac10" );
+ case WEAPON_P90:
+ return xors( "p90" );
+ case WEAPON_UMP45:
+ return xors( "ump45" );
+ case WEAPON_XM1014:
+ return xors( "xm1014" );
+ case WEAPON_BIZON:
+ return xors( "bizon" );
+ case WEAPON_MAG7:
+ return xors( "mag7" );
+ case WEAPON_NEGEV:
+ return xors( "negev" );
+ case WEAPON_SAWEDOFF:
+ return xors( "sawed-off" );
+ case WEAPON_TEC9:
+ return xors( "tec9" );
+ case WEAPON_TASER:
+ return xors( "zeus" );
+ case WEAPON_HKP2000:
+ return xors( "p2000" );
+ case WEAPON_MP7:
+ return xors( "mp7" );
+ case WEAPON_MP9:
+ return xors( "mp9" );
+ case WEAPON_NOVA:
+ return xors( "nova" );
+ case WEAPON_P250:
+ return xors( "p250" );
+ case WEAPON_SCAR20:
+ return xors( "scar20" );
+ case WEAPON_SG556:
+ return xors( "sg556" );
+ case WEAPON_SSG08:
+ return xors( "ssg08" );
+ case WEAPON_KNIFEGG:
+ return xors( "golden knife" ); // for the gun game hackers
+ case WEAPON_KNIFE:
+ return xors( "knife" );
+ case WEAPON_FLASHBANG:
+ return xors( "flash" );
+ case WEAPON_HEGRENADE:
+ return xors( "nade" );
+ case WEAPON_SMOKEGRENADE:
+ return xors( "smoke" );
+ case WEAPON_MOLOTOV:
+ return xors( "molotov" );
+ case WEAPON_DECOY:
+ return xors( "decoy" );
+ case WEAPON_INCGRENADE:
+ return xors( "incendiary" );
+ case WEAPON_C4:
+ return xors( "c4" );
+ case WEAPON_KNIFE_T:
+ return xors( "knife" );
+ case WEAPON_M4A1_SILENCER:
+ return xors( "M4A1" );
+ case WEAPON_USP_SILENCER:
+ return xors( "usp" );
+ case WEAPON_CZ75A:
+ return xors( "cz75" );
+ case WEAPON_R8REVOLVER:
+ return xors( "revolver" );
+ default:
+ return xors( "none" );
+ }
+}
|