Bonjour,
je suis un peu mort de rire en lisant toutes les réponses.
1) LES AIMBOTS, WALLHACKS, THIRPDS, et AUTRES HACKS sont totalement legal dans la fabrications, ce qu'il est moins, s'est leurs utilisation sur des serveurs. Pour cela mieux faut mettre PB en route s'est plus sur;
2) Pour faire un bot, il faut avoir un minimun de connaissance en programmation: C++ ou Visual Basic 6.
3)Obtenir le Code source d'un aimbot, dans mon cas j'utilise Gna pour SOF et SOF2, et fearbot pour Fear, ainsi que CSBOT pour Counter.
Quand je lis Psykose, je suis MDr, si s'etais aussi simple, tu crois qu'il y aurait pas plus de cheaters. Alors tu peux utiliser des termes genre je suis matheux avec formule, mais ça reste de la connerie ton truc. Si tu n'as de bot, tu peux pas faire AUTO AIM AUTOFIRE, WH, ESP, headvis, lockvis AIMPOINT, ou aimvecs.
Donc je sera&is curieux de voir un exemple de ce que tu avance, j'entends AIMBOTS + CFG, ou a priori juste un cfg qui marcherais sans le aimbot lol.
Voila juste un exemple de SRc, sachant qu'il y a plus de 6à fichiers comme celui la qu'il faut compiler par la suite avec l'extension correct:
/*
* Sof2 hook
* Copyright (c) Gna 2004
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <windows.h>
#include <stdio.h>
#include <stdarg.h>
#include "prepare.h"
#include "aimbot.h"
#include <math.h>
//#include "addlog.h"
#include "time.h"
#include "Hook.h"
CAimbot ca;
float *fx = (float *) 0x009A1410;
float *fy = (float *) 0x009A140C;
int bursttime, burstwait;
void CAimbot::LeanOrg( vec3_t vieworg,ei_t *einfo )
{
vec3_t fireAngs, right;
VectorCopy( cg.refdef.viewangles, fireAngs );
AngleVectors( fireAngs, NULL, right, NULL );
VectorMA( vieworg, 30, right, einfo->aimvecs[B_LEANRIGHT] );
VectorMA( vieworg, -30, right, einfo->aimvecs[B_LEANLEFT] );
}
int CAimbot::Q_rand( int *seed )
{
*seed = (69069 * *seed + 1);
return *seed;
}
vec_t CAimbot::VectorNormalize( vec3_t v )
{
float length, ilength;
length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
length = sqrt (length);
if ( length ) {
ilength = 1/length;
v[0] *= ilength;
v[1] *= ilength;
v[2] *= ilength;
}
return length;
}
qboolean CAimbot::Q_TestRaySphere ( vec3_t origin, float radius, const vec3_t start, const vec3_t end )
{
float v;
float disc;
vec3_t temp;
vec3_t dir;
VectorSubtract ( origin, start, temp );
VectorSubtract ( end, start, dir );
VectorNormalize ( dir );
// Make sure the sphere isnt behind them
v = DotProduct ( temp, dir );
if ( v < 0 )
{
return qfalse;
}
// Determine if it hit the sphere or not
disc = radius * radius - (DotProduct ( temp, temp ) - v * v );
if ( disc < 0 )
{
return qfalse;
}
return qtrue;
}
///SelectAiming ??
void CAimbot::SelectAiming ( void )
{
static int dir;
static bool fire = false, lock_mouse = false;
static int fire_start = 0;
int tc;
if( snapi && pcg )
{
if( ei.EnemyFound == EF_LEANVISIBLELEFT )
dir = LLeft;
else if( ei.EnemyFound == EF_LEANVISIBLERIGHT )
dir = LRight;
else
dir = LNULL;
DoLean2( dir );
if (( ei.EnemyFound == EF_VISIBLE
||ei.EnemyFound == EF_LOCKVISIBLE )
&& gcg_aim.integer
&& pps->weapon < WP_MM1_GRENADE_LAUNCHER
&& pps->weapon != WP_KNIFE )
{
AimAtOrigin( ei.aimvecs[B_TARGET], ei.distance );
lock_mouse = true;
if ( gcg_fire.integer )
{
if( ei.EnemyFound == EF_VISIBLE )
ca.Autoshoot();
if( ashoot == 0 )
{
trap_SendConsoleCommand("+movedown\n");
ashoot = 2;
}
}
if ( gcg_fire.integer == 3 )
{
tc = GetTickCount ();
if ( tc - fire_start > burstwait )
{
fire = aim_fire ( true );
fire_start = tc;
}
}
}
else
{
lock_mouse = false;
if( leanblock == 2 )
{
leanblock =0;
trap_SendConsoleCommand("-leanleft\n");
trap_SendConsoleCommand("-leanright\n");
}
}
ei.EnemyFound = EF_NULL;
dir = LNULL;
if ( lock_mouse )
{
if (*ca.sensitivity)
{
trap_Cvar_Set ("sensitivity", "0");
}
else
{
trap_Cvar_VariableStringBuffer ("sensitivity", ca.sensitivity,
sizeof (ca.sensitivity));
trap_Cvar_Set ("sensitivity", "0");
}
}
else if (*ca.sensitivity)
{
trap_Cvar_Set ("sensitivity", ca.sensitivity);
ca.sensitivity[0] = '\0';
}
if( fire )
fire = aim_fire ( false );
}
}
void CAimbot::BG_CalculateBulletEndpoint ( vec3_t muzzlePoint, vec3_t fireAngs, float inaccuracy, float range, vec3_t end, int *seed )
{
float fGaussianX = 0;
float fGaussianY = 0;
vec3_t dir;
vec3_t fwd;
vec3_t up;
vec3_t right,temp;
AngleVectors ( fireAngs, fwd, right, up );
VectorMA (muzzlePoint, range, fwd, temp);
// No inaccuracy so just extend it forward by the range
/*if ( inaccuracy <= 0.0f )
{
VectorMA (muzzlePoint, range, fwd, end);
return;
}*/
// Gaussian spread should keep it a bit less random looking
while ( 1 )
{
float fGaussian;
float f1;
float f2;
f1 = (float)((unsigned int)Q_rand ( seed ) % 15000) / 15000.0f;
f2 = (float)((unsigned int)Q_rand ( seed ) % 15000) / 15000.0f;
fGaussianX = (f1-0.5f) + (f2-0.5f);
f1 = (float)((unsigned int)Q_rand ( seed ) % 15000) / 15000.0f;
f2 = (float)((unsigned int)Q_rand ( seed ) % 15000) / 15000.0f;
fGaussianY = (f1-0.5f) + (f2-0.5f);
fGaussian = fGaussianX * fGaussianX + fGaussianY * fGaussianY;
if ( fGaussian < 1 )
{
break;
}
}
VectorMA ( fwd, -gcg_inc.value * inaccuracy * fGaussianX, right, dir );
VectorMA ( dir, -gcg_inc.value * inaccuracy * fGaussianY, up, dir );
VectorMA (muzzlePoint, range, dir, end);
VectorSubtract(end,temp,end);
}
void CAimbot::VectorAngles ( const vec3_t forward, vec3_t angles )
{
float tmp, yaw, pitch;
if ( forward[1] == 0 && forward[0] == 0 )
{
yaw = 0;
if ( forward[2] > 0 )
pitch = 90;
else
pitch = 270;
}
else
{
yaw = ( atan2( forward[1], forward[0] ) * 180 / M_PI );
if ( yaw < 0 )
yaw += 360;
tmp = sqrt( forward[0] * forward[0] + forward[1] * forward[1] );
pitch = ( atan2( forward[2], tmp ) * 180 / M_PI );
if ( pitch < 0 )
pitch += 360;
}
angles[0] = pitch;
angles[1] = yaw;
angles[2] = 0;
}
void CAimbot::AimAtOrigin( vec3_t origin, float length )
{
static int seed;
static float inaccuracy = 0;
vec3_t org, ang, porg,end;
VectorCopy( cg.refdef.vieworg,porg );
if( gcg_inc.value != 0 )
{
inaccuracy = float( pcg->predictedPlayerState.inaccuracy ) / 1000.0f;
seed = pcg->predictedPlayerState.stats[STAT_SEED];
if ( pcg->predictedPlayerState.pm_flags & PMF_DUCKED )
inaccuracy *= DUCK_ACCURACY_MODIFIER;
else if ( pcg->predictedPlayerState.pm_flags & PMF_JUMPING )
inaccuracy *= JUMP_ACCURACY_MODIFIER;
this->BG_CalculateBulletEndpoint ( cg.refdef.vieworg, cg.refdef.viewangles, inaccuracy, length, end, &seed );
VectorAdd( end, origin, origin );
}
VectorSubtract( origin, porg, org );
this->VectorAngles( org, ang );
ang[PITCH] = -ang[PITCH];
if ( ang[YAW] > 180.0f )
ang[YAW] -= 360.0f;
else if ( ang[YAW] < -180.0f )
ang[YAW] += 360.0f;
if ( ang[PITCH] > 180.0f )
ang[PITCH] -= 360.0f;
else if ( ang[PITCH] < -180.0f )
ang[PITCH] += 360.0f;
AnglesToAxis( ang, cg.refdef.viewaxis );
ang[YAW] -= myviewangles[YAW];
if ( ang[YAW] > 180.0f )
ang[YAW] -= 360.0f;
else if ( ang[YAW] < -180.0f )
ang[YAW] += 360.0f;
ang[PITCH] -= myviewangles[PITCH];
if ( ang[PITCH] > 180.0f )
ang[PITCH] -= 360.0f;
else if ( ang[PITCH] < -180.0f )
ang[PITCH] += 360.0f;
// end Noskills code;
if ( gcg_recoil.integer )
ang[PITCH] += float( pcg->predictedPlayerState.kickPitch ) / gcg_recoil.value;
*fx += ang[YAW];
*fy += ang[PITCH];
}
void CAimbot::Autoshoot ( void )
{
static int rate = 0;
static int rate2 = 0;
static float inaccuracy;
if ( gcg_fire.integer == 1 )
{
if( ei.distance < 200 )
{
rate = this->fduration[0] + this->fpause[0] ;
rate2 = this->fduration[0];
}
else
{
rate = this->fduration[1] + this->fpause[1];
rate2 =this->fduration[1];
}
if( ei.distance > 900 )
{
rate = this->fduration[2] + this->fpause[2];
rate2 =this->fduration[2];
}
if( ei.distance > 1500 )
{
rate = this->fduration[3] + this->fpause[3];
rate2 = this->fduration[3];
}
this->endwait = cg.time;
this->endwait1 = cg.time;
if (( this->endwait - this->startwait ) < rate )
this->wait = true;
else
{
this->startwait = this->endwait;
this->startwait1= this->endwait1;
}
if(( this->endwait1 - this->startwait1 ) < rate2 )
this->wait=false;
if( !this->wait )
{
if( !this->cs )
{
trap_SendConsoleCommand("+attack\n");
this->cs = true;
}
}
else if( this->cs )
{
trap_SendConsoleCommand("-attack\n");
this->cs = false;
}
}
if ( gcg_fire.integer == 2 )
{
if( ei.distance < 200 )
rate = this->fduration[0] ;
else if( ei.distance < 700 )
rate = this->fduration[1];
else if( ei.distance < 1200 )
rate = this->fduration[2];
else
rate = this->fduration[3];
}
if ( gcg_fire.integer == 2 )
{
inaccuracy = float( pcg->predictedPlayerState.inaccuracy ) / 1000.0f;
if ( pcg->predictedPlayerState.pm_flags & PMF_DUCKED )
inaccuracy *= DUCK_ACCURACY_MODIFIER;
else if ( pcg->predictedPlayerState.pm_flags & PMF_JUMPING )
inaccuracy *= JUMP_ACCURACY_MODIFIER;
if( !this->cs && inaccuracy < gcg_inblock.value )
{
trap_SendConsoleCommand("+attack\n");
this->cs = true;
}
else if( this->cs )
{
trap_SendConsoleCommand("-attack\n");
this->cs = false;
}
}
}
//aimbot.cpp
bool CAimbot::aim_fire ( bool startnow )
{
static int start_time = 0;
int tc = GetTickCount ();
if ( startnow && !start_time )
{
start_time = tc;
trap_SendConsoleCommand ( "+attack\n" );
return true;
}
else if ( tc - start_time > bursttime )
{
trap_SendConsoleCommand ( "-attack\n" );
start_time = 0;
return false;
}
else if ( start_time != 0 )
return true;
return false;
}
Sur ce PSYKOSE sans rancune.
LOL:
Unlocked, membre active du Clan Aw: www.aimbotwarfare.com
