Quote Originally Posted by ThePhailure772 View Post
I love how you call me sub-par, lol.

I guess I'll take the discussion off-topic because of OP being a faggot.

Kore - A GunZ protocol exploiter which was used to attack many servers and spam advertisements.

Veldi - A GunZ client emulator for NHN's exclusive GunZ server.

Since I have no idea what I'm talking about why is it every self-release I've made you added a thanks to and loved the general idea I had behind it?

Sinceie I'm so sub-par why was Kemo so fast and efficient?

For those who don't know what Kemo is/was here are some examples:

LoginHandler:

Code:
#pragma once
#include <stdio.h>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/protocol/Match_RequestAccountCharList.h"
using namespace cockpit;

void Client::OnLoginResponse (
    const uint32_t& Result,
    const std::string& ServerName,
    const int8_t& mode,
    const std::string& account,
    const uint8_t& grade, 
    const uint8_t& premium,
    const uint64_t& clientId
)
{
    printf("Result: (%i).\r\nServer: (%s)\r\nMode: (%i)\r\nAccount: (%s)\r\nUGrade: (%i)\r\nMUID: (%u)\r\n",
            Result, ServerName.c_str(), mode, account.c_str(), grade, clientId);

    if (Result == 0)
    {
        myMUID.setUID((uint32_t)clientId);
        packet::blob emsg(1,20);
        emsg.add_param(packet::zeros(20));

        Send (packet::protocol::Match_RequestAccountCharList(emsg));
    }
}
CharacterListHandler:
Code:
#include <stdio.h>
#include <boost/tuple/tuple_io.hpp>
#include <boost/optional/optional.hpp>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/util/buffer.h"
#include "packet/protocol/Match_RequestSelectChar.h"

using namespace cockpit;

struct Characters
{
    char Name[32];
    uint8_t Index;
    uint8_t Level;
};

void Client::OnResponseCharList(const boost::tuple<Buffer, size_t, size_t >& charData)
{
    const Buffer& b = boost::get<0>(charData);
    const size_t& count = boost::get<1>(charData);
    const size_t& size = boost::get<2>(charData);

    Characters charList[count];
    const uint8_t* buffer = b.data();

    for (int i = 0; i < count; ++i)
    {
        memcpy (charList[i].Name,  buffer + (i * size), 32);
        memcpy (&charList[i].Index, buffer + (i * size) + 32, 1);
        memcpy (&charList[i].Level,  buffer + (i * size) + 33, 1);

        printf ("Character: (%s). Index(%i). Level(%i)\n", charList[i].Name, charList[i].Index, charList[i].Level);
    }

    packet::MUID uid(0, myMUID.getUID());
    packet::uint32 charindex(charList[0].Index);
    Send (packet::protocol::Match_RequestSelectChar(uid, charindex));
}
CharacterSelectionHandler:
Code:
#include <stdio.h>
#include <boost/tuple/tuple_io.hpp>
#include <boost/optional/optional.hpp>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/util/buffer.h"
#include "packet/protocol/Channel_Join.h"
#include "packet/protocol/Stage_Create.h"

using namespace cockpit;

void Client::OnResponseSelectChar(const uint32_t& result,
        const boost::tuple<Buffer, size_t, size_t >& charData,
        const boost::tuple<Buffer, size_t, size_t >& extraData)
{
    if (result == 0)
    {
        Buffer buffer = boost::get<2>(charData);
        uint8_t* data = buffer.data();

        memcpy (&myCharInfo, data, sizeof(CharacterInfo));
        packet::MUID charId(0, myMUID.getUID());
        packet::MUID chanId(0, 1);

        Send (packet::protocol::Channel_Join(charId,chanId));
    }
}
StageHandler:
Code:
#include <stdio.h>
#include <boost/optional/optional.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <vector>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/util/buffer.h"
#include "packet/protocol/Stage_RequestJoin.h"
#include "packet/protocol/Stage_Request_EnterBattle.h"
#include "packet/protocol/Stage_RequestPeerList.h"

void Client::OnStageList (const uint8_t& prevCount, const uint8_t& nextCount, const boost::tuple<Buffer, size_t, size_t>& stageData)
{
    const Buffer& buffer = boost::get<0>(stageData);
    const size_t& count = boost::get<1>(stageData);
    const size_t& size = boost::get<2>(stageData);
    const uint8_t* data = buffer.data();
    uint8_t go = 1;
    
    for (size_t i = 0; i < count; ++i)
    {
        StageList* tmp = new StageList;
        memcpy (tmp, data + (i * size), size);

        for(std::vector<StageList*>::iterator it = stageList.begin(); it < stageList.end(); it++)
        {
            if((*it)->StageId.getUID() == tmp->StageId.getUID())
            {
                delete tmp;
                go = 0;
            }
        }
        
        if (go == 0)
        {
            go = 1;
            continue;
        }
        stageList.push_back(tmp);
        printf ("[%u](%i)Found Stage: %s\n", tmp->StageId.getUID(), tmp->StageIndex, tmp->Name);

    }
}
ChannelChatHandler:
Code:
#include <stdio.h>
#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <string.h>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/util/buffer.h"
#include "packet/protocol/Channel_Chat.h"
#include "packet/protocol/Channel_Request_Chat.h"
#include "packet/protocol/Admin_RequestBanPlayer.h"

void Client::OnResponseChannelChat (
        const uint64_t& uidChannel,
        const std::string& player,
        const std::string& message,
        const uint32_t& ugrade)
{
    printf ("[%s]<%s>: %s\n", ugrade > 251 ? "Staff" : "User", player.c_str(), message.c_str());
    if (!strcasecmp(player.c_str(), myCharInfo.Name))
    {
        if (message.at(1) == '/')
        {
            cockpit::packet::MUID channel(0, 0);
            cockpit::packet::MUID user(0, myMUID.getUID());
            cockpit::packet::string msgg(message);
            Send(cockpit::packet::protocol::Channel_Request_Chat(channel,user,msgg));
        }
    }
    std::string msg = message;
    std::transform(msg.begin(), msg.end(), msg.begin(), tolower);

    if (msg.find("gamena", 0) != std::string::npos || msg.find("game nao") != std::string::npos)
    {
        cockpit::packet::MUID uid(myMUID.getUID());
        cockpit::packet::string plr("u said a bad word!");
        cockpit::packet::MUID channel(0, 1);
        cockpit::packet::string msgg(message);
        
        Send(cockpit::packet::protocol::Channel_Request_Chat(channel,uid,plr));
        Send(cockpit::packet::protocol::Admin_RequestBanPlayer(uid, plr));

    }
}
ChannelResponsePlayerListHandler:
Code:
#include <stdio.h>
#include <boost/optional/optional.hpp>
#include "Client.h"
#include "packet/Packet.h"
#include "packet/util/buffer.h"
#include "packet/protocol/Stage_Create.h"

using namespace cockpit;

void Client::OnResponseChannelPlayerList (const uint8_t& totalPlayer, const uint8_t& page,  const boost::tuple<Buffer, size_t, size_t >& lobbyData)
{
    const Buffer& buffer = boost::get<0>(lobbyData);
    const size_t& count = boost::get<1>(lobbyData);
    const size_t& size = boost::get<2>(lobbyData);
    const uint8_t* data = buffer.data();

    uint8_t go = 1;

    for (uint32_t i = 0; i < count; ++i)
    {
        LobbyPlayerList *player = new LobbyPlayerList;
        memcpy(player, data+(i*size), size);
        for(std::vector<LobbyPlayerList*>::iterator it = lobbyPlayers.begin(); it < lobbyPlayers.end(); it++)
            if((*it)->PlayerId.getUID() == player->PlayerId.getUID())
                go = 0;

        if (go == 0)
        {
            go = 1;
            delete player;
            continue;
        }
        
        printf ("[%u]Found Player: (%s). Level: (%i). Access: (%i)\n", player->PlayerId.getUID(), player->Name, player->Level, player->Access);

        lobbyPlayers.push_back(player);
    }
}
???
Wow you learned to use google, all the information was released, your supposed scripts can be found from any of the numerous released attempts at a gunz emulator you have nothing to brag about no one is perfect