|
allen
Pe lista neagra
Inregistrat: acum 12 ani
Postari: 15
|
|
Aimbot.cpp
//==============================================================================
// Aimbot.cpp
//==============================================================================
#define WIN32_LEAN_AND_MEAN
#pragma warning(disable:4786)
#pragma warning(disable:4305)
#pragma warning(disable:4800)
#pragma warning(disable:4244)
#pragma warning(disable:4101)
#pragma warning(disable:4715)
#include <windows.h>
#include <stdlib.h>
#include <math.h>
#undef NDEBUG
#include <assert.h>
#include <memory.h>
#include <map>
#include <vector>
#include <fstream>
#include "aimbot.h"
using namespace std;
typedef float TransformMatrix[MAXSTUDIOBONES][3][4];
#define M_PI 3.14159265358979323846
CAimbot Aimbot;
float mainViewOrigin[3];
//===================================================================================
float predahead = 0.20; // Some default Values ;D
int predback = 0;
static void PredictTarget(int index,float *pred)
{
// if (cvar.pred)
// {
/* cl_entity_s* ent = gEngfuncs.GetEntityByIndex(index);
int historyIndex = (ent->current_position+HISTORY_MAX-predback)%HISTORY_MAX;
vec3_t vFromOrigin , vToOrigin , vDeltaOrigin,vPredictedOrigin;
vFromOrigin = ent->ph[historyIndex].origin;
vToOrigin = ent->ph[ent->current_position].origin;
vDeltaOrigin = vToOrigin - vFromOrigin;
vDeltaOrigin[0] *= predahead;
vDeltaOrigin[1] *= predahead;
vDeltaOrigin[2] *= predahead;
vPredictedOrigin = ent->origin + vDeltaOrigin;
VectorCopy(vPredictedOrigin,pred); */
cl_entity_s* ent = gEngfuncs.GetEntityByIndex(index);
VectorCopy(ent->origin, pred);
/* }
else
{
VectorCopy(vPlayers[index].getEnt()->origin,pred);
}*/
}
//==============================================================================
float vpreahead = 1.2;
bool bSoonvisible(int iIndex)
{
float to[3], lastpred = predahead;
predahead = vpreahead;// apply some leeb value here :)
PredictTarget(iIndex,(float*)to);
predahead = lastpred;
pmtrace_t tr;
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
gEngfuncs.pEventAPI->EV_PlayerTrace( me.pmEyePos, to, PM_WORLD_ONLY, me.ent->index, &tr );
// return ( tr.fraction == 1.0 );
if (tr.fraction == 0.75 )
return true;
return false;
}
//==============================================================================
void VectorAngles( const float *forward, float *angles )
{
float tmp, yaw, pitch;
if( forward[1] == 0 && forward[0] == 0 )
{
yaw = 0;
if( forward[2] > 0 )
pitch = 90.0f;
else
pitch = 270.0f;
}
else
{
yaw = ( float )( ( atan2( forward[1], forward[0] ) * 180 / M_PI ) );
if( yaw < 0 )
yaw += 360.0f;
tmp = sqrt( forward[0] * forward[0] + forward[1] * forward[1] );
pitch = ( float )( ( atan2( forward[2], tmp ) * 180 / M_PI ) );
}
angles[0] = pitch;
angles[1] = yaw;
angles[2] = 0;
}
//==============================================================================
int CanPenetrate( float *start, float *end, int power )
{
pmtrace_t pmtrace;
pmtrace_t * tr = (pmtrace_t*) &pmtrace;
float view[3];
float dir[3];
view[0] = end[0] - start[0];
view[1] = end[1] - start[1];
view[2] = end[2] - start[2];
float length = VectorLength(view);
dir[0] = view[0] / length;
dir[1] = view[1] / length;
dir[2] = view[2] / length;
float position[3];
position[0] = start[0];
position[1] = start[1];
position[2] = start[2];
tr->startsolid = true;
while( power )
{
if( !tr->startsolid )
power--;
tr = gEngfuncs.PM_TraceLine( position, end, PM_TRACELINE_PHYSENTSONLY, 2, -1);
if( tr->fraction==1.0f )
return 1;
if( tr->allsolid )
return 0;
position[0] = tr->endpos[0] + dir[0] * 8.0f;
position[1] = tr->endpos[1] + dir[1] * 8.0f;
position[2] = tr->endpos[2] + dir[2] * 8.0f;
}
return 0;
}
//==============================================================================
void VectorTransform (float *in1, float in2[3][4], float *out)
{
out[0] = DotProduct(in1, in2[0]) + in2[0][3];
out[1] = DotProduct(in1, in2[1]) + in2[1][3];
out[2] = DotProduct(in1, in2[2]) + in2[2][3];
}
//==============================================================================
#include <gl\gl.h>
void CAimbot::DrawAimSpot(void)
{
if(!cvar.avdraw) return;
for(int i = 0; i < 32; i++)
{
if(!vPlayers[i].bDrawn || !vPlayers[i].isUpdatedAddEnt()) continue;
float fVecScreen[2];
vec3_t vecEnd, up, right, forward, EntViewOrg, playerAngles;
if (!vPlayers[i].fixHbAim) {VectorCopy(vPlayers[i].vHitbox,EntViewOrg);}
else {VectorCopy(vPlayers[i].origin(),EntViewOrg);}
// calculate angle vectors
playerAngles[0]=0;
playerAngles[1]=vPlayers[iTarget].getEnt()->angles[1];
playerAngles[2]=0;
gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
forward[2] = -forward[2];
EntViewOrg = EntViewOrg + forward * cvar.hadj_f;
EntViewOrg = EntViewOrg + up * cvar.hadj_h;
EntViewOrg = EntViewOrg + right * cvar.hadj_r;
if(!CalcScreen(EntViewOrg, fVecScreen)) continue;
tintArea(fVecScreen[0], fVecScreen[1], 2, 2, 255, 255, 255, 255);
}
}
void CAimbot::CalculateHitbox( cl_entity_s *pEnt )
{
if( !cvar.aimingmethod )
return;
if(cvar.aimingmethod == 1)
{
if( !vPlayers[pEnt->index].bGotHead )
{
int iIndex = pEnt->index;
model_s *pModel = pStudio->SetupPlayerModel( iIndex );
studiohdr_t *pStudioHeader = ( studiohdr_t* )pStudio->Mod_Extradata( pModel );
mstudiobbox_t *pStudioBox;
TransformMatrix *pBoneTransform = ( TransformMatrix* )pStudio->StudioGetBoneTransform( );
vec3_t vMin, vMax;
pStudioBox = ( mstudiobbox_t* )( ( byte* )pStudioHeader + pStudioHeader->hitboxindex );
//Head 11 bone 7 | Low Head 9 bone 5 | Chest 8 bone 4 | Stomach 7 bone 3
int i = 11;
if (cvar.aimspot == 1) i = 11;
else if (cvar.aimspot == 2) i = 9;
else if (cvar.aimspot == 3) i = 8;
VectorTransform(pStudioBox[i].bbmin, (*pBoneTransform)[pStudioBox[i].bone], vMin);
VectorTransform(pStudioBox[i].bbmax, (*pBoneTransform)[pStudioBox[i].bone], vMax);
vPlayers[iIndex].vHitbox = ( vMin + vMax ) * 0.5f;
vPlayers[iIndex].bGotHead = true;
}
}
if(cvar.aimingmethod == 2)
{
int ax = pEnt->index;
if(!vPlayers[ax].bGotHead)
{
vec3_t pos;
// studiohdr_t* pStudioHeader = (studiohdr_t*)oEngStudio.Mod_Extradata( pEnt->model );
TransformMatrix* pbonetransform = (TransformMatrix*)pStudio->StudioGetBoneTransform();
//Head 11 bone 7 | Low Head 9 bone 5 | Chest 8 bone 4 | Stomach 7 bone 3
int i = 7;
if (cvar.aimspot == 1) i = 7;
else if (cvar.aimspot == 2) i = 5;
else if (cvar.aimspot == 3) i = 4;
pos[ 0 ] = (*pbonetransform)[ i ][ 0 ][ 3 ];
pos[ 1 ] = (*pbonetransform)[ i ][ 1 ][ 3 ];
pos[ 2 ] = (*pbonetransform)[ i ][ 2 ][ 3 ];
VectorCopy(pos, vPlayers[ax].vHitbox);
vPlayers[ax].bGotHead = true;
}
}
}
//==============================================================================
void CAimbot::CalculateAimingView( void )
{
float view[3];
vec3_t vecEnd, up, right, forward, EntViewOrg, playerAngles;
if (!vPlayers[iTarget].fixHbAim) {VectorCopy(vPlayers[iTarget].vHitbox,EntViewOrg);}
else {VectorCopy(vPlayers[iTarget].origin(),EntViewOrg);}
// calculate angle vectors
playerAngles[0]=0;
playerAngles[1]=vPlayers[iTarget].getEnt()->angles[1];
playerAngles[2]=0;
gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
forward[2] = -forward[2];
EntViewOrg = EntViewOrg + forward * cvar.hadj_f;
EntViewOrg = EntViewOrg + up * cvar.hadj_h;
EntViewOrg = EntViewOrg + right * cvar.hadj_r;
view[0] = EntViewOrg[0] - me.pmEyePos[0];
view[1] = EntViewOrg[1] - me.pmEyePos[1];
view[2] = EntViewOrg[2] - me.pmEyePos[2];
VectorAngles(view,aim_viewangles);
aim_viewangles[0] *= -1;
if (aim_viewangles[0]>180) aim_viewangles[0]-=360;
if (aim_viewangles[1]>180) aim_viewangles[1]-=360;
}
//==============================================================================
int CorrectGunX()
{
int currentWeaponID = GetCurWeaponID();
if (currentWeaponID == WEAPON_SG550 || currentWeaponID == WEAPON_G3SG1 || currentWeaponID == WEAPON_SCOUT || currentWeaponID == WEAPON_AWP)
{ return 3; }
if (currentWeaponID == WEAPON_AUG || currentWeaponID == WEAPON_PARA || currentWeaponID == WEAPON_COLT || currentWeaponID == WEAPON_DEAGLE || currentWeaponID == WEAPON_SIG || currentWeaponID == WEAPON_AK)
{ return 2; }
{ return 1; }
}
//====================================================================================
bool CAimbot::pathFree(float* xfrom,float* xto)
{
int pathtest;
pmtrace_t tr;
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
gEngfuncs.pEventAPI->EV_PlayerTrace( xfrom, xto, PM_GLASS_IGNORE, me.ent->index, &tr );
pathtest = (tr.fraction == 1.0);
if (!pathtest && cvar.autowall && CorrectGunX())
{
pathtest = CanPenetrate(xfrom, xto, CorrectGunX());
}
return pathtest;
}
//====================================================================================
bool CAimbot::TargetRegion(int ax)
{
vec3_t vecEnd, up, right, forward, EntViewOrg,playerAngles;
cl_entity_s* ent = vPlayers[ax].getEnt();
// calculate angle vectors
playerAngles[0]=0;
playerAngles[1]=ent->angles[1];
playerAngles[2]=0;
gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
forward[2] = -forward[2];
if (vPlayers[ax].bGotHead) {VectorCopy(vPlayers[ax].vHitbox,EntViewOrg);vPlayers[ax].fixHbAim=false;}
else {VectorCopy(vPlayers[ax].origin(),EntViewOrg);vPlayers[ax].fixHbAim=true;}
EntViewOrg = EntViewOrg + forward * cvar.hadj_f;
EntViewOrg = EntViewOrg + up * cvar.hadj_h;
EntViewOrg = EntViewOrg + right * cvar.hadj_r;
if(pathFree(me.pmEyePos,EntViewOrg) || pathFree(me.pmEyePos, ent->origin)) return true;
return false;
}
//==============================================================================
bool isValidEnt(cl_entity_s *ent)
{
if(ent && (ent != gEngfuncs.GetLocalPlayer()) && ent->player && !ent->curstate.spectator && ent->curstate.solid && !(ent->curstate.messagenum < gEngfuncs.GetLocalPlayer()->curstate.messagenum))
return true;
else
return false;
}
//==============================================================================
void CAimbot::FindTarget( void )
{
if (!me.alive) return;
SetTarget(-1);
for (int ax=0;ax<MAX_VPLAYERS;ax++)
{
if ( vPlayers[ax].isUpdatedAddEnt() && vPlayers[ax].canAim && vPlayers[ax].isAlive()) // No Dead People
{
if( !HasTarget() ) { SetTarget(ax); continue; }
if( vPlayers[ax].fovangle < vPlayers[iTarget].fovangle ) { SetTarget(ax); }
}
}
}
//==============================================================================
float CAimbot::calcFovAngle(const float* origin_viewer, const float* angle_viewer, const float* origin_target)
{
double vec[3], view[3];
double dot;
view[0] = origin_target[0] - origin_viewer[0];
view[1] = origin_target[1] - origin_viewer[1];
view[2] = origin_target[2] - origin_viewer[2];
dot = sqrt(view[0] * view[0] + view[1] * view[1] + view[2] * view[2]);
dot = 1/dot;
vec[0] = view[0] * dot;
vec[1] = view[1] * dot;
vec[2] = view[2] * dot;
view[0] = sin((angle_viewer[1] + 90) * (M_PI / 180));
view[1] = -cos((angle_viewer[1] + 90) * (M_PI / 180));
view[2] = -sin( angle_viewer[0] * (M_PI / 180));
dot = view[0] * vec[0] + view[1] * vec[1] + view[2] * vec[2];
// dot to angle:
return (float)((1.0-dot)*180.0);
}
//==============================================================================
bool CAimbot::CheckTeam(int ax)
{
if (me.team != vPlayers[ax].team) return true;
return false;
}
bool bAim = false;
char* gGetWeaponName( int weaponmodel );
int DoHLHAiming(int eventcode)
{
char *szWeapon;
UpdateMe();
szWeapon = gGetWeaponName(me.ent->curstate.weaponmodel);
if(strstr(szWeapon, "nade") || strstr(szWeapon, "c4") || strstr(szWeapon, "flashbang")) return 1;
if (eventcode == 1)
{
bAim = true;
gEngfuncs.pfnClientCmd("+attack");
return 0;
}
else
{
bAim = false;
gEngfuncs.pfnClientCmd("-attack");
return 1;
}
}
//==============================================================================
extern float gSpeed;
int DoSpeed(int eventcode)
{
if (eventcode == 1)
{
if (cvar.knivespeed && IsCurWeaponKnife()) gSpeed = 20.0f;
else gSpeed = cvar.speed;
}
else
gSpeed = 0.0;
return 0;
}
//==============================================================================
int getSeqInfo(int ax);
bool CAimbot::IsShielded(int ax)
{
int seqinfo = getSeqInfo(ax);
if (seqinfo & SEQUENCE_RELOAD)
return false;
if (seqinfo & SEQUENCE_SHIELD)
return true;
return false;
}
//==============================================================================
void CAimbot::calcFovangleAndVisibility(int ax)
{
PlayerInfo& r = vPlayers[ax];
r.fovangle = calcFovAngle(me.pmEyePos, me.viewAngles, r.origin() );
if(r.updateType() == 0 || r.updateType() == 2 || !r.isAlive()) { r.visible = false; return; }
float fov = 0; //1=10 , 2=30 , 3=90 , 4=360
if (cvar.fov == 1) fov = 10;
else if (cvar.fov == 2) fov = 30;
else if (cvar.fov == 3) fov = 90;
else if (cvar.fov == 4) fov = 360;
r.visible = TargetRegion(ax);
if(0) {}
else if (!CheckTeam(ax)) { r.canAim = 0; }
else if (IsShielded(ax)) { r.canAim = 0; }
else if (r.fovangle>fov) { r.canAim = 0; }
else if (bSoonvisible(ax)) { r.canAim = 1; }
else if (cvar.autowall)
{
int damage = GetDamageVec(ax, true);
if (damage)
{
r.canAim = 2;
}
else
{
damage = GetDamageVec(ax, false);
if (damage)
r.canAim = 1;
else
r.canAim = 0;
}
}
else { r.canAim = r.visible; }
}
//==============================================================================
int CAimbot::GetDamageVec(int ax, bool onlyvis)
{
int hitdamage, penetration = WALL_PEN0;
vec3_t vecEnd, up, right, forward, EntViewOrg, PlayerOrigin, playerAngles, targetspot;
VectorCopy(vPlayers[ax].vHitbox,PlayerOrigin);
playerAngles[0]=0;
playerAngles[1]=vPlayers[ax].getEnt()->angles[1];
playerAngles[2]=0;
gEngfuncs.pfnAngleVectors(playerAngles, forward, right, up);
forward[2] = -forward[2];
if (!onlyvis)
penetration = CorrectGunX();
targetspot[0] = PlayerOrigin[0] + up[0] * cvar.hadj_h + forward[0] * cvar.hadj_f + right[0] * cvar.hadj_r;
targetspot[1] = PlayerOrigin[1] + up[1] * cvar.hadj_h + forward[1] * cvar.hadj_f + right[1] * cvar.hadj_r;
targetspot[2] = PlayerOrigin[2] + up[2] * cvar.hadj_h + forward[2] * cvar.hadj_f + right[2] * cvar.hadj_r;
hitdamage = CanPenetrate(me.pmEyePos, targetspot, penetration);
if (hitdamage > 0)
return hitdamage;
return 0;
}
//==============================================================================
#define SPIN_REVS_PER_SECOND 6.0f // adjust to taste
void CAimbot::FixupAngleDifference(usercmd_t *usercmd)
{
// thanks tetsuo for this copy/paste
cl_entity_t *pLocal;
Vector viewforward, viewright, viewup, aimforward, aimright, aimup, vTemp;
float newforward, newright, newup, newmagnitude, fTime;
float forward = g_Originalcmd.forwardmove;
float right = g_Originalcmd.sidemove;
float up = g_Originalcmd.upmove;
pLocal = gEngfuncs.GetLocalPlayer();
if(!pLocal)
return;
// this branch makes sure your horizontal velocity is not affected when fixing up the movement angles -- it isn't specific to spinning and you can use it with the source tetsuo posted in his forum too
if(pLocal->curstate.movetype == MOVETYPE_WALK)
{
gEngfuncs.pfnAngleVectors(Vector(0.0f, g_Originalcmd.viewangles.y, 0.0f), viewforward, viewright, viewup);
}
else
{
gEngfuncs.pfnAngleVectors(g_Originalcmd.viewangles, viewforward, viewright, viewup);
}
// SPIN!!!
int iHasShiftHeld = GetAsyncKeyState(VK_LSHIFT);
if(pLocal->curstate.movetype == MOVETYPE_WALK && !iHasShiftHeld && !(usercmd->buttons & IN_ATTACK) && !(usercmd->buttons & IN_USE))
{
fTime = gEngfuncs.GetClientTime();
usercmd->viewangles.y = fmod(fTime * SPIN_REVS_PER_SECOND * 360.0f, 360.0f);
}
// this branch makes sure your horizontal velocity is not affected when fixing up the movement angles -- it isn't specific to spinning and you can use it with the source tetsuo posted in his forum too
if(pLocal->curstate.movetype == MOVETYPE_WALK)
{
gEngfuncs.pfnAngleVectors(Vector(0.0f, usercmd->viewangles.y, 0.0f), aimforward, aimright, aimup);
}
else
{
gEngfuncs.pfnAngleVectors(usercmd->viewangles, aimforward, aimright, aimup);
}
newforward = DotProduct(forward * viewforward.Normalize(), aimforward) + DotProduct(right * viewright.Normalize(), aimforward) + DotProduct(up * viewup.Normalize(), aimforward);
newright = DotProduct(forward * viewforward.Normalize(), aimright) + DotProduct(right * viewright.Normalize(), aimright) + DotProduct(up * viewup.Normalize(), aimright);
newup = DotProduct(forward * viewforward.Normalize(), aimup) + DotProduct(right * viewright.Normalize(), aimup) + DotProduct(up * viewup.Normalize(), aimup);
usercmd->forwardmove = newforward;
usercmd->sidemove = newright;
usercmd->upmove = newup;
}
|
Aimbot.h
#ifndef AIMBOT_H
#define AIMBOT_H
#include <windows.h>
#include <vector>
using namespace std;
struct Aimvec
{
float h;
float f;
float r;
};
class CAimbot
{
protected:
void init()
{
iTarget = -1;
active = false;
}
public:
int iTarget;
bool active;
vec3_t aim_viewangles;
void DrawAimSpot(void);
void CalculateHitbox( cl_entity_s *pEnt );
void CalculateAimingView( void );
inline void SetTarget( int iIndex ){ iTarget = iIndex; }
bool HasTarget( void ){ return iTarget != -1; }
void FindTarget( void );
bool CheckTeam(int ax);
bool IsShielded(int ax);
float calcFovAngle(const float* origin_viewer, const float* angle_viewer, const float* origin_target);
void calcFovangleAndVisibility(int ax);
bool pathFree(float* xfrom,float* xto);
bool TargetRegion(int ax);
int GetDamageVec(int ax, bool onlyvis);
void FixupAngleDifference(usercmd_t *usercmd);
usercmd_t g_Originalcmd;
public:
CAimbot() { init(); }
};
extern CAimbot Aimbot;
extern float mainViewOrigin[3];
extern bool isValidEnt(cl_entity_s *ent);
extern int DoSpeed(int eventcode);
extern int DoHLHAiming(int eventcode);
#endif
|
Modificat de allen (acum 12 ani)
|
|
