Neue Release Multihack

.Infinity · 05/23/2012, 00:58

Hallo Elitepvpers,

es ist fast 1 Uhr und ich bin sowas von totmüde, aber ich habe mich entschieden die Vollversion meines Multihacks + Source zu veröffentlichen. Ich hab übrigends nen neuen Thread erstellt, weil der alte mir zu zugespammt ist.

Alles wichtige findet ihr hier..

Es sind ein zwei neue Funktionen glaube ich dazu gekommen, keine Ahnung mehr..

Der Temporäre GM Rechte Hack in der 2089 Revision bezieht sich nur auf eine bestimmte Game, die die Lücke hatte, benutzen nicht viele..

Bitte den Changelog lesen!

Source:

Spoiler

PHP Code:


			
#include "stdafx.h"
using namespace std;

void (__stdcall* SendFunction)();
void (__stdcall* RecvFunction)();
void (__stdcall* MainFunc)();
bool SetPacketData(unsigned char* self, const unsigned char* body, unsigned long size);
bool AppendSignature(unsigned char* self);
void string_to_bytearray(std::string str, unsigned char* &array, int& size);
std::string LPW2stdstring(LPWSTR pw, UINT codepage = CP_ACP);
std::string ReplaceString(const std::string &stringSearchString, const std::string &stringReplaceString, std::string stringStringToReplace);
bool ScanForOffsets();
void SendPacket(const unsigned char* packetdata, unsigned long len);
void* GetCallDest(void* addr);

// VID Kram
void (__stdcall* RegisterVid)();
DWORD *vids = new DWORD[1000];
DWORD *nVID = new DWORD[1000];
int nVIDcount = 0;
int VIDcount = 0;
DWORD nhVID = 0;
int GetInstanceType(long vid);
void RefreshVids();
void AddVID();
bool appIsPressed(long Key);
bool pullmobs_other = true;
bool Key1IsPressed = false;

HANDLE ph;
DWORD Offset1 = 0;
DWORD Offset2 = 0;
DWORD Offset3 = 0;
DWORD Offset4 = 0;
DWORD Offset5 = 0;

//Variablen
void Main();
void autopot_sleep();
void auto_pullmobs();
void auto_hiddenattack();
double GetCharacterDistance(long vid);
int wahl;
int wahl_autopot;
int wahl_autolot_item;
int wahl_autoattack;
int wahl_hiddenattack;
int wahl_hiddenattack2;
int autopot2;
int autopot3;
int autolot_item2;
int autoattack2;
int autoattack3;
int hiddenattack2;
int hiddenattack3;
int wahl_pullmobs;
int pullmobs2;
int wahl_autopullmobs;
int autopullmobs2;
int autopullmobs3;
int potbombywahl;
int check_potbomby;
long speed;    
long zoom_range;
long combo_type;
long attack_speed;
long skill_group;
int wahl_hideplayer;
long waittime;

HANDLE MainAutoThread;
HANDLE MainAutoThread2;
HANDLE MainAutoThread3;

// Hackfunktionen

class Functions{
    public:
    long pickupitem();
    long GetTargetVID();
    long GetVID();
    void StartAutoAttack();
    void StopAutoAttack();
    void ShowPlayer();
    void HidePlayer();
    long SetMoveSpeed(long speed);
    long SetComboType(long combo_type);
    long SetAttackSpeed(long attack_speed);
    long SetCameraDistance(long zoom_range);
    void refine_norm();
    void refine_dt();
    void autopot();
    void autolot_item();
    void autoattack();
    void hiddenattack();
    void fastkick();
    void yangslow();
    void YangBomb();
    void yanghard();
    void potbomb();
    void glasfake();
    void gmrights();
    void pullmobs();
    void gmrights_2089();
    void lightpanelspam();
    void lightpanelspam1();
};

long Functions::pickupitem(){
    PyObject* args = PyTuple_New(0);
    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "PickCloseItem"), args, NULL);
    double result = PyFloat_AsDouble(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

long Functions::GetTargetVID(){
    PyObject* args = PyTuple_New(0);
    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "GetTargetVID"), args, NULL);
    double result = PyFloat_AsDouble(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

long Functions::GetVID(){
    PyObject* args = PyTuple_New(0);
    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("net"), "GetMainActorVID"), args, NULL);
    double result = PyFloat_AsDouble(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

void Functions::StartAutoAttack(){
    PyObject* args = PyTuple_New(1);
    Py_INCREF(Py_True);
    PyTuple_SetItem(args, 0, Py_True);

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "SetAttackKeyState"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
}

void Functions::StopAutoAttack(){
    PyObject* args = PyTuple_New(1);
    Py_INCREF(Py_False);
    PyTuple_SetItem(args, 0, Py_False);

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "SetAttackKeyState"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
}

void Functions::ShowPlayer(){
    PyObject* args = PyTuple_New(0);
    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "ShowPlayer"), args, NULL);
    Py_XDECREF(ret);
    Py_XDECREF(args);
}

void Functions::HidePlayer(){
    PyObject* args = PyTuple_New(0);
    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "HidePlayer"), args, NULL);
    Py_XDECREF(ret);
    Py_XDECREF(args);
}

long Functions::SetMoveSpeed(long speed){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(speed));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("chr"), "SetMoveSpeed"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
    return true;
}

long Functions::SetComboType(long combo_type){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(combo_type));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("chr"), "testSetComboType"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
    return true;
}

long Functions::SetAttackSpeed(long attack_speed){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(attack_speed));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("chr"), "SetAttackSpeed"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
    return true;
}

long Functions::SetCameraDistance(long zoom_range){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(zoom_range));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("app"), "SetCameraMaxDistance"), args, NULL);

    Py_XDECREF(ret);
    Py_XDECREF(args);
    return true;
}

void Functions::refine_norm(){
    unsigned char buf[] = {0x60, 0x00, 0x00};
    int size = 3;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::refine_dt(){
    unsigned char buf[] = {0x60, 0x00, 0x04};
    int size = 3;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::autopot(){
    if(autopot3 == TRUE){

        if(autopot3 == TRUE){
            unsigned char buf[] = {0x0B, 0x00};
            int size = 2;
            SendPacket(buf, size);
            delete [] buf;
        }

        if(autopot3 == TRUE){
            unsigned char buf[] = {0x0B, 0x01};
            int size = 2;
            SendPacket(buf, size);
            delete [] buf;
        }

        if(autopot3 == TRUE){
            unsigned char buf[] = {0x0B, 0x02};
            int size = 2;
            SendPacket(buf, size);
            delete [] buf;
        }

        if(autopot3 == TRUE){
            unsigned char buf[] = {0x0B, 0x03};
            int size = 2;
            SendPacket(buf, size);
            delete [] buf;
        }

        if(autopot3 == TRUE){
            unsigned char buf[] = {0x0B, 0x04};
            int size = 2;
            SendPacket(buf, size);
            delete [] buf;
        }
    }
}

void Functions::autolot_item(){
    Functions *func = new Functions;
    if(autolot_item2 == TRUE)
    {
        func->pickupitem();
    }
}

void Functions::autoattack(){
    Functions *func = new Functions;
    if(autoattack2 == TRUE){
        func->StartAutoAttack();
    }

    if(autoattack2 == FALSE && autoattack3 == TRUE){
        func->StopAutoAttack();
    }
}

void Functions::hiddenattack(){
    Functions *func = new Functions;
    if(hiddenattack3 == TRUE){
        unsigned char buf[] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x2F};
        *(DWORD *)(buf + 2) = DWORD(func->GetTargetVID());

        int size = 8;
        SendPacket(buf, size);
        delete [] buf;
    }
}

void Functions::fastkick(){
    unsigned char buf[] = {0x0A, 0xCF};
    int size = 2;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::yangslow(){
    Functions *func = new Functions;
    for(int x = 0; x < 50; x++)    {
        func->YangBomb();
    }
    Main();
}

void Functions::YangBomb(){
    unsigned char buf[] = {0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};
    int size = 7;
    SendPacket(buf, size);
    delete [] buf;
}

void Functions::yanghard(){
    Functions *func = new Functions;
    for(int x = 0; x < 1000000; x++){
        func->YangBomb();
    }
    Main();
}

void Functions::potbomb(){
    if(check_potbomby == TRUE){
        if(TRUE){
            unsigned char buf[] = {0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
            int size = 7;
            SendPacket(buf, size);
            delete [] buf;
        }
        if(TRUE){
            unsigned char buf[] = {0x14, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01};
            int size = 7;
            SendPacket(buf, size);
            delete [] buf;
        }
        if(TRUE){
            unsigned char buf[] = {0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
            int size = 7;
            SendPacket(buf, size);
            delete [] buf;
        }
        if(TRUE){
            unsigned char buf[] = {0x14, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01};
            int size = 7;
            SendPacket(buf, size);
            delete [] buf;
        }
        if(TRUE){
            unsigned char buf[] = {0x14, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01};
            int size = 7;
            SendPacket(buf, size);
            delete [] buf;
        }
    }
}

void Functions::glasfake(){
    unsigned char buf[] = {0x03, 0x42, 0x00, 0x06, 0x56, 0x65, 0x72, 0x6B, 0x61, 0x75, 0x66, 0x65, 0x20, 0x7C, 0x63, 0x66, 0x66, 0x66, 0x31, 0x65, 0x36, 0x63, 0x30, 0x7C, 0x48, 0x69, 0x74, 0x65, 0x6D, 0x3A, 0x31, 0x33, 0x35, 0x3A, 0x31, 0x3A, 0x31, 0x3A, 0x30, 0x3A, 0x30, 0x7C, 0x68, 0x5B, 0x47, 0x4D, 0x52, 0x45, 0x43, 0x48, 0x54, 0x5D, 0x7C, 0x68, 0x7C, 0x72, 0x20, 0x6E, 0x75, 0x72, 0x20, 0x31, 0x20, 0x4B, 0x4B, 0x0003, 0x42, 0x00, 0x06, 0x56, 0x65, 0x72, 0x6B, 0x61, 0x75, 0x66, 0x65, 0x20, 0x7C, 0x63, 0x66, 0x66, 0x66, 0x31, 0x65, 0x36, 0x63, 0x30, 0x7C, 0x48, 0x69, 0x74, 0x65, 0x6D, 0x3A, 0x31, 0x33, 0x35, 0x3A, 0x31, 0x3A, 0x31, 0x3A, 0x30, 0x3A, 0x30, 0x7C, 0x68, 0x5B, 0x47, 0x4D, 0x52, 0x45, 0x43, 0x48, 0x54, 0x5D, 0x7C, 0x68, 0x7C, 0x72, 0x20, 0x6E, 0x75, 0x72, 0x20, 0x31, 0x20, 0x4B, 0x4B, 0x00};
    int size = 66;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::gmrights(){
    unsigned char buf[] = {0x1C, 0x09};
    int size = 2;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::pullmobs(){
    if(appIsPressed(25) == TRUE){
        if ((Key1IsPressed == false) && (pullmobs_other == false)){
            pullmobs_other = true;
        }
        Key1IsPressed = true;
    }
    else{
        Key1IsPressed = false;
    }

    if(pullmobs2 == TRUE){
        if (pullmobs_other == false) {return;}
        pullmobs_other = false;
        int pulledmobs = 0;
        for(int i=0; i <= VIDcount && pulledmobs < 113; i++){
            if (GetInstanceType(vids[i]) == 0){
                if (GetCharacterDistance(vids[i]) < 4000){
                    unsigned char buf[] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x2F};
                    *(DWORD *)(buf + 2) = DWORD(vids[i]);
                    int size = 8;
                    SendPacket(buf, size);
                    delete [] buf;
                    pulledmobs++;
                }
            }
        }

    }
    if(autopullmobs3 == TRUE){
        int pulledmobs = 0;
        for(int i=0; i <= VIDcount && pulledmobs < 113; i++){
            if (GetInstanceType(vids[i]) == 0){
                if (GetCharacterDistance(vids[i]) < 4000){
                    unsigned char buf[] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x2F};
                    *(DWORD *)(buf + 2) = DWORD(vids[i]);
                    int size = 8;
                    SendPacket(buf, size);
                    delete [] buf;
                    pulledmobs++;
                }
            }
        }
    }
}

void Functions::gmrights_2089(){
    unsigned char buf[] = {0x1C, 0x0B};
    int size = 2;
    SendPacket(buf, size);
    delete [] buf;

    Main();
}

void Functions::lightpanelspam(){
    for(int spam=0; spam < 100; spam++){
        lightpanelspam1();
        Sleep(300);
    }
    Main();
}

void Functions::lightpanelspam1(){
    unsigned char buf[] = {0x03 ,0x09 ,0x00 ,0x00 ,0x2F ,0x78 ,0x20 ,0x31 ,0x00};
    int size = 9;    
    SendPacket(buf, size);
    delete [] buf;
}

void autopot_sleep(){
    if(autopot2 == TRUE){
        Sleep(2000);
        autopot3 = TRUE;
        Sleep(50);
        autopot3 = FALSE;
        autopot_sleep();
    }
}

void auto_hiddenattack(){
    if(hiddenattack2 == TRUE){
        Sleep(waittime);
        hiddenattack3 = TRUE;
        Sleep(75);
        hiddenattack3 = FALSE;
        auto_hiddenattack();
    }
}

void auto_pullmobs(){
    if(autopullmobs2 == TRUE){
        Sleep(20000);
        autopullmobs3 = TRUE;
        Sleep(50);
        autopullmobs3 = FALSE;
        auto_pullmobs();
    }
}

//Detect Funks musicinstructor

void Hook_MainFunc(){
    Functions *func = new Functions;
    _asm pushad
    RefreshVids();
    func->autopot();
    func->autolot_item();
    func->hiddenattack();
    func->autoattack();
    func->pullmobs();
    func->potbomb();
    __asm popad
    return (*MainFunc)();
}

void Send(){
    unsigned char* buf = NULL;
    int size;
    LPWSTR edit_content[255];
    
    std::string hexstring = ReplaceString(" ","", LPW2stdstring(LPWSTR(edit_content))); 
    string_to_bytearray(hexstring,buf,size);
    
    SendPacket(buf, size);
    delete [] buf;
}

void SendPacket(const unsigned char* packetdata, unsigned long len){
    DWORD dwSendFunc = Offset2;
    DWORD dwAddSignatureByte = Offset3;
    __asm
    {
        PUSH packetdata
        PUSH len
        MOV EAX, Offset1
        MOV ECX, DWORD PTR DS:[EAX]
        CALL dwSendFunc
        MOV EAX, Offset1
        MOV ECX, DWORD PTR DS:[EAX]
        CALL dwAddSignatureByte
    }
}

void string_to_bytearray(std::string str, unsigned char* &array, int& size){
    int length = str.length();
    if(length%2 == 1)
    {
        str = "0" + str;
        length++;
    }

    array = new unsigned char[length/2];
    size = length/2;

    std::stringstream sstr(str);
    for(int i=0; i < size; i++)
    {
        char ch1, ch2;
        sstr >> ch1 >> ch2;
        int dig1, dig2;
        if(isdigit(ch1)) dig1 = ch1 - '0';
        else if(ch1>='A' && ch1<='F') dig1 = ch1 - 'A' + 10;
        else if(ch1>='a' && ch1<='f') dig1 = ch1 - 'a' + 10;
        if(isdigit(ch2)) dig2 = ch2 - '0';
        else if(ch2>='A' && ch2<='F') dig2 = ch2 - 'A' + 10;
        else if(ch2>='a' && ch2<='f') dig2 = ch2 - 'a' + 10;
        array[i] = dig1*16 + dig2;
    }
}

std::string LPW2stdstring(LPWSTR pw, UINT codepage){

   std::string s;
        char* p = 0;
        int bsz;

        bsz = WideCharToMultiByte(codepage,
                                  0,
                                  pw,-1,
                                  0,0,
                                  0,0);
        if (bsz > 0) {
            p = new char[bsz];

            int rc = WideCharToMultiByte(codepage,
                                        0,
                                        pw,-1,
                                        p,bsz,
                                        0,0);

        if (rc != 0) {
            p[bsz-1] = 0;
            s = p;
        }
    }
    delete [] p;
   return s;
}

std::string ReplaceString(const std::string &stringSearchString, const std::string &stringReplaceString, std::string stringStringToReplace){
        std::string::size_type pos = stringStringToReplace.find(stringSearchString, 0);
        int intLengthSearch = stringSearchString.length();
        int intLengthReplacment = stringReplaceString.length();

        while(std::string::npos != pos)
        {
                stringStringToReplace.replace(pos, intLengthSearch, stringReplaceString);
                pos = stringStringToReplace.find(stringSearchString, pos + intLengthReplacment);
        }

        return stringStringToReplace;
} 

bool bDataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask){
    for(;*szMask;++szMask,++pData,++bMask)
        if(*szMask=='x' && *pData!=*bMask ) 
            return false;
    return (*szMask) == NULL;
}

DWORD dwFindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask){
    for(DWORD i=0; i < dwLen; i++)
        if( bDataCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
            return (DWORD)(dwAddress+i);   
    return 0;
}

bool ScanForOffsets(){
    DWORD Base = 0x00400000;
    DWORD SizeOfCode;

    DWORD i = Base;
    while ((memcmp((void *)i, "PE\0\0", 4)) && (i <= Base + 0x1000))
        i++;

    if (i <= Base + 0x1000)
        SizeOfCode = *(DWORD *)(i + 0x1C);


    BYTE Signature1[] = { 0x8B, 0x0D, 0xF4, 0x1C, 0x5F, 0x00, 0x52, 0x50, 0xE8, 0x67,
                          0x60, 0x00, 0x00, 0xE8, 0x12, 0x7B, 0x12, 0x00, 0x5E};


    BYTE Signature2[] = { 0x8B, 0xC1, 0x8B, 0x50, 0x38, 0x8B, 0x48, 0x34, 0x53, 0x8B,
                          0x5C, 0x24, 0x08, 0x2B, 0xCA, 0x3B, 0xD9};

    BYTE Signature3[] = { 0xC2, 0x04, 0x00, 0x8B, 0xCE, 0xE8, 0xB2, 0xCE, 0x0D, 0x00,
                          0x5E};

    BYTE Signature4[] = { 0x83, 0xEC, 0x08, 0x56, 0x8B, 0xF1, 0x8D, 0x44, 0x24, 0x04,
                          0x50, 0x8D, 0x4C, 0x24, 0x0C, 0x51};

    BYTE Signature5[] = { 0x8B, 0x44, 0x24, 0x04, 0x89, 0x81, 0x9C, 0x04, 0x00, 0x00,
                          0xC2, 0x04, 0x00};


    Offset1 = *(DWORD *)(dwFindPattern(Base + 0x1000, SizeOfCode, Signature1, "xx????xxx????x????x") + 2);
    Offset2 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature2, "xxxxxxxxxxxxxxxxx");
    DWORD Offset3_Address = (dwFindPattern(Base + 0x1000, SizeOfCode, Signature3, "xxxxxx????x") + 6);
    Offset3 = reinterpret_cast<DWORD>(GetCallDest((DWORD *)(Offset3_Address - 1)));
    Offset4 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature4, "xxxxxxxxxxxxxxxx");
    Offset5 = dwFindPattern(Base + 0x1000, SizeOfCode, Signature5, "xxxxxxxxxxxxx") + 4;


    if ((Offset1))
        return true;
    else
        return false;
}

void* GetCallDest(void* addr){
    unsigned char* callDestAddr = reinterpret_cast<unsigned char*>(addr) + 1;

    uintptr_t relativeDest = *reinterpret_cast<uintptr_t *>(callDestAddr);
    return reinterpret_cast<void*>(uintptr_t(addr) + relativeDest + 5);
}

//Mobpullghackmusicinstructor Funks

bool appIsPressed(long Key){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(Key));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("app"), "IsPressed"), args, NULL);

    bool result = PyInt_AsLong(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

int GetInstanceType(long vid){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(vid));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("chr"), "GetInstanceType"), args, NULL);

    int result = PyInt_AsLong(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

double GetCharacterDistance(long vid){
    PyObject* args = PyTuple_New(1);
    PyTuple_SetItem(args, 0, PyInt_FromLong(vid));

    PyObject* ret = PyObject_Call(PyObject_GetAttrString(PyImport_ImportModule("player"), "GetCharacterDistance"), args, NULL);

    double result = PyFloat_AsDouble(ret);
    Py_DECREF(ret);
    Py_XDECREF(args);
    return result;
}

void Hook_RegisterVid(){
    __asm pushad
    __asm MOV nhVID, EAX
    AddVID();
    __asm popad
    return (*RegisterVid)();
}

void RefreshVids(){
    for(int nvi = 0; nvi < nVIDcount; nvi++)
    {
        if (GetInstanceType(nVID[nvi]) == 0) //Check if vid is monster
        {
            DWORD *new_vids = new DWORD[1000];
            int ni = 0;
            for(int i=0; i < 1000; i++)
            {
                if (GetInstanceType(vids[i]) == 0) //Check if vid is still there
                {
                    new_vids[ni] = vids[i];
                    ni++;
                }
            }
            new_vids[ni] = nVID[nvi];
            VIDcount = ni;
            delete [] vids; //delete the old array
            vids = &*new_vids; //make vids pointing to the new generated array
        }
    }
    nVIDcount = 0; //reset Vid Count
}

void AddVID(){
    nVID[nVIDcount] = nhVID;
    nVIDcount++;
}

//Display Funktions

void OpenConsole(){
    int hCrtIn, hCrtOut;
    FILE *conIn, *conOut;

    AllocConsole();
    hCrtIn = _open_osfhandle ((intptr_t) GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
    hCrtOut = _open_osfhandle ((intptr_t) GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
    conIn = _fdopen( hCrtIn, "r" );
    conOut = _fdopen( hCrtOut, "w" );
    *stdin = *conIn;
    *stdout = *conOut;

    system("mode 85,35");
    system("title Hack-Dll by .Infinity");
    system("color A");
}

void Main(){
    Functions *func = new Functions;
    HANDLE hModule;
    OpenConsole();

    cout << "1 - First Slot Upper - Normaler Schmied" << endl;
    cout << "2 - First Slot Upper - DT-Schmied ( Alle Schmiede )" << endl;
    cout << "3 - AutoPotter" << endl;
    cout << "4 - AutoItemPickUp" << endl;
    cout << "5 - AutoAttack" << endl;
    cout << "6 - Hidden-Attack" << endl;
    cout << "7 - Fast Kick" << endl;
    cout << "8 - Yang Bomber ( SLOW )" << endl;
    cout << "9 - Yang Bomber ( HARD )" << endl;
    cout << "10 - Glas der Einsicht Fake" << endl;
    cout << "11 - MobPull" << endl;
    cout << "12 - AutoMobPull ( 20 Sec )" << endl;
    cout << "13 - SpeedHack" << endl;
    cout << "14 - ComboHack" << endl;
    cout << "15 - AttackSpeedHack" << endl;
    cout << "16 - Tempor" << (char) 0x84 << "re GM Rechte ( Old Exploit )" << endl;
    cout << "17 - HidePlayer" << endl;
    cout << "18 - ZoomHack" << endl;
    cout << "19 - Tempor" << (char) 0x84 << "re GM Rechte ( 2089 Exploit )" << endl;
    cout << "20 - LightBotHackSpam ( GM Rights need )" << endl;
    cout << "21 - Potbomber" << endl;
    cout << "22 - Hiddenattack Hard(NINJA | DOLCH)" << endl << endl;
    cout << "Deine Player VID : " << DWORD(func->GetVID()) << endl;
    cout << "Die ausgew" << (char) 0x84 << "hlte Player VID : " << DWORD(func->GetTargetVID()) << endl;
    cout << endl << endl << "Nachdem \"MobPull\" aktiviert ist -> Ingame P f" << (char) 0x9A  << "r MobPull!" << endl << endl;
    cout << "Deine Wahl : ";
    cin >> wahl;
    system("cls");
    
    switch(wahl){
        case 1:
            func->refine_norm();
        case 2:
            func->refine_dt();
        case 3:
            cout << "1 - AutoPotter ( ON )" << endl;
            cout << "2 - AutoPotter( OFF )" << endl;
            cin >> wahl_autopot;
            system("cls");

            MainAutoThread3 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)autopot_sleep, hModule, 0, NULL);
            
            switch(wahl_autopot){    
                case 1:
                    autopot2 = TRUE;
                    Main();
                case 2:
                    autopot2 = FALSE;
                    TerminateThread(MainAutoThread3, 0);
                    Main();
                default:
                    Main();
            }
        case 4:
            cout << "1 - AutoItemPickUp ( ON )" << endl;
            cout << "2 - AutoItemPickUp ( OFF )" << endl;
            cin >> wahl_autolot_item;
            system("cls");
            
            switch(wahl_autolot_item){
                case 1:
                    autolot_item2 = TRUE;
                    Main();
                case 2:
                    autolot_item2 = FALSE;
                    Main();
                default:
                    Main();
            }
        case 5:
            cout << "1 - AutoAttack ( ON )" << endl;
            cout << "2 - AutoAttack ( OFF )" << endl;
            cin >> wahl_autoattack;
            system("cls");
            
            switch(wahl_autoattack){
                case 1:
                    autoattack2 = TRUE;
                    Main();
                case 2:
                    autoattack2 = FALSE;
                    autoattack3 = TRUE;
                    Sleep(100);
                    autoattack3 = FALSE;
                    Main();
                default:
                    Main();
            }
        case 6:
            cout << "1 - Hiddenattack ( ON )" << endl;
            cout << "2 - Hiddenattack ( OFF )" << endl;
            cin >> wahl_hiddenattack;
            system("cls");

            MainAutoThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)auto_hiddenattack, hModule, 0, NULL);
            
            switch(wahl_hiddenattack){
                case 1:
                    waittime = 300;
                    hiddenattack2 = TRUE;
                    Main();
                case 2:
                    hiddenattack2 = FALSE;
                    TerminateThread(MainAutoThread, 0);
                    Main();
                default:
                    Main();
            }
        case 7:
            func->fastkick();
        case 8:
            func->yangslow();
        case 9:
            func->yanghard();
        case 10:
            func->glasfake();
        case 11:
            cout << "1 - MobPull ( ON )" << endl;
            cout << "2 - MobPull ( OFF )" << endl;
            cin >> wahl_pullmobs;
            system("cls");

            switch(wahl_pullmobs){
                case 1:
                    pullmobs2 = TRUE;
                    Main();
                case 2:
                    pullmobs2 = FALSE;
                    Main();
                default:
                    Main();
            }
        case 12:
            cout << "1 - AutoMobPull ( ON )" << endl;
            cout << "2 - AutoMobPull ( OFF )" << endl;
            cin >> wahl_autopullmobs;
            system("cls");

            MainAutoThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)auto_pullmobs, hModule, 0, NULL);
            
            switch(wahl_autopullmobs){
                case 1:
                    autopullmobs2 = TRUE;
                    Main();
                case 2:
                    autopullmobs2 = FALSE;
                    TerminateThread(MainAutoThread2, 0);
                    Main();
                default:
                    Main();
            }
        case 13:
            cout << "Bitte geben sie ihre SpeedZahl ein :" << endl;
            cin >> speed;

            system("cls");
            func->SetMoveSpeed(speed);
            Main();
        case 14:
            cout << "Bitte geben sie den ComboType an ( 0 - 2 ) :" << endl;
            cin >> combo_type;

            system("cls");        
            func->SetComboType(combo_type);    
            Main();
        case 15:
            cout << "Bitte geben sie ihre AttackSpeedZahl ein :" << endl;
            cin >> attack_speed;

            system("cls");
            func->SetAttackSpeed(attack_speed);
            Main();
        case 16:
            func->gmrights();
        case 17:
            cout << "1 - HidePlayer ( ON )" << endl;
            cout << "2 - HidePlayer ( OFF )" << endl;
            cin >> wahl_hideplayer;
            system("cls");
            
            switch(wahl_hideplayer){
                case 1:
                    func->HidePlayer();
                    Main();
                case 2:
                    func->ShowPlayer();
                    Main();
                default:
                    Main();
            }
        case 18:
            cout << "Bitte geben sie die Zoomreichweite ein :" << endl;
            cin >> zoom_range;

            system("cls");
            func->SetCameraDistance(zoom_range);
            Main();
        case 19:
            func->gmrights_2089();
        case 20:
            func->lightpanelspam();
        case 21:
            cout << "1 - Potbomber ( ON )" << endl;
            cout << "2 - Potbomber ( OFF )" << endl;
            cin>> potbombywahl;
            switch(potbombywahl){
                case 1:
                    check_potbomby = TRUE;
                    Main();
                case 2:
                    check_potbomby = FALSE;
                    Main();
                default:
                    Main();
            }
        case 22:
            cout << "1 - Hiddenattack ( NINJA | DOLCH | ON )" << endl;
            cout << "2 - Hiddenattack ( NINJA | DOLCH | ON )" << endl;
            cin >> wahl_hiddenattack;
            system("cls");
            
            switch(wahl_hiddenattack){
                case 1:
                    hiddenattack3 = TRUE;
                    Main();
                case 2:
                    hiddenattack3 = FALSE;
                    Main();
                default:
                    Main();
            }
        default:
            Main();        
    }      
}

BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
    switch (ul_reason_for_call)
    {
        case DLL_PROCESS_ATTACH:
            ScanForOffsets();
            MainFunc = (void (__stdcall*)())DetourFunction((PBYTE)Offset4, (PBYTE)Hook_MainFunc);
            RegisterVid = (void (__stdcall*)())DetourFunction((PBYTE)Offset5, (PBYTE)Hook_RegisterVid);
            CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Main, hModule, 0, NULL);
            break;
        case DLL_THREAD_ATTACH:
            break;
        case DLL_THREAD_DETACH:
            break;
        case DLL_PROCESS_DETACH:
            break;
    }
    return TRUE;
}

Changelog:

Spoiler

~~kamarun~~ · 05/23/2012, 01:01

Erster

wow Danke für den Source kann ich wieder was lernen

lg

~~#SoNiice~~ · 05/23/2012, 01:14

C++ nehme ich mal an, hätte man vielleicht schöner machen können, aber dennoch danke

°Secret2 · 05/23/2012, 01:14

unnötig!!

~~#SoNiice~~ · 05/23/2012, 01:19

Quote:

Originally Posted by °Secret2

unnötig!!

Dein Post? definitiv. Nenn mir einen Grund, weshalb das unnötig war?

.Infinity · 05/23/2012, 01:23

Gibt in 1-2 Minuten noch ein Update, wo der Potbomber schneller ist & sich ein und ausschalten lässt. In dem Multihack war noch ne ältere Version drin ^^

#Edit: Online

Quote:

Originally Posted by SoNiice'

C++ nehme ich mal an, hätte man vielleicht schöner machen können, aber dennoch danke

Was willste da noch schöner dran machen?

Mein Teil Hackfunktions ist in Classen geschrieben und naja mir reicht es

Übersichtlich genug. Den Teil von musicinstructor wollte ich unberührt lassen, da ich nichts schrotten wollte

LxR'EsoZiaL · 05/23/2012, 01:33

Bei mir kakt dass nach den Injekten ab.

Quote:

Originally Posted by Errorlog.txt

Module Name: X:\Metin2 Zeugs\PServer\unknown_name\metin2client.exe
Time Stamp: 0x7375705f - Tue May 20 22:45:19 2031

Exception Type: 0xc0000005

eax: 0x404a9608 ebx: 0x00000000
ecx: 0x00732a90 edx: 0x00000029
esi: 0x00000001 edi: 0x00010055
ebp: 0x00000010 esp: 0x0012f1f0

0x004960e0 metin2client.exe

€ es ist eine normale .exe. also die 2011er die 4,18MB groß ist und Autopotts drin hat

.Infinity · 05/23/2012, 01:34

Ich garantiere nicht, dass es sich auf jedem Server injecten lässt. Kann sein, dass spezielle Schutzmaßnahmen getroffen wurden. Ich habs auf einem Server getestet & es ging. Damit war für mich die Sache durch^^

LxR'EsoZiaL · 05/23/2012, 01:39

Quote:

Originally Posted by .Infinity

Ich garantiere nicht, dass es sich auf jedem Server injecten lässt. Kann sein, dass spezielle Schutzmaßnahmen getroffen wurden. Ich habs auf einem Server getestet & es ging. Damit war für mich die Sache durch^^

Ich habe ja auf den Server ja eine Stinknormale AutoPott .exe, die nurn geänderten Pong hat xD

.Infinity · 05/23/2012, 01:40

Das hab ich jetzt nicht verstanden :O.. Naja wie gesagt, ich habs auf einem Server getestet und auf den meisten sollte es ohne Schwierigkeiten klappen. Auf DE sollte es mit nem HS Bypass auch gehen. Ich glaub es wurde ja einer released. Da ist grad zum Bosse klatschen der Hiddenattack ganz sinnvoll. ^^

Kadso™ · 05/23/2012, 08:04

Gute Arbeit, aber durch den Source werden viele die Funktionen klauen

lRaZeRl · 05/23/2012, 10:28

Danke Infi. Gut gut

Wie immer von dir..

Zum Bosse klatschen klar, aber da kann man auch HitDmg nehmen deiner ist auch nicht schneller..

CreXes · 05/23/2012, 12:01

Danke für dein Release.

Aber eine Frage, wieso geht der Hidden-Attack nur 1x mal ? also ich visiere eine Person dann kommt nur 1x DMG dann nicht mehr ?! sollte es nicht dauerhaft so gehen ?

.Infinity · 05/23/2012, 12:05

Weil die Geschwindigkeit für einen Ninja ausgelegt ist. Der Server hat ne Grenze drin, wie viel DMG man mit bestimmter Schlaggeschwindigkeit und Klasse machen kann.
Damit er auch besser als Krieger und so läuft, müsste ich ihn umscripten. Da fehlte mir bis jetzt die Zeit für und nen Server, wo ich GM Rechte habe, um alle 4 Klassen perfekt anpassen zu können.

Probiers mal mit Grünen Pots und so. Alles was die Angriffsgeschwindigkeit hoch macht

CreXes · 05/23/2012, 12:08

Okay, danke für die schnelle antwort.