EMO Style ForumPro - Hos Geldiniz
Giriş yap

Şifremi unuttum

Istatistikler
Toplam 202 kayıtlı kullanıcımız var
Son kaydolan kullanıcımız: AnthonyFurey3

Kullanıcılarımız toplam 1186 mesaj attılar bunda 862 konu
Tarıyıcı
 Kapı
 Indeks
 Üye Listesi
 Profil
 SSS
 Arama
Arama
 
 

Sonuç :
 


Rechercher çıkıntı araştırma

RSS akısı


Yahoo! 
MSN 
AOL 
Netvibes 
Bloglines 


Kimler hatta?
Toplam 2 kullanıcı online :: 0 Kayıtlı, 0 Gizli ve 2 Misafir

Yok

[ Bütün listeye bak ]


Sitede bugüne kadar en çok 92 kişi Paz Ağus. 28, 2016 6:58 am tarihinde online oldu.
En son konular
» İnternetten Para Kazandıran Oyun ! Ödeme Alt Limiti Yok ! DEV KONU
Cuma Ağus. 29, 2014 8:33 am tarafından Hello EMO

» goldenchase.net maden yaparak para kazanma
Cuma Ağus. 29, 2014 8:18 am tarafından Hello EMO

» etichal hacker görsel egitim seti
Çarş. Ağus. 06, 2014 4:57 am tarafından Hello EMO

» KO TBL Source C#
Ptsi Ara. 09, 2013 6:36 am tarafından Hello EMO

» x86 Registers
C.tesi Ağus. 24, 2013 5:02 am tarafından Hello EMO

» [Tutorial] Pegando Address, Pointers de WYD
Çarş. Tem. 10, 2013 7:25 am tarafından Hello EMO

» [Tutorial] Pegando Address, Pointers de CS Metodo²
Çarş. Tem. 10, 2013 7:23 am tarafından Hello EMO

» [Tutorial] Aprendendo basico deASM OLLYDBG
Çarş. Tem. 10, 2013 7:22 am tarafından Hello EMO

» Basic C# DLL injector
Ptsi Tem. 08, 2013 7:48 am tarafından Hello EMO

Reklam

XHACK C++ /\ ASM

Önceki başlık Sonraki başlık Aşağa gitmek

XHACK C++ / ASM

Mesaj tarafından Hello EMO Bir Çarş. Mayıs 11, 2011 3:50 am

[quote name='BlackRain' timestamp='1305102181' post='77']
Kod:
#include
#include
#include
#include
#include
#include
#include "XHackDLL.h"
#include "DLGAutoAtack.h"
#include "DLGAutoLoot.h"
#include "DLGTimmedSkills.h"
#include "DLGLocations.h"
#include "DLGOther.h"


// Send my packets to KO server
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
    }
}


// functions to avoid the protection of read/write memory api functions
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;
}



// DLL entry point...lol
BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{
    int x;
    char tmppath[512];
    switch(ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        tmpModule = hModule;
        AttachedProcess=GetCurrentProcessId() ;
        DisableThreadLibraryCalls(hModule);
        LastHotKey=GetTickCount();
        InitCommonControls();
        GetModuleFileName(hModule,tmppath,512);
        for( x=(int)strlen(tmppath);x>0;x--)
        {
            if(tmppath[x]==' \')
            {
                tmppath[ x+1] = 0;
                break;
            }
        }
        strcpy(XHackPath, tmppath);

        ThreadHandle=CreateThread(NULL, NULL,XHackMainThread,NULL,NULL,&ThreadId);

        return true;

    case DLL_PROCESS_DETACH:
        FreeModule(tmpModule) ;
        return true;
    }
    return false;
}


// Main running thread
DWORD WINAPI XHackMainThread(LPVOID lpParam){
   
    MSG msg;
    LONG i;
    DWORD x,y;
    char strtmp[32];

//    lstrcpy(CharName,"LondDongSilver") ;

    //PatchKO();
    //DisableXTrap() ;
    //WaitKOWindow();
    //UnPatchKO();
    //HookDInput();
    WaitKOLoad();
    UnloadXTrap();

//    FreeLibrary((HMODULE) FindModule("xtrapapi.dll"));

    GetCharName();
    Initialize();
    LoadINI();

    MainWndClass.cbSize=sizeof(WNDCLASSEX);
    MainWndClass. style = CS_HREDRAW | CS_VREDRAW;
    MainWndClass.lpfnWndProc = XHackMainWndProc;
    MainWndClass.cbClsExtra = 0;
    MainWndClass.cbWndExtra = 0;
    MainWndClass.hInstance = NULL;
    MainWndClass.hIcon = NULL;
    MainWndClass.hCursor = NULL;
    MainWndClass.hbrBackground = (HBRUSH)(COLOR_BACKGROUND+1);
    MainWndClass.lpszMenuName = NULL;
    MainWndClass.lpszClassName = XHackClsName;
    MainWndClass.hIconSm = NULL;
    RegisterClassEx(&MainWndClass);

    x=GetXResolution();
    y=GetYResolution();

    if (x!=1){
        x=x-330;
    }
    if (y!=1){
        y=y-330;
    }

    MainWnd = CreateWindowEx(
        WS_EX_TOOLWINDOW | WS_EX_OVERLAPPEDWINDOW,
        XHackClsName,
        WndTitle,
        WS_OVERLAPPED | WS_CAPTION ,
        x,
        y,
        260,
        300,
        KOWnd,
        NULL,
        NULL,
        NULL);
    SetWindowText( MainWnd,WndTitle);

    WndControls[100]=CreateWindowEx(0,
                                    (char *)"STATIC","",
                                    WS_CHILD | WS_VISIBLE,
                                    0,
                                    0,
                                    260,
                                    300,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    WndControls[0] =CreateWindowEx(0,
                                    (char *)"BUTTON","Auto Atack",
                                    WS_CHILD | BS_AUTOCHECKBOX,
                                    3,
                                    3,
                                    90,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 1]=CreateWindowEx(0,
                                    (char *)"BUTTON","Timmed Skills",
                                    WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
                                    3,
                                    26,
                                    90,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    WndControls[ 2]=CreateWindowEx(0,
                                    (char *)"BUTTON","Auto Pot",
                                    WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
                                    3,
                                    49,
                                    90,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 3]=CreateWindowEx(0,
                                    (char *)"BUTTON","Auto Loot",
                                    WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | WS_DISABLED,
                                    3,
                                    72,
                                    90,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    WndControls[ 4]=CreateWindowEx(0,
                                    (char *)"STATIC","HP Pot",
                                    WS_CHILD | WS_VISIBLE,
                                    15,
                                    120,
                                    60,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    WndControls[ 5]=CreateWindowEx(0,
                                    (char *)"STATIC","MP Pot",
                                    WS_CHILD | WS_VISIBLE,
                                    15,
                                    145,
                                    60,
                                    26,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    WndControls[ 6]=CreateWindowEx(WS_EX_CLIENTEDGE,
                                    (char *)"EDIT","",
                                    WS_CHILD | WS_VISIBLE | ES_NUMBER | ES_RIGHT,
                                    90,
                                    120,
                                    45,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);
   
    WndControls[7]=CreateWindowEx(WS_EX_CLIENTEDGE,
                                    (char *)"EDIT","",
                                    WS_CHILD | WS_VISIBLE | ES_NUMBER | ES_RIGHT,
                                    90,
                                    145,
                                    45,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 8]=CreateWindowEx(WS_EX_CLIENTEDGE,
                                    (char *)"COMBOBOX","",
                                    WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
                                    140,
                                    120,
                                    85,
                                    216,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 9]=CreateWindowEx(WS_EX_CLIENTEDGE,
                                    (char *)"COMBOBOX","",
                                    WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
                                    140,
                                    145,
                                    85,
                                    216,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 10]=CreateWindowEx(0,
                                    (char *)"BUTTON","Atack",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT,
                                    10,
                                    185,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 11]=CreateWindowEx(0,
                                    (char *)"BUTTON","Auto Loot",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT | WS_DISABLED,
                                    145,
                                    185,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 12]=CreateWindowEx(0,
                                    (char *)"BUTTON","Timmed",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT,
                                    10,
                                    215,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 13]=CreateWindowEx(0,
                                    (char *)"BUTTON","Locations",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT,
                                    145,
                                    215,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);
    WndControls[ 14]=CreateWindowEx(0,
                                    (char *)"BUTTON","Report",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT | WS_DISABLED,
                                    10,
                                    245,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 15]=CreateWindowEx(0,
                                    (char *)"BUTTON","Other",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT,
                                    145,
                                    245,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);

    WndControls[ 16]=CreateWindowEx(0,
                                    (char *)"BUTTON","Save",
                                    WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_TEXT | BS_FLAT,
                                    155,
                                    10,
                                    85,
                                    20,
                                    MainWnd,
                                    NULL,
                                    NULL,
                                    NULL);


    for (i=0;i<=5;i++){
        SendMessage(WndControls[ 8],
                    CB_ADDSTRING,
                    0,
                    (LPARAM)((LPCTSTR) ComboHPPots[i]));
    }
   
    for (i=0;i<=4;i++){
        SendMessage(WndControls[ 9],
                    CB_ADDSTRING,
                    0,
                    (LPARAM)((LPCTSTR) ComboMPPots[i]));
    }

    SetBkMode( GetDC(WndControls[0]),OPAQUE);
    SetBkMode(GetDC(WndControls[ 1]),OPAQUE);
    SetBkMode(GetDC(WndControls[2]) ,OPAQUE);
    SetBkMode(GetDC(WndControls[3]),OPAQUE) ;
    SetBkMode(GetDC(WndControls[4]),OPAQUE);
    SetBkMode(GetDC(WndControls[5]),OPAQUE);

    if (AutoAtack==1){SendMessage(WndControls[0],BM_SETCHECK,(WPARAM)BST_CHECKED, 0);}
    if (TimmedSkills==1){SendMessage(WndControls[1],BM_SETCHECK,(WPARAM)BST_CHECKED, 0);}
    if (AutoPot==1){SendMessage(WndControls[2],BM_SETCHECK,(WPARAM)BST_CHECKED,0) ;}
    if (AutoLoot==1){SendMessage(WndControls[3],BM_SETCHECK,(WPARAM)BST_CHECKED, 0);}
    sprintf(strtmp,"%d",HPCondition);
    SetWindowText(WndControls[6],strtmp);
    sprintf(strtmp, "%d",MPCondition);
    SetWindowText(WndControls[7],strtmp) ;

    SendMessage(WndControls[8],
            CB_SETCURSEL,
            (WPARAM)HPPot,
            0);

    SendMessage(WndControls[9],
            CB_SETCURSEL,
            (WPARAM)MPPot,
            0);

    for (i=0;i<=16;i++){
        if (WndControls[i]!=0){
            SendMessage(WndControls[i], WM_SETFONT, (WPARAM)GetStockObject(ANSI_VAR_FONT), MAKELPARAM(true, 0));
            ShowWindow(WndControls[ i], SW_SHOWNORMAL);
        }
    }

    ShowWindow(MainWnd, SW_SHOWNORMAL);
    UpdateWindow(MainWnd);
    XHackWndVisible=1;
    CreateThread(NULL,NULL,XHackAuxThread,NULL,NULL,NULL) ;
    CreateThread(NULL,NULL,XHackAutoAtackThread,NULL,NULL,NULL);
    CreateThread(NULL,NULL,XHackAutoPotThread,NULL,NULL,NULL);

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(& msg);
        DispatchMessage(&msg);
    }

   
    return 0;

}

LRESULT APIENTRY XHackMainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){
    HDC hdc;
    PAINTSTRUCT ps;
    //char pck[2];
    switch (message)
    {
        case WM_COMMAND:
            if ((lParam==(LPARAM)WndControls[10]) && (HIWORD(wParam)==BN_CLICKED)) {
                / *pck[0]=(char)0x4b;
                pck[1]=(char)0xef;
                pck[2]=(char)0x0b;
                SendPackets( pck, 3);
                MessageBox(0,"Atack","",0);*/
                AutoAtackSetup();
            }

            if ((lParam==(LPARAM)WndControls[11]) && (HIWORD(wParam)==BN_CLICKED)) {
                MessageBox( 0,"Loot","",0);
            }

            if ((lParam==(LPARAM)WndControls[12]) && (HIWORD(wParam)==BN_CLICKED)) {
                TimmedSkillsSetup( );
            }

            if ((lParam==(LPARAM)WndControls[13]) && (HIWORD(wParam)==BN_CLICKED)) {
                LocationsFunction( );
            }

            if ((lParam==(LPARAM)WndControls[14]) && (HIWORD(wParam)==BN_CLICKED)) {
                MessageBox( 0,"Report","",0);
            }

            if ((lParam==(LPARAM)WndControls[15]) && (HIWORD(wParam)==BN_CLICKED)) {
                OtherSetup( );
            }
           
            if ((lParam==(LPARAM)WndControls[16]) && (HIWORD(wParam)==BN_CLICKED)) {
                SaveINI( );
            }
           
           
           
            break;
        case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);
            EndPaint( hWnd, &ps);
            break;
        case WM_CLOSE:
            CloseWindow( hWnd);
            XHackWndVisible=0;
            return 0;
            break;
        case WM_DESTROY:
            CloseWindow( hWnd);
            XHackWndVisible=0;
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return DefWindowProc(hWnd, message, wParam, lParam);
}

void WaitKOLoad(){
    DWORD pMS;
    pMS=1000;
    while (GetTotalMP()==0){
        Sleep(pMS) ;
    }
}

void SaveINI(){
    char *ini_file;
    char tmppath[512];
    char pstr[32];
    char pstr2[32];

    DWORD i;

    strcpy(tmppath, XHackPath);
    ini_file=lstrcat(tmppath,"XHack.ini");


    if (SendMessage(WndControls[0],BM_GETCHECK,0,0)==BST_CHECKED){AutoAtack=1;}else{AutoAtack=0; }
    if (SendMessage(WndControls[1],BM_GETCHECK,0,0)==BST_CHECKED){TimmedSkills=1;}else{TimmedSkills=0; }
    if (SendMessage(WndControls[2],BM_GETCHECK,0,0)==BST_CHECKED){AutoPot=1;}else{AutoPot=0; }
    if (SendMessage(WndControls[3],BM_GETCHECK,0,0)==BST_CHECKED){AutoLoot=1;}else{AutoLoot=0; }
   
   
    sprintf(pstr," %d",AutoAtack);
    WritePrivateProfileString(CharName,"AutoAtack" ,pstr,ini_file);

    sprintf(pstr,"%d",AutoAtackAutoSelect) ;
    WritePrivateProfileString(CharName,"AutoAtack.AutoSelect",pstr, ini_file);

    sprintf(pstr,"%d",AutoAtackManualSelect);
    WritePrivateProfileString(CharName,"AutoAtack.ManualSelect",pstr,ini_file) ;

    sprintf(pstr,"%d",AutoAtackRuntoMob);
    WritePrivateProfileString(CharName,"AutoAtack.RuntoMob",pstr,ini_file);

    sprintf(pstr,"%d",AutoAtackDontRuntoMob);
    WritePrivateProfileString(CharName,"AutoAtack.DontRuntoMob",pstr,ini_file);

    sprintf(pstr,"%d",AutoAtackSlide);
    WritePrivateProfileString( CharName,"AutoAtack.Slide",pstr,ini_file);

    sprintf(pstr," %d",AutoAtackMaxDistance);
    WritePrivateProfileString(CharName," AutoAtack.MaxDistance",pstr,ini_file);

    sprintf(pstr,"%d" ,AutoLoot);
    WritePrivateProfileString(CharName,"AutoLoot",pstr, ini_file);

    sprintf(pstr,"%d",TimmedSkills);
    WritePrivateProfileString(CharName,"TimmedSkills",pstr,ini_file);

    sprintf(pstr,"%d",AutoPot);
    WritePrivateProfileString( CharName,"AutoPot",pstr,ini_file);

    sprintf(pstr,"%d" ,UseTScroll);
    WritePrivateProfileString(CharName,"UseTS",pstr, ini_file);

    sprintf(pstr,"%d",MonsterID);
    WritePrivateProfileString(CharName,"TS.MonsterID",pstr,ini_file);
   

    sprintf(pstr,"%d",LockSpeed);
    WritePrivateProfileString(CharName,"LockSpeed",pstr,ini_file);
   
    sprintf(pstr,"%d",SpeedModifier);
    WritePrivateProfileString(CharName,"SpeedModifier",pstr,ini_file);
   
    GetWindowText(WndControls[6],pstr,32) ;
    WritePrivateProfileString(CharName,"HPPot.Condition",pstr,ini_file) ;

    if (SendMessage(WndControls[8],CB_GETCURSEL,0,0)!=CB_ERR){
        sprintf(pstr,"%d",SendMessage(WndControls[8],CB_GETCURSEL, 0,0));
        WritePrivateProfileString(CharName, "HPPot.Item",pstr,ini_file);
    }else{
        WritePrivateProfileString(CharName,"HPPot.Item","0",ini_file) ;
    }


    GetWindowText(WndControls[7] ,pstr,32);
    WritePrivateProfileString(CharName,"MPPot.Condition" ,pstr,ini_file);

    if (SendMessage(WndControls[9],CB_GETCURSEL,0,0)!=CB_ERR){
        sprintf(pstr,"%d",SendMessage(WndControls[9],CB_GETCURSEL, 0,0));
        WritePrivateProfileString(CharName, "MPPot.Item",pstr,ini_file);
    }else{
        WritePrivateProfileString(CharName,"MPPot.Item","0",ini_file) ;
    }

   


    for (i=0;i<=9;i++){
        sprintf(pstr,"AutoAtack[ %d].Page",i);
        sprintf(pstr2,"%d" ,pAtackSkills[i].PageID);
        WritePrivateProfileString( CharName,pstr,pstr2,ini_file);

        sprintf(pstr, "AutoAtack[%d].Slot",i);
        sprintf( pstr2,"%d",pAtackSkills[i].SlotID);
        WritePrivateProfileString(CharName,pstr,pstr2,ini_file);
    }
   
    for (i=0;i<=9;i++){
        sprintf(pstr,"TimmedSkills[ %d].Page",i);
        sprintf(pstr2,"%d" ,pTimmedSkills[i].PageID);
        WritePrivateProfileString( CharName,pstr,pstr2,ini_file);

        sprintf(pstr, "TimmedSkills[%d].Slot",i);
        sprintf( pstr2,"%d",pTimmedSkills[i].SlotID);
        WritePrivateProfileString(CharName,pstr,pstr2,ini_file);

        sprintf(pstr,"TimmedSkills[%d].Time",i);
        sprintf(pstr2,"%d",pTimmedSkills[i].CastTime);
        WritePrivateProfileString(CharName,pstr,pstr2,ini_file) ;
    }

    LoadINI();
}

void LoadINI(){
    DWORD ret,i;
    char retstr[32];
    char pstr[32];
    char *ini_file;
    char tmppath[512];

    strcpy(tmppath, XHackPath);
    ini_file=lstrcat(tmppath,"XHack.ini");

    ret=GetPrivateProfileString(CharName,"AutoAtack","0", retstr, sizeof(retstr), ini_file);
    AutoAtack=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.AutoSelect","0", retstr, sizeof(retstr), ini_file);
    AutoAtackAutoSelect=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.ManualSelect","0", retstr, sizeof(retstr), ini_file);
    AutoAtackManualSelect=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.RuntoMob","0", retstr, sizeof(retstr), ini_file);
    AutoAtackRuntoMob=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.DontRuntoMob","0", retstr, sizeof(retstr), ini_file);
    AutoAtackDontRuntoMob=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.Slide","0", retstr, sizeof(retstr), ini_file);
    AutoAtackSlide=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoAtack.MaxDistance","0", retstr, sizeof(retstr), ini_file);
    AutoAtackMaxDistance=atoi(retstr);


    ret=GetPrivateProfileString(CharName,"AutoLoot","0", retstr, sizeof(retstr), ini_file);
    AutoLoot=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"TimmedSkills","0", retstr, sizeof(retstr), ini_file);
    TimmedSkills=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"AutoPot","0", retstr, sizeof(retstr), ini_file);
    AutoPot=atoi(retstr);

    ret=GetPrivateProfileString( CharName,"UseTS","0", retstr, sizeof(retstr), ini_file);
    UseTScroll=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"TS.MonsterID","0", retstr, sizeof(retstr), ini_file);
    MonsterID=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"LockSpeed","0", retstr, sizeof(retstr), ini_file);
    LockSpeed=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"SpeedModifier","0", retstr, sizeof(retstr), ini_file);
    SpeedModifier=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"HPPot.Condition","0", retstr, sizeof(retstr), ini_file);
    HPCondition=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"HPPot.Item","0", retstr, sizeof(retstr), ini_file);
    HPPot=atoi(retstr);

    ret=GetPrivateProfileString( CharName,"MPPot.Condition","0", retstr, sizeof(retstr), ini_file);
    MPCondition=atoi(retstr);

    ret=GetPrivateProfileString(CharName,"MPPot.Item","0", retstr, sizeof(retstr), ini_file);
    MPPot=atoi(retstr);

    for (i=0;i<=8;i++){
        sprintf(pstr,"AutoAtack[ %d].Page",i);
        ret=GetPrivateProfileString( CharName,pstr,"0", retstr, sizeof(retstr), ini_file);
        pAtackSkills[i].PageID=atoi( retstr);

        sprintf(pstr,"AutoAtack[ %d].Slot",i);
        ret=GetPrivateProfileString( CharName,pstr,"0", retstr, sizeof(retstr), ini_file);
        pAtackSkills[i].SlotID=atoi( retstr);

        sprintf(pstr,"TimmedSkills[ %d].Page",i);
        ret=GetPrivateProfileString( CharName,pstr,"0", retstr, sizeof(retstr), ini_file);
        pTimmedSkills[i].PageID=atoi( retstr);

        sprintf(pstr,"TimmedSkills[ %d].Slot",i);
        ret=GetPrivateProfileString( CharName,pstr,"0", retstr, sizeof(retstr), ini_file);
        pTimmedSkills[i].SlotID=atoi( retstr);
   
        sprintf( pstr,"TimmedSkills[%d].Time",i);
        ret=GetPrivateProfileString(CharName,pstr,"0", retstr, sizeof(retstr), ini_file);
        pTimmedSkills[i].CastTime=atoi( retstr);
   
    }
}

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);
}

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;
}



DWORD WINAPI XHackAuxThread(LPVOID lpParam){
    DWORD SleepTime;
    char ptitle[255];
    SleepTime=1;

    while (1==1){
        Sleep(SleepTime);
        if (GetAsyncKeyState(VK_INSERT)!=0){
            if ((LastHotKey+500)<=GetTickCount()){
                LastHotKey=GetTickCount();
                if (XHackWndVisible==0){
                    ShowWindow(MainWnd, SW_SHOWNORMAL);
                    XHackWndVisible=1;
                }else{
                    CloseWindow(MainWnd);
                    XHackWndVisible=0;
                }
            }
        }
        if (XHackWndVisible==1){SetActiveWindow(MainWnd);}
        sprintf(ptitle,"%d",MemReadDWord(0x9ECFAC));
        SetWindowText(MainWnd,ptitle);

    }
    return 0;
}

void Initialize(){
    DWORD i;
    pWarpLocation[0].LocationName="Abyss";
    pWarpLocation[0].LocationID=0x0bef;

    pDisguise[0].MobName=" Kecoon bone collector";
    pDisguise[0].MobID=470020;

    for (i=1;i<=16;i++){
        pDisguise[i].MobName=" NO MOB";
        pDisguise[i].MobID=0;
    }
}

DWORD WINAPI XHackAutoAtackThread(LPVOID lpParam){
    DWORD SleepTime;
    DWORD NextSkill;
    SleepTime=1;
    NextSkill=0;
    while (1==1){
        Sleep(SleepTime);
        if (AutoAtack==1){
            if (AutoAtackAutoSelect==1){SelectMob();}
            if (AutoAtackRuntoMob){
                SetRAtack(1);
                while (GetCharMoviment()==0){
                    Sleep(SleepTime);
                }
                if (pAtackSkills[NextSkill].PageID!=0){SendDInputKeys(TranslateKeyFInt(pAtackSkills[ NextSkill].PageID));}
                if (pAtackSkills[NextSkill].SlotID!=0){SendDInputKeys(TranslateKeyInt(pAtackSkills[ NextSkill].PageID));}
                NextSkill++;
                if (NextSkill>=10){NextSkill=0;}
            }

            if (AutoAtackDontRuntoMob){
                if (pAtackSkills[NextSkill].PageID!=0){SendDInputKeys(TranslateKeyFInt(pAtackSkills[ NextSkill].PageID));}
                if (pAtackSkills[NextSkill].SlotID!=0){SendDInputKeys(TranslateKeyInt(pAtackSkills[ NextSkill].PageID));}
                NextSkill++;
                if (NextSkill>=10){NextSkill=0;}
            }

            if (AutoAtackSlide){
                SetRAtack(1);
                SetCharMoviment(2);
                if (pAtackSkills[NextSkill].PageID!=0){SendDInputKeys(TranslateKeyFInt(pAtackSkills[ NextSkill].PageID));}
                if (pAtackSkills[NextSkill].SlotID!=0){SendDInputKeys(TranslateKeyInt(pAtackSkills[ NextSkill].PageID));}
                NextSkill++;
                if (NextSkill>=10){NextSkill=0;}
            }
        }
    }
    return 0;
}


DWORD WINAPI XHackAutoPotThread(LPVOID lpParam){
    DWORD SleepTime;
    SleepTime=1;
    while (1==1){
        Sleep(SleepTime);
    }
    return 0;
}

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

void SelectMob(){
    SendDInputKeys(DINPUT_K_Z);
}

BOOL ThreadIsRunning(HANDLE phThread){
    DWORD lpExitCode;
    GetExitCodeThread(phThread,&lpExitCode);
    if (lpExitCode==STILL_ACTIVE){
        return true;
    }else{
        return false;
    }
}

DWORD TranslateKeyInt(INT pKey){
    switch (pKey)
    {
        case 1: return DINPUT_K_1; break;
        case 2: return DINPUT_K_2; break;
        case 3: return DINPUT_K_3; break;
        case 4: return DINPUT_K_4; break;
        case 5: return DINPUT_K_5; break;
        case 6: return DINPUT_K_6; break;
        case 7: return DINPUT_K_7; break;
        case 8: return DINPUT_K_8; break;

        default:return 0;
    }
}

DWORD TranslateKeyFInt(INT pKey){
    switch (pKey)
    {
        case 1: return DINPUT_K_F1; break;
        case 2: return DINPUT_K_F2; break;
        case 3: return DINPUT_K_F3; break;
        case 4: return DINPUT_K_F4; break;
        case 5: return DINPUT_K_F5; break;
        case 6: return DINPUT_K_F6; break;
        case 7: return DINPUT_K_F7; break;
        case 8: return DINPUT_K_F8; break;

        default:return 0;
    }
}

void MoveTargetImage(){
    DWORD pImageSize;
    DWORD i;
    BYTE pImageByte;
    DWORD pImageBase;

    pImageBase=0x400000;
    pImageSize=4073084;

    NewImageLocation=VirtualAlloc(0,pImageSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE) ;

    for (i=0;i<=(pImageSize-1);i++){
        pImageByte=MemReadByte( (pImageBase+i));
        MemWriteByte((DWORD) NewImageLocation+i,pImageByte);
    }
}

void PatchKO(){
    HANDLE hSnapShot;
    BOOL r;
    PROCESSENTRY32 lppe;
    char pProcessName[255];
    DWORD XPatchPID;
    DWORD PatchPoint;

    PatchPoint=0x79429b;

    XPatchPID=0;
    lppe.dwSize=sizeof(PROCESSENTRY32);

    while (XPatchPID==0){
        hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
        r = Process32First(hSnapShot, &lppe);

        while(r){
            lstrcpy(pProcessName,lppe.szExeFile) ;
            CharLower(pProcessName) ;
            if (lstrcmpi(pProcessName,"xpatch.exe")==0){
                XPatchPID=lppe.th32ProcessID;
                break;
            }
            r = Process32Next(hSnapShot, &lppe);
        }
        CloseHandle(hSnapShot);
    }
    if (XPatchPID!=0){
        MoveTargetImage() ;
        MemWriteByte(PatchPoint    ,0x68);
        MemWriteDWord((PatchPoint+1) ,TranslateImageBase(PatchPoint));
        MemWriteByte( (PatchPoint+5),0xc3);
        MemWriteByte(( PatchPoint+6),0x90);
    }
}

void UnPatchKO(){
    DWORD PatchPoint;

    PatchPoint=0x79429b;

    MemWriteByte( PatchPoint    ,0x74);
    MemWriteByte(PatchPoint+1  ,0x19);
    MemWriteByte(PatchPoint+2  ,0xa3);
    MemWriteByte(PatchPoint+3  ,0x9c);
    MemWriteByte( PatchPoint+4  ,0xcf);
    MemWriteByte(PatchPoint+5  ,0x9e);
    MemWriteByte(PatchPoint+6  ,0x00);


}

DWORD TranslateImageBase(DWORD OriginalAddress){
    DWORD pOffSet;

    pOffSet=OriginalAddress-0x400000;
    return ((DWORD)NewImageLocation+pOffSet);
}

void DisableXTrap(){
    DWORD pAddy;
    LPVOID PatcherPos;

    PatcherPos=VirtualAlloc(0,32,MEM_COMMIT,PAGE_EXECUTE_READWRITE) ;

    pAddy=0x794362;// Set infinite time
    MemWriteByte(pAddy  ,0x6a);
    MemWriteByte(pAddy+1,0xff);
    MemWriteByte(pAddy+2,0x90);
    MemWriteByte(pAddy+3,0x90);
    MemWriteByte(pAddy+4, 0x90);

    pAddy=0x794037;// NOP the XProc1
    MemWriteByte(pAddy  ,0x90);
    MemWriteByte(pAddy+1,0x90);
    MemWriteByte(pAddy+2,0x90);
    MemWriteByte(pAddy+3,0x90);

    pAddy=0x79405d;// MOV EAX,0A5001; RETN
    MemWriteByte(pAddy  ,0xb8);
    MemWriteByte(pAddy+1,0x01);
    MemWriteByte(pAddy+2,0x50);
    MemWriteByte(pAddy+3,0x0a);
    MemWriteByte(pAddy+4, 0x00);
    MemWriteByte(pAddy+5,0xc3);
    MemWriteByte( pAddy+6,0x90);
    MemWriteByte(pAddy+7,0x90);
    MemWriteByte(pAddy+8,0x90);

    pAddy=0x795588;// MOV DWORD PTR SS:[ESP+38],EAX
    MemWriteByte(pAddy  ,0x89);
    MemWriteByte(pAddy+1,0x44);
    MemWriteByte( pAddy+2,0x24);
    MemWriteByte(pAddy+3,0x38);


    pAddy=0x794053;// JMP to PatcherPos
    MemWriteByte(pAddy  ,0xc8);
    MemWriteDWord(pAddy+1,(DWORD)PatcherPos);
    MemWriteByte(pAddy+5 ,0xc3);
    MemWriteByte(pAddy+6 ,0x90);
    MemWriteByte(pAddy+7 ,0x90);
    MemWriteByte(pAddy+8 ,0x90);
    MemWriteByte(pAddy+9 ,0x90);
    MemWriteByte(pAddy+10,0x90);
    MemWriteByte(pAddy+11,0x90);
    MemWriteByte(pAddy+12,0x90);
    MemWriteByte(pAddy+13,0x90);
    MemWriteByte( pAddy+14,0x90);
    MemWriteByte(pAddy+15,0x90);
   
   
    //5E            POP ESI
    //5D            POP EBP
    //5F            POP EDI
    //5B            POP EBX
    //81C4 24080000 ADD ESP,824
    //B8 01500A00  MOV EAX,0A5001
    //C3            RETN

    MemWriteByte((DWORD)PatcherPos    ,0x5e);
    MemWriteByte((DWORD)PatcherPos+1  ,0x5d) ;
    MemWriteByte((DWORD)PatcherPos+2  ,0x5f);
    MemWriteByte((DWORD)PatcherPos+3  ,0x5b);
    MemWriteByte((DWORD)PatcherPos+4  ,0x81);
    MemWriteByte( (DWORD)PatcherPos+5  ,0xc4);
    MemWriteByte((DWORD) PatcherPos+6  ,0x24);
    MemWriteByte((DWORD)PatcherPos+7  ,0x08);
    MemWriteByte((DWORD)PatcherPos+8  ,0x00) ;
    MemWriteByte((DWORD)PatcherPos+9  ,0x00);
    MemWriteByte((DWORD)PatcherPos+10 ,0xb8);
    MemWriteByte((DWORD)PatcherPos+11 ,0x01);
    MemWriteByte((DWORD)PatcherPos+12 ,0x50);
    MemWriteByte((DWORD)PatcherPos+13 ,0x0a);
    MemWriteByte((DWORD)PatcherPos+14 ,0x00);
    MemWriteByte((DWORD)PatcherPos+15 ,0xc3);



}

void UnloadXTrap(){
    HMODULE hXTrapDLL;
    HANDLE XTrapThreadID;
   
    XTrapThreadID=(HANDLE)MemReadDWord(0x9ECFAC);
    hXTrapDLL=(HMODULE)MemReadDWord(0x9ECFA4);
    FreeLibrary(hXTrapDLL);
    TerminateThread((HANDLE)MemReadDWord(0x9ECFAC),0);
    CloseHandle(XTrapThreadID);
    MemWriteDWord(0x9ECFAC,(DWORD)XTrapThreadID);
}
[/quote]


Hello Kitty
vs
eMoStyLe



avatar
Hello EMO
EMO Team
EMO Team

Cinsiyet : Erkek
Burçlar : Yay
Yılan
Mesaj Sayısı : 935
Puan : 246143
Rep Puanı : 18
Doğum tarihi : 28/11/89
Kayıt tarihi : 21/07/09
Yaş : 27
Nerden : EMO WorlD
İş/Hobiler : RCE Student / Game Hacking / Learn Beginner C#,C++,Delphi
Lakap : EMO

Kullanıcı profilini gör http://emostyle.myforumpro.com

Sayfa başına dön Aşağa gitmek

Önceki başlık Sonraki başlık Sayfa başına dön


 
Bu forumun müsaadesi var:
Bu forumdaki mesajlara cevap veremezsiniz