[Tutorial] OGL Aimbot

01.06.2004, 22:48

Guten Abend,

ich habe mich dazu entschlossen ein Aimbot Tutorial zu schreiben. Diese Methode des Zielens benutze ich in dem aktuellen spieletermine.de OGL Hook 1.0 der morgen veröffentlicht wird.

Gut dann fangen wir auch gleich an mit der Structur

Code:

typedef struct {
          int mode;
          int target;
          int fov;
          bool thru;
          bool active;
          float zone;
  } aim_s;

soweit ist sicher alles verständlich

mode - ob mouse 1 oder autoshot usw.
target - ziel sprich terror oder ct
fov - field of view in pixel
thru - visible prüfung
active an/aus
zone - jedoch in px auf der Z-Achse

Nun noch zwei Structuren für die Modelerkennung und das eigentliche Zielen

Code:

typedef struct {
          int team;
          int num;
          bool get;
          float min_vertex;
          float max_vertex;
          float highest_x;
          float highest_y;
          float highest_z;
          float lowest_x;
          float lowest_y;
          float lowest_z;
          float height;
          float distance;
          float vertex;
  }model_s;
  
  typedef struct {
          int team;
          float x;
          float y;
          float z;
          float distance;
          float vector_x;
          float vector_y;
          float vector_z;
  }player_s;

Der bisherige Code kommt in eine extra Datei z.B. "vars.h" oder "aimbot.h".

Und nun geht es zu der Modelerkennung die wir für den Aimbot brauchen damit wir wissen ob es ein Terror oder ein CT ist.

Als erstes deklinieren wir die Structuren

Code:

aim_s aim;
  model_s model;
  player_s player[40];

player[40] deshalb weil ich sonst öffters einen crash hatte ansich undenkbar da Half-Life ja nur max. 32 Player hat jedoch war es so.

glPopMatrix:

Code:

if (model.get) model.get = false;

Wie setzten die Bool auf true damit wir wissen das HL ein Model Drawed.

glShadeModel:

Code:

GLdouble wx,wy,wz;
          
          glGetDoublev(GL_MODELVIEW_MATRIX,mm);
          glGetDoublev(GL_PROJECTION_MATRIX ,pm);
          glDisable(GL_TEXTURE_2D);
  
          if ((mode == GL_SMOOTH) && (!model.get)) 
          {
                  model.get = true;
                  model.highest_z = -99999;
                  model.lowest_z = -99999;
                  model.vertex = 0;
          }
          else 
          {
                  if (model.get) 
                  {
                  gluProject(model.highest_x,model.highest_y,model.highest_z,mm,pm,vp,&wx ,&wy ,&wz );
                         model.distance = getDist(model.highest_x,model.highest_y,model.highest_z,origin[0],origin[1],origin[2])/40;
  
                         if ((model.vertex>=model.min_vertex) && (model.vertex<=model.max_vertex))
                          {
                                 modelnum = checkVertex(0,-1,model.vertex);
                          if ((modelnum < 8) && (modelnum != -1) && (model.height>40) && (model.height<90) && model.num <=40)
                                  {
                                  player[model.num].x = model.highest_x;
                                  player[model.num].y = model.highest_y;
                                  player[model.num].z = model.highest_z;
                                  player[model.num].distance = model.distance;
                                  if ((modelnum < 4) && (modelnum != -1))
                                   player[model.num].team = 1;
                                  else if ((modelnum > 3) && (modelnum < 8))
                                   player[model.num].team = 0;
                                          else
                                   player[model.num].team = -1;
                                         model.num++;
                                  }
                          }
                  }
          }
          glEnable(GL_TEXTURE_2D);

Wir speichern alle Models die in ein Array damit wir später darauf zurück greifen können.Ansich ist der Code selbst erklärend da die Variablen klar benannet sind.

glTranslatef

Code:

if (((x!=0) && (y!=0) && (z!=0)))
          {
                  origin[0]=x*-1;
                  origin[1]=y*-1;
                  origin[2]=z*-1;
          }

Hier Speichern wir unsere aktuelle Position in dem Raster in einem Array damit wir die Distance zwischen uns und den Playermodels berechnen können.

glVertex3f

Code:

if (model.get)
          {
                  model.vertex++;
                  if ( (z > model.highest_z) || (model.highest_z==-99999))
                  {
                          model.highest_x=x;
                          model.highest_y=y;
                          model.highest_z=z;
                  }
                  if ( (z < model.lowest_z) || (model.lowest_z==-99999)) {
                          model.lowest_x=x;
                          model.lowest_y=y;
                          model.lowest_z=z;
                  }
  
                  model.height=model.highest_z-model.lowest_z;
          }

Hier gucken wir ob ein Model gemalt wird und wenn ja dann speichern wir dessen hösten und niedrigsten Vertex in einer Variable.

glVertex3fv:

Code:

modelviewport=true;

Wenn HL diese Funktion aufruft ist das Model fertig gemalt.

glViewport:

Code:

if (modelviewport)
          {
                  model.highest_z=-99999;
                  model.lowest_z=-99999;
                  model.vector_x=0;
                  model.vector_y=0;
                  modelviewport=false;
          }

Hier setzten wir die Variablen zurück damit das Spiel von neuem Beginnen kann.

wglSwapBuffers:

Code:

if (!draw.menu && aim.active && ( ((aim.mode == 0) && (mouse.button == 1)) || ((aim.mode == 1) && (mouse.button == 2)) || (aim.mode == 2) || (aim.mode == 3) ) )
                          DoAim();
          model.num = 0;

Hier aufgepasst ich wette ihr habt euer KeyHandling anders realisiert z.B. mit GetAsyncKeyStat(); dann müsst ihr das hier anpassen.

So nun das eigentliche Zielen

Code:

void DoAim(void)
  {
          int num=-1;
          float distance=99999.0;
         // Wenn Aim thru aus ist dann müssen wir überprüfen ob wir das Model sehen und gleichzeitig finden wir das Model was am nähesten bei uns ist.
          if (!aim.thru)
          {
                  for (int i=0;i < model.num;i++)
                  {
                          if ((player[i].distance < distance)  
                                 && (aim.target == player[i].team))
                          {
                                  if (checkVisible(i))
                                  {
                                         distance = player[i].distance;
                                         num = i;
                                  }
                          }
                  }
          }
  // Wenn Aim thru aus ist müssen wir nur das näheste Model finden
          else
          {
                  for (int i=0;i < model.num;i++)
                  {
                         if ((player[i].distance < distance) && (aim.target == player[i].team))
                          {
                                  distance = player[i].distance;
                                  num = i;
                          }
                  }
          }
          
          // Wenn es ein Model gibt das den Kriterien entspricht dann Ziehlen wir hier darauf
          if (num != -1)
          {
                  GLdouble wx,wy,wz;
              gluProject(player[num].x,player[num].y,player[num].z-aim.zone,mm,pm,vp,&wx ,&wy ,&wz );
                  
                  if (aim.active && (player[num].team == aim.target))
                  {
                         if ((wx>=vp[2]/2-aim.fov/2) && (wx<=vp[2]/2+aim.fov/2) && (wy>=vp[3]/2-aim.fov/2) && (wy<=vp[3]/2+aim.fov/2)) //Gucken ob das Model im AimFOV ist (da seh ich gerade das ich das noch verbessern kann jedoch nciht in diesem tut :))
                          {
                                 int aimx=(float)((wx*65535)/vp[2]);
                                 int aimy=(float)(((vp[3]-wy)*65535)/vp[3]);
  
                          mouse_event(MOUSEEVENTF_MOVE|MOUSEEVENTF_ABSOLUTE,aimx,aimy,0,0);
                                  if (aim.mode == 3)
                                  { // Mein Cooler Autoshot :)
                                         if (iShoot > 20)
                                         {        
                                                 bWait = true;
                                          }
                                  if (bWait && (iShoot > 50))
                                          {
                                                 bWait = false;
                                          iShoot = 0;        
                                          }
  
                                         KeyHandle(MK_LBUTTON);
                                  if (!bWait && (iShoot %10 == 0))
                                          {
                                   mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
                                   mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
                                          }
                                         iShoot++;
                                  }
                          }
                  }
          }
  }

Diese Funktion Rufen wir jeweils zum Ende eines jeden Frames auf.

Nun noch Funktionen die ihr für die umsetzung braucht

Code:

int IsPointVisible(GLdouble x, GLdouble y, GLdouble z)
  {        
          GLdouble        winX, winY, winZ;
          GLfloat                pix;
  
          glGetDoublev(GL_MODELVIEW_MATRIX,mm);
          glGetDoublev(GL_PROJECTION_MATRIX ,pm);
  
          if (gluProject (x, y, z, mm, pm, vp, &winX, &winY, &winZ) == GL_TRUE)
          {
                  glReadPixels((int)winX,(int)winY,1,1,GL_DEPTH_COMPONENT ,GL_FLOAT,&pix);
                  if (pix > winZ) 
                          return 1;
                  else 
                          return 0;
          }
          else
                  return 0;
  }

Code:

int checkVertex (int start, int offset, float vertcount) 
  {
          if (offset == -1) 
                  offset = vertexcount;
          for(int i=start;i < offset+1;i++) 
          {
                  for (int y=0; y < 3;y++) {
                          if (vertcount == vertex[i].vert[y])
                          {
                                 sprintf(curmodel,"%s",vertex[i].name);
                                  return i;
                          }
                  }
          }
          return -1;
  }

Diese Funktion muss nur einmal aufgerufen werden.

Code:

void loadModelRec (void)
  {
          // Gign
          sprintf(vertex[0].name,"%c%c%c%c",103,105,103,110);
          vertex[0].vert[0] = 1158;
          vertex[0].vert[1] = 1262;
          vertex[0].vert[2] = 0;
  
          // GSG-9
          sprintf(vertex[1].name,"%c%c%c%c",103,115,103,57);
          vertex[1].vert[0] = 1110;
          vertex[1].vert[1] = 1214;
          vertex[1].vert[2] = 0;
  
          // Sas
          sprintf(vertex[2].name,"%c%c%c",115,97,115);
          vertex[2].vert[0] = 1052;
          vertex[2].vert[1] = 1156;
          vertex[2].vert[2] = 0;
  
          // Seal
          sprintf(vertex[3].name,"%c%c%c%c",115,101,97,108);
          vertex[3].vert[0] = 1130;
          vertex[3].vert[1] = 1234;
          vertex[3].vert[2] = 0;
  
          // Leet
          sprintf(vertex[4].name,"%c%c%c%c",108,101,101,116);
          vertex[4].vert[0] = 1162;
          vertex[4].vert[1] = 1230;
          vertex[4].vert[2] = 0;
  
          // Arctic
          sprintf(vertex[5].name,"%c%c%c%c%c%c",97,114,99,116,105,99);
          vertex[5].vert[0] = 1061;
          vertex[5].vert[1] = 1129;
          vertex[5].vert[2] = 0;
  
          // Terror
          sprintf(vertex[6].name,"%c%c%c%c%c%c",116,101,114,114,111,114);
          vertex[6].vert[0] = 1078;
          vertex[6].vert[1] = 1146;
          vertex[6].vert[2] = 0;
  
          // Guerilla
          sprintf(vertex[7].name,"%c%c%c%c%c%c%c%c",103,117,101,114,105,108,108,97);
          vertex[7].vert[0] = 1136;
          vertex[7].vert[1] = 1078;
          vertex[7].vert[2] = 0;
  
          // M4A1
          sprintf(vertex[8].name,"%c%c%c%c",109,52,97,49);
          vertex[8].vert[0] = 238;
          vertex[8].vert[1] = 0;
          vertex[8].vert[2] = 0;
  
          // AK 47
          sprintf(vertex[9].name,"%c%c%c%c",97,107,52,55);
          vertex[9].vert[0] = 214;
          vertex[9].vert[1] = 0;
          vertex[9].vert[2] = 0;
  
          // USP
          sprintf(vertex[10].name,"%c%c%c",117,115,112);
          vertex[10].vert[0] = 164;
          vertex[10].vert[1] = 0;
          vertex[10].vert[2] = 0;
  
          // Knife
          sprintf(vertex[11].name,"%c%c%c%c%c",107,110,105,102,101);
          vertex[11].vert[0] = 172;
          vertex[11].vert[1] = 0;
          vertex[11].vert[2] = 0;
  
          // Deagle
          sprintf(vertex[12].name,"%c%c%c%c%c%c",100,101,97,103,108,101);
          vertex[12].vert[0] = 170;
          vertex[12].vert[1] = 0;
          vertex[12].vert[2] = 0;
  
          // Gallil
          sprintf(vertex[13].name,"%c%c%c%c%c%c",103,97,108,108,105,108);
          vertex[13].vert[0] = 288;
          vertex[13].vert[1] = 0;
          vertex[13].vert[2] = 0;
  
          // Glock18
          sprintf(vertex[14].name,"%c%c%c%c%c%c%c",103,108,111,99,107,49,56);
          vertex[14].vert[0] = 144;
          vertex[14].vert[1] = 130;
          vertex[14].vert[2] = 0;
  
          // Granade
          sprintf(vertex[15].name,"%c%c%c%c%c%c%c",103,114,97,110,97,100,101);
          vertex[15].vert[0] = 98;
          vertex[15].vert[1] = 0;
          vertex[15].vert[2] = 0;
  
          // xm1014
          sprintf(vertex[16].name,"%c%c%c%c%c%c",120,109,49,48,49,52);
          vertex[16].vert[0] = 232;
          vertex[16].vert[1] = 0;
          vertex[16].vert[2] = 0;
  
          // AUG
          sprintf(vertex[17].name,"%c%c%c",97,117,103);
          vertex[17].vert[0] = 252;
          vertex[17].vert[1] = 0;
          vertex[17].vert[2] = 0;
  
          //MP5
          sprintf(vertex[18].name,"%c%c%c",109,112,53);
          vertex[18].vert[0] = 290;
          vertex[18].vert[1] = 0;
          vertex[18].vert[2] = 0;
  
          // SG 552
          sprintf(vertex[19].name,"%c%c%c%c%c",115,103,53,53,50);
          vertex[19].vert[0] = 264;
          vertex[19].vert[1] = 0;
          vertex[19].vert[2] = 0;
  
          // C4
          sprintf(vertex[20].name,"%c%c",99,52);
          vertex[20].vert[0] = 0;
          vertex[20].vert[1] = 0;
          vertex[20].vert[2] = 0;
  
          // M3
          sprintf(vertex[21].name,"%c%c",109,51);
          vertex[21].vert[0] = 226;
          vertex[21].vert[1] = 0;
          vertex[21].vert[2] = 0;
  
          // Elites
          sprintf(vertex[22].name,"%c%c%c%c%c%c",101,108,105,116,101,115);
          vertex[22].vert[0] = 388;
          vertex[22].vert[1] = 0;
          vertex[22].vert[2] = 0;
  
          // Mac10
          sprintf(vertex[23].name,"%c%c%c%c%c",109,97,99,49,48);
          vertex[23].vert[0] = 216;
          vertex[23].vert[1] = 0;
          vertex[23].vert[2] = 0;
  
          // UMP .45
          sprintf(vertex[24].name,"%c%c%c%c%c",117,109,112,52,53);
          vertex[24].vert[0] = 245;
          vertex[24].vert[1] = 0;
          vertex[24].vert[2] = 0;
  
          // TMP
          sprintf(vertex[25].name,"%c%c%c",116,109,112);
          vertex[25].vert[0] = 182;
          vertex[25].vert[1] = 0;
          vertex[25].vert[2] = 0;
  
          // P 90
          sprintf(vertex[26].name,"%c%c%c",112,57,48);
          vertex[26].vert[0] = 140;
          vertex[26].vert[1] = 0;
          vertex[26].vert[2] = 0;
  
          // Para
          sprintf(vertex[27].name,"%c%c%c%c",112,97,114,97);
          vertex[27].vert[0] = 222;
          vertex[27].vert[1] = 0;
          vertex[27].vert[2] = 0;
  
          // SG550
          sprintf(vertex[28].name,"%c%c%c%c%c",115,103,53,53,48);
          vertex[28].vert[0] = 274;
          vertex[28].vert[1] = 0;
          vertex[28].vert[2] = 0;
          
          // Shield
          sprintf(vertex[29].name,"%c%c%c%c%c%c",115,104,105,101,108,100);
          vertex[29].vert[0] = 306;
          vertex[29].vert[1] = 0;
          vertex[29].vert[2] = 0;
  
          // Scout
          sprintf(vertex[30].name,"%c%c%c%c%c",115,99,111,117,116);
          vertex[30].vert[0] = 146;
          vertex[30].vert[1] = 0;
          vertex[30].vert[2] = 0;
  
          // AWP
          sprintf(vertex[31].name,"%c%c%c",97,119,112);
          vertex[31].vert[0] = 224;
          vertex[31].vert[1] = 0;
          vertex[31].vert[2] = 0;
  
          // G3SG1
          sprintf(vertex[32].name,"%c%c%c%c%c",103,51,115,103,49);
          vertex[32].vert[0] = 250;
          vertex[32].vert[1] = 0;
          vertex[32].vert[2] = 0;
  
          // Famas
          sprintf(vertex[33].name,"%c%c%c%c%c",102,97,109,97,115);
          vertex[33].vert[0] = 266;
          vertex[33].vert[1] = 0;
          vertex[33].vert[2] = 0;
  
          vertexcount = 33;
  }

Diese Funktion brauchen wir auch nur einmal aufrufen

Code:

void SetMinMaxVertex(void)
  {
          for(int i=0;i < vertexcount + 1;i++)
          {
                  for (int y=0; y < 3;y++)
                  {
                          if (vertex[i].vert[y] < model.min_vertex)
                                 model.min_vertex = vertex[i].vert[y];
                          if (vertex[i].vert[y] > model.max_vertex)
                                 model.max_vertex = vertex[i].vert[y];
                  }
          }
  }

Code:

bool checkVisible(int number)
  {
          if (number == -1)
                  return false;
          bool gldepthtest=false;
          bool visible=false;
          if (glIsEnabled(GL_DEPTH_TEST))
                  gldepthtest=true;
          glEnable(GL_DEPTH_TEST);
  
          if (IsPointVisible(player[number].x,player[number].y,player[number].z+5)) visible = true;
     else if (IsPointVisible(player[number].x-10,player[number].y-10,player[number].z-30)) visible = true;
          else if (IsPointVisible(player[number].x+10,player[number].y-10,player[number].z-30)) visible = true;
          else if (IsPointVisible(player[number].x+10,player[number].y+10,player[number].z-55)) visible = true;
          else if (IsPointVisible(player[number].x-10,player[number].y+10,player[number].z-55)) visible = true;
          if (!gldepthtest)
                  glDisable(GL_DEPTH_TEST);
  
          return visible;
  }