API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 20th, 2018
74
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.29 KB | None | 0 0
raw download clone embed print report
  1. #include "resolver_recode.h"
  2. #include "..\lagcompensation\lagcompensation.h"
  3. /*
  4. void resolver::fsn( ) {
  5. if (!g_ctx.m_local->is_alive( ) )
  6. return;
  7. for ( int i = 1; i <= g_csgo.m_globals( )->m_maxclients; i++ ) {
  8. auto e = static_cast< player_t * >( g_csgo.m_entitylist( )->GetClientEntity( i ) );
  9. if ( !e->valid( true ) ) {
  10. g_ctx.m_globals.missed_shots[ i ] = 0;
  11. record_t temp;
  12. m_resolver_records[ i ].m_current = temp;
  13. m_resolver_records[ i ].m_records.clear( );
  14. continue;
  15. }
  16. m_resolver_records[ i ].e = e;
  17. m_resolver_records[ i ].update( );
  18. m_resolver_records[ i ].m_records.push_front( m_resolver_records[ i ].m_current );
  19. if ( m_resolver_records[ i ].m_records.size( ) >= 16 )
  20. m_resolver_records[ i ].m_records.pop_back( );
  21. m_resolver_records[ i ].resolve( );
  22. m_resolver_records[ i ].m_previous = m_resolver_records[ i ].m_current;
  23. m_resolver_records[ i ].m_initiazlied_previous = true;
  24. }
  25. }
  26. enum {
  27. CURRENT_LAYER,
  28. PREVIOUS_LAYER
  29. };
  30. bool float_near( float v1, float v2, float tolerance ) {
  31. return std::abs( v1 - v2 ) <= std::abs( tolerance );
  32. }
  33. void resolver::info_t::update( ) {
  34. float server_time = util::server_time( );
  35. m_current.layer_count = e->animlayer_count( );
  36. for ( int i = 0; i < m_current.layer_count; i++ )
  37. m_current.layers[ i ] = e->get_animlayers( )[ i ];
  38. m_current.tickcount = g_csgo.m_globals( )->m_tickcount;
  39. m_current.flags = e->m_fFlags( );
  40. m_current.velocity = e->m_vecVelocity( ).Length( );
  41. m_current.lowerbody = e->m_flLowerBodyYawTarget( );
  42. m_current.eye_angle = e->m_angEyeAngles( ).y;
  43. m_current.lby180 = m_current.lowerbody + 180;
  44. m_current.bodyeye_delta = m_current.eye_angle - m_current.lowerbody;
  45. m_current.at_target_yaw = math::calculate_angle( e->m_vecOrigin( ),
  46. g_ctx.m_local->m_vecOrigin( ) ).y;
  47. m_current.fakewalk = m_current.fakewalk_check( e );
  48. m_current.in_air = !( m_current.flags & FL_ONGROUND );
  49. m_current.moving = m_current.velocity >= 0.1;
  50. m_current.lby_updated = false;
  51. if ( !m_current.in_air && m_current.moving && m_current.velocity < 450.0f && !m_current.fakewalk ) {
  52. m_current.lby_updated = true;
  53. m_current.moving_lby = m_current.lowerbody;
  54. }
  55. if ( m_current.last_lby != m_current.lowerbody ) {
  56. //m_current.lby_updated = true;
  57. m_current.last_lby = m_current.lowerbody;
  58. }
  59. m_current.breaking_lby = false;
  60. m_current.breaking_lby_u120 = false;
  61. AnimationLayer layers[ 2 ];
  62. if ( m_current.adjusting_balance( e, &layers[ CURRENT_LAYER ] ) &&
  63. m_current.adjusting_balance( e, &layers[ PREVIOUS_LAYER ] ) ) {
  64. if ( ( layers[ PREVIOUS_LAYER ].m_flCycle != layers[ CURRENT_LAYER ].m_flCycle ) || layers[ CURRENT_LAYER ].m_flWeight == 1.f )
  65. m_current.breaking_lby = true;
  66. if ( layers[ CURRENT_LAYER ].m_flWeight == 0.f && ( layers[ PREVIOUS_LAYER ].m_flCycle > 0.92f && layers[ CURRENT_LAYER ].m_flCycle > 0.92f ) )
  67. m_current.breaking_lby_u120 = true;
  68. }
  69. m_current.moving_lby_valid = m_current.moving_lby != INT_MAX;
  70. }
  71. void resolver::info_t::resolve( ) {
  72. auto weapon = e->m_hActiveWeapon( ).Get( );
  73. if ( weapon ) {
  74. if ( weapon->m_iClip1( ) != m_current.last_ammo ) {
  75. m_current.last_ammo = weapon->m_iClip1( );
  76. return;
  77. }
  78. }
  79. int shots = g_ctx.m_globals.missed_shots[ e->EntIndex( ) ];
  80. if ( m_records.size( ) > 1 && m_initiazlied_previous ) {
  81. m_current.lby_comparing_tick = get_lby_comparing_ticks( );
  82. m_current.delta_comparing_tick = get_delta_comparing_ticks( );
  83. m_current.lbydelta = m_current.eye_angle - m_records.front( ).lowerbody;
  84. if ( m_current.lby_updated ) {
  85. m_resolver_mode = "LBY";
  86. e->m_angEyeAngles( ).y = m_current.lowerbody;
  87. } else {
  88. if ( m_current.in_air ) {
  89. if ( !m_current.moving_lby_valid ) {
  90. m_resolver_mode = "BRUTE TARGET";
  91. constexpr int angles[ 4 ] = { 90, -90, 180, 0 };
  92. e->m_angEyeAngles( ).y = m_current.at_target_yaw + angles[ shots % 4 ];
  93. } else {
  94. m_resolver_mode = "MOVE LBY BRUTE";
  95. e->m_angEyeAngles( ).y = m_current.moving_lby + ( shots % 8 * 45 );
  96. }
  97. } else {
  98. if ( m_current.fakewalk ) {
  99. if ( m_current.moving && !m_current.in_air ) {
  100. if ( delta_keeps_changing( 10.f ) ) {
  101. m_resolver_mode = "DELTA CHANGE";
  102. e->m_angEyeAngles( ).y = e->m_angEyeAngles( ).y - m_current.delta_comparing_tick;
  103. } else if ( lby_keeps_changing( 10.f ) ) {
  104. m_resolver_mode = "LBY CHANGE";
  105. e->m_angEyeAngles( ).y = m_current.lby_comparing_tick;
  106. } else {
  107. m_resolver_mode = "BRUTE TARGET";
  108. constexpr int angles[ 4 ] = { 90, -90, 180, 0 };
  109. e->m_angEyeAngles( ).y = m_current.at_target_yaw + angles[ shots % 4 ];
  110. }
  111. }
  112. } else {
  113. AnimationLayer layers[ 2 ];
  114. if ( m_current.breaking_lby ) {
  115. if ( m_current.lbydelta < 35 && m_current.lbydelta > -35 ) {
  116. m_resolver_mode = "LBY CALCULATE";
  117. e->m_angEyeAngles( ).y = m_current.delta_comparing_tick + 180;
  118. } else if ( fabsf( m_current.bodyeye_delta ) < 35.f && fabsf( m_current.bodyeye_delta ) > 0.f ) {
  119. m_resolver_mode = "BODYEYE DELTA";
  120. e->m_angEyeAngles( ).y = m_records.front( ).lowerbody + m_current.bodyeye_delta;
  121. } else {
  122. m_resolver_mode = "LBY 180";
  123. e->m_angEyeAngles( ).y = m_current.lby180;
  124. }
  125. } else if ( m_current.breaking_lby_u120 ) {
  126. if ( m_current.lbydelta < 35 && m_current.lbydelta > -35 ) {
  127. m_resolver_mode = "LBY CALCULATE";
  128. e->m_angEyeAngles( ).y = m_current.delta_comparing_tick + 180;
  129. } else if ( fabsf( m_current.bodyeye_delta ) < 35.f && fabsf( m_current.bodyeye_delta ) > 0.f ) {
  130. m_resolver_mode = "BODYEYE DELTA";
  131. e->m_angEyeAngles( ).y = m_records.front( ).lowerbody + m_current.bodyeye_delta;
  132. } else {
  133. m_resolver_mode = shots % 2 ? "LBY 150" : "LBY -150";
  134. e->m_angEyeAngles( ).y = shots % 2 ? m_current.lowerbody + 150 : m_current.lowerbody - 150;
  135. }
  136. } else {
  137. if ( has_static_real( 15 ) ) {
  138. m_resolver_mode = "STATIC YAW";
  139. e->m_angEyeAngles( ).y = ( m_records.front( ).lowerbody ) + ( math::random_float( 0.f, 1.f ) > 0.f ? 10 : -10 );
  140. } else if ( has_static_difference( 15 ) ) {
  141. m_resolver_mode = "STATIC YAW FAKE";
  142. e->m_angEyeAngles( ).y = m_current.eye_angle - m_current.lbydelta;
  143. } else if ( has_steady_difference( 15 ) ) {
  144. m_resolver_mode = "STEADY YAW";
  145. float
  146. tickdif = static_cast< float >( m_records.front( ).tickcount - m_records.at( 1 ).tickcount ),
  147. lbydif = delta( m_records.front( ).lowerbody, m_records.at( 1 ).lowerbody ),
  148. ntickdif = static_cast< float >( g_csgo.m_globals( )->m_tickcount - m_records.front( ).tickcount );
  149. e->m_angEyeAngles( ).y = ( lbydif / tickdif ) * ntickdif;
  150. } else if ( delta_keeps_changing( 15 ) ) {
  151. m_resolver_mode = "DELTA CHANGE";
  152. e->m_angEyeAngles( ).y = m_current.eye_angle - delta_keeps_changing( 15 );
  153. } else if ( lby_keeps_changing( 15.f ) ) {
  154. m_resolver_mode = "LBY CHANGE";
  155. e->m_angEyeAngles( ).y = m_current.lby_comparing_tick;
  156. } else {
  157. if ( m_current.moving_lby_valid ) {
  158. m_resolver_mode = "MOVE LBY";
  159. e->m_angEyeAngles( ).y = m_current.moving_lby;
  160. } else {
  161. m_resolver_mode = "BRUTE TARGET";
  162. constexpr int angles[ 4 ] = { 90, -90, 180, 0 };
  163. e->m_angEyeAngles( ).y = m_current.at_target_yaw + angles[ shots % 4 ];
  164. }
  165. }
  166. }
  167.  
  168. }
  169. }
  170. }
  171. } else {
  172. m_resolver_mode = "LBY";
  173. e->m_angEyeAngles( ).y = m_current.lowerbody;
  174. }
  175. if ( g_csgo.m_inputsys( )->IsButtonDown( g_cfg.ragebot.override_key ) ) {
  176. m_resolver_mode = "OVERRIDE";
  177. vec3_t screen;
  178. if ( math::world_to_screen( e->m_vecOrigin( ), screen ) ) {
  179. POINT mouse; GetCursorPos( &mouse );
  180. float delta = mouse.x - screen.x;
  181. if ( delta > 0 ) e->m_angEyeAngles( ).y = m_current.at_target_yaw + 90;
  182. else e->m_angEyeAngles( ).y = m_current.at_target_yaw - 90;
  183. }
  184. }
  185. //if ( !g_cfg.misc.anti_untrusted )
  186. // e->m_angEyeAngles( ).x = shots % 4 ? 89.f : -89.f;
  187. }
  188. float resolver::info_t::delta( float a, float b ) {
  189. return abs( math::normalize_yaw( a - b ) );
  190. }
  191. bool resolver::info_t::different( float a, float b, float tolerance ) {
  192. return ( delta( a, b ) > tolerance );
  193. }
  194. int resolver::info_t::get_different_lbys( float tolerance ) {
  195. std::vector<float> vec;
  196. for ( auto var : m_records ) {
  197. float curyaw = var.lowerbody;
  198. bool add = true;
  199. for ( auto fl : vec ) {
  200. if ( !different( curyaw, fl, tolerance ) )
  201. add = false;
  202. }
  203. if ( add )
  204. vec.push_back( curyaw );
  205. }
  206. return vec.size( );
  207. }
  208. float resolver::info_t::get_lby_comparing_ticks( ) {
  209. int
  210. modulo = 1,
  211. difangles = get_different_lbys( 15 ),
  212. inc = modulo * difangles;
  213. for ( auto var : m_records ) {
  214. for ( int lasttick = var.tickcount; lasttick < g_csgo.m_globals( )->m_tickcount; lasttick += inc ) {
  215. if ( lasttick == g_csgo.m_globals( )->m_tickcount )
  216. return var.tickcount;
  217. }
  218. }
  219. return 0.f;
  220. }
  221. bool resolver::info_t::lby_keeps_changing( float tolerance ) {
  222. return ( get_different_lbys( tolerance ) > 180 / 2 );
  223. }
  224. int resolver::info_t::get_different_deltas( float tolerance ) {
  225. std::vector<float> vec;
  226. for ( auto var : m_records ) {
  227. float curdelta = var.eye_angle - var.lowerbody;
  228. bool add = true;
  229. for ( auto fl : vec ) {
  230. if ( !different( curdelta, fl, tolerance ) )
  231. add = false;
  232. }
  233. if ( add )
  234. vec.push_back( curdelta );
  235. }
  236. return vec.size( );
  237. }
  238. float resolver::info_t::get_delta_comparing_ticks( ) {
  239. int
  240. modulo = 1,
  241. difangles = get_different_deltas( 15 ),
  242. inc = modulo * difangles;
  243. for ( auto var : m_records ) {
  244. for ( int lasttick = var.tickcount; lasttick < g_csgo.m_globals( )->m_tickcount; lasttick += inc ) {
  245. if ( lasttick == g_csgo.m_globals( )->m_tickcount )
  246. return var.eye_angle - var.lowerbody;
  247. }
  248. }
  249. return 0.f;
  250. }
  251. bool resolver::info_t::delta_keeps_changing( float tolerance ) {
  252. return ( get_different_deltas( tolerance ) > 180 / 2 );
  253. }
  254. bool resolver::info_t::has_static_real( float tolerance ) {
  255. auto minmax = std::minmax_element( std::begin( m_records ), std::end( m_records ), [ ] ( const record_t t1, const record_t t2 ) { return t1.lowerbody < t2.lowerbody; } );
  256. return ( fabsf( ( *minmax.first ).lowerbody - ( *minmax.second ).lowerbody ) <= tolerance );
  257. }
  258. bool resolver::info_t::has_static_difference( float tolerance ) {
  259. auto lby_delta = [ ] ( const record_t record ) -> float {
  260. return record.eye_angle - record.lowerbody;
  261. };
  262. for ( auto i = m_records.begin( ); i < m_records.end( ) - 1;) {
  263. if ( delta( lby_delta( *i ), lby_delta( *++i ) ) > tolerance )
  264. return false;
  265. }
  266. return true;
  267. }
  268. bool resolver::info_t::has_steady_difference( float tolerance ) {
  269. size_t misses = 0;
  270. for ( size_t i = 0; i < m_records.size( ) - 1; i++ ) {
  271. float
  272. tickdif = static_cast< float >( m_records.at( i ).simtime - m_records.at( i + 1 ).tickcount ),
  273. lbydif = delta( m_records.at( i ).lowerbody, m_records.at( i + 1 ).lowerbody ),
  274. ntickdif = static_cast< float >( g_csgo.m_globals( )->m_tickcount - m_records.at( i ).tickcount );
  275. if ( ( ( lbydif / tickdif ) * ntickdif ) > tolerance ) misses++;
  276. }
  277. return ( misses <= ( m_records.size( ) / 3 ) );
  278. }
  279. bool resolver::record_t::adjusting_balance( player_t * e, AnimationLayer * set ) {
  280. const auto activity = e->sequence_activity( layers[ 3 ].m_nSequence );
  281. if ( activity == 979 ) {
  282. *set = layers[ 3 ];
  283. return true;
  284. }
  285. return false;
  286. }
  287. bool resolver::record_t::fakewalk_check( player_t * e ) {
  288. bool
  289. fakewalking = false,
  290. stage1 = false, // stages needed cause we are iterating all layers, otherwise won't work :)
  291. stage2 = false,
  292. stage3 = false;
  293. for ( int i = 0; i < 14; i++ ) {
  294. AnimationLayer record = e->get_animlayers( )[ i ];
  295. if ( record.m_nSequence == 26 && record.m_flWeight < 0.4f )
  296. stage1 = true;
  297. if ( record.m_nSequence == 7 && record.m_flWeight > 0.001f )
  298. stage2 = true;
  299. if ( record.m_nSequence == 2 && record.m_flWeight == 0 )
  300. stage3 = true;
  301. }
  302. if ( stage1 && stage2 )
  303. if ( stage3 || ( e->m_fFlags( ) & FL_DUCKING ) ) // since weight from stage3 can be 0 aswell when crouching, we need this kind of check, cause you can fakewalk while crouching, thats why it's nested under stage1 and stage2
  304. fakewalking = true;
  305. else
  306. fakewalking = false;
  307. else
  308. fakewalking = false;
  309. return fakewalking;
  310. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!