Neue Release Multihack

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.

[Only registered and activated users can see links. Click Here To Register...]

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..

[Only registered and activated users can see links. Click Here To Register...]

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