Jump to content
  • Kaydol

C++ Bazı Koxp Fonksiyonları


POK3M0N
 Share

Önerilen Mesajlar

#include <stddef.h>
#include <windows.h>
#include <winuser.h>
#include <stdio.h>
#include <Tlhelp32.h>
#include <commctrl.h>
#include "XHackDLL.h"
#include "DLGAutoAtack.h"
#include "DLGAutoLoot.h"
#include "DLGTimmedSkills.h"
#include "DLGLocations.h"
#include "DLGOther.h"

Yazma okuma fonksyonları :

void MemWriteByte(DWORD paddy, BYTE pval){
    __asm {
        mov ebx,paddy
        xor eax,eax
        mov al,pval
        mov BYTE PTR DS:[ebx],al
    }
}

void MemWriteWord(DWORD paddy, WORD pval){
    __asm {
        mov ebx,paddy
        xor eax,eax
        mov ax,pval
        mov WORD PTR DS:[ebx],ax
    }
}

void MemWriteDWord(DWORD paddy, DWORD pval){
    __asm {
        mov ebx,paddy
        xor eax,eax
        mov eax,pval
        mov DWORD PTR DS:[ebx],eax
    }
}

void MemWriteFloat(DWORD paddy, FLOAT pval){
    __asm {
        mov ebx,paddy
        xor eax,eax
        mov eax,pval
        mov DWORD PTR DS:[ebx],eax
    }
}

BYTE MemReadByte(DWORD paddy){
    BYTE retval;
    __asm {
        mov ebx,[paddy]
        xor eax,eax
        mov al,BYTE PTR DS:[ebx]
        mov retval,al
    }
    return retval;
}

WORD MemReadWord(DWORD paddy){
    WORD retval;
    __asm {
        mov ebx,[paddy]
        xor eax,eax
        mov ax,WORD PTR DS:[ebx]
        mov retval,ax
    }
    return retval;
}

DWORD MemReadDWord(DWORD paddy){
    DWORD retval;
    __asm {
        mov ebx,[paddy]
        xor eax,eax
        mov eax,DWORD PTR DS:[ebx]
        mov retval,eax
    }
    return retval;
}

FLOAT MemReadFloat(DWORD paddy){
    FLOAT retval;
    __asm {
        mov ebx,[paddy]
        xor eax,eax
        mov eax,DWORD PTR DS:[ebx]
        mov retval,eax
    }
    return retval;
}
Sendpackets;
//şuanki
   pushad
   mov edi, getcurrentthreadid
   call edi
   mov [KO_MTID], eax
   mov ecx, [KO_PKTB]
   push pSize
   push pBytes
   mov edi, KO_SNDF
   call edi
   mov [KO_MTID], KO_MAIN_THREAD_ID
   mov byte ptr [KO_PKTB+C1],00
   popad
   Ret
//eski fonksiyonu
void SendPackets(char *pdata, DWORD psize){
    __asm{
        mov edx,KO_SOCKET_BMA
        mov eax,dword ptr ds:[edx]
        mov ecx,dword ptr ds:[edx]
        mov edx,psize
        push edx
        push pdata
        mov edi,KO_SEND_FUNC
        call edi
    }
}

Char bilgileri (offsetler eskidir)

DWORD GetXResolution(){
    DEVMODE dmSettings;
    memset(&dmSettings,0,sizeof(dmSettings));

    if (!EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dmSettings))
     {
        return 1;
    }

    return dmSettings.dmPelsWidth;
}

DWORD GetYResolution(){
    DEVMODE dmSettings;
    memset(&dmSettings,0,sizeof(dmSettings));

    if (!EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dmSettings))
     {
        return 1;
    }

    return dmSettings.dmPelsHeight;
}

BYTE GetCharMoviment(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadByte(lPtr+796);
}

void SetCharMoviment(BYTE pVal){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    MemWriteByte( lPtr+796,pVal);
}

BOOL GetCharName(){
    DWORD lPtr;
    /*DWORD i;
    BYTE ret;*/
    lPtr=MemReadDWord(MemReadDWord(KO_CHAR_BMA)+1232);

    lstrcpy(CharName,(LPSTR)lPtr);
    
/*    i=-1;
    while (ret!=0){
        i++;
         CharName[i]=(char)MemReadByte(lPtr+i);
     }
    if (i==-1){
        return true;
    }else{
        return false;
    }*/
    return true;
}

FLOAT GetCharX(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadFloat(lPtr+152);
}

FLOAT GetCharY(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadFloat(lPtr+160);
}

BYTE GetCrossState(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadByte(lPtr+2996);
}

FLOAT GetCrossX(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadFloat(lPtr+3008);
}

FLOAT GetCrossY(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadFloat(lPtr+3016);
}

DWORD GetCurExp(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+2192);
}

DWORD GetMyID(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+1224);
}

DWORD GetTotalExp(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+2188);
}

DWORD GetHP(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+1268);
}

DWORD GetTotalHP(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+1264);
}

DWORD GetMP(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+2176);
}

DWORD GetTotalMP(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    if (lPtr!=0){
        return MemReadDWord(lPtr+2172);
    }else{
         return 0;
    }
}

BYTE GetRAtack(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadByte(lPtr+2917);
}

void SetRAtack(BYTE pVal){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    MemWriteByte( lPtr+2917,pVal);
}

DWORD GetSelected(){
    DWORD lPtr;
    lPtr=MemReadDWord(KO_CHAR_BMA);
    return MemReadDWord(lPtr+1172);
}

Dinput fonksyonları

DWORD FindModule(LPTSTR pModuleName){
    HANDLE hSnapshot;
    BOOL ret;
    MODULEENTRY32 lpme;

    lpme.dwSize=sizeof(MODULEENTRY32);

     hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, 0);

    ret=Module32First(hSnapshot, &lpme);
    while(ret){
         ret=Module32Next(hSnapshot, &lpme);
        if (lstrcmpi(lpme.szModule,pModuleName)==0){
             return (DWORD)lpme.hModule;
             break;
        }
    }

     return 0;
}

void HookDInput(){
    DWORD DIKeyPtr;

    DInputMod=FindModule("dinput8.dll");
     if (DInputMod==0){
        MessageBox(0,"DInput8 not loaded!","",0);
        TerminateProcess( GetCurrentProcess(), 0);
    }
    DIKeyPtr=FindDInputKeyPtr();
    if (DIKeyPtr!=0){
    
         DINPUT_K_1 = DIKeyPtr + 2;
        DINPUT_K_2 = DIKeyPtr + 3;
        DINPUT_K_3 = DIKeyPtr + 4;
        DINPUT_K_4 = DIKeyPtr + 5;
        DINPUT_K_5 = DIKeyPtr + 6;
        DINPUT_K_6 = DIKeyPtr + 7;
        DINPUT_K_7 = DIKeyPtr + 8;
        DINPUT_K_8 = DIKeyPtr + 9;
    
        DINPUT_K_TAB = DIKeyPtr + 15;
        DINPUT_K_Q = DIKeyPtr + 16;
        DINPUT_K_W = DIKeyPtr + 17;
        DINPUT_K_E = DIKeyPtr + 18;
        DINPUT_K_R = DIKeyPtr + 19;
        DINPUT_K_T = DIKeyPtr + 20;
        DINPUT_K_Y = DIKeyPtr + 21;
        DINPUT_K_U = DIKeyPtr + 22;
        DINPUT_K_I = DIKeyPtr + 23;
        DINPUT_K_O = DIKeyPtr + 24;
        DINPUT_K_P = DIKeyPtr + 25;
    
        DINPUT_K_A = DIKeyPtr + 30;
        DINPUT_K_S = DIKeyPtr + 31;
        DINPUT_K_D = DIKeyPtr + 32;
        DINPUT_K_F = DIKeyPtr + 33;
        DINPUT_K_G = DIKeyPtr + 34;
        DINPUT_K_H = DIKeyPtr + 35;
        DINPUT_K_J = DIKeyPtr + 36;
        DINPUT_K_K = DIKeyPtr + 37;
        DINPUT_K_L = DIKeyPtr + 38;
    
        DINPUT_K_Z = DIKeyPtr + 44;
        DINPUT_K_X = DIKeyPtr + 45;
        DINPUT_K_C = DIKeyPtr + 46;
        DINPUT_K_V = DIKeyPtr + 47;
        DINPUT_K_B = DIKeyPtr + 48;
        DINPUT_K_N = DIKeyPtr + 49;
        DINPUT_K_M = DIKeyPtr + 50;
    
        DINPUT_K_F1 = DIKeyPtr + 59;
        DINPUT_K_F2 = DIKeyPtr + 60;
        DINPUT_K_F3 = DIKeyPtr + 61;
        DINPUT_K_F4 = DIKeyPtr + 62;
        DINPUT_K_F5 = DIKeyPtr + 63;
        DINPUT_K_F6 = DIKeyPtr + 64;
        DINPUT_K_F7 = DIKeyPtr + 65;
        DINPUT_K_F8 = DIKeyPtr + 66;
    
    }
}

void WaitKOWindow(){
    DWORD pMS;
    HWND Ret;
    Ret=0;
    pMS=1000;
    while (Ret==0){
        Ret=FindWindow(NULL,"Knight OnLine Client");
        Sleep(pMS);
     }
    KOWnd=Ret;
}

DWORD FindDInputKeyPtr(){
    DWORD i;
    DWORD retd;
    retd=0;
    for (i=(DInputMod);i<=(DInputMod+0x3a0000);i++){
         if (MemReadByte( i )==0x57 &&
            MemReadByte(i+1)==0x6a &&    
             MemReadByte(i+2)==0x40 &&
            MemReadByte(i+3)==0x33 &&    
             MemReadByte(i+4)==0xc0 &&
            MemReadByte(i+5)==0x59 &&    
             MemReadByte(i+6)==0xbf){

             retd=MemReadDWord(i+7);

             break;
        }
     }
    return (DWORD)retd;
}




void SendDInputKeys(DWORD DIKey){
    DWORD pSleepTime;
    pSleepTime=50;
    MemWriteByte(DIKey, 128);
    Sleep(pSleepTime);
    MemWriteByte( DIKey,0);
}

void SelectMob(){
    SendDInputKeys(DINPUT_K_Z);
}

(Offsetler eskidir) Yazılış biçimi olarak bilgi sahibi olamanız için  paylaştım

Yorum bağlantısı
Sitelerde Paylaş

  • 3 months later...
  • 2 weeks later...
  • 1 month later...
  • 1 month later...
  • 4 weeks later...
  • 1 month later...
  • 2 months later...
  • 3 weeks later...
  • 2 months later...
Misafir
Bu konu kapalıdır ama konuya cevap yazmaya yetkiniz var görünüyor.
 Share

×
×
  • Yeni Oluştur...