From 3d412a4b30a9f7c7f51ea6562e694315948bd3da Mon Sep 17 00:00:00 2001
From: boris <wzn@moneybot.cc>
Date: Wed, 28 Nov 2018 16:00:02 +1300
Subject: 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
---
 internal_rewrite/ragebot.cpp | 1142 ------------------------------------------
 1 file changed, 1142 deletions(-)
 delete mode 100644 internal_rewrite/ragebot.cpp

(limited to 'internal_rewrite/ragebot.cpp')

diff --git a/internal_rewrite/ragebot.cpp b/internal_rewrite/ragebot.cpp
deleted file mode 100644
index 4a85078..0000000
--- a/internal_rewrite/ragebot.cpp
+++ /dev/null
@@ -1,1142 +0,0 @@
-#include "ragebot.hpp"
-#include "interface.hpp"
-#include "settings.hpp"
-#include "context.hpp"
-#include "math.hpp"
-#include "base_cheat.hpp"
-#include "input_system.hpp"
-
-namespace features
-{
-	c_ragebot::c_ragebot( ) :
-		m_antiaim( std::make_shared< c_antiaim >( ) ),
-		m_lagcomp( std::make_shared< c_lagcomp >( ) ),
-		m_resolver( std::make_shared< c_resolver >( ) ) { }
-
-	void c_ragebot::operator()( user_cmd_t* cmd ) {
-		if( !cmd ) return;
-		m_cmd = cmd;
-
-		m_antiaim->run( cmd );
-		run( );
-		m_antiaim->fix_movement( );
-	}
-
-	vec3_t head_scale( c_base_player* ent, vec3_t pos ) {
-
-		// broke, crashes the hack
-		//not what it is
-		//return pos;
-
-		vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
-		CTraceFilterOneEntity filter;
-		Ray_t ray;
-		CGameTrace trace;
-
-		filter.ent = ent;
-
-		float height{ };
-		float highest_dmg{ };
-		float max_height{ };
-
-		const float max = 6.5f * g_settings.rage.active->m_hitbox_scale;
-
-		for( float i = 0.f; i < max; i += 0.25f ) {
-			vec3_t end = pos;
-			end.z += i;
-
-			ray.Init( eye_pos, end );
-			g_csgo.m_trace( )->TraceRay( ray, 0x46004003, &filter, &trace );
-
-			if( trace.m_pEnt == ent->ce( ) ) {
-				max_height = i;
-				if( trace.hitgroup == HITGROUP_HEAD && !height ) {
-					height = i;
-				}
-			}
-		}
-
-		if( height < 0.5f ) {
-			pos.z += height;
-			return pos;
-		}
-
-		pos.z += ( height + max_height ) * 0.5f;
-		return pos;
-	}
-
-	int c_ragebot::get_min_dmg( c_base_player* ent ) {
-		int hp = ent->m_iHealth( );
-		int dmg = g_settings.rage.active->m_damage( );
-		int scale = g_settings.rage.active->m_damage_scale( );
-		return std::min< int >( ( int )( hp * scale * 0.01f ) + dmg, 100 );
-	}
-
-	vec3_t c_ragebot::multipoint( c_base_player* ent, int hitbox, float* out_dmg ) {
-		auto should_multipoint = [ ]( int hitbox, bool moving ) -> bool {
-			if( !g_settings.rage.multipoint_enable )
-				return false;
-
-			auto& setting = g_settings.rage.multipoint;
-
-			switch( hitbox ) {
-			case HITBOX_HEAD:
-				return setting.head;
-			case HITBOX_PELVIS:
-			case HITBOX_BODY:
-				return setting.stomach;
-				//case HITBOX_CHEST:
-			case HITBOX_UPPER_CHEST:
-			case HITBOX_THORAX:
-				return setting.chest;
-			case HITBOX_RIGHT_THIGH:
-			case HITBOX_LEFT_THIGH:
-				if( moving && g_settings.rage.ignore_limbs_moving )
-					return false;
-
-				if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
-					return false;
-
-				return setting.thighs;
-
-			case HITBOX_LEFT_CALF:
-			case HITBOX_RIGHT_CALF:
-				if( moving && g_settings.rage.ignore_limbs_moving )
-					return false;
-
-				if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
-					return false;
-
-				return setting.calves;
-			default:
-				return false;
-			}
-		};
-
-		bool moving = ent->m_vecVelocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( );
-
-		vec3_t pos = ent->get_hitbox_pos( hitbox );
-		if( hitbox == HITBOX_HEAD )
-			pos = head_scale( ent, pos );
-
-		float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pos );
-		if( dmg > get_min_dmg( ent ) ) {
-			*out_dmg = dmg;
-			return pos;
-		}
-
-		if( should_multipoint( hitbox, moving ) ) {
-			const auto model = ent->ce( )->GetModel( );
-			if( !model ) return vec3_t{ };
-
-			auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
-			if( !hdr ) return vec3_t{ };
-
-			matrix3x4 bone_matrix[ 128 ];
-			if( !ent->ce( )->SetupBones( bone_matrix, 128, 0x100, g_csgo.m_globals->m_curtime ) ) {
-				return vec3_t{ };
-			}
-
-			auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) );
-			if( !set ) return vec3_t{ };
-
-			//literally 20000 iq, the best multipoint
-			//im an actual fucking retard jesus christ
-			auto box = set->pHitbox( hitbox );
-			if( !box ) return vec3_t{ };
-
-			vec3_t center = ( box->bbmax + box->bbmin ) * 0.5f;
-
-			float dist = box->m_flRadius;
-
-			if( box->m_flRadius == -1.f )
-				dist = center.dist_to( box->bbmin ) * 0.85f;
-			vec3_t min_dir = math::angle_vectors( math::vector_angles( center, box->bbmin ) );
-			vec3_t min = center + min_dir * dist * g_settings.rage.active->m_hitbox_scale * 1.1f;
-
-			if( box->m_flRadius == -1.f )
-				dist = center.dist_to( box->bbmax ) * 0.85f;
-			vec3_t max_dir = math::angle_vectors( math::vector_angles( center, box->bbmax ) );
-			vec3_t max = center + max_dir * dist * g_settings.rage.active->m_hitbox_scale * 1.1f;
-
-			static int point_index[ 65 ][ HITBOX_MAX ];
-
-			std::vector< vec3_t > points;
-			
-			if( g_settings.rage.multipoint_enable( ) == 1 ||
-				hitbox == HITBOX_LEFT_CALF || hitbox == HITBOX_RIGHT_CALF ||
-				hitbox == HITBOX_LEFT_THIGH || hitbox == HITBOX_RIGHT_THIGH ) {
-				points.push_back( vec3_t{ min.x, min.y, center.z } );
-				points.push_back( vec3_t{ max.x, min.y, center.z } );
-				points.push_back( vec3_t{ min.x, max.y, center.z } );
-				points.push_back( vec3_t{ max.x, max.y, center.z } );
-			}
-			else if( g_settings.rage.multipoint_enable( ) == 2 ) {
-				points.push_back( vec3_t{ max.x, max.y, max.z } );
-				points.push_back( vec3_t{ min.x, max.y, max.z } );
-				points.push_back( vec3_t{ max.x, min.y, max.z } );
-				points.push_back( vec3_t{ min.x, min.y, max.z } );
-
-				points.push_back( vec3_t{ max.x, max.y, min.z } );
-				points.push_back( vec3_t{ min.x, max.y, min.z } );
-				points.push_back( vec3_t{ max.x, min.y, min.z } );
-				points.push_back( vec3_t{ min.x, min.y, min.z } );
-			}
-			else if( g_settings.rage.multipoint_enable( ) == 3 ) {
-				points.push_back( vec3_t{ min.x, min.y, center.z } );
-				points.push_back( vec3_t{ max.x, min.y, center.z } );
-				points.push_back( vec3_t{ min.x, max.y, center.z } );
-				points.push_back( vec3_t{ max.x, max.y, center.z } );
-
-				points.push_back( vec3_t{ max.x, max.y, max.z } );
-				points.push_back( vec3_t{ min.x, max.y, max.z } );
-				points.push_back( vec3_t{ max.x, min.y, max.z } );
-				points.push_back( vec3_t{ min.x, min.y, max.z } );
-
-				points.push_back( vec3_t{ max.x, max.y, min.z } );
-				points.push_back( vec3_t{ min.x, max.y, min.z } );
-				points.push_back( vec3_t{ max.x, min.y, min.z } );
-				points.push_back( vec3_t{ min.x, min.y, min.z } );
-			}
-
-			float min_dmg = get_min_dmg( ent );
-			auto& point_idx = point_index[ ent->ce( )->GetIndex( ) ][ hitbox ];
-
-			float percentage = g_settings.rage.multipoint_scale( ) * 0.01f;
-			int mul = ( int )( g_csgo.m_globals->m_frametime / TICK_INTERVAL( ) );
-
-			int count = math::min< int >( math::max< int >( mul * points.size( ) * percentage,
-				points.size( ) * percentage, 
-				1 ), points.size( ) );
-
-			for( int i{ }; i < count; ++i ) {
-				point_idx %= points.size( );
-
-				vec3_t point = points[ point_idx ];
-
-				vec3_t trans_point = math::vector_transform( point, bone_matrix[ box->bone ] );
-				CTraceFilterOneEntity filter;
-				CGameTrace trace;
-				Ray_t ray;
-
-				filter.ent = ent;
-				ray.Init( g_ctx.m_local->get_eye_pos( ), trans_point );
-				g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &trace );
-
-				if( trace.m_pEnt == ent->ce( ) ) {
-					float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, trans_point );
-					if( dmg > min_dmg ) {
-						*out_dmg = dmg;
-						return trans_point;
-					}
-					else {
-						point_idx++;
-					}
-				}
-				else {
-					point_idx++;
-				}
-			}
-		}
-
-		return ent->get_hitbox_pos( hitbox );
-	}
-
-	int c_ragebot::hitscan( c_base_player* ent, bool baim, vec3_t& out_pos, float& out_dmg ) {
-		auto should_histcan = []( int hitbox, bool moving ) -> bool {
-			switch ( hitbox ) {
-			case HITBOX_HEAD:
-			case HITBOX_NECK:
-				return g_settings.rage.hitscan.head;
-			case HITBOX_PELVIS:
-			case HITBOX_BODY:
-				return g_settings.rage.hitscan.stomach;
-			case HITBOX_CHEST:
-			case HITBOX_UPPER_CHEST:
-			case HITBOX_THORAX:
-				return g_settings.rage.hitscan.chest;
-			case HITBOX_RIGHT_HAND:
-			case HITBOX_LEFT_HAND:
-				if( moving && g_settings.rage.ignore_limbs_moving )
-					return false;
-
-				if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
-					return false;
-
-				return g_settings.rage.hitscan.arms;
-			case HITBOX_RIGHT_THIGH:
-			case HITBOX_LEFT_THIGH:
-			case HITBOX_LEFT_CALF:
-			case HITBOX_RIGHT_CALF:
-				if( moving && g_settings.rage.ignore_limbs_moving )
-					return false;
-
-				if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
-					return false;
-
-				return g_settings.rage.hitscan.legs;
-
-			case HITBOX_RIGHT_FOOT:
-			case HITBOX_LEFT_FOOT:
-				if( moving )
-					return false;
-
-				if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
-					return false;
-				
-				return g_settings.rage.hitscan.feet;
-			default:
-				return false;
-			}
-		};
-
-		constexpr std::array< std::pair< PlayerHitboxes_t, int >, 15 > hitbox_order = {
-			std::make_pair( HITBOX_HEAD, 3 ),
-			
-			std::make_pair( HITBOX_PELVIS, 3 ),
-			std::make_pair( HITBOX_BODY, 3 ),
-			std::make_pair( HITBOX_THORAX, 3 ),
-			std::make_pair( HITBOX_CHEST, 3 ),
-			std::make_pair( HITBOX_UPPER_CHEST, 3 ),
-
-			std::make_pair( HITBOX_NECK, 2 ),
-
-			std::make_pair( HITBOX_RIGHT_HAND, 2 ),
-			std::make_pair( HITBOX_LEFT_HAND, 2 ),
-
-			std::make_pair( HITBOX_RIGHT_THIGH, 2 ),
-			std::make_pair( HITBOX_LEFT_THIGH, 2 ),
-
-			std::make_pair( HITBOX_RIGHT_CALF, 1 ),
-			std::make_pair( HITBOX_LEFT_CALF , 1 ),
-
-			std::make_pair( HITBOX_RIGHT_FOOT, 0 ),
-			std::make_pair( HITBOX_LEFT_FOOT, 0 ),
-		};
-
-		bool moving = ent->m_vecVelocity( ).length( ) > 0.1f && !ent->is_fakewalking( );
-		float min_dmg = get_min_dmg( ent );
-
-		if( g_settings.rage.hitbox != -1 ) {
-			float dmg{ };
-			vec3_t pos = multipoint( ent, g_settings.rage.hitbox, &dmg );
-
-			if( dmg > min_dmg && pos ) {
-				out_dmg = dmg;
-				out_pos = pos;
-				return g_settings.rage.hitbox;
-			}
-
-			return -1;
-		}
-
-		struct hitbox_t {
-			float dmg;
-			int hitbox;
-			int priority;
-			vec3_t position;
-		};
-
-		std::vector< hitbox_t > hitboxes;
-
-		for( size_t i{ }; i < hitbox_order.size( ); ++i ) {
-			auto hitbox = hitbox_order[ i ];
-			if( !should_histcan( hitbox.first, moving ) ) {
-				continue;
-			}
-
-			float dmg{ };
-			vec3_t pos = multipoint( ent, hitbox.first, &dmg ); 
-
-			if( pos )
-				hitboxes.push_back( { dmg, hitbox.first, hitbox.second, pos } );
-		}
-
-		std::sort( hitboxes.begin( ), hitboxes.end( ), [ &ent, &baim ]( hitbox_t& a, hitbox_t& b ) -> bool {
-			int hp = ent->m_iHealth( );
-
-			bool a_head = !( a.hitbox == HITBOX_HEAD || a.hitbox == HITBOX_NECK );
-			bool b_head = !( b.hitbox == HITBOX_HEAD || b.hitbox == HITBOX_NECK );
-
-			if( a.dmg != b.dmg ) {
-				if( a.dmg > ( float )( hp + 10 ) && ( float )( b.dmg > hp + 10 ) ) {
-					if( a_head != b_head ) {
-						return a_head > b_head;
-					}
-				}
-			}
-
-			if( a_head != b_head && baim )
-				return a_head > b_head;
-
-			if( a.priority != b.priority ) {
-				return a.priority > b.priority;
-			}
-
-			if( a.dmg != b.dmg ) {
-				return a.dmg > b.dmg;
-			}
-
-			return a.hitbox > b.hitbox;
-		} );
-
-		for( auto& it : hitboxes ) {
-			if( it.dmg > min_dmg ) {
-				out_dmg = it.dmg;
-				out_pos = it.position;
-
-				return it.hitbox;
-			}
-		}
-
-		return -1;
-	}
-
-	void c_ragebot::update_settings( ) {
-		auto weapon = g_ctx.m_local->get_weapon( );
-		if( !weapon ) return;
-		int  weapon_id = weapon->m_iItemDefinitionIndex( );
-
-		switch ( weapon_id ) {
-		case WEAPON_DEAGLE:
-		case WEAPON_R8REVOLVER:
-			g_settings.rage.active = &g_settings.rage.heavy_pistols;
-			break;
-		case WEAPON_AWP:
-		case WEAPON_SSG08:
-			g_settings.rage.active = &g_settings.rage.snipers;
-			break;
-		case WEAPON_G3SG1:
-		case WEAPON_SCAR20:
-			g_settings.rage.active = &g_settings.rage.auto_snipers;
-			break;
-		default:
-			g_settings.rage.active = &g_settings.rage.general;
-			break;
-		}
-	}
-
-	bool c_ragebot::should_baim_entity( c_base_player* ent, bool backtracked ) {
-		int index = ent->ce( )->GetIndex( );
-
-		auto weap = g_ctx.m_local->get_weapon( );
-		if( weap->m_iItemDefinitionIndex( ) == WEAPON_TASER )
-			return true;
-
-		if( !g_cheat.m_player_mgr.is_cheater( index ) )
-			return false;
-
-		int min_hp = g_settings.rage.active->m_baim_health;
-		int min_shots = g_settings.rage.active->m_baim_shots;
-
-		if( m_resolver->get_shots( index ) >= min_shots )
-			return true;
-
-		if( ent->m_iHealth( ) <= min_hp )
-			return true;
-
-		if( !( ent->m_fFlags( ) & FL_ONGROUND ) && g_settings.rage.active->m_baim_air )
-			return true;
-
-		if( !backtracked && g_settings.rage.active->m_baim_fake )
-			return true;
-
-		return false;
-	}
-
-	void quick_stop( user_cmd_t* cmd ) {
-		if( g_cheat.m_ragebot.m_antiaim->is_fakewalking( ) )
-			return;
-
-		if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
-			return;
-
-		vec3_t vel = g_ctx.m_local->m_vecVelocity( );
-		float speed = vel.length2d( );
-
-		if( g_settings.rage.active->m_auto_stop == 1 || g_settings.rage.active->m_auto_stop == 4 ) {
-			auto wep = g_ctx.m_local->get_weapon( );
-			auto wep_info = wep->get_wpn_info( );
-
-			bool scoped = g_ctx.m_local->m_bIsScoped( );
-			float max_vel = scoped ? wep_info->max_speed_alt : wep_info->max_speed;
-
-			if( speed < max_vel / 3 )
-				return;
-		}
-
-		if( speed < 0.1f ) {
-			g_ctx.get_last_cmd( )->m_forwardmove = 0.f;
-			g_ctx.get_last_cmd( )->m_sidemove = 0.f;
-			return;
-		}
-
-		static auto sv_accelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_accelerate" ) );
-		float accel = sv_accelerate->get_float( );
-		float max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed;
-		if( g_ctx.m_local->get_weapon( )->is_sniper( ) && g_ctx.m_local->m_bIsScoped( ) ) {
-			max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed_alt;
-		}
-
-		// thx ida
-		max_speed = std::min< float >( max_speed, 250.f );
-
-		if( g_ctx.m_local->m_fFlags( ) & FL_DUCKING ) {
-		//	max_speed /= 3.f;
-		//	accel /= 3.f;
-		}
-
-		float surf_friction = 1.f;
-		float max_accelspeed = accel * g_csgo.m_globals->m_interval_per_tick * max_speed * surf_friction;
-
-		float wishspeed{ };
-
-		if( speed - max_accelspeed <= -1.f ) {
-			wishspeed = max_accelspeed / ( speed / ( accel * g_csgo.m_globals->m_interval_per_tick ) );
-		}
-		else {
-			wishspeed = max_accelspeed;
-		}
-
-		vec3_t ndir = math::vector_angles( vel * -1.f );
-		ndir.y = g_csgo.m_engine( )->GetViewAngles( ).y - ndir.y;
-		ndir = math::angle_vectors( ndir );
-
-		g_ctx.get_last_cmd( )->m_forwardmove = ndir.x * wishspeed;
-		g_ctx.get_last_cmd( )->m_sidemove = ndir.y * wishspeed;
-	}
-
-	std::array< int, 65 > c_ragebot::get_sorted_targets( ) {
-		typedef struct {
-			int index;
-			float dist;
-			float fov;
-			bool moving;
-			int hp;
-			float simtime;
-		} target;
-
-		std::array< target, 65 > targets{ };
-		std::array< int, 65 > ret{ };
-
-		vec3_t local_pos = g_ctx.m_local->get_eye_pos( );
-		vec3_t cur_ang, dir_vec;
-		g_csgo.m_engine( )->GetViewAngles( cur_ang );
-
-		dir_vec = math::angle_vectors( cur_ang );
-
-		for( size_t i{ }; i < 65; ++i ) {
-			auto& cur_target = targets.at( i );
-			auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
-			cur_target.index = i;
-
-			if( !ent || ent == g_ctx.m_local || !ent->is_valid( ) ) 
-				continue;
-
-			if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) &&
-				!g_settings.rage.friendlies( ) )
-				continue;
-
-			if( !ent->has_valid_anim( ) ) 
-				continue;
-
-			auto pos = ent->m_vecOrigin( );
-			pos.z += 30.f; //eh
-
-			auto dir = ( pos - local_pos );
-			dir.normalize_vector( );
-
-			float fov = dir_vec.fov_to( dir ) * M_RADPI; // epic fov fix by friendly....
-			
-			cur_target.fov = fov;
-			cur_target.dist = pos.dist_to( local_pos );
-			cur_target.hp = ent->m_iHealth( );
-			cur_target.moving = ent->m_vecVelocity( ).length2d( ) > 0.1f
-				&& !ent->is_fakewalking( )
-				&& ( ent->m_fFlags( ) & FL_ONGROUND );
-			cur_target.simtime = ent->m_flSimulationTime( );
-		}
-
-		auto sort_fn = [ ]( const target& a, const target& b ) {
-			if( g_settings.rage.prefer_low_hp ) {
-				if( a.hp != b.hp )
-					return a.hp < b.hp;
-			}
-
-			if( g_settings.rage.prefer_moving ) {
-				if( a.moving != b.moving )
-					return a.moving > b.moving;
-			}
-
-			if( g_settings.rage.selection_type == 0 ) {
-				if( a.fov != b.fov )
-					return a.fov < b.fov;
-			}
-			else if( g_settings.rage.selection_type == 1 ) {
-				if( a.dist != b.dist )
-					return a.dist < b.dist;
-			}
-			else if( g_settings.rage.selection_type == 2 ) {
-				if( a.simtime != b.simtime )
-					return a.simtime > b.simtime;
-			}
-
-			return a.index > b.index;
-		};
-
-		std::sort( targets.begin( ), targets.end( ), sort_fn );
-		for( size_t i{ }; i < 65; ++i ) {
-			if( targets[ i ].fov < g_settings.rage.fov ) {
-				ret[ i ] = targets[ i ].index;
-			}
-		}
-
-		return ret;
-	}
-
-	bool c_ragebot::can_hit_without_ping( int entity ) {
-		auto ent = g_csgo.m_entlist( )->GetClientEntity( entity );
-
-		if( !ent )
-			return false;
-
-		int min_dmg = get_min_dmg( ent );
-		auto check_records = [ &ent, &min_dmg ]( std::deque< lag_record_t >* records ) {
-			auto& front = records->front( );
-			vec3_t pred_pos = front.m_vecPelvisPos;
-
-			float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pred_pos, false );
-			if( dmg > min_dmg )
-				return true;
-
-			pred_pos = front.m_vecHeadPos;
-			dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pred_pos, false );
-			if( dmg > min_dmg )
-				return true;
-
-			return false;
-		};
-
-		auto lby_records = m_lagcomp->get_records( entity, RECORD_LBY );
-		auto sim_records = m_lagcomp->get_records( entity, RECORD_NORMAL );
-
-		if( lby_records->size( ) ) {
-			if( check_records( lby_records ) )
-				return true;
-		}
-
-		if( sim_records->size( ) ) {
-			if( check_records( sim_records ) )
-				return true;
-		}
-
-		return false;
-	}
-
-	int c_ragebot::knifebot( ) {
-		auto aim_pos = g_ctx.m_local->get_eye_pos( );
-
-		float dist = FLT_MAX;
-		int ideal_ent = 0;
-		int ideal_tick = 0;
-		int hp = 0;
-		vec3_t pos;
-
-		for( size_t i{ }; i < 65; ++i ) {
-			auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
-
-			if( !ent || !ent->is_valid( ) || ent == g_ctx.m_local || !ent->has_valid_anim( ) || ent->m_bGunGameImmunity( ) )
-				continue;
-
-			auto newest_record = m_lagcomp->get_newest_valid_record( i );
-			if( !newest_record )
-				continue;
-
-			if( newest_record->m_vecPelvisPos.dist_to( aim_pos ) < dist ) {
-				hp = ent->m_iHealth( );
-				ideal_ent = i;
-				ideal_tick = newest_record->m_tickcount;
-				pos = newest_record->m_vecPelvisPos;
-
-				dist = pos.dist_to( aim_pos );
-			}
-		}
-
-		if( ideal_ent && dist < 80.f ) {
-			int attack = 0;
-
-			if( dist < 65.f )
-				attack = IN_ATTACK2;
-			else if( hp < 35 )
-				attack = IN_ATTACK;
-			else
-				return -1;
-
-			vec3_t ang = math::vector_angles( aim_pos, pos );
-			float fov = ang.dist_to( g_csgo.m_engine( )->GetViewAngles( ) );
-
-			if( fov < g_settings.rage.fov ) {
-				m_cmd->m_viewangles = math::vector_angles( aim_pos, pos );
-				m_cmd->m_tick_count = ideal_tick;
-				m_cmd->m_buttons |= attack;
-
-				return ideal_ent;
-			}
-			else {
-				return -1;
-			}
-		}
-
-		return -1;
-	}
-
-	bool c_ragebot::can_hit_target( int it, aim_target_t* ret, bool zeus, bool hitchance ) {
-		vec3_t aim_ang;
-		vec3_t aim_pos;
-		vec3_t local_pos = g_ctx.m_local->get_eye_pos( );
-
-		auto entity = g_csgo.m_entlist( )->GetClientEntity< >( it );
-		if( !entity || !entity->is_valid( ) || entity == g_ctx.m_local ) 
-			return false;
-		if( entity->m_bGunGameImmunity( ) ) 
-			return false;
-		if( !entity->has_valid_anim( ) ) 
-			return false;
-		if( entity->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && !g_settings.rage.friendlies )
-			return false;
-
-		bool baim = false;
-		bool should_baim = true;
-		bool backtracked = false;
-		bool restore = false;
-		float hit_damage = 0.f;
-		vec3_t extrapolate{ };
-
-		lag_record_t   original_record( entity );
-		lag_record_t*  backtracked_record{ };
-
-		int tick_count = m_cmd->m_tick_count;
-		float lerp = util::get_lerptime( );
-		auto record_type = m_lagcomp->can_backtrack_entity( it );
-		if( !g_settings.rage.resolver( ) ) {
-			if( !util::is_tick_valid( entity->m_flSimulationTime( ) + lerp ) ) {
-				int new_tickcount = m_lagcomp->backtrack_entity( it,
-					record_type, &backtracked_record );
-
-				if( new_tickcount != -1 ) {
-					restore = true;
-					tick_count = new_tickcount;
-				}
-				else if( g_settings.misc.net_fakelag == 4 && can_hit_without_ping( it ) ) {
-					m_can_fakeping = false;
-				}
-			}
-		}
-		else {
-			int new_tickcount = m_lagcomp->backtrack_entity( it, record_type, &backtracked_record );
-			if( new_tickcount != -1 ) {
-				tick_count = new_tickcount;
-				should_baim = record_type != RECORD_LBY;
-				backtracked = record_type == RECORD_LBY;
-				restore = true;
-			}
-			else {
-				if( g_settings.misc.net_fakelag == 4 ) {
-					//if( can_hit_without_ping( it ) )
-					//	m_can_fakeping = false;
-				}
-
-				lag_record_t* last_simtime_record = m_lagcomp->get_newest_valid_record( it );
-				if( last_simtime_record ) {
-					//ENSURE THE MOST ACCURATE DATA
-					entity->m_vecVelocity( ) = entity->get_animdata( ).m_last_velocity;
-
-					auto velocity = entity->m_vecVelocity( );
-					auto min_vel = 64 / TICK_INTERVAL( ) / 14;
-
-					//IS HE A SLOW BOI OR A FAST NIGGER
-					if( g_settings.rage.fakelag_resolver( ) && velocity.length2d( ) > min_vel - 10.f ) {
-						auto new_record = *last_simtime_record;
-
-						//FUCK FAKE PINGERS WE IN THIS BITCH
-						auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); //GOD FUCKING KNOWS WHY
-						float latency = nci->GetLatency( 0 ) + g_csgo.m_globals->m_frametime;
-
-						auto pred_choke = g_cheat.m_prediction.get_predicted_choke( it );
-						auto latency_ticks = TIME_TO_TICKS( latency );
-
-						float time_since_update = g_ctx.pred_time( ) + latency - entity->m_flSimulationTime( );
-
-						//NIGGA UPDATED ALREADY FUCK ADAPTIVE
-						if( TIME_TO_TICKS( time_since_update ) > pred_choke && pred_choke > 0 ) {
-							if( g_settings.rage.fakelag_resolver( ) == 1 )
-								return false;
-
-							else if( latency_ticks > 0 ) {
-								int update_count = TIME_TO_TICKS( time_since_update ) / pred_choke;
-
-								vec3_t extrapolated_origin = g_cheat.m_prediction.full_walk_move( entity, update_count * pred_choke );
-								new_record.m_vecRenderOrigin = extrapolated_origin;
-								new_record.m_tickcount += update_count * pred_choke;
-							}
-						}
-
-						//if( !new_record.is_valid( ) )
-						//	continue;
-
-						int shots = m_resolver->get_shots( it );
-						bool recalc = shots != last_simtime_record->m_shots;
-
-						new_record.restore( true, recalc );
-						tick_count = new_record.m_tickcount;
-						backtracked_record = last_simtime_record;
-						restore = true;
-					}
-					else {
-						int shots = m_resolver->get_shots( it );
-						bool recalc = shots != last_simtime_record->m_shots;
-
-						last_simtime_record->restore( recalc, recalc );
-						tick_count = last_simtime_record->m_tickcount;
-						backtracked_record = last_simtime_record;
-						restore = true;
-					}
-				}
-				else {
-					//fake ping, just wait for an update
-					return false;
-				}
-			}
-		}
-
-		baim = should_baim_entity( entity, !should_baim );
-
-		auto restore_player = [ &original_record, &restore, &entity, this ]( ) {
-			original_record.restore( true );
-			//entity->m_flLastBoneSetupTime( ) = std::numeric_limits< float >::quiet_NaN( );
-		};
-
-		int hitbox = hitscan( entity, baim, aim_pos, hit_damage );
-		if( hitbox == -1 ) {
-			restore_player( );
-			return false;
-		}
-
-		if( aim_pos.dist_to( local_pos ) > 150.f && zeus ) {
-			restore_player( );
-			return false;
-		}
-
-		aim_ang = math::vector_angles( local_pos, aim_pos ).clamp( );
-
-		if( g_settings.rage.active->m_auto_stop( ) == 2 )
-			quick_stop( m_cmd );
-		else if( g_settings.rage.active->m_auto_stop( ) == 3 ) {
-			m_antiaim->run_fakewalk( );
-		}
-
-		if( g_settings.rage.active->m_auto_stop( ) == 5 ) {
-			m_cmd->m_buttons |= IN_DUCK;
-		}
-
-		if( hitchance && !util::hitchance( it, aim_ang,
-			g_settings.rage.active->m_hitchance, hitbox )  ) {
-			if( g_settings.rage.active->m_auto_stop( ) == 1 || g_settings.rage.active->m_auto_stop( ) == 4 )
-				quick_stop( m_cmd );
-
-			if( g_settings.rage.active->m_auto_stop( ) == 5 ) {
-				if( g_ctx.m_local->m_flDuckAmount( ) < 1.f )
-					quick_stop( m_cmd );
-			}
-
-			if( g_settings.rage.active->m_auto_stop( ) == 4 && g_cheat.m_lagmgr.get_choked( ) < 10 && !m_antiaim->is_fakewalking( ) )
-				g_cheat.m_lagmgr.set_state( false );
-
-			if( g_settings.rage.auto_scope( ) && g_ctx.m_local->get_weapon( )->is_sniper( ) ) {
-				if( !g_ctx.m_local->m_bIsScoped( ) ) {
-					m_cmd->m_buttons |= IN_ATTACK2;
-				}
-			}
-
-			restore_player( );
-			return false;
-		}
-
-		ret->m_ent_index = it;
-		ret->m_position = aim_pos;
-		ret->m_tick_count = tick_count;
-		ret->m_hitbox = hitbox;
-		ret->m_backtracked = backtracked;
-		ret->m_min = entity->get_hitbox_mins( hitbox );
-		ret->m_max = entity->get_hitbox_maxs( hitbox );
-		ret->m_radius = entity->get_hitbox_radius( hitbox );
-
-		memcpy( m_shot_matrix, entity->m_CachedBoneData( ).GetElements( ), sizeof( matrix3x4 ) * entity->m_CachedBoneData( ).GetSize( ) );
-
-		m_shot_target = it;
-
-		restore_player( );
-
-		return true;
-	}
-
-	c_ragebot::aim_target_t c_ragebot::find_best_target( ) {
-		aim_target_t ret{ -1, m_cmd->m_tick_count, -1, vec3_t{ }, vec3_t{ }, vec3_t{ }, 0.f, 0 };
-		vec3_t	aim_angle{ };
-		vec3_t	aim_pos{ };
-		auto	weapon_info = g_ctx.m_local->get_weapon( )->get_wpn_info( );
-		bool	is_zeus = g_ctx.m_local->get_weapon( )->m_iItemDefinitionIndex( ) == WEAPON_TASER;
-		int		damage = weapon_info->damage;
-
-		auto players = get_sorted_targets( );
-		auto data = players.data( );
-
-		for( size_t i{ }; i < players.size( ); ++i ) {
-			if( can_hit_target( data[ i ], &ret, is_zeus ) )
-				break;
-		}
-
-		return ret;
-	}
-
-	void c_ragebot::set_angles( const vec3_t& angles ) {
-		auto weapon = g_ctx.m_local->get_weapon( );
-
-		// TODO: Implement the get_spread_direction here I guess.
-		if( g_settings.rage.compensate_spread ) {
-			int seed = m_cmd->m_random_seed;
-
-			float inaccuracy = g_ctx.m_weapon_inaccuracy;
-			float spread = g_ctx.m_weapon_spread;
-
-			util::set_random_seed( ( seed & 0xff ) + 1 );
-
-			float rand_a = util::get_random_float( 0.0f, 1.0f );
-			float pi_rand_a = util::get_random_float( 0.f, 2.f * M_PI );
-			float rand_b = util::get_random_float( 0.f, 1.0f );
-			float pi_rand_b = util::get_random_float( 0.f, 2.f * M_PI );
-
-			float spread_x = cos( pi_rand_a ) * ( rand_a * inaccuracy ) + cos( pi_rand_b ) * ( rand_b * spread );
-			float spread_y = sin( pi_rand_a ) * ( rand_a * inaccuracy ) + sin( pi_rand_b ) * ( rand_b * spread );
-
-			vec3_t forward, right, up;
-			math::angle_vectors( angles, &forward, &right, &up );
-
-			vec3_t spread_dir = forward + ( right * -spread_x ) + ( up * -spread_y );
-			spread_dir.normalize_vector( );
-
-			vec3_t comp = math::vector_angles( vec3_t( ), spread_dir );
-			
-			m_cmd->m_viewangles = comp;
-		}
-		else {
-			m_cmd->m_viewangles = angles;
-		}
-
-		//if( g_settings.rage.silent == 2 ) {
-		//	if( !m_antiaim->is_fakewalking( ) )
-		//		g_cheat.m_lagmgr.set_state( g_cheat.m_lagmgr.get_choked( ) );
-		//}
-		
-		if( g_settings.rage.silent == 1 && !m_antiaim->is_fakewalking( ) ) {
-			//if( weapon->m_iItemDefinitionIndex( ) != WEAPON_R8REVOLVER )
-				g_cheat.m_lagmgr.set_state( !g_cheat.m_lagmgr.get_sent( ) );
-		}
-
-		if( !g_settings.rage.silent( ) ) {
-			g_csgo.m_engine( )->SetViewAngles( m_cmd->m_viewangles );
-		}
-	}
-
-	void c_ragebot::aim_at_target( const aim_target_t& target ) {
-		auto ent = g_csgo.m_entlist( )->GetClientEntity< >( target.m_ent_index );
-		if( !ent )	
-			return;
-
-		if( g_ctx.m_local->get_weapon( )->m_iItemDefinitionIndex( ) != WEAPON_R8REVOLVER ) {
-			if( g_settings.rage.active->m_delay_type == 2 ) {
-				static auto time_to_fire = 0.f;
-				const float delay = float( g_settings.rage.active->m_delay( ) ) * 0.001f;
-				const float time = g_ctx.pred_time( );
-
-				float delta = time_to_fire - time;
-
-				if( delta > delay ) {
-					time_to_fire = time + delay;
-				}
-
-				if( delta < 0.f ) {
-					time_to_fire = time + delay;
-					delta = delay;
-				}
-
-				if( delta > g_csgo.m_globals->m_interval_per_tick ) {
-					return;
-				}
-			}
-			if( g_settings.rage.active->m_delay_type == 3 ) {
-				static float time_to_fire = 0.f;
-				const float time = g_ctx.pred_time( );
-
-				float delta = time_to_fire - time;
-
-				vec3_t velocity = ent->m_vecVelocity( );
-				float speed = velocity.length2d( );
-				if( speed > g_ctx.m_local->m_vecVelocity( ).length2d( ) && speed > 100.f ) {
-					vec3_t head_pos = ent->get_hitbox_pos( 0 );
-					vec3_t origin = ent->m_vecOrigin( );
-					origin.z = head_pos.z = 0.f;
-
-					float dist = origin.dist_to( head_pos ); //1 / 64
-					auto delay = dist / speed + 0.015625f;
-
-					if( delta > delay )
-						time_to_fire = time + delay;
-
-					if( delta < 0.f ) {
-						time_to_fire = time + delay;
-						delta = delay;
-					}
-
-					if( delta > g_csgo.m_globals->m_interval_per_tick )
-						return;
-				}
-			}
-		}
-
-		if( g_settings.rage.active->m_auto_stop && !m_antiaim->is_fakewalking( ) && !g_settings.rage.compensate_spread )
-			m_cmd->m_forwardmove = m_cmd->m_sidemove = 0.f;
-
-		m_cmd->m_buttons |= IN_ATTACK;
-		m_cmd->m_buttons &= ~IN_USE;
-
-		vec3_t position = target.m_position;
-		m_cmd->m_tick_count = target.m_tick_count;
-	
-		auto angle = math::vector_angles(
-			g_ctx.m_local->get_eye_pos( ),
-			target.m_position );
-
-		static auto weapon_recoil_scale = g_csgo.m_cvar( )->FindVar( xors( "weapon_recoil_scale" ) );
-		angle -= g_ctx.m_local->m_aimPunchAngle( ) * weapon_recoil_scale->get_float( );
-
-		g_cheat.m_visuals.store_shot( target.m_position );
-
-		if( !target.m_backtracked && g_cheat.m_player_mgr.is_cheater( target.m_ent_index ) ) {
-			m_resolver->aimbot( 
-				target.m_ent_index, 
-				target.m_hitbox, angle, 
-				target.m_position,
-				target.m_min,
-				target.m_max,
-				target.m_radius );
-		}
-		else {
-			context::shot_data_t new_shot{ };
-			new_shot.m_angle = angle;
-			new_shot.m_enemy_index = target.m_ent_index;
-			
-			new_shot.m_hitbox.max = target.m_min;
-			new_shot.m_hitbox.min = target.m_max;
-			new_shot.m_hitbox.radius = target.m_radius;
-			new_shot.m_hitgroup = target.m_hitbox;
-
-			new_shot.m_enemy_pos = target.m_position;
-
-			g_ctx.m_last_shot++;
-			g_ctx.m_last_shot %= 128;
-
-			g_ctx.m_shot_data[ g_ctx.m_last_shot ] = new_shot;
-			g_ctx.m_has_incremented_shots = true;
-		}
-
-		memcpy( g_ctx.m_shot_data[ g_ctx.m_last_shot ].m_matrix,
-			m_shot_matrix,
-			sizeof( matrix3x4 ) * ent->m_CachedBoneData( ).GetSize( ) );
-
-		set_angles( angle.clamp( ) );
-
-		if( g_settings.rage.active->m_auto_stop && !g_settings.rage.compensate_spread( ) )
-			quick_stop( m_cmd );
-	}
-
-	void c_ragebot::run( ) {
-		if( !g_settings.rage.enabled( ) || !g_ctx.run_frame( ) || !g_ctx.m_local->is_valid( ) ) {
-			m_target = -1;
-			return;
-		}
-
-		update_settings( );
-
-		if( m_send_next ) {
-			if( !g_cheat.m_lagmgr.get_sent( ) && !m_antiaim->is_fakewalking( ) )
-				g_cheat.m_lagmgr.set_state( true );
-
-			m_send_next = false;
-		}
-
-		auto wep = g_ctx.m_local->get_weapon( );
-		if( !wep ) {
-			m_target = -1;
-			return;
-		}
-
-		bool is_revolver = wep->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER;
-
-		bool in_attack = false;
-
-		m_can_fakeping = true;
-
-		if ( g_settings.rage.activation_type == 0 ) in_attack = true;
-		else in_attack = g_input.is_key_pressed(
-			( VirtualKeys_t )g_settings.rage.aimkey( ) );
-
-		if( !in_attack ) {
-			m_target = -1;
-			return;
-		}
-
-		if( wep->is_knife( ) ) {
-			m_target = knifebot( );
-			return;
-		}
-
-		if( !wep->m_iClip1( ) || wep->is_grenade( ) ) {
-			m_target = -1;
-			return;
-		}
-
-		if( !g_ctx.m_local->can_attack( ) ) {
-			aim_target_t t{ };
-			bool is_zeus = wep->m_iItemDefinitionIndex( ) == WEAPON_TASER;
-
-			if( m_target != -1 && !m_antiaim->is_fakewalking( ) ) {
-				bool can_hit = can_hit_target( m_target, &t, is_zeus, false );
-				
-				if( !can_hit )
-					m_target = -1;
-
-				else if( g_settings.rage.active->m_auto_stop == 3 && can_hit ) {
-					m_antiaim->run_fakewalk( );
-					//if( !g_cheat.m_lagmgr.get_choked( ) || g_cheat.m_lagmgr.get_state( ) )
-					m_cmd->m_viewangles.y = m_antiaim->get_yaw( );
-				}
-			}
-			return;
-		}
-
-		// do not
-		if( g_settings.rage.silent == 2 && !g_cheat.m_lagmgr.get_choked( ) && !is_revolver ) {
-			if( !m_antiaim->is_fakewalking( ) )
-				g_cheat.m_lagmgr.set_state( false );
-			return;
-		}
-
-		auto target = find_best_target( );
-		if ( target.m_ent_index != -1 ) {
-			aim_at_target( target );
-		}
-
-		m_target = target.m_ent_index;
-	}
-}
\ No newline at end of file
-- 
cgit v1.2.3