Guía de DakosmuHack

Dakosmu · Mar 06, 2025, 04:01 PM

Guía de DakosmuHack

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

stdafx.h

#define DK_ANTIHACK 1

DakosmuHack.cpp

#include "stdafx.h"
#if(DK_ANTIHACK)
#include "DakosmuHack.h"
#include "Import.h"
#include "User.h"
#include "PrintPlayer.h"
#include "Offset.h"
#include "Defines.h"
#include "Extras.h"
#include "Util.h"
CDakosmuHack gDakosmuHack;

CDakosmuHack::CDakosmuHack()
{
    this->BLevelCache = 0;
}
#define BGetModelPlaySpeed                        ((int(__thiscall*)(int thisa, int Action)) 0x0051A220)
#define sub_5B0170            (( void(__cdecl*)(int a4, int a5, float a6)) 0x5B0170)
#define sub_5AB0B0            (( void(__cdecl*)(int a4, int a5, float a6)) 0x5AB0B0)
#define sub_5AD040            (( void(__cdecl*)(int a4, int a5, float a6)) 0x5AD040)
#define sub_59FCA0            (( void(__cdecl*)(int a4, int a5, float a6)) 0x59FCA0)
#define sub_5B3310            (( void(__cdecl*)(int a4, int a5, float a6)) 0x5B3310)
#define sub_59B580            (( char(__cdecl*)(int a4, int a5)) 0x59B580)
#define sub_5A0A30            (( char(__cdecl*)(int a4, int a5)) 0x5A0A30)
#define sub_59E590            (( void(__cdecl*)(int a4, int a5)) 0x0059E590)
#define sub_59C260            (( void(__cdecl*)(int a4, int a5)) 0x0059C260)
#define sub_X404D70            ((int(__thiscall*)(unsigned __int16* This, int a2, int a3)) 0x00404D70)
DWORD CalcTimeSkill[6] = { 0 };

void DK_AttackSkill_1(int a4, int a5, float a6)      
{

    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    sub_5AB0B0(a4, a5, a6);
}

char DK_AttackSkill_6(int a4, int a5)        
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    return sub_5A0A30(a4, a5);
}
void DK_AttackSkillPhep(int a4, int a5, float a6)        
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    sub_5B0170(a4, a5, a6);
}
void DK_AttackSkill_2(int a4, int a5, float a6)        
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    sub_5AD040(a4, a5, a6);
}

void DK_AttackSkill_3(int a4, int a5, float a6)      
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    sub_59FCA0(a4, a5, a6);

}
void DK_AttackSkillRF(int a4, int a5)      
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    sub_59E590(a4, a5);

}

int __thiscall CDakosmuHack::DK_SendPacketAttack(unsigned __int16* This, int a2, int a3)
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(0, FameSpeed);
    return sub_X404D70(This, a2, a3);
}

void __cdecl DK_UseSkillWarrior(int a1, int a2)        
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);
    return sub_59C260(a1, a2);
}
#include "Interface.h"
DWORD TimeSendSkill = 0;
WORD SkillIDSend = -1;
void CDakosmuHack::DK_SendLogUseSkill(WORD mSkillID, float mFameSpeed)
{
    if ((GetTickCount() - TimeSendSkill) < 500 && SkillIDSend == mSkillID) return;

    DK_USESKILL_LOG pMsg;
    pMsg.header.set(0xD4, 0xAC, sizeof(pMsg)); 
    pMsg.SkillID = mSkillID; //
    pMsg.FameSpeed = mFameSpeed; //
    DataSend((LPBYTE)& pMsg, pMsg.header.size);
    
    TimeSendSkill = GetTickCount();
    SkillIDSend = mSkillID;

}
void __cdecl sub_59CC40(float* a1, float* a2)        
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);

    return ((void(__cdecl*)(float* a1, float* a2))0x0059CC40)(a1, a2);
}
void __cdecl DK_AttackCommon(float* a1, float* a2)      
{
    float FameSpeed = *(float*)(BGetModelPlaySpeed(BMDthisa(), gObjUser.lpViewPlayer->m_Model.AnimationID) + 4);
    gDakosmuHack.DK_SendLogUseSkill(gObjUser.GetActiveSkill(), FameSpeed);

    return ((void(__cdecl*)(float* a1, float* a2))0x005B3310)(a1, a2);
}


BOOL CDakosmuHack::DK_CheckMuduleName(char* NameModule) 
{
    auto pos = std::find(mListModuleItem.begin(), mListModuleItem.end(), NameModule);

    if (pos != mListModuleItem.end())
    {

        return 1;
    }

    return 0;
}

int DK_PrintModules(DWORD processID)
{

    HMODULE hMods[1024];
    HANDLE hProcess;
    DWORD cbNeeded;
    unsigned int i;


    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
        PROCESS_VM_READ,
        FALSE, processID);
    if (NULL == hProcess)
        return 1;

    
    int Count = 1;
    gDakosmuHack.HackLogSendGS.clear();
    
    if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))
    {
        for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++)
        {
            TCHAR szModName[MAX_PATH];

            

            if (GetModuleFileNameEx(hProcess, hMods[i], szModName,
                sizeof(szModName) / sizeof(TCHAR)))
            {

                if (gDakosmuHack.DK_CheckMuduleName(PathFindFileName(szModName)))
                {
                    gDakosmuHack.isHackDetect = 1;
                    gDakosmuHack.HackLogSendGS += PathFindFileName(szModName);
                    gDakosmuHack.HackLogSendGS += ",";
                    
                }
                
                Count++;
            }
        }
    }


    CloseHandle(hProcess);
    
    return 1;
}

void CDakosmuHack::DK_GetModuleInject()
{
    if (gDakosmuHack.isHackDetect != 0) { return; }

    if (DK_PrintModules(GetCurrentProcessId()) == 1)
    {
        DK_RECV_MODULE pMsg;
        pMsg.header.set(0xD4, 0xAB, sizeof(pMsg));
        pMsg.TypeRecv = gDakosmuHack.isHackDetect; //
        memcpy(pMsg.LogRecv, strdup(gDakosmuHack.HackLogSendGS.c_str()), sizeof(pMsg.LogRecv));
        DataSend((LPBYTE)& pMsg, pMsg.header.size);
        gDakosmuHack.isHackDetect = 0;
    }
}
void CDakosmuHack::DK_MouduleDataInfo(DK_MODULE_DATA_SEND* lpMsg)
{
    
    mListModuleItem.clear();
    
    for (int i = 0; i < lpMsg->count; i++)
    {
        MODULE_DATA* lpInfo = (MODULE_DATA*)(((BYTE*)lpMsg) + sizeof(DK_MODULE_DATA_SEND) + (sizeof(MODULE_DATA) * i));
        mListModuleItem.push_back(lpInfo->NameModule);
        
    }
    //===Scan
    if (lpMsg->count > 0)
    {
        gDakosmuHack.DK_GetModuleInject();
    }
}

void CDakosmuHack::DK_Load()
{
    this->mListModuleItem.clear();
    this->isHackDetect = 0;
    //====Get Skill Attack
    SetCompleteHook(0xE8, 0x005B5662, &DK_AttackCommon);
    SetCompleteHook(0xE8, 0x005A1ACB, &sub_59CC40);
    SetCompleteHook(0xE8, 0x005B14A2, &sub_59CC40);
    
    SetCompleteHook(0xE8, 0x005B563F, &DK_AttackSkillPhep);
    SetCompleteHook(0xE8, 0x005B55D0, &DK_AttackSkill_1);
    SetCompleteHook(0xE8, 0x005A1E60, &DK_AttackSkill_2);
    SetCompleteHook(0xE8, 0x005B55F9, &DK_AttackSkill_2);
    SetCompleteHook(0xE8, 0x005A01A5, &DK_AttackSkillRF); //RF
    SetCompleteHook(0xE8, 0x005A021D, &DK_AttackSkillRF); //RF
    SetCompleteHook(0xE8, 0x005A0232, &DK_AttackSkillRF); //RF
    SetCompleteHook(0xE8, 0x005A02DC, &DK_AttackSkillRF); //RF
    SetCompleteHook(0xE8, 0x005A1F8E, &DK_AttackSkillRF); //RF
    SetCompleteHook(0xE8, 0x005B557B, &DK_AttackSkill_6);
    SetCompleteHook(0xE8, 0x0059B4FB, &DK_UseSkillWarrior);
    SetCompleteHook(0xE8, 0x005A199A, &DK_UseSkillWarrior);
    SetCompleteHook(0xE8, 0x005A179C, &CDakosmuHack::DK_SendPacketAttack); //Attack Meele
}
CDakosmuHack::~CDakosmuHack()
{

}

int CDakosmuHack::DK_LargerFrame()
{
    if (pFrameValue1 > DK_FRAME_VALUE)
    {
        return pFrameValue1;
    }
    else if (pFrameValue2 > DK_FRAME_VALUE)
    {
        return pFrameValue2;
    }
    else if (pFrameValue3 > DK_FRAME_VALUE)
    {
        return pFrameValue3;
    }
    else if (pFrameValue4 > DK_FRAME_VALUE)
    {
        return pFrameValue4;
    }

    return 0;
}
void CDakosmuHack::DK_GSInfo(DK_GUARD_REQ_CHECK* pRequest)
{

    gObjUser.Refresh();
    int BLevelCache = *(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x0E);
    
    DKGUARD_ANS_CHECK pResult;
    pResult.header.set(0xD4, 0xAA, sizeof(pResult)); //Up Level

    ZeroMemory(pResult.Data, sizeof(pResult.Data));

    for (int i = 0; i < emMaxCheckVars; i++)
    {
        pResult.Data[i].Status = true;
    }


    if (gObjUser.lpPlayer->Level != this->BLevelCache && this->BLevelCache != 0 && gObjUser.lpPlayer->Level > pRequest->Level + DK_LEVEL_VALUE)
    {
        pResult.Data[emLevel].Status = false;
        pResult.Data[emLevel].Value = gObjUser.lpPlayer->Level;
    }

    if (ViewPoint != pRequest->LevelPoint)
    {
        pResult.Data[emLevelPoint].Status = false;
        pResult.Data[emLevelPoint].Value = ViewPoint;
    }

    if (pRequest->Strength < 65535)
    {
        if ((ViewStrength+ ViewAddStrength) > pRequest->Strength + DK_STAT_LIMIT || pRequest->Strength > (ViewStrength + ViewAddStrength) + DK_STAT_LIMIT)
        {
            pResult.Data[emStrength].Status = false;
            pResult.Data[emStrength].Value = (ViewStrength + ViewAddStrength);
        }
    }

    if (pRequest->Dexterity < 65535)
    {
        if ((ViewDexterity+ ViewAddDexterity) > pRequest->Dexterity + DK_STAT_LIMIT || pRequest->Dexterity > (ViewDexterity + ViewAddDexterity) + DK_STAT_LIMIT)
        {
            pResult.Data[emDexterity].Status = false;
            pResult.Data[emDexterity].Value = (ViewDexterity + ViewAddDexterity);
        }
    }

    if (pRequest->Vitality < 65535)
    {
        if ((ViewVitality+ ViewAddVitality) > pRequest->Vitality + DK_STAT_LIMIT || pRequest->Vitality > (ViewVitality + ViewAddVitality) + DK_STAT_LIMIT)
        {
            pResult.Data[emVitality].Status = false;
            pResult.Data[emVitality].Value = (ViewVitality + ViewAddVitality);
        }
    }

    if (pRequest->Energy < 65535)
    {
        if ((ViewEnergy+ ViewAddEnergy) > pRequest->Energy + DK_STAT_LIMIT || pRequest->Energy > (ViewEnergy + ViewAddEnergy) + DK_STAT_LIMIT)
        {
            pResult.Data[emEnergy].Status = false;
            pResult.Data[emEnergy].Value = (ViewEnergy + ViewAddEnergy);
        }
    }

    if (pRequest->Leadership < 65535)
    {
        if ((ViewLeadership+ ViewAddLeadership) > pRequest->Leadership + DK_STAT_LIMIT || pRequest->Leadership > (ViewLeadership + ViewAddLeadership) + DK_STAT_LIMIT)
        {
            pResult.Data[emLeadership].Status = false;
            pResult.Data[emLeadership].Value = (ViewLeadership + ViewAddLeadership);
        }
    }

    int MaxSpeedCountCheck = DK_SPEED_LIMIT;

    if (gObjUser.lpViewPlayer->WeaponFirstExcellent || gObjUser.lpViewPlayer->WeaponSecondExcellent)
    {
        MaxSpeedCountCheck = (DK_SPEED_LIMIT * 1.5);
    }

    if ((gObjUser.lpPlayer->AttackSpeed > (pRequest->AttackSpeed + MaxSpeedCountCheck))
        || (gObjUser.lpPlayer->MagicSpeed > (pRequest->MagicSpeed + MaxSpeedCountCheck)))
    {
        
        pResult.Data[emAttackSpeed].Status = false;
        pResult.Data[emAttackSpeed].Value = gObjUser.lpPlayer->AttackSpeed;
        pResult.Data[emMagicSpeed].Value = gObjUser.lpPlayer->MagicSpeed;
        //}
    }

    if (gObjUser.lpViewPlayer->PetSlot != -1)
    {
        if ((gObjUser.lpViewPlayer->PetSlot - 1171) != pRequest->CharSetItem[8])
        {
            pResult.Data[emPetSlot].Status = false;
            pResult.Data[emPetSlot].Value = (gObjUser.lpViewPlayer->PetSlot - 1171);
            gObjUser.lpViewPlayer->PetSlot = pRequest->CharSetItem[8] + 1171;
        }
    }

    if (gObjUser.lpViewPlayer->WeaponFirstSlot != -1 && !InChaosCastle(pMapNumber)) {

        if ((gObjUser.lpViewPlayer->WeaponFirstSlot - 1171) != pRequest->CharSetItem[0])
        {
            pResult.Data[emWeaponFirstSlot].Status = false;
            pResult.Data[emWeaponFirstSlot].Value = (gObjUser.lpViewPlayer->WeaponFirstSlot - 1171);
            gObjUser.lpViewPlayer->WeaponFirstSlot = pRequest->CharSetItem[0] + 1171;
        }
    }

    if (gObjUser.lpViewPlayer->WeaponSecondSlot != -1 && !InChaosCastle(pMapNumber)) {

        if ((gObjUser.lpViewPlayer->WeaponSecondSlot - 1171) != pRequest->CharSetItem[1])
        {
            pResult.Data[emWeaponSecondSlot].Status = false;
            pResult.Data[emWeaponSecondSlot].Value = (gObjUser.lpViewPlayer->WeaponSecondSlot - 1171);
            gObjUser.lpViewPlayer->WeaponSecondSlot = pRequest->CharSetItem[1] + 1171;
        }
    }

    if (gObjUser.lpViewPlayer->HelmSlot >= ITEM2(7, 0) && gObjUser.lpViewPlayer->HelmSlot < ITEM2(7, 512)) {

        if ((gObjUser.lpViewPlayer->HelmSlot - 1171) != pRequest->CharSetItem[2])
        {
            pResult.Data[emHelmSlot].Status = false;
            pResult.Data[emHelmSlot].Value = (gObjUser.lpViewPlayer->HelmSlot - 1171);
            
        }
    }

    if (gObjUser.lpViewPlayer->ArmorSlot >= ITEM2(8, 0) && gObjUser.lpViewPlayer->ArmorSlot < ITEM2(8, 512)) {



        if ((gObjUser.lpViewPlayer->ArmorSlot - 1171) != pRequest->CharSetItem[3])
        {
            pResult.Data[emArmorSlot].Status = false;
            pResult.Data[emArmorSlot].Value = (gObjUser.lpViewPlayer->ArmorSlot - 1171);
            
        }
    }


    if (gObjUser.lpViewPlayer->PantsSlot >= ITEM2(9, 0) && gObjUser.lpViewPlayer->PantsSlot < ITEM2(9, 512)) {

        if ((gObjUser.lpViewPlayer->PantsSlot - 1171) != pRequest->CharSetItem[4])
        {
            pResult.Data[emPantsSlot].Status = false;
            pResult.Data[emPantsSlot].Value = (gObjUser.lpViewPlayer->PantsSlot - 1171);
            
        }
    }

    if (gObjUser.lpViewPlayer->GlovesSlot >= ITEM2(10, 0) && gObjUser.lpViewPlayer->GlovesSlot < ITEM2(10, 512)) {

        if ((gObjUser.lpViewPlayer->GlovesSlot - 1171) != pRequest->CharSetItem[5])
        {
            pResult.Data[emGlovesSlot].Status = false;
            pResult.Data[emGlovesSlot].Value = (gObjUser.lpViewPlayer->GlovesSlot - 1171);
            
        }
    }

    if (gObjUser.lpViewPlayer->BootsSlot >= ITEM2(11, 0) && gObjUser.lpViewPlayer->BootsSlot < ITEM2(11, 512)) {

        if ((gObjUser.lpViewPlayer->BootsSlot - 1171) != pRequest->CharSetItem[6])
        {
            pResult.Data[emBootsSlot].Status = false;
            pResult.Data[emBootsSlot].Value = (gObjUser.lpViewPlayer->BootsSlot - 1171);
            
        }
    }

    if (gObjUser.lpViewPlayer->WingsSlot != -1) {

        if ((gObjUser.lpViewPlayer->WingsSlot - 1171) != pRequest->CharSetItem[7] && (gObjUser.lpViewPlayer->WingsSlot - 1171) != 6279 && pRequest->CharSetItem[7] != 6193)
        {
            pResult.Data[emWingsSlot].Status = false;
            pResult.Data[emWingsSlot].Value = (gObjUser.lpViewPlayer->WingsSlot - 1171);
            gObjUser.lpViewPlayer->WingsSlot = pRequest->CharSetItem[7] + 1171;
        }
    }

    DataSend((BYTE*)& pResult, pResult.header.size);


}

#endif

DakosmuHack.h

Código [Seleccionar]

#pragma once
#include <psapi.h>
#pragma comment(lib,"Psapi.lib")
#include <shlwapi.h>
#include <string>
#include "Protocol.h"

#define DK_FRAME_VALUE        400
#define DK_LEVEL_VALUE        10
#define DK_SPEED_LIMIT        100
#define DK_STAT_LIMIT        1000
#if(DK_ANTIHACK)
enum DK_TypeHack
{
    eHackPlayerEditor,
    eHackSpeedMove,
    eHackSpeedCheck,
    eHackFrameSpeedCheck,
    eHackCheckInject,
};
enum DK_StatMember
{
    emLevel = 0,
    emLevelPoint = 1,
    emStrength = 2,
    emDexterity = 3,
    emVitality = 4,
    emEnergy = 5,
    emLeadership = 6,
    emAttackSpeed = 7,
    emMagicSpeed = 8,
    emFrameValue = 9,
    emAnimation = 10,
    //====
    emPetSlot = 11,
    emHelmSlot = 12,
    emArmorSlot = 13,
    emPantsSlot = 14,
    emGlovesSlot = 15,
    emBootsSlot = 16,
    emWeaponFirstSlot = 17,
    emWeaponSecondSlot = 18,
    emWingsSlot = 19,
    //====
    emEditGame = 20,
    emMaxCheckVars,
};
#pragma pack(push, 1)
struct DK_GUARD_REQ_CHECK
{
    PSWMSG_HEAD header;

    short        Level;
    int            LevelPoint;
    int          Strength;
    int          Dexterity;
    int          Vitality;
    int          Energy;
    int          Leadership;
    int            AttackSpeed;
    int            MagicSpeed;
    short        CharSetItem[10];
};
#pragma pack(pop)
#pragma pack(push, 1)
struct DKGUARD_ANS_DATA
{
    bool        Status;
    int            Value;
};
#pragma pack(pop)
#pragma pack(push, 1)
struct DKGUARD_ANS_CHECK
{
    PSBMSG_HEAD header; // C3:F3:03

    DKGUARD_ANS_DATA Data[emMaxCheckVars];
};
//====Moudule Inject
struct MODULE_DATA
{
    int Index;
    char NameModule[60];
};

struct DK_MODULE_DATA_SEND
{
    PSWMSG_HEAD header;
    int count;
};
struct DK_RECV_MODULE
{
    PSBMSG_HEAD header; // C3:F3:03
    WORD TypeRecv;
    char LogRecv[128];
};
#pragma pack(pop)
#pragma pack(push, 1)
struct DK_USESKILL_LOG
{
    PSBMSG_HEAD header; // C3:F3:03
    WORD SkillID;
    float FameSpeed;

};
#pragma pack(pop)

class CDakosmuHack
{
public:
    CDakosmuHack();
    virtual ~CDakosmuHack();
    void CDakosmuHack::DK_Load();
    int CDakosmuHack::DK_LargerFrame();
    void CDakosmuHack::DK_GSInfo(DK_GUARD_REQ_CHECK* pRequest);
    int BLevelCache;
    void CDakosmuHack::DK_SendLogUseSkill(WORD mSkillID, float mFameSpeed);
    static int __thiscall DK_SendPacketAttack(unsigned __int16* This, int a2, int a3);
    void CDakosmuHack::DK_GetModuleInject();
    std::string HackLogSendGS;
    BOOL CDakosmuHack::DK_CheckMuduleName(char* NameModule);
    std::vector<std::string> mListModuleItem;
    void CDakosmuHack::DK_MouduleDataInfo(DK_MODULE_DATA_SEND* lpMsg);
    int isHackDetect;
private:
    
};

extern CDakosmuHack gDakosmuHack;
#endif

Main.cpp

Código [Seleccionar]

#if(DK_ANTIHACK)
#include "DakosmuHack.h"
#endif

Dentro de extern "C" _declspec(dllexport) void EntryProc() // OK

Código [Seleccionar]

    #if(DK_ANTIHACK)
    gDakosmuHack.DK_Load();
    #endif

Protocol.cpp

Código [Seleccionar]

#if(DK_ANTIHACK)
#include "DakosmuHack.h"
#endif

Código [Seleccionar]

        #if(DK_ANTIHACK)
        case 0xD4:
        switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
        {
            case 0xAA: //
            {
                gDakosmuHack.DK_GSInfo((DK_GUARD_REQ_CHECK*) lpMsg);
            }
            break;
            case 0xAC: //
            {
                gDakosmuHack.DK_MouduleDataInfo((DK_MODULE_DATA_SEND*)lpMsg);
            }
            break;                
        }
        #endif

PRONTO SUBIRE EL LADO GAMESERVER

Noticias:

Guía de DakosmuHack

Dakosmu