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