//Alt + G = Godmode
//Alt + L = Lawnmower
//Alt + R = Rapeshot

#include <windows.h>

#define ZRuleBerserker__BonusHealthAddr 0x4C12A0
#define ZPostStageEnterBattleAddr 0x4AD4B0
#define ZGetGameAddr 0x4B9730
#define ZGetGameClientAddr 0x4B9620
#define ZBypassAddr 0x5A1857
#define ZNewCmdAddr 0x4D1DA0
#define ZPostCommandAddr 0x4D1E60
#define ZUnknownOneAddr 0x5A2CE0
#define ZUnknownTwoAddr 0x63C632
#define ZUnknownThreeAddr 0x517150
#define ZUnknownFourAddr 0x5195F0

bool godmode,lawnmower,rapeshot;

struct MUID
{
    DWORD LowID;
    DWORD HighID;
};

void ToggleSound(bool on)
{
    if(on)
{
}
    else
{
}
}

DWORD ZGetGame()
{
    DWORD GAME;
    __asm
    {
        MOV EAX,ZGetGameAddr
        CALL EAX
        MOV GAME,EAX
    }
    return GAME;
}

DWORD ZGetGameClient()
{
    DWORD CLIENT;
    __asm
    {
        MOV EAX,ZGetGameClientAddr
        CALL EAX
        MOV CLIENT,EAX
    }
    return CLIENT;
}

MUID *GetPlayer()
{
    return(MUID*)(ZGetGameClient()+0x1A0);
}

MUID *GetStage()
{
    return(MUID*)(ZGetGameClient()+0x1B0);
}

int GetGameType()
{
    return *(int*)(ZGetGameClient()+0xD20);
}
DWORD ZMyCharacter()
{
    DWORD Game;
    __asm
    {
        MOV EAX,ZGetGameAddr
        CALL EAX
        CMP EAX,0
        JA RetGame
        MOV Game,0
        JMP End
        RetGame:
        LEA EAX,DWORD PTR DS:[EAX+0x94]
        MOV EAX,DWORD PTR DS:[EAX]
        MOV Game,EAX
        End:
    }
    return Game;
}

float *GetPosition(DWORD ZCharacter)
{
    float *POS;
    __asm
    {
        PUSH ESI
        MOV ESI,ZCharacter
        MOV EAX,DWORD PTR DS:[ESI+0x30]
        TEST EAX,EAX
        JNZ OP2
        LEA EAX,DWORD PTR DS:[ESI+0x24]
        OP2:
        MOV EAX,DWORD PTR DS:[EAX]
        MOV POS,EAX
        POP ESI
    }
    return POS;
}

float *GetDirection(DWORD ZCharacter)
{
    float *DIR;
    __asm
    {
        PUSH ESI
        MOV ESI,DWORD PTR SS:[EBP+8]
        ADD ESI,0x340
        MOV DIR,ESI
        POP ESI
    }
    return DIR;
}

void Rejoin()
{
    MUID *PLAYER=GetPlayer();
    MUID *STAGE=GetStage();
    __asm
    {
        PUSH STAGE
        PUSH PLAYER
        MOV EAX,ZPostStageEnterBattleAddr
        CALL EAX
    }
}

void BonusHealth()
{
    __asm
    {
        PUSH HEALTHRET
        PUSH EBP
        MOV EBP,ESP
        CALL ZMyCharacter
        PUSH EAX
        PUSH ZBypassAddr
        MOV EAX,ZRuleBerserker__BonusHealthAddr
        JMP EAX
        HEALTHRET:
    }
}

void __declspec(naked) ZPostShot(float *Pos,float *Dir,int)
{
    __asm
    {
        PUSH EBP
        MOV EBP,ESP
        MOV DWORD PTR FS:[0],ESP
        SUB ESP,0xC4
        PUSH EBX
        PUSH ESI
        PUSH EDI
        MOV EAX,ZGetGameAddr
        CALL EAX
        MOV EAX,DWORD PTR DS:[EAX+0x30]
        MOV EAX,DWORD PTR DS:[EAX]
        MOV ECX,DWORD PTR DS:[EAX]
        MOV ESI,DWORD PTR SS:[EBP+8]
        FLD DWORD PTR DS:[ESI]
        MOV DWORD PTR SS:[EBP-0x84],ECX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        FLD DWORD PTR DS:[ESI+4]
        MOV WORD PTR SS:[EBP-0x80],AX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        FLD DWORD PTR DS:[ESI+8]
        MOV WORD PTR SS:[EBP-0x7E],AX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        MOV ESI,[EBP+0x0C]
        FLD DWORD PTR DS:[ESI]
        MOV WORD PTR SS:[EBP-0x7C],AX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        FLD DWORD PTR DS:[ESI+4]
        MOV WORD PTR SS:[EBP-0x7A],AX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        FLD DWORD PTR DS:[ESI+8]
        MOV WORD PTR SS:[EBP-0x78],AX
        MOV EAX,ZUnknownOneAddr
        CALL EAX
        MOV DL,BYTE PTR SS:[EBP+0x10]
        MOV WORD PTR SS:[EBP-0x76],AX
        MOV BYTE PTR SS:[EBP-0x74],DL
        PUSH 0x2732
        MOV EAX,ZNewCmdAddr
        CALL EAX
        PUSH 0x10
        MOV ESI,EAX
        MOV EAX,ZUnknownTwoAddr
        CALL EAX
        ADD ESP,0x10
        MOV DWORD PTR SS:[EBP-0x10],EAX
        TEST EAX,EAX
        MOV DWORD PTR SS:[EBP-4],0
        JE LNJ1
        PUSH 0x11
        LEA ECX,DWORD PTR SS:[EBP-0x84]
        PUSH ECX
        MOV ECX,EAX
        MOV EAX,ZUnknownThreeAddr
        CALL EAX
        JMP LNJ2
        LNJ1:
        XOR EAX,EAX
        LNJ2:
        MOV ECX,ESI
        PUSH EAX
        MOV DWORD PTR SS:[EBP-4],-1
        MOV EAX,ZUnknownFourAddr
        CALL EAX
        PUSH SHOTRET
        PUSH EBP
        MOV EBP,ESP
        PUSH ESI
        PUSH ZBypassAddr
        MOV EAX,ZPostCommandAddr
        JMP EAX
        SHOTRET:
        ADD ESP,4
        MOV ECX,DWORD PTR SS:[EBP-0xC]
        POP EDI
        POP ESI
        POP EBX
        MOV DWORD PTR FS:[0],ECX
        MOV ESP,EBP
        POP EBP
        RETN
    }
}

void Keys()
{
    while(true)
    {
         if((GetAsyncKeyState(0x12)&0x8000)&&(GetAsyncKeyState('G')&0x8000))
        {
            godmode=!godmode;
            ToggleSound(godmode);
        Sleep( 500 );
        }
         if((GetAsyncKeyState(0x12)&0x8000)&&(GetAsyncKeyState('L')&0x8000))
        {
            lawnmower=!lawnmower;
            ToggleSound(lawnmower);
        Sleep( 500 );
        }
         if((GetAsyncKeyState(0x12)&0x8000)&&(GetAsyncKeyState('R')&0x8000))
        {
            rapeshot=!rapeshot;
            ToggleSound(rapeshot);
        Sleep( 500 );
        }
        Sleep(30);
    }
}

void Execute()
{
    while(true)
    {
        if(ZMyCharacter())
        {
            if(godmode)
            {
                BonusHealth();
            }
            if(lawnmower)
            {
                 ZPostShot(GetPosition(ZMyCharacter()),GetDirection(ZMyCharacter()),7);
                 ZPostShot(GetPosition(ZMyCharacter()),GetDirection(ZMyCharacter()),1);
            }
            if(rapeshot&&(GetAsyncKeyState(0x01)&0x8000))
            {
                float *MyPosition=GetPosition(ZMyCharacter());
                float *MyDirection=GetDirection(ZMyCharacter());
                float NewPosition[3];
                NewPosition[0]=MyPosition[0];
                NewPosition[1]=MyPosition[1];
                NewPosition[2]=MyPosition[2]+200;
                float NewDirection[3];
                NewDirection[0]=MyPosition[0]+(MyDirection[0]*9001);
                NewDirection[1]=MyPosition[1]+(MyDirection[1]*9001);
                NewDirection[2]=200+MyPosition[2]+(MyDirection[2]*9001);
                for(int i=0;i<10;i++)
                {
                    ZPostShot(NewPosition,NewDirection,8);
                    ZPostShot(NewPosition,NewDirection,1);
                    ZPostShot(NewPosition,NewDirection,9);
                    ZPostShot(NewPosition,NewDirection,1);
                }
                Rejoin();
                Sleep(200);
            }
        }
        Sleep(10);
    }
}

extern "C"
{
        __declspec(dllexport) BOOL __stdcall DllMain(HINSTANCE  hInst,DWORD reason,LPVOID lpv)
        {
                if(reason==DLL_PROCESS_ATTACH)
                {
                        DisableThreadLibraryCalls(hInst);
                         CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Keys,NULL,0,NULL);
                         CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Execute,NULL,0,NULL);
                        Beep(500,500);
                }
                return true;
        }
}