作弊器添加 bone 瞄准模式

作弊器添加 bone 瞄准模式

作弊器除了vec瞄准模式 inverse瞄准模式
还可添加 bone 瞄准模式

vec为传统瞄准点模式,根据自己手中武器的不同,瞄准对方头部的位置也不同 inverse则相反,根据对方手中的武器来确定头部瞄准位置,由于CS中人物持不同的武器时姿势也会稍有不同,头部的位置就会不一样,所以这种瞄准方式更科学,理论上讲应该比传统vec方式准,不过实际测试感觉差不多,玩家可以根据自己的喜好来选择用哪一种方式....



first of all you have to add the aimbot part for boneaim

k got o your aimbot.cpp #include "console.h"

now look for:

OriginAimbot gAimbot;

change that to:

BoneAimbot gAimbot;

now at the bottom of your aimbot where your CalcViewAngles below add this for bone
Code:

//===================================================================================
class DrawPoints
{
public:
void aggregate(float* _origin, DWORD _color=0xFFFFFFFF, int _size=1);
void draw_all ();

protected:
// scheduled draw points
struct ScheduledDrawPoint
{
  ScheduledDrawPoint() : active(false) {}
  vec3_t origin;
  DWORD color_compiled;
  int  size;
  bool  active;
};
enum { MAX_DRAW_POINTS=64 };
std::vector<ScheduledDrawPoint> vecDrawPoints;//(64);
int DrawPointsNextIndex;

public:
DrawPoints() : DrawPointsNextIndex(0), vecDrawPoints(MAX_DRAW_POINTS) {}
};

//===================================================================================
void DrawPoints::aggregate(float* _origin, DWORD _color , int _size )
{
VectorCopy(_origin,vecDrawPoints[DrawPointsNextIndex].origin);
vecDrawPoints[DrawPointsNextIndex].color_compiled = _color;
vecDrawPoints[DrawPointsNextIndex].size = _size;
vecDrawPoints[DrawPointsNextIndex].active = true;

DrawPointsNextIndex++;
if( DrawPointsNextIndex>=(int)vecDrawPoints.size() ) DrawPointsNextIndex=0;
}

// ======= DrawAllHudPoints
void DrawPoints::draw_all()
{
typedef vector<ScheduledDrawPoint> vp;
for( vp::iterator pos=vecDrawPoints.begin(); pos!=vecDrawPoints.end(); ++pos )
{
  if( (*pos).active )
  {
    ScheduledDrawPoint& point = (*pos);
    point.active=false;
    gDrawFilledBoxAtLocation(point.origin,point.color_compiled,point.size);
  }
}
}
// global DrawPoints
static DrawPoints gDrawPoints;

//==========================================================================================
void BoneAimbot::CalcTargetSpot(float* out)
{
if( vPlayers[target].numTargetSpots && cvar.modelaim )
{
  ModelBasedAim(out);
}
else
{
  OriginAimbot::CalcTargetSpot(out);
}
}

// ========================================================================
void BoneAimbot::ModelBasedAim(float* TargetVec)
{
// try first spot:
int i = firstaimspot;
if( i<vPlayers[target].numTargetSpots && i>=0 )
{
  float* testvec = vPlayers[target].TargetSpots;
  if(pathFree(me.pmEyePos,testvec))
  {
    VectorCopy(testvec,TargetVec);
    return;
  }
}

for(i=0;i<vPlayers[target].numTargetSpots;i++)
{
  if(i==firstaimspot) continue;

  float* testvec = vPlayers[target].TargetSpots;
  if(pathFree(me.pmEyePos,testvec))
  {
    VectorCopy(testvec,TargetVec);
    return;
  }
}
VectorCopy(vPlayers[target].TargetSpots[0], TargetVec );
}

//==========================================================================================
BoneAimbot::ModelInfo* BoneAimbot::getModelInfo(const char* arg_name)
{
assert(arg_name);

if(hashToInfo.size()>32)
{
  gConsole.echo("&rerror: Model limit reached.");
  return NULL;
}
ModelInfo& info = hashToInfo[arg_name];
info.name = arg_name;
return &info;
}

//==========================================================================================
void BoneAimbot::draw()
{
if(cvar.avdraw<=2) { OriginAimbot::draw(); return; };
gDrawPoints.draw_all();
}

//==============================================================================
void BoneAimbot::load(const char* filename)
{

}

//==============================================================================
void BoneAimbot::save(const char* filename)
{
ofstream ofs(filename);
if(!ofs) { gConsole.echo( "&w%s&r write error.",filename); return; }
else  { gConsole.echo( "&w%s&g saved."  ,filename); }

ofs<<"// this file is generated automatically. do not edit!"<<endl;
ofs<<"mdl clear_models"<<endl;

for( iterator pos = hashToInfo.begin(); pos!=hashToInfo.end(); ++pos )
{
  ModelInfo& info = (*pos).second;
  ofs<<endl<<"mdl new "<<info.name<<endl;

  for(int i=0;i<info.numAimspots;i++)
  {
    ModelAimSpot& spot = info.aimspots;
    if(spot.boneindex)
    ofs<<"mdl add_spot "<<spot.boneindex<<" "<<spot.boneindex2<<" "<<spot.factor2<<endl;
    else
    ofs<<"mdl add_spot "<<spot.boneindex<<endl;
  }
}
ofs<<endl<<"mdl ov "<<offset_first.h<<" "<<offset_first.f<<" "<<offset_first.r<<endl;
}

// ==================================================================
static void calcPredictDelta(cl_entity_s* ent, float *delta)
{
if (cvar.pred)
{
  int historyIndex = (ent->current_position+HISTORY_MAX-cvar.predback)%HISTORY_MAX;
  
  float* vFromOrigin = ent->ph[historyIndex].origin;
  float* vToOrigin  = ent->ph[ent->current_position].origin;
  
  delta[0] = vToOrigin[0] - vFromOrigin[0];
  delta[1] = vToOrigin[1] - vFromOrigin[1];
  delta[2] = vToOrigin[2] - vFromOrigin[2];

  delta[0] *= cvar.predahead;
  delta[1] *= cvar.predahead;
  delta[2] *= cvar.predahead;
}
else
{
  delta[0]=delta[1]=delta[2]=0;
}
}

////==============================================================================
void BoneAimbot:ostStudioDrawPlayer( int flags, struct entity_state_s *pplayer )
{
int ax = pplayer->number;
if(!vPlayers[ax].getPVS()) return;

// non visible players return wrong bones!
if(GetAimingFov(ax) < (40.0-180.0)/-180.0) return;

cl_entity_s* ent = vPlayers[ax].getEnt();

model_s* pModel = pstudio->SetupPlayerModel(ax-1);
studiohdr_t* pStudioHeader = (studiohdr_t*)pstudio->Mod_Extradata( pModel );

// get bone transform
typedef float TransformMatrix[ MAXSTUDIOBONES ][ 3 ][ 4 ];
TransformMatrix* pbonetransform = (TransformMatrix*)pstudio->StudioGetBoneTransform();

// get model info
if(cvar.avdraw==3) gSetHudMessage(pStudioHeader->name);
ModelInfo* l_modelInfo = getModelInfo(pStudioHeader->name);
if(!l_modelInfo) return;

// grab target spots:
vec3_t predictDelta;
calcPredictDelta(ent, predictDelta );

for( int i=0;i<l_modelInfo->numAimspots;i++ )
{
  ModelAimSpot& spot = l_modelInfo->aimspots;
  vec3_t&  pos = vPlayers[ax].TargetSpots;

  pos [ 0 ] = (*pbonetransform)[ spot.boneindex ][ 0 ][ 3 ];
  pos [ 1 ] = (*pbonetransform)[ spot.boneindex ][ 1 ][ 3 ];
  pos [ 2 ] = (*pbonetransform)[ spot.boneindex ][ 2 ][ 3 ];

  // interpolate between two bones
  if( spot.boneindex2 )
  {
    vec3_t to, diff;
    
    to [ 0 ] = (*pbonetransform)[ spot.boneindex2 ][ 0 ][ 3 ];
    to [ 1 ] = (*pbonetransform)[ spot.boneindex2 ][ 1 ][ 3 ];
    to [ 2 ] = (*pbonetransform)[ spot.boneindex2 ][ 2 ][ 3 ];

    diff = to - pos;
    
    pos[0] += (spot.factor2 * diff[0]);
    pos[1] += (spot.factor2 * diff[1]);
    pos[2] += (spot.factor2 * diff[2]);
  }

  // predict
  pos[0] += predictDelta[0];
  pos[1] += predictDelta[1];
  pos[2] += predictDelta[2];

  // offset first spot
  if(!i)
  {
    vec3_t anglevec, forward, right, up, offset;
    anglevec[0]  = 0;
    anglevec[1]  = pplayer->angles[1];
    anglevec[2]  = 0;
    gEngfuncs.pfnAngleVectors(pplayer->angles,forward,right,up);
    
    offset = forward*offset_first.f + right*offset_first.r + up*offset_first.h;
    vPlayers[ax].TargetSpots[0][0] += offset[0];
    vPlayers[ax].TargetSpots[0][1] += offset[1];
    vPlayers[ax].TargetSpots[0][2] += offset[2];
  }

  {
    // log for drawing
    if( cvar.avdraw==4 )
    {
    if( i==firstaimspot ) gDrawPoints.aggregate(pos,0xFF1111FF,2);
    else        gDrawPoints.aggregate(pos,0xFFFFFFFF);
    } else
    if( cvar.avdraw==5 )
    {
    if( i==firstaimspot ) gDrawPoints.aggregate(pos,0xFF1111FF,2);
    }
  }
}

// handle Drawing
if(cvar.avdraw>=3)
{
  int i = my_curSelectedBone;
  if( i>=0 && i<pStudioHeader->numbones )
  {
    vec3_t pos;
    pos[ 0 ] = (*pbonetransform)[ i ][ 0 ][ 3 ];
    pos[ 1 ] = (*pbonetransform)[ i ][ 1 ][ 3 ];
    pos[ 2 ] = (*pbonetransform)[ i ][ 2 ][ 3 ];
    gDrawPoints.aggregate( pos, 0xFFFFAAFF, 2 );
    
    mstudiobone_t *pbones = (mstudiobone_t *)((byte *)pStudioHeader + pStudioHeader->boneindex);
    char tmp[64];sprintf(tmp,"#%d: %s",i,pbones.name);
    gSetHudMessage2(tmp);
  }
}
// update info:
vPlayers[ax].numTargetSpots = l_modelInfo->numAimspots;