Source Aimbot ³

Bom galera achei isso na net e gostaria de compartilhar:
/EDIT COPIEI O CODIGO ERRADO KKKK MAUS
aimbot.cpp

(include no recoil e outros...)

Code:

#pragma once

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include "aimtools.h"

// ==   DEFINES   ==
#define pLocal		 (0x000000)
#define spdPatch	 (0x000000)
#define gStructLocal (0x000000)
#define addCmdPtr	 (0x000000)
#define playerVecPtr (0x000000)
#define conoutPtr	 (0x000000)

#define gStructSize (0x128)
#define wStructSize (0x70)


#define vecloop(v) for(int i=0;i<(v)->length();i++)
#define intloop(s) for(int i=0;i<s;i++)

#define playerTable vector<playerObj*>

#define isteam(a,b)   (strcmp(a, b)==0)

#define RAD ((3.1415927)/180)
// == END DEFINES ==

// ==   ENUMS   ==

enum
{
    ARG_1INT, ARG_2INT, ARG_3INT, ARG_4INT,
    ARG_NONE,
    ARG_1STR, ARG_2STR, ARG_3STR, ARG_4STR, ARG_5STR, ARG_6STR, ARG_7STR, ARG_8STR,
    ARG_DOWN,
    ARG_1EXP, ARG_2EXP,
    ARG_1EXPF, ARG_2EXPF,
    ARG_1EST, ARG_2EST,
    ARG_IVAL, ARG_FVAL, ARG_SVAL,
    ARG_CONC, ARG_CONCW,
    ARG_VARI
};

enum { GUN_KNIFE = 0, GUN_PISTOL, GUN_SHOTGUN, GUN_SUBGUN, GUN_SNIPER, GUN_ASSAULT, GUN_GRENADE, GUN_AKIMBO, NUMGUNS };

// == END ENUMS ==

// ==   FORWARD DEFINITIONS   ==
class localPtr;
class playerObj;
struct guninfo;
class weapon;
// == END FORWARD DEFINITIONS ==

class localPtr
{
public:
	playerObj* obj; //0000
};

class playerObj
{
public:
	__int32 Unknown0; //0000
	vec o; //0004
	vec vel; //0010
	vec delta; //001C
	vec newPos; //0028
	float yaw; //0034
	float pitch; //0038
	float roll; //003C
	float pitchvel; //0040
	float maxspeed; //0044
	__int32 timeinair; //0048
	float radius; //004C
	float eyeheight; //0050
	float maxeyeheight; //0054
	float aboveeye; //0058
	__int8 inwater; //005C
	__int8 onfloor; //005D
	__int8 onladder; //005E
	__int8 jumpnext; //005F
	__int8 crouching; //0060
	__int8 trycrouch; //0061
	__int8 cancollide; //0062
	__int8 stuck; //0063
	__int32 lastsplash; //0064
	__int8 move; //0068
	__int8 strafe; //0069
	__int8 state; //006A
	__int8 type; //006B
	float eyeheightvel; //006C
	char unknown1[108];
	__int32 health; //00DC
	__int32 armor; //00E0
	char unknown2[112];
	__int32 clientnum; //0154
	__int32 lastupdate; //0158
	__int32 plag; //015C
	__int32 ping; //0160
	__int32 lifesequence; //0164
	__int32 frags; //0168
	__int32 flagscore; //016C
	__int32 deaths; //0170
	char unknown3[20];
	__int8 Unknown4; //0188
	char name[16]; //0189
	char unknown5[244];
	char team[16]; //028D
	char unknown6[272];
	__int16 Unknown7; //03AD
	__int8 Unknown8; //03AF
	weapon *weapons[NUMGUNS]; //03B0
	weapon *prevweaponsel; //03D4
	weapon *weaponsel; //03D8
	weapon *nextweaponsel; //03DC
	weapon *primweap; //03E0
	weapon *nextprimweap; //03E4
	char unknown10[132];
	vec head; //046C
};


struct guninfo
{
	char modelname[16]; //0000
	char unknown1[244];
	__int16 sound; //0104
	__int16 reload; //0106
	__int16 reloadtime; //0108
	__int16 attackdelay; //010A
	__int16 damage; //010C
	__int16 projspeed; //010E
	__int16 part; //0110
	__int16 spread; //0112
	__int16 recoil; //0114
	__int16 magsize; //0116
	__int16 mdl_kick_rot; //0118
	__int16 mdl_kick_back; //011A
	__int16 recoilincrease; //011C
	__int16 recoilbase; //011E
	__int16 maxrecoil; //0120
	__int16 recoilbackfade; //0122
	__int16 pushfactor; //0124
	__int16 isauto; //0126
};

class weapon
{
public:
	__int32 type; //0000
	__int32 unknown0; // 0004
	playerObj *owner; //0008
	__int32 infoA; //000C
	__int32 ammoA; //0010
	__int32 magA; //0014
	__int32 gunwaitA; //0018
	char unknown1[88]; // 002C
};
}

aimtools

Code:

#include <iostream>

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;

#define ASSERT(c) if(!(c)) { __asm int 3 }

template <class T>
struct databuf
{
    enum
    {
        OVERREAD  = 1<<0,
        OVERWROTE = 1<<1
    };

    T *buf;
    int len, maxlen;
    uchar flags;

    template <class U>
    databuf(T *buf, U maxlen) : buf(buf), len(0), maxlen((int)maxlen), flags(0) {}

    const T &get()
    {
        static T overreadval;
        if(len<maxlen) return buf[len++];
        flags |= OVERREAD;
        return overreadval;
    }

    databuf subbuf(int sz)
    {
        sz = min(sz, maxlen-len);
        len += sz;
        return databuf(&buf[len-sz], sz);
    }

    void put(const T &val)
    {
        if(len<maxlen) buf[len++] = val;
        else flags |= OVERWROTE;
    }

    void put(const T *vals, int numvals)
    {
        if(maxlen-len<numvals) flags |= OVERWROTE;
        memcpy(&buf[len], vals, min(maxlen-len, numvals)*sizeof(T));
        len += min(maxlen-len, numvals);
    }

    int length() const { return len; }
    int remaining() const { return maxlen-len; }
    bool overread() const { return flags&OVERREAD; }
    bool overwrote() const { return flags&OVERWROTE; }

    void forceoverread()
    {
        len = maxlen;
        flags |= OVERREAD;
    }
};

typedef databuf<char> charbuf;
typedef databuf<uchar> ucharbuf;

template <class T> struct vector
{
   static const int MINSIZE = 8;

    T *buf;
    int alen, ulen;

    vector() : buf(NULL), alen(0), ulen(0)
    {
    }

    vector(const vector &v) : buf(NULL), alen(0), ulen(0)
    {
        *this = v;
    }

    ~vector() { setsize(0); if(buf) delete[] (uchar *)buf; }

    vector<T> &operator=(const vector<T> &v)
    {
        setsize(0);
        if(v.length() > alen) vrealloc(v.length());
        loopv(v) add(v[i]);
        return *this;
    }

    T &add(const T &x)
    {
        if(ulen==alen) vrealloc(ulen+1);
        new (&buf[ulen]) T(x);
        return buf[ulen++];
    }

    T &add()
    {
        if(ulen==alen) vrealloc(ulen+1);
        new (&buf[ulen]) T;
        return buf[ulen++];
    }

    T &dup()
    {
        if(ulen==alen) vrealloc(ulen+1);
        new (&buf[ulen]) T(buf[ulen-1]);
        return buf[ulen++];
    }

    bool inrange(size_t i) const { return i<size_t(ulen); }
    bool inrange(int i) const { return i>=0 && i<ulen; }

    T &pop() { return buf[--ulen]; }
    T &last() { return buf[ulen-1]; }
    void drop() { buf[--ulen].~T(); }
    bool empty() const { return ulen==0; }

    int length() const { return ulen; }
    T &operator[](int i) { ASSERT(i>=0 && i<ulen); return buf[i]; }
    const T &operator[](int i) const { ASSERT(i >= 0 && i<ulen); return buf[i]; }

    void setsize(int i)         { ASSERT(i<=ulen); while(ulen>i) drop(); }
    void setsizenodelete(int i) { ASSERT(i<=ulen); ulen = i; }

    void deletecontentsp() { while(!empty()) delete   pop(); }
    void deletecontentsa() { while(!empty()) delete[] pop(); }

    T *getbuf() { return buf; }
    const T *getbuf() const { return buf; }
    bool inbuf(const T *e) const { return e >= buf && e < &buf[ulen]; }

    template<class ST>
    void sort(int (__cdecl *cf)(ST *, ST *), int i = 0, int n = -1)
    {
        qsort(&buf[i], n<0 ? ulen : n, sizeof(T), (int (__cdecl *)(const void *,const void *))cf);
    }

    template<class ST>
    T *search(T *key, int (__cdecl *cf)(ST *, ST *), int i = 0, int n = -1)
    {
        return (T *) bsearch(key, &buf[i], n<0 ? ulen : n, sizeof(T), (int (__cdecl *)(const void *,const void *))cf);
    }

    void vrealloc(int sz)
    {
        int olen = alen;
        if(!alen) alen = max(MINSIZE, sz);
        else while(alen < sz) alen *= 2;
        if(alen <= olen) return;
        uchar *newbuf = new uchar[alen*sizeof(T)];
        if(olen > 0)
        {
            memcpy(newbuf, buf, olen*sizeof(T));
            delete[] (uchar *)buf;
        }
        buf = (T *)newbuf;
    }

    databuf<T> reserve(int sz)
    {
        if(ulen+sz > alen) vrealloc(ulen+sz);
        return databuf<T>(&buf[ulen], sz);
    }

    void addbuf(const databuf<T> &p)
    {
        ulen += p.length();
    }

    void remove(int i, int n)
    {
        for(int p = i+n; p<ulen; p++) buf[p-n] = buf[p];
        ulen -= n;
    }

    T remove(int i)
    {
        T e = buf[i];
        for(int p = i+1; p<ulen; p++) buf[p-1] = buf[p];
        ulen--;
        return e;
    }

    int find(const T &o)
    {
        loopi(ulen) if(buf[i]==o) return i;
        return -1;
    }

    void removeobj(const T &o)
    {
        loopi(ulen) if(buf[i]==o) remove(i--);
    }

    void replacewithlast(const T &o)
    {
        if(!ulen) return;
        loopi(ulen-1) if(buf[i]==o)
        {
            buf[i] = buf[ulen-1];
        }
        ulen--;
    }

    T &insert(int i, const T &e)
    {
        add(T());
        for(int p = ulen-1; p>i; p--) buf[p] = buf[p-1];
        buf[i] = e;
        return buf[i];
    }
};

struct vec
{
    union
    {
        struct { float x, y, z; };
        float v[3];
        int i[3];
    };

    vec() {}
    vec(float a, float b, float c) : x(a), y(b), z(c) {}
    vec(float *v) : x(v[0]), y(v[1]), z(v[2]) {}

    float &operator[](int i)       { return v[i]; }
    float  operator[](int i) const { return v[i]; }

    bool iszero() const { return x==0 && y==0 && z==0; }

    bool operator==(const vec &o) const { return x == o.x && y == o.y && z == o.z; }
    bool operator!=(const vec &o) const { return x != o.x || y != o.y || z != o.z; }
    vec operator-() const { return vec(-x, -y, -z); }

    vec &mul(float f) { x *= f; y *= f; z *= f; return *this; }
    vec &div(float f) { x /= f; y /= f; z /= f; return *this; }
    vec &add(float f) { x += f; y += f; z += f; return *this; }
    vec &sub(float f) { x -= f; y -= f; z -= f; return *this; }

    vec &add(const vec &o) { x += o.x; y += o.y; z += o.z; return *this; }
    vec &sub(const vec &o) { x -= o.x; y -= o.y; z -= o.z; return *this; }

    float squaredlen() const { return x*x + y*y + z*z; }
    float dot(const vec &o) const { return x*o.x + y*o.y + z*o.z; }

    float magnitude() const { return sqrtf(squaredlen()); }
    vec &normalize() { div(magnitude()); return *this; }

    float dist(const vec &e) const { vec t; return dist(e, t); }
    float dist(const vec &e, vec &t) const { t = *this; t.sub(e); return t.magnitude(); }

    float distxy(const vec &e) const { float dx = e.x - x, dy = e.y - y; return sqrtf(dx*dx + dy*dy); }
    float magnitudexy() const { return sqrtf(x*x + y*y); }

    bool reject(const vec &o, float max) const { return x>o.x+max || x<o.x-max || y>o.y+max || y<o.y-max; }

    vec &cross(const vec &a, const vec &b) { x = a.y*b.z-a.z*b.y; y = a.z*b.x-a.x*b.z; z = a.x*b.y-a.y*b.x; return *this; }

    void rotate_around_z(float angle) { *this = vec(cosf(angle)*x-sinf(angle)*y, cosf(angle)*y+sinf(angle)*x, z); }
    void rotate_around_x(float angle) { *this = vec(x, cosf(angle)*y-sinf(angle)*z, cosf(angle)*z+sinf(angle)*y); }
    void rotate_around_y(float angle) { *this = vec(cosf(angle)*x-sinf(angle)*z, y, cosf(angle)*z+sinf(angle)*x); }

    vec &rotate(float angle, const vec &d)
    {
        float c = cosf(angle), s = sinf(angle);
        return rotate(c, s, d);
    }

    vec &rotate(float c, float s, const vec &d)
    {
        *this = vec(x*(d.x*d.x*(1-c)+c) + y*(d.x*d.y*(1-c)-d.z*s) + z*(d.x*d.z*(1-c)+d.y*s),
                    x*(d.y*d.x*(1-c)+d.z*s) + y*(d.y*d.y*(1-c)+c) + z*(d.y*d.z*(1-c)-d.x*s),
                    x*(d.x*d.z*(1-c)-d.y*s) + y*(d.y*d.z*(1-c)+d.x*s) + z*(d.z*d.z*(1-c)+c));
        return *this;
    }

    void orthogonal(const vec &d)
    {
        int i = fabs(d.x) > fabs(d.y) ? (fabs(d.x) > fabs(d.z) ? 0 : 2) : (fabs(d.y) > fabs(d.z) ? 1 : 2);
        v[i] = d[(i+1)%3];
        v[(i+1)%3] = -d[i];
        v[(i+2)%3] = 0;
    }
};
}

Creditos do aimbot: ?°

Eai o que me dizem?
#Discussion aberta!!!

Source Aimbot ³

Post a Reply

Tags for this Thread