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);
}
}
???
Reply With Quote
Originally Posted by DawsonByrd
I think interlude is a prime example of that. Inve v6? Lololol. Plus as far as thanking your releases this is the GunZ Section how much shit actually gets released? Anything that is new gets my thanks.
