void WorldSession::HandleRequestRatedBgInfo(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: CMSG_REQUEST_RATED_BG_INFO");
uint8 type;
recvData >> type;
TC_LOG_DEBUG("bg.battleground", "WorldSession::HandleRequestRatedBgInfo: unk = %u", type);
WorldPacket packet1(SMSG_BATTLEFIELD_RATED_INFO);
packet1 << uint32(sWorld->getIntConfig(CONFIG_ARENA_CONQUEST_POINTS_REWARD)); // Reward
packet1 << uint8(0); // for arena
packet1 << uint32(0); // Raiting
packet1 << uint32(0); // Unk UInt32 3
packet1 << uint32(0); // Conquest Points Weekly Cap
packet1 << uint32(0); // Unk UInt32 5
packet1 << uint32(0); // Unk UInt32 6
packet1 << uint32(0); // Current Conquest Points
SendPacket(&packet1);
WorldPacket packet2(SMSG_BATTLEFIELD_RATED_INFO);
packet2 << uint32(sWorld->getIntConfig(CONFIG_RBG_CONQUEST_POINTS_REWARD)); // Reward
packet2 << uint8(3); // for rbg
packet2 << uint32(_player->GetRatedBGRating()); // Raiting
packet2 << uint32(0); // Unk UInt32 3
packet2 << uint32(0); // Conquest Points Weekly Cap
packet2 << uint32(0); // Unk UInt32 5
packet2 << uint32(0); // Unk UInt32 6
packet2 << uint32(0); // Current Conquest Points
SendPacket(&packet2);
}
void Pvp::dead(Client* client, Player* killer) {
randomizeCoord();
if(client->getCharacter()->getTeam() == network::PacketType::FACTION_TEAM1) {
m_scoreTeam2++;
client->getCharacter()->setCoord(m_team1Spawn);
} else {
m_scoreTeam1++;
client->getCharacter()->setCoord(m_team2Spawn);
}
network::Packet packetscore(NULL, network::PacketType::GAME_SCORE_UPGRADE);
packetscore << m_scoreTeam1 << m_scoreTeam2 << client->getCharacter()->getID() << killer->getID();
m_game->sendAll(packetscore);
network::Packet packet(NULL, network::PacketType::GAME_PLAYERTELEPORT);
packet << client->getCharacter()->getID() << client->getCharacter()->getCoord().x << client->getCharacter()->getCoord().y << network::PacketType::DIRECTION_NONE;
m_game->sendAll(packet);
client->getCharacter()->setAlive(true);
client->getCharacter()->setTarget(NULL);
client->getCharacter()->getStat()->setLife(client->getCharacter()->getStat()->maxLife());
network::Packet packet2(NULL, network::PacketType::GAME_STAT_LIFE);
packet2 << client->getCharacter()->getID() << client->getCharacter()->getStat()->life();
m_game->sendAll(packet2);
m_game->getChat()->send(killer->getName()+" have slained "+client->getCharacter()->getName()+" !");
}
//--------------------------------------------------------------------------------------//
// Change Guild Master
//--------------------------------------------------------------------------------------//
void CClientSession::SendUpdateGuildMaster(CNtlPacket * pPacket, CChatServer * app)
{
sUT_GUILD_CHANGE_GUILD_MASTER_REQ * req = (sUT_GUILD_CHANGE_GUILD_MASTER_REQ *)pPacket->GetPacketData();
app->db->prepare("CALL ChangeGuildMaster (?,?,?, @wResultCode)");
app->db->setInt(1, req->targetMemberCharId);
app->db->setString(2, this->GetGuildName().c_str());
app->db->setInt(3, this->GetCharacterId());
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
CNtlPacket packet(sizeof(sTU_GUILD_CHANGE_GUILD_MASTER_RES));
sTU_GUILD_CHANGE_GUILD_MASTER_RES * res = (sTU_GUILD_CHANGE_GUILD_MASTER_RES *)packet.GetPacketData();
res->newMasterCharId = req->targetMemberCharId;
res->wOpCode = TU_GUILD_CHANGE_GUILD_MASTER_RES;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_CHANGE_GUILD_MASTER_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
if(app->db->getInt("@wResultCode") == CHAT_SUCCESS)
{
CNtlPacket packet2(sizeof(sTU_GUILD_GUILD_MASTER_CHANGED_NFY));
sTU_GUILD_GUILD_MASTER_CHANGED_NFY * res2 = (sTU_GUILD_GUILD_MASTER_CHANGED_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_GUILD_MASTER_CHANGED_NFY;
res2->memberCharId = req->targetMemberCharId;
packet2.SetPacketLen( sizeof(sTU_GUILD_GUILD_MASTER_CHANGED_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
//--------------------------------------------------------------------------------------//
// Leave Guild
//--------------------------------------------------------------------------------------//
void CClientSession::SendLeaveGuildReq(CNtlPacket * pPacket, CChatServer * app)
{
app->db->prepare("CALL LeaveGuild (?, @wResultCode)");
app->db->setInt(1, this->GetCharacterId());
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
CNtlPacket packet(sizeof(sTU_GUILD_LEAVE_RES));
sTU_GUILD_LEAVE_RES * res = (sTU_GUILD_LEAVE_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_LEAVE_RES;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_LEAVE_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
printf("%i \n ", app->db->getInt("@wResultCode"));
if(app->db->getInt("@wResultCode") == 348)
{
CNtlPacket packet2(sizeof(sTU_GUILD_MEMBER_LEFT_NFY));
sTU_GUILD_MEMBER_LEFT_NFY * res2 = (sTU_GUILD_MEMBER_LEFT_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_MEMBER_LEFT_NFY;
res2->memberCharId = this->GetCharacterId();
//app->UserBroadcastothers(&packet2, this); // CHANGE THAT IT ONLY BROADCAST TO OTHER GUILD MEMBERS
packet2.SetPacketLen( sizeof(sTU_GUILD_MEMBER_LEFT_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
//--------------------------------------------------------------------------------------//
// Remove second guild master
//--------------------------------------------------------------------------------------//
void CClientSession::SendRemoveSecondGuildMaster(CNtlPacket * pPacket, CChatServer * app)
{
sUT_GUILD_DISMISS_SECOND_MASTER_REQ * req = (sUT_GUILD_DISMISS_SECOND_MASTER_REQ *)pPacket->GetPacketData();
app->db->prepare("UPDATE guilds SET GuildSecondMaster = 0 WHERE GuildSecondMaster = ?");
app->db->setInt(1, req->targetMemberCharId);
app->db->execute();
app->db->prepare("UPDATE guild_members SET is_secondguildmaster = 0 WHERE MemberID = ?");
app->db->setInt(1, req->targetMemberCharId);
app->db->execute();
CNtlPacket packet(sizeof(sTU_GUILD_DISMISS_SECOND_MASTER_RES));
sTU_GUILD_DISMISS_SECOND_MASTER_RES * res = (sTU_GUILD_DISMISS_SECOND_MASTER_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_DISMISS_SECOND_MASTER_RES;
res->wResultCode = CHAT_SUCCESS;
packet.SetPacketLen( sizeof(sTU_GUILD_DISMISS_SECOND_MASTER_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
CNtlPacket packet2(sizeof(sTU_GUILD_SECOND_MASTER_DISMISSED_NFY));
sTU_GUILD_SECOND_MASTER_DISMISSED_NFY * res2 = (sTU_GUILD_SECOND_MASTER_DISMISSED_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_SECOND_MASTER_DISMISSED_NFY;
res2->memberCharId = req->targetMemberCharId;
packet2.SetPacketLen( sizeof(sTU_GUILD_SECOND_MASTER_DISMISSED_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
//--------------------------------------------------------------------------------------//
// Disband Guild
//--------------------------------------------------------------------------------------//
void CClientSession::SendDisbandGuild(CNtlPacket * pPacket, CChatServer * app)
{
app->db->prepare("CALL DisbandGuild (?,?, @wResultCode)");
app->db->setString(1, this->GetGuildName().c_str());
app->db->setInt(2, this->GetCharacterId());
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
CNtlPacket packet(sizeof(sTU_GUILD_DISBAND_RES));
sTU_GUILD_DISBAND_RES * res = (sTU_GUILD_DISBAND_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_DISBAND_RES;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_DISBAND_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
if(app->db->getInt("@wResultCode") == 320)
{
CNtlPacket packet2(sizeof(sTU_GUILD_DISBANDED_NFY));
sTU_GUILD_DISBANDED_NFY * res2 = (sTU_GUILD_DISBANDED_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_DISBANDED_NFY;
packet2.SetPacketLen( sizeof(sTU_GUILD_DISBANDED_NFY));
//app->UserBroadcastothers(&packet2, this); // CHANGE THAT IT ONLY BROADCAST TO OTHER GUILD MEMBERS
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
//--------------------------------------------------------------------------------------//
// Change guild notice
//--------------------------------------------------------------------------------------//
void CClientSession::SendGuildChangeNotice(CNtlPacket * pPacket, CChatServer * app)
{
sUT_GUILD_CHANGE_NOTICE_REQ * req = (sUT_GUILD_CHANGE_NOTICE_REQ *)pPacket->GetPacketData();
app->db->prepare("CALL UpdateGuildNotice (?,?, @wResultCode)");
app->db->setInt(1, this->GetCharacterId());
app->db->setString(2, Ntl_WC2MB(req->awchNotice));
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
CNtlPacket packet(sizeof(sTU_GUILD_CHANGE_NOTICE_RES));
sTU_GUILD_CHANGE_NOTICE_RES * res = (sTU_GUILD_CHANGE_NOTICE_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_CHANGE_NOTICE_RES;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_CHANGE_NOTICE_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
if(app->db->getInt("@wResultCode") == 300)
{
CNtlPacket packet2(sizeof(sTU_GUILD_CHANGE_NOTICE_NFY));
sTU_GUILD_CHANGE_NOTICE_NFY * res2 = (sTU_GUILD_CHANGE_NOTICE_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_CHANGE_NOTICE_NFY;
wcscpy_s(res2->awchCharName, NTL_MAX_SIZE_CHAR_NAME_UNICODE, s2ws(this->GetCharName()).c_str());
memcpy(res2->awchNotice, req->awchNotice, sizeof(wchar_t)* NTL_MAX_LENGTH_OF_GUILD_NOTICE_UNICODE);
res2->wNoticeLengthInUnicode = req->wNoticeLengthInUnicode;
//app->UserBroadcastothers(&packet2, this); // CHANGE THAT IT ONLY BROADCAST TO OTHER GUILD MEMBERS
packet2.SetPacketLen( sizeof(sTU_GUILD_CHANGE_NOTICE_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
//--------------------------------------------------------------------------------------//
// Load Guild info
//--------------------------------------------------------------------------------------//
void CClientSession::SendLoadGuildInfo(CNtlPacket * pPacket, CChatServer * app)
{
app->db->prepare("CALL GuildInfo (?, @guild_id,@guild_name,@guild_master,@guild_notice,@guild_rep,@second_guild_master)");
app->db->setInt(1, this->GetCharacterId());
app->db->execute();
app->db->execute("SELECT @guild_id,@guild_name,@guild_master,@guild_notice,@guild_rep,@second_guild_master");
app->db->fetch();
//Check if user inside guild
if(app->db->getInt("@guild_id") != 0)
{
//SET GUILD INFO
CNtlPacket packet(sizeof(sTU_GUILD_INFO));
sTU_GUILD_INFO * res = (sTU_GUILD_INFO *)packet.GetPacketData();
int guildID = app->db->getInt("@guild_id");
this->guildName = app->db->getString("@guild_name");
res->wOpCode = TU_GUILD_INFO;
res->guildInfo.dwGuildReputation = app->db->getInt("@guild_rep");
res->guildInfo.guildId = guildID;
res->guildInfo.guildMaster = app->db->getInt("@guild_master");
res->guildInfo.guildSecondMaster[0] = app->db->getInt("@second_guild_master");
wcscpy_s(res->guildInfo.wszName, NTL_MAX_SIZE_GUILD_NAME_IN_UNICODE, s2ws(app->db->getString("@guild_name")).c_str());
wcscpy_s(res->guildInfo.awchName, NTL_MAX_SIZE_CHAR_NAME_UNICODE, s2ws(this->GetCharName()).c_str());
wcscpy_s(res->guildInfo.awchNotice, NTL_MAX_LENGTH_OF_GUILD_NOTICE_UNICODE, s2ws(app->db->getString("@guild_notice")).c_str());
packet.SetPacketLen( sizeof(sTU_GUILD_INFO));
int rc = g_pApp->Send( this->GetHandle(), &packet);
printf("Guild ID: %i \n",guildID);
//SET GUILD MEMBERS
CNtlPacket packet2(sizeof(sTU_GUILD_MEMBER_INFO));
sTU_GUILD_MEMBER_INFO * res2 = (sTU_GUILD_MEMBER_INFO *)packet2.GetPacketData();
app->db->prepare("SELECT CharID,CharName,Level,Race,Class FROM characters WHERE GuildID = ?");
app->db->setInt(1, guildID);
app->db->execute();
while(app->db->fetch())
{
res2->wOpCode = TU_GUILD_MEMBER_INFO;
res2->guildMemberInfo.bIsOnline = true;
res2->guildMemberInfo.byClass = app->db->getInt("Class");
res2->guildMemberInfo.byLevel = app->db->getInt("Level");
res2->guildMemberInfo.byRace = app->db->getInt("Race");
res2->guildMemberInfo.charId = app->db->getInt("CharID");
res2->guildMemberInfo.dwReputation = 0;
wcscpy_s(res2->guildMemberInfo.wszMemberName, NTL_MAX_SIZE_CHAR_NAME_UNICODE, s2ws(app->db->getString("CharName")).c_str());
packet2.SetPacketLen( sizeof(sTU_GUILD_MEMBER_INFO));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
}
void CClientSession::SendServerListOneReq(CNtlPacket * pPacket)
{
// Load farm info
printf("--- LOAD SERVER FARM INFO --- \n");
CNtlPacket packet(sizeof(sCU_SERVER_FARM_INFO));
sCU_SERVER_FARM_INFO * res = (sCU_SERVER_FARM_INFO *)packet.GetPacketData();
res->wOpCode = CU_SERVER_FARM_INFO;
res->serverFarmInfo.serverFarmId = 0;
wcscpy_s((wchar_t*)res->serverFarmInfo.wszGameServerFarmName, NTL_MAX_SIZE_SERVER_FARM_NAME_UNICODE, L"AKCore");
res->serverFarmInfo.byServerStatus = DBO_SERVER_STATUS_UP;
res->serverFarmInfo.dwLoad = 10;
res->serverFarmInfo.dwMaxLoad = 100;
packet.SetPacketLen(sizeof(sCU_SERVER_FARM_INFO));
int rc = g_pApp->Send(this->GetHandle(), &packet);
// Load Server list
printf("--- LOAD SERVER LIST ONE --- \n");
CNtlPacket packet2(sizeof(sCU_CHARACTER_SERVERLIST_ONE_RES));
sCU_CHARACTER_SERVERLIST_ONE_RES * res2 = (sCU_CHARACTER_SERVERLIST_ONE_RES *)packet2.GetPacketData();
res2->wOpCode = CU_CHARACTER_SERVERLIST_ONE_RES;
res2->wResultCode = CHARACTER_SUCCESS;
packet2.SetPacketLen(sizeof(sCU_CHARACTER_SERVERLIST_ONE_RES));
rc = g_pApp->Send(this->GetHandle(), &packet2);
// Load Channel
printf("--- LOAD SERVER CHANNEL --- \n");
CNtlPacket packet3(sizeof(sCU_SERVER_CHANNEL_INFO));
sCU_SERVER_CHANNEL_INFO * res3 = (sCU_SERVER_CHANNEL_INFO *)packet3.GetPacketData();
res3->wOpCode = CU_SERVER_CHANNEL_INFO;
res3->byCount = 1;
res3->serverChannelInfo[0].serverFarmId = 0;
res3->serverChannelInfo[0].byServerChannelIndex = 0;
res3->serverChannelInfo[0].dwLoad = 10;
res3->serverChannelInfo[0].bIsVisible = true;
res3->serverChannelInfo[0].dwMaxLoad = 100;
res3->serverChannelInfo[0].byServerStatus = DBO_SERVER_STATUS_UP;
packet3.SetPacketLen(sizeof(sCU_SERVER_CHANNEL_INFO));
rc = g_pApp->Send(this->GetHandle(), &packet3);
}
//--------------------------------------------------------------------------------------//
// Connection check and login queue function
//--------------------------------------------------------------------------------------//
void CClientSession::SendCharWaitCheckReq(CNtlPacket * pPacket)
{
CNtlPacket packet(sizeof(sCU_CONNECT_WAIT_CHECK_RES));
sCU_CONNECT_WAIT_CHECK_RES * sPacket = (sCU_CONNECT_WAIT_CHECK_RES *)packet.GetPacketData();
sPacket->wOpCode = CU_CONNECT_WAIT_CHECK_RES;
sPacket->wResultCode = GAME_SUCCESS;
packet.SetPacketLen( sizeof(sCU_CONNECT_WAIT_CHECK_RES) );
int rc = g_pApp->Send( this->GetHandle(), &packet);
CNtlPacket packet2(sizeof(sCU_CONNECT_WAIT_COUNT_NFY));
sCU_CONNECT_WAIT_COUNT_NFY * sPacket2 = (sCU_CONNECT_WAIT_COUNT_NFY *)packet2.GetPacketData();
sPacket2->wOpCode = CU_CONNECT_WAIT_COUNT_NFY;
sPacket2->dwCountWaiting = 0; /// How many players are in queue?
packet2.SetPacketLen( sizeof(sCU_CONNECT_WAIT_COUNT_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
TEST(Packets, PacketParameterWriteTest)
{
DigitalOutputPacket packet1(13, true);
std::ostringstream outputStream;
std::string expectedOutput;
std::string actualOutput;
expectedOutput = "\xFF\x02\x0D\x02\xFF";
packet1.write(outputStream);
actualOutput = outputStream.str();
CHECK_EQUAL(expectedOutput, actualOutput);
outputStream.str("");
DigitalOutputPacket packet2(5, false);
expectedOutput = "\xFF\x02\x05\x01\xFF";
packet2.write(outputStream);
actualOutput = outputStream.str();
CHECK_EQUAL(expectedOutput, actualOutput);
}
//--------------------------------------------------------------------------------------//
// Appoint second guildmaster
//--------------------------------------------------------------------------------------//
void CClientSession::SendNewSecondGuildMaster(CNtlPacket * pPacket, CChatServer * app)
{
sUT_GUILD_APPOINT_SECOND_MASTER_REQ * req = (sUT_GUILD_APPOINT_SECOND_MASTER_REQ *)pPacket->GetPacketData();
app->db->prepare("CALL NewSecondGuildMaster (?,?, @wResultCode)");
app->db->setInt(1, req->targetMemberCharId);
app->db->setString(2, this->GetGuildName().c_str());
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
CNtlPacket packet(sizeof(sTU_GUILD_APPOINT_SECOND_MASTER_RES));
sTU_GUILD_APPOINT_SECOND_MASTER_RES * res = (sTU_GUILD_APPOINT_SECOND_MASTER_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_APPOINT_SECOND_MASTER_RES;
res->secondMasterCharId = req->targetMemberCharId;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_APPOINT_SECOND_MASTER_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
if(app->db->getInt("@wResultCode") == CHAT_SUCCESS)
{
CNtlPacket packet2(sizeof(sTU_GUILD_SECOND_MASTER_APPOINTED_NFY));
sTU_GUILD_SECOND_MASTER_APPOINTED_NFY * res2 = (sTU_GUILD_SECOND_MASTER_APPOINTED_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_SECOND_MASTER_APPOINTED_NFY;
res2->memberCharId = req->targetMemberCharId;
//app->UserBroadcastothers(&packet2, this); // CHANGE THAT IT ONLY BROADCAST TO OTHER GUILD MEMBERS
packet2.SetPacketLen( sizeof(sTU_GUILD_SECOND_MASTER_APPOINTED_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
}
}
//--------------------------------------------------------------------------------------//
// Kick from Guild
//--------------------------------------------------------------------------------------//
void CClientSession::SendKickFromGuildReq(CNtlPacket * pPacket, CChatServer * app)
{
sUT_GUILD_KICK_OUT_REQ * req = (sUT_GUILD_KICK_OUT_REQ *)pPacket->GetPacketData();
app->db->prepare("CALL KickGuild (?, @wResultCode)");
app->db->setInt(1, req->targetMemberCharId);
app->db->execute();
app->db->execute("SELECT @wResultCode");
app->db->fetch();
printf("target id %i \n", req->targetMemberCharId);
CNtlPacket packet(sizeof(sTU_GUILD_KICK_OUT_RES));
sTU_GUILD_KICK_OUT_RES * res = (sTU_GUILD_KICK_OUT_RES *)packet.GetPacketData();
res->wOpCode = TU_GUILD_KICK_OUT_RES;
res->wResultCode = app->db->getInt("@wResultCode");
packet.SetPacketLen( sizeof(sTU_GUILD_KICK_OUT_RES));
int rc = g_pApp->Send( this->GetHandle(), &packet);
printf("%i \n ", app->db->getInt("@wResultCode"));
if(app->db->getInt("@wResultCode") == CHAT_SUCCESS)
{
CNtlPacket packet2(sizeof(sTU_GUILD_MEMBER_KICKED_OUT_NFY));
sTU_GUILD_MEMBER_KICKED_OUT_NFY * res2 = (sTU_GUILD_MEMBER_KICKED_OUT_NFY *)packet2.GetPacketData();
res2->wOpCode = TU_GUILD_MEMBER_KICKED_OUT_NFY;
res2->memberCharId = req->targetMemberCharId;
//app->UserBroadcastothers(&packet2, this); // CHANGE THAT IT ONLY BROADCAST TO OTHER GUILD MEMBERS
packet2.SetPacketLen( sizeof(sTU_GUILD_MEMBER_KICKED_OUT_NFY));
rc = g_pApp->Send( this->GetHandle(), &packet2);
printf("kicked out %i \n", req->targetMemberCharId);
}
}
void CDplusProtocol::SendDvHeader(CDvHeaderPacket *packet, CDplusClient *client)
{
// encode it
CBuffer buffer;
if ( EncodeDvPacket(*packet, &buffer) )
{
if ( (client->IsDextraDongle() || !client->HasModule()) )
{
// clone the packet and patch it
CDvHeaderPacket packet2(*((CDvHeaderPacket *)packet));
CCallsign rpt2 = packet2.GetRpt2Callsign();
rpt2.PatchCallsign(0, (const uint8 *)"XRF", 3);
packet2.SetRpt2Callsign(rpt2);
// encode it
CBuffer buffer2;
if ( EncodeDvPacket(packet2, &buffer2) )
{
// and send it
m_Socket.Send(buffer2, client->GetIp());
}
// client type known ?
if ( !client->HasModule() )
{
// no, send also the genuine packet
m_Socket.Send(buffer, client->GetIp());
}
}
else
{
// otherwise, send the original packet
m_Socket.Send(buffer, client->GetIp());
}
}
}
//--------------------------------------------------------------------------------------//
// Load Characters
//--------------------------------------------------------------------------------------//
void CClientSession::SendCharLoadReq(CNtlPacket * pPacket, CCharServer * app)
{
sUC_CHARACTER_LOAD_REQ * req = (sUC_CHARACTER_LOAD_REQ*)pPacket->GetPacketData();
printf("--- LOAD CHARACTERS ACC ID: %i Farm ID: %i --- \n", req->accountId, req->serverFarmId);
app->db->prepare("SELECT * FROM characters WHERE AccountID = ?");
app->db->setInt(1, req->accountId);
app->db->execute();
cout << " TOTAL CHARACTERS: " << app->db->rowsCount() << endl;
// character info
CNtlPacket packet(sizeof(sCU_CHARACTER_INFO));
sCU_CHARACTER_INFO * res = (sCU_CHARACTER_INFO *)packet.GetPacketData();
res->wOpCode = CU_CHARACTER_INFO;
res->byCount = (int)app->db->rowsCount();
for ( int i = 0; i < (int)app->db->rowsCount(); i++ )
{
app->db->fetch();
wcscpy_s(res->sPcData[i].awchName, NTL_MAX_SIZE_CHAR_NAME_UNICODE, s2ws(app->db->getString("CharName")).c_str() );res->sPcData[i].charId = app->db->getInt("CharID");
res->sPcData[i].byRace = app->db->getInt("Race");
res->sPcData[i].byClass = app->db->getInt("Class");
res->sPcData[i].bIsAdult = app->db->getBoolean("Adult");
res->sPcData[i].byGender = app->db->getInt("Gender");
res->sPcData[i].byFace = app->db->getInt("Face");
res->sPcData[i].byHair = app->db->getInt("Hair");
res->sPcData[i].byHairColor = app->db->getInt("HairColor");
res->sPcData[i].bySkinColor = app->db->getInt("SkinColor");
res->sPcData[i].byLevel = app->db->getInt("Level");
res->sPcData[i].bTutorialFlag = app->db->getInt("TutorialFlag");
res->sPcData[i].bNeedNameChange = app->db->getBoolean("NameChange");
res->sPcData[i].dwMoney = app->db->getInt("Money");
res->sPcData[i].dwMoneyBank = app->db->getInt("MoneyBank");
res->sPcData[i].worldId = app->db->getInt("WorldID");
res->sPcData[i].worldTblidx = app->db->getInt("WorldTable");
res->sPcData[i].dwMapInfoIndex = app->db->getInt("MapInfoIndex");
for(int j = 0; j < NTL_MAX_EQUIP_ITEM_SLOT; j++)
{
//Get items which the characters is wearing
app->db2->prepare("select * from items WHERE place=7 AND pos=? AND owner_id=?");
app->db2->setInt(1, j);
app->db2->setInt(2, app->db->getInt("CharID"));
app->db2->execute();
app->db2->fetch();
if(app->db2->rowsCount() == 0)
{
res->sPcData[i].sItem[j].tblidx = INVALID_TBLIDX;
}
else
{
res->sPcData[i].sItem[j].tblidx = app->db2->getInt("tblidx");
}
}
}
packet.SetPacketLen( sizeof(sCU_CHARACTER_INFO) );
int rc = g_pApp->Send( this->GetHandle(), &packet );
// load characters
CNtlPacket packet2(sizeof(sCU_CHARACTER_LOAD_RES));
sCU_CHARACTER_LOAD_RES * res2 = (sCU_CHARACTER_LOAD_RES *)packet2.GetPacketData();
res2->wOpCode = CU_CHARACTER_LOAD_RES;
res2->wResultCode = CHARACTER_SUCCESS;
packet2.SetPacketLen( sizeof(sCU_CHARACTER_LOAD_RES) );
rc = g_pApp->Send( this->GetHandle(), &packet2 );
}
void Server::client_readyRead()
{
QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
if (!socket) {
qWarning("Server::client_readyRead(): Cast of sender() to QTcpSocket* failed");
return;
}
#ifdef DEBUG
qDebug("\nServer::client_readyRead(): %li bytes available", (long)socket->bytesAvailable());
#endif
Client *client = m_clients[socket];
QDataStream in(socket);
in.setVersion(QDataStream::Qt_4_0);
if (client->packetSize == 0) {
if (socket->bytesAvailable() < (int)sizeof(quint32)) // packet size
return;
in >> client->packetSize;
}
if (socket->bytesAvailable() < client->packetSize)
return;
client->packetSize = 0; // reset packet size
qint32 type;
in >> type;
#ifdef DEBUG
qDebug("PacketType %i (%s) from '%s' (%s:%i)", type,
qPrintable(QccPacket::typeString((QccPacket::PacketType)type)),
qPrintable(client->user ? client->user->username() : "[no user object]"),
qPrintable(socket->peerAddress().toString()), socket->peerPort());
#endif
switch ((QccPacket::PacketType)type) {
case QccPacket::UserRegister:
{
QString username, password;
QByteArray publicKey;
in >> username >> password >> publicKey;
#ifdef DEBUG
qDebug("Username = '******' password = '******'", qPrintable(username), qPrintable(password));
#endif
if (username.isEmpty()) {
QString reason = "The username cannot be empty.";
QccPacket packet(QccPacket::RegisterFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("RegisterFailure: %s", qPrintable(reason));
#endif
break;
}
if (m_users.contains(username)) {
QString reason = QString("The username \"%1\" is not available.").arg(username);
QccPacket packet(QccPacket::RegisterFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("RegisterFailure: %s", qPrintable(reason));
#endif
break;
}
#ifdef DEBUG
qDebug("RegisterSuccess");
#endif
User *user = new User(username, password);
user->setPublicKey(publicKey);
user->setSocket(socket);
connect(user, SIGNAL(statusChanged()), SLOT(client_statusChanged()));
user->setStatus(User::Online);
m_users.insert(username, user);
saveUsers();
client->user = user;
QccPacket(QccPacket::RegisterSuccess).send(socket);
break;
}
case QccPacket::UserAuthentication:
{
QString username, password;
QByteArray publicKey;
in >> username >> password >> publicKey;
#ifdef DEBUG
qDebug("Username = '******' password = '******'", qPrintable(username), qPrintable(password));
#endif
User *user = m_users.contains(username) ? m_users[username] : NULL;
if (user && user->matchPassword(password)) {
#ifdef DEBUG
qDebug("AuthenticationSuccess");
#endif
user->setPublicKey(publicKey);
user->setSocket(socket);
user->setStatus(User::Online);
client->user = user;
QccPacket(QccPacket::AuthenticationSuccess).send(socket);
} else {
QString reason = "The username or password you entered is incorrect.";
QccPacket packet(QccPacket::AuthenticationFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("AuthenticationFailure: %s", qPrintable(reason));
#endif
}
break;
}
case QccPacket::RequestAuthorization:
{
QString username;
in >> username;
if (!m_users.contains(username)) {
QString reason = QString("The user \"%1\" does not exist.").arg(username);
QccPacket packet(QccPacket::AuthorizationFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("AuthorizationFailure: %s", qPrintable(reason));
#endif
break;
}
if (client->user->username() == username) {
QString reason = QString("You cannot add yourself.");
QccPacket packet(QccPacket::AuthorizationFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("AuthorizationFailure: %s", qPrintable(reason));
#endif
break;
}
if (client->user->containsContact(username)) {
QString reason = QString("The user \"%1\" is already on your contact list.").arg(username);
QccPacket packet(QccPacket::AuthorizationFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("AuthorizationFailure: %s", qPrintable(reason));
#endif
break;
}
User *receiver = m_users.value(username);
if (receiver && receiver->isOnline()) {
QccPacket packet(QccPacket::RequestAuthorization);
packet.stream() << client->user->username();
packet.send(receiver->socket());
#ifdef DEBUG
qDebug("RequestAuthorization: forwarded to '%s'", qPrintable(username));
#endif
} else {
QString reason = QString("The user \"%1\" is not online.").arg(username);
QccPacket packet(QccPacket::AuthorizationFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("AuthorizationFailure: %s", qPrintable(reason));
#endif
}
break;
}
case QccPacket::AuthorizationAccepted:
{
QString username;
in >> username;
if (username.isEmpty())
break;
User *receiver = m_users[username];
if (receiver && receiver->isOnline()) {
receiver->addContact(client->user->username());
client->user->addContact(username);
saveUsers();
QccPacket packet(QccPacket::AuthorizationAccepted);
packet.stream() << client->user->username() << (qint32)client->user->status() << client->user->publicKey();
packet.send(receiver->socket());
QccPacket packet2(QccPacket::AuthorizationAccepted);
packet2.stream() << username << (qint32)receiver->status() << receiver->publicKey();
packet2.send(socket);
}
#ifdef DEBUG
qDebug("AuthorizationAccepted: forwarded to '%s'", qPrintable(username));
#endif
break;
}
case QccPacket::AuthorizationDeclined:
{
QString username;
in >> username;
if (username.isEmpty())
break;
User *receiver = m_users.value(username);
if (receiver && receiver->isOnline()) {
QccPacket packet(QccPacket::AuthorizationDeclined);
packet.stream() << client->user->username();
packet.send(receiver->socket());
}
#ifdef DEBUG
qDebug("AuthorizationDeclined: forwarded to '%s'", qPrintable(username));
#endif
break;
}
case QccPacket::RequestContactList:
{
QccPacket packet(QccPacket::ContactList);
QSet<QString> contacts = client->user->contacts();
packet.stream() << (qint32)contacts.count();
foreach (const QString &contactName, contacts) {
User *contact = m_users.value(contactName);
if (!contact) continue;
packet.stream() << contactName << qint32(contact->status()) << contact->publicKey();
}
packet.send(socket);
#ifdef DEBUG
qDebug("ContactList: %i contacts send", contacts.count());
#endif
break;
}
case QccPacket::RemoveContact:
{
QString username;
in >> username;
if (client->user->removeContact(username)) {
QccPacket packet(QccPacket::ContactRemoved);
packet.stream() << username;
packet.send(socket);
User *receiver = m_users[username];
if (receiver && receiver->removeContact(client->user->username()) && receiver->isOnline()) {
QccPacket packet2(QccPacket::ContactRemoved);
packet2.stream() << client->user->username();
packet2.send(receiver->socket());
}
saveUsers();
#ifdef DEBUG
qDebug("ContactRemoved: contact '%s' removed", qPrintable(username));
#endif
}
break;
}
case QccPacket::Message:
{
qint32 id;
QString receiverName;
QString message;
in >> id >> receiverName >> message;
if (!client->user->containsContact(receiverName)) {
QString reason = QString("The user \"%1\" is not on your contact list.").arg(receiverName);
QccPacket packet(QccPacket::MessageFailure);
packet.stream() << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("MessageFailure: %s", qPrintable(reason));
#endif
break;
}
User *receiver = m_users.value(receiverName);
if (receiver && receiver->isOnline()) {
QccPacket packet(QccPacket::Message);
packet.stream() << id << client->user->username() << message;
packet.send(receiver->socket());
#ifdef DEBUG
qDebug("Message: forwarded to '%s'", qPrintable(receiverName));
#endif
} else {
QString reason = QString("The user \"%1\" is not online.").arg(receiverName);
QccPacket packet(QccPacket::MessageFailure);
packet.stream() << id << receiverName << reason;
packet.send(socket);
#ifdef DEBUG
qDebug("MessageFailure: failed to forward to '%s' => %s",
qPrintable(receiverName), qPrintable(reason));
#endif
}
break;
}
case QccPacket::MessageSuccess:
{
qint32 id;
QString receiverName;
in >> id >> receiverName;
User *receiver = m_users.value(receiverName);
if (receiver && receiver->isOnline()) {
QccPacket packet(QccPacket::MessageSuccess);
packet.stream() << id << client->user->username();
packet.send(receiver->socket());
#ifdef DEBUG
qDebug("MessageSuccess: forwarded to '%s'", qPrintable(receiverName));
#endif
}
break;
}
default:
qWarning("Server::client_readyRead(): Illegal PacketType %i", type);
return;
}
void CDplusProtocol::HandleQueue(void)
{
m_Queue.Lock();
while ( !m_Queue.empty() )
{
// get the packet
CPacket *packet = m_Queue.front();
m_Queue.pop();
// get our sender's id
int iModId = g_Reflector.GetModuleIndex(packet->GetModuleId());
// check if it's header and update cache
if ( packet->IsDvHeader() )
{
// this relies on queue feeder setting valid module id
m_DvHeadersCache[iModId] = CDvHeaderPacket((const CDvHeaderPacket &)*packet);
m_iSeqCounters[iModId] = 0;
}
// encode it
CBuffer buffer;
if ( EncodeDvPacket(*packet, &buffer) )
{
// and push it to all our clients who are not streaming in
// note that for dplus protocol, all stream of all modules are push to all clients
// it's client who decide which stream he's interrrested in
CClients *clients = g_Reflector.GetClients();
int index = -1;
CClient *client = NULL;
while ( (client = clients->FindNextClient(PROTOCOL_DPLUS, &index)) != NULL )
{
// is this client busy ?
if ( !client->IsAMaster() )
{
// check if client is a dextra dongle
// then replace RPT2 with XRF instead of REF
// if the client type is not yet known, send bothheaders
if ( packet->IsDvHeader() )
{
// sending header in Dplus is client specific
SendDvHeader((CDvHeaderPacket *)packet, (CDplusClient *)client);
}
else if ( packet->IsDvFrame() )
{
// and send the DV frame
m_Socket.Send(buffer, client->GetIp());
// is it time to insert a DVheader copy ?
if ( (m_iSeqCounters[iModId]++ % 21) == 20 )
{
// yes, clone it
CDvHeaderPacket packet2(m_DvHeadersCache[iModId]);
// and send it
SendDvHeader(&packet2, (CDplusClient *)client);
}
}
else
{
// otherwise, send the original packet
m_Socket.Send(buffer, client->GetIp());
}
}
}
g_Reflector.ReleaseClients();
}
// done
delete packet;
}
m_Queue.Unlock();
}
