Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-15 23:20:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/GuildFinder: Remove as preparation for 9.1.5

Browse Source
This commit is contained in:
Shauren
2021-11-02 18:14:49 +01:00
parent 6305b290c9
commit edc94e8ae8
15 changed files with 4 additions and 1382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
sql/base/characters_database.sql
View File

@@ -2508,62 +2508,6 @@ LOCK TABLES `guild_eventlog` WRITE;
/*!40000 ALTER TABLE `guild_eventlog` ENABLE KEYS */;
UNLOCK TABLES;
--
-- Table structure for table `guild_finder_applicant`
--
DROP TABLE IF EXISTS `guild_finder_applicant`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `guild_finder_applicant` (
`guildId` bigint(20) unsigned NOT NULL DEFAULT '0',
`playerGuid` bigint(20) unsigned NOT NULL DEFAULT '0',
`availability` tinyint(3) unsigned DEFAULT '0',
`classRole` tinyint(3) unsigned DEFAULT '0',
`interests` tinyint(3) unsigned DEFAULT '0',
`comment` varchar(255) DEFAULT NULL,
`submitTime` bigint(20) DEFAULT NULL,
PRIMARY KEY (`guildId`,`playerGuid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Dumping data for table `guild_finder_applicant`
--
LOCK TABLES `guild_finder_applicant` WRITE;
/*!40000 ALTER TABLE `guild_finder_applicant` DISABLE KEYS */;
/*!40000 ALTER TABLE `guild_finder_applicant` ENABLE KEYS */;
UNLOCK TABLES;
--
-- Table structure for table `guild_finder_guild_settings`
--
DROP TABLE IF EXISTS `guild_finder_guild_settings`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `guild_finder_guild_settings` (
`guildId` bigint(20) unsigned NOT NULL,
`availability` tinyint(3) unsigned NOT NULL DEFAULT '0',
`classRoles` tinyint(3) unsigned NOT NULL DEFAULT '0',
`interests` tinyint(3) unsigned NOT NULL DEFAULT '0',
`level` tinyint(3) unsigned NOT NULL DEFAULT '1',
`listed` tinyint(3) unsigned NOT NULL DEFAULT '0',
`comment` varchar(255) DEFAULT NULL,
PRIMARY KEY (`guildId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;
--
-- Dumping data for table `guild_finder_guild_settings`
--
LOCK TABLES `guild_finder_guild_settings` WRITE;
/*!40000 ALTER TABLE `guild_finder_guild_settings` DISABLE KEYS */;
/*!40000 ALTER TABLE `guild_finder_guild_settings` ENABLE KEYS */;
UNLOCK TABLES;
--
-- Table structure for table `guild_member`
--
@@ -3725,7 +3669,8 @@ INSERT INTO `updates` VALUES
('2021_10_02_00_characters.sql','31CEACE4E9A4BE58A659A2BDE4A7C51D2DB8AC41','ARCHIVED','2021-10-02 21:21:37',0),
('2021_10_02_01_characters.sql','F97B956F3B5F909294CA399F75B5795A07C4D8EC','ARCHIVED','2021-10-02 21:47:38',0),
('2021_10_15_00_characters.sql','906FECD65CBA7C406969F45FDF28DDEF8AAF8715','ARCHIVED','2021-10-15 10:11:47',0),
('2021_10_16_00_characters.sql','B5A31BB6FBC34512767475EDF13099DEC948EBB7','RELEASED','2021-10-16 01:12:20',0);
('2021_10_16_00_characters.sql','B5A31BB6FBC34512767475EDF13099DEC948EBB7','RELEASED','2021-10-16 01:12:20',0),
('2021_11_02_00_characters.sql','A3C0A6DA70CC70803C80685E4E2ED6255156520A','RELEASED','2021-11-02 18:11:13',0);
/*!40000 ALTER TABLE `updates` ENABLE KEYS */;
UNLOCK TABLES;

2
sql/updates/characters/master/2021_11_02_00_characters.sql Normal file
View File

@@ -0,0 +1,2 @@
DROP TABLE IF EXISTS `guild_finder_applicant`;
DROP TABLE IF EXISTS `guild_finder_guild_settings`;

6
src/server/database/Database/Implementation/CharacterDatabase.cpp
View File

@@ -695,12 +695,6 @@ void CharacterDatabaseConnection::DoPrepareStatements()
PrepareStatement(CHAR_DEL_CHAR_CUF_PROFILES_BY_ID, "DELETE FROM character_cuf_profiles WHERE guid = ? AND id = ?", CONNECTION_ASYNC);
PrepareStatement(CHAR_DEL_CHAR_CUF_PROFILES, "DELETE FROM character_cuf_profiles WHERE guid = ?", CONNECTION_ASYNC);
// Guild Finder
PrepareStatement(CHAR_REP_GUILD_FINDER_APPLICANT, "REPLACE INTO guild_finder_applicant (guildId, playerGuid, availability, classRole, interests, comment, submitTime) VALUES(?, ?, ?, ?, ?, ?, ?)", CONNECTION_ASYNC);
PrepareStatement(CHAR_DEL_GUILD_FINDER_APPLICANT, "DELETE FROM guild_finder_applicant WHERE guildId = ? AND playerGuid = ?", CONNECTION_ASYNC);
PrepareStatement(CHAR_REP_GUILD_FINDER_GUILD_SETTINGS, "REPLACE INTO guild_finder_guild_settings (guildId, availability, classRoles, interests, level, listed, comment) VALUES(?, ?, ?, ?, ?, ?, ?)", CONNECTION_ASYNC);
PrepareStatement(CHAR_DEL_GUILD_FINDER_GUILD_SETTINGS, "DELETE FROM guild_finder_guild_settings WHERE guildId = ?", CONNECTION_ASYNC);
// Items that hold loot or money
PrepareStatement(CHAR_SEL_ITEMCONTAINER_ITEMS, "SELECT container_id, item_id, item_count, follow_rules, ffa, blocked, counted, under_threshold, needs_quest, rnd_bonus, context, bonus_list_ids FROM item_loot_items", CONNECTION_SYNCH);
PrepareStatement(CHAR_DEL_ITEMCONTAINER_ITEMS, "DELETE FROM item_loot_items WHERE container_id = ?", CONNECTION_ASYNC);

5
src/server/database/Database/Implementation/CharacterDatabase.h
View File

@@ -574,11 +574,6 @@ enum CharacterDatabaseStatements : uint32
CHAR_DEL_CHAR_CUF_PROFILES_BY_ID,
CHAR_DEL_CHAR_CUF_PROFILES,
CHAR_REP_GUILD_FINDER_APPLICANT,
CHAR_DEL_GUILD_FINDER_APPLICANT,
CHAR_REP_GUILD_FINDER_GUILD_SETTINGS,
CHAR_DEL_GUILD_FINDER_GUILD_SETTINGS,
CHAR_REP_CALENDAR_EVENT,
CHAR_DEL_CALENDAR_EVENT,
CHAR_REP_CALENDAR_INVITE,

5
src/server/game/Guilds/Guild.cpp
View File

@@ -27,7 +27,6 @@
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "GameTime.h"
#include "GuildFinderMgr.h"
#include "GuildMgr.h"
#include "GuildPackets.h"
#include "Language.h"
@@ -1254,8 +1253,6 @@ void Guild::Disband()
CharacterDatabase.CommitTransaction(trans);
sGuildFinderMgr->DeleteGuild(GetGUID());
sGuildMgr->RemoveGuild(m_id);
}
@@ -2751,8 +2748,6 @@ bool Guild::AddMember(CharacterDatabaseTransaction& trans, ObjectGuid guid, uint
joinNotificationPacket.VirtualRealmAddress = GetVirtualRealmAddress();
BroadcastPacket(joinNotificationPacket.Write());
sGuildFinderMgr->RemoveAllMembershipRequestsFromPlayer(guid);
// Call scripts if member was succesfully added (and stored to database)
sScriptMgr->OnGuildAddMember(this, player, rankId);

362
src/server/game/Guilds/GuildFinderMgr.cpp
View File

@@ -1,362 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "GuildFinderMgr.h"
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "GameTime.h"
#include "Guild.h"
#include "GuildMgr.h"
#include "GuildFinderPackets.h"
#include "Log.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "World.h"
MembershipRequest::MembershipRequest() : _availability(0), _classRoles(0), _interests(0), _time(GameTime::GetGameTime())
{
}
MembershipRequest::MembershipRequest(ObjectGuid const& playerGUID, ObjectGuid const& guildId, uint32 availability, uint32 classRoles, uint32 interests, std::string comment, time_t submitTime) :
_comment(std::move(comment)), _guildId(guildId), _playerGUID(playerGUID), _availability(availability), _classRoles(classRoles), _interests(interests), _time(submitTime)
{
}
GuildFinderMgr::GuildFinderMgr()
{
}
GuildFinderMgr::~GuildFinderMgr()
{
}
void GuildFinderMgr::LoadFromDB()
{
LoadGuildSettings();
LoadMembershipRequests();
}
void GuildFinderMgr::LoadGuildSettings()
{
TC_LOG_INFO("server.loading", "Loading guild finder guild-related settings...");
// 0 1 2 3 4 5 6 7
QueryResult result = CharacterDatabase.Query("SELECT gfgs.guildId, gfgs.availability, gfgs.classRoles, gfgs.interests, gfgs.level, gfgs.listed, gfgs.comment, c.race "
"FROM guild_finder_guild_settings gfgs "
"LEFT JOIN guild_member gm ON gm.guildid=gfgs.guildId "
"LEFT JOIN characters c ON c.guid = gm.guid LIMIT 1");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 guild finder guild-related settings. Table `guild_finder_guild_settings` is empty.");
return;
}
uint32 count = 0;
uint32 oldMSTime = getMSTime();
do
{
Field* fields = result->Fetch();
ObjectGuid guildId = ObjectGuid::Create<HighGuid::Guild>(fields[0].GetUInt64());
uint8 availability = fields[1].GetUInt8();
uint8 classRoles = fields[2].GetUInt8();
uint8 interests = fields[3].GetUInt8();
uint8 level = fields[4].GetUInt8();
bool listed = (fields[5].GetUInt8() != 0);
std::string comment = fields[6].GetString();
TeamId guildTeam = TEAM_NEUTRAL;
if (ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(fields[7].GetUInt8()))
guildTeam = (TeamId)raceEntry->Alliance;
LFGuildSettings settings(listed, guildTeam, guildId, classRoles, availability, interests, level, comment);
_guildSettings[guildId] = settings;
++count;
} while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u guild finder guild-related settings in %u ms.", count, GetMSTimeDiffToNow(oldMSTime));
}
void GuildFinderMgr::LoadMembershipRequests()
{
TC_LOG_INFO("server.loading", "Loading guild finder membership requests...");
// 0 1 2 3 4 5 6
QueryResult result = CharacterDatabase.Query("SELECT guildId, playerGuid, availability, classRole, interests, comment, submitTime "
"FROM guild_finder_applicant");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 guild finder membership requests. Table `guild_finder_applicant` is empty.");
return;
}
uint32 count = 0;
uint32 oldMSTime = getMSTime();
do
{
Field* fields = result->Fetch();
ObjectGuid guildId = ObjectGuid::Create<HighGuid::Guild>(fields[0].GetUInt64());
ObjectGuid playerId = ObjectGuid::Create<HighGuid::Player>(fields[1].GetUInt64());
uint8 availability = fields[2].GetUInt8();
uint8 classRoles = fields[3].GetUInt8();
uint8 interests = fields[4].GetUInt8();
std::string comment = fields[5].GetString();
time_t submitTime = fields[6].GetInt64();
MembershipRequest request(playerId, guildId, availability, classRoles, interests, std::move(comment), submitTime);
_membershipRequestsByGuild[guildId][playerId] = request;
_membershipRequestsByPlayer[playerId][guildId] = request;
++count;
} while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u guild finder membership requests in %u ms.", count, GetMSTimeDiffToNow(oldMSTime));
}
void GuildFinderMgr::AddMembershipRequest(ObjectGuid const& guildGuid, MembershipRequest const& request)
{
_membershipRequestsByGuild[guildGuid][request.GetPlayerGUID()] = request;
_membershipRequestsByPlayer[request.GetPlayerGUID()][guildGuid] = request;
CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_GUILD_FINDER_APPLICANT);
stmt->setUInt64(0, request.GetGuildGuid().GetCounter());
stmt->setUInt64(1, request.GetPlayerGUID().GetCounter());
stmt->setUInt8(2, request.GetAvailability());
stmt->setUInt8(3, request.GetClassRoles());
stmt->setUInt8(4, request.GetInterests());
stmt->setString(5, request.GetComment());
stmt->setInt64(6, request.GetSubmitTime());
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
// Notify the applicant his submittion has been added
if (Player* player = ObjectAccessor::FindPlayer(request.GetPlayerGUID()))
SendMembershipRequestListUpdate(player);
// Notify the guild master and officers the list changed
if (Guild* guild = sGuildMgr->GetGuildByGuid(guildGuid))
SendApplicantListUpdate(guild);
}
void GuildFinderMgr::RemoveAllMembershipRequestsFromPlayer(ObjectGuid const& playerId)
{
auto playerItr = _membershipRequestsByPlayer.find(playerId);
if (playerItr == _membershipRequestsByPlayer.end())
return;
CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
for (auto& guildRequestPair : playerItr->second)
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_FINDER_APPLICANT);
stmt->setUInt64(0, guildRequestPair.first.GetCounter());
stmt->setUInt64(1, playerId.GetCounter());
trans->Append(stmt);
// Notify the guild master and officers the list changed
if (Guild* guild = sGuildMgr->GetGuildByGuid(guildRequestPair.first))
SendApplicantListUpdate(guild);
auto guildItr = _membershipRequestsByGuild.find(guildRequestPair.first);
if (guildItr == _membershipRequestsByGuild.end())
continue;
guildItr->second.erase(playerId);
if (guildItr->second.empty())
_membershipRequestsByGuild.erase(guildItr);
}
CharacterDatabase.CommitTransaction(trans);
_membershipRequestsByPlayer.erase(playerItr);
}
void GuildFinderMgr::RemoveMembershipRequest(ObjectGuid const& playerId, ObjectGuid const& guildId)
{
auto guildItr = _membershipRequestsByGuild.find(guildId);
if (guildItr != _membershipRequestsByGuild.end())
{
guildItr->second.erase(playerId);
if (guildItr->second.empty())
_membershipRequestsByGuild.erase(guildItr);
}
auto playerItr = _membershipRequestsByPlayer.find(playerId);
if (playerItr != _membershipRequestsByPlayer.end())
{
playerItr->second.erase(guildId);
if (playerItr->second.empty())
_membershipRequestsByPlayer.erase(playerItr);
}
CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_FINDER_APPLICANT);
stmt->setUInt64(0, guildId.GetCounter());
stmt->setUInt64(1, playerId.GetCounter());
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
// Notify the applicant his submittion has been removed
if (Player* player = ObjectAccessor::FindPlayer(playerId))
SendMembershipRequestListUpdate(player);
// Notify the guild master and officers the list changed
if (Guild* guild = sGuildMgr->GetGuildByGuid(guildId))
SendApplicantListUpdate(guild);
}
std::vector<MembershipRequest const*> GuildFinderMgr::GetAllMembershipRequestsForPlayer(ObjectGuid const& playerGuid)
{
std::vector<MembershipRequest const*> resultSet;
auto playerItr = _membershipRequestsByPlayer.find(playerGuid);
if (playerItr == _membershipRequestsByPlayer.end())
return resultSet;
resultSet.reserve(playerItr->second.size());
for (auto const& guildRequestPair : playerItr->second)
resultSet.push_back(&guildRequestPair.second);
return resultSet;
}
uint8 GuildFinderMgr::CountRequestsFromPlayer(ObjectGuid const& playerId)
{
auto playerItr = _membershipRequestsByPlayer.find(playerId);
return playerItr != _membershipRequestsByPlayer.end() ? playerItr->second.size() : 0;
}
std::vector<LFGuildSettings const*> GuildFinderMgr::GetGuildsMatchingSetting(LFGuildPlayer& settings, TeamId faction)
{
std::vector<LFGuildSettings const*> resultSet;
for (LFGuildStore::const_iterator itr = _guildSettings.begin(); itr != _guildSettings.end(); ++itr)
{
LFGuildSettings const& guildSettings = itr->second;
if (!guildSettings.IsListed())
continue;
if (guildSettings.GetTeam() != faction)
continue;
if (!(guildSettings.GetAvailability() & settings.GetAvailability()))
continue;
if (!(guildSettings.GetClassRoles() & settings.GetClassRoles()))
continue;
if (!(guildSettings.GetInterests() & settings.GetInterests()))
continue;
if (!(guildSettings.GetLevel() & settings.GetLevel()))
continue;
resultSet.push_back(&itr->second);
}
return resultSet;
}
bool GuildFinderMgr::HasRequest(ObjectGuid const& playerId, ObjectGuid const& guildId)
{
auto guildItr = _membershipRequestsByGuild.find(guildId);
if (guildItr == _membershipRequestsByGuild.end())
return false;
return guildItr->second.count(playerId) > 0;
}
void GuildFinderMgr::SetGuildSettings(ObjectGuid const& guildGuid, LFGuildSettings const& settings)
{
_guildSettings[guildGuid] = settings;
CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_GUILD_FINDER_GUILD_SETTINGS);
stmt->setUInt64(0, settings.GetGUID().GetCounter());
stmt->setUInt8(1, settings.GetAvailability());
stmt->setUInt8(2, settings.GetClassRoles());
stmt->setUInt8(3, settings.GetInterests());
stmt->setUInt8(4, settings.GetLevel());
stmt->setUInt8(5, settings.IsListed());
stmt->setString(6, settings.GetComment());
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
}
void GuildFinderMgr::DeleteGuild(ObjectGuid const& guildId)
{
CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
auto guildItr = _membershipRequestsByGuild.find(guildId);
if (guildItr != _membershipRequestsByGuild.end())
{
for (auto playerRequestPair : guildItr->second)
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_FINDER_APPLICANT);
stmt->setUInt64(0, guildId.GetCounter());
stmt->setUInt64(1, playerRequestPair.first.GetCounter());
trans->Append(stmt);
auto playerItr = _membershipRequestsByPlayer.find(playerRequestPair.first);
if (playerItr != _membershipRequestsByPlayer.end())
{
playerItr->second.erase(guildId);
if (playerItr->second.empty())
_membershipRequestsByPlayer.erase(playerItr);
}
// Notify the applicant his submition has been removed
if (Player* player = ObjectAccessor::FindPlayer(playerRequestPair.first))
SendMembershipRequestListUpdate(player);
}
}
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_FINDER_GUILD_SETTINGS);
stmt->setUInt64(0, guildId.GetCounter());
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
_membershipRequestsByGuild.erase(guildId);
_guildSettings.erase(guildId);
// Notify the guild master the list changed (even if he's not a GM any more, not sure if needed)
if (Guild* guild = sGuildMgr->GetGuildByGuid(guildId))
SendApplicantListUpdate(guild);
}
void GuildFinderMgr::SendApplicantListUpdate(Guild* guild)
{
WorldPackets::GuildFinder::LFGuildApplicantListChanged applicantListChanged;
guild->BroadcastPacketToRank(applicantListChanged.Write(), GR_OFFICER);
if (Player* player = ObjectAccessor::FindPlayer(guild->GetLeaderGUID()))
player->SendDirectMessage(applicantListChanged.GetRawPacket());
}
void GuildFinderMgr::SendMembershipRequestListUpdate(Player* player)
{
player->SendDirectMessage(WorldPackets::GuildFinder::LFGuildApplicationsListChanged().Write());
}
GuildFinderMgr* GuildFinderMgr::instance()
{
static GuildFinderMgr instance;
return &instance;
}

252
src/server/game/Guilds/GuildFinderMgr.h
View File

@@ -1,252 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __TRINITY_GUILDFINDER_H
#define __TRINITY_GUILDFINDER_H
#include "Common.h"
#include "ObjectGuid.h"
#include "SharedDefines.h"
#include <unordered_map>
class Guild;
class Player;
enum GuildFinderOptionsInterest
{
INTEREST_QUESTING = 0x01,
INTEREST_DUNGEONS = 0x02,
INTEREST_RAIDS = 0x04,
INTEREST_PVP = 0x08,
INTEREST_ROLE_PLAYING = 0x10,
ALL_INTERESTS = INTEREST_QUESTING | INTEREST_DUNGEONS | INTEREST_RAIDS | INTEREST_PVP | INTEREST_ROLE_PLAYING
};
enum GuildFinderOptionsAvailability
{
AVAILABILITY_WEEKDAYS = 0x1,
AVAILABILITY_WEEKENDS = 0x2,
AVAILABILITY_ALWAYS = AVAILABILITY_WEEKDAYS | AVAILABILITY_WEEKENDS
};
enum GuildFinderOptionsRoles
{
GUILDFINDER_ROLE_TANK = 0x1,
GUILDFINDER_ROLE_HEALER = 0x2,
GUILDFINDER_ROLE_DPS = 0x4,
GUILDFINDER_ALL_ROLES = GUILDFINDER_ROLE_TANK | GUILDFINDER_ROLE_HEALER | GUILDFINDER_ROLE_DPS
};
enum GuildFinderOptionsLevel
{
ANY_FINDER_LEVEL = 0x1,
MAX_FINDER_LEVEL = 0x2,
ALL_GUILDFINDER_LEVELS = ANY_FINDER_LEVEL | MAX_FINDER_LEVEL
};
/// Holds all required informations about a membership request
struct MembershipRequest
{
public:
MembershipRequest();
MembershipRequest(ObjectGuid const& playerGUID, ObjectGuid const& guildId, uint32 availability, uint32 classRoles, uint32 interests, std::string comment, time_t submitTime);
ObjectGuid const& GetGuildGuid() const { return _guildId; }
ObjectGuid const& GetPlayerGUID() const { return _playerGUID; }
uint8 GetAvailability() const { return _availability; }
uint8 GetClassRoles() const { return _classRoles; }
uint8 GetInterests() const { return _interests; }
time_t GetSubmitTime() const { return _time; }
time_t GetExpiryTime() const { return time_t(_time + 30 * 24 * 3600); } // Adding 30 days
std::string const& GetComment() const { return _comment; }
private:
std::string _comment;
ObjectGuid _guildId;
ObjectGuid _playerGUID;
uint8 _availability;
uint8 _classRoles;
uint8 _interests;
time_t _time;
};
/// Holds all informations about a player's finder settings. _NOT_ stored in database.
struct LFGuildPlayer
{
public:
LFGuildPlayer()
{
_roles = 0;
_availability = 0;
_interests = 0;
_level = 0;
}
LFGuildPlayer(ObjectGuid const& guid, uint8 role, uint8 availability, uint8 interests, uint8 level)
{
_guid = guid;
_roles = role;
_availability = availability;
_interests = interests;
_level = level;
}
LFGuildPlayer(ObjectGuid const& guid, uint8 role, uint8 availability, uint8 interests, uint8 level, std::string& comment) : _comment(comment)
{
_guid = guid;
_roles = role;
_availability = availability;
_interests = interests;
_level = level;
}
ObjectGuid const& GetGUID() const { return _guid; }
uint8 GetClassRoles() const { return _roles; }
uint8 GetAvailability() const { return _availability; }
uint8 GetInterests() const { return _interests; }
uint8 GetLevel() const { return _level; }
std::string const& GetComment() const { return _comment; }
private:
std::string _comment;
ObjectGuid _guid;
uint8 _roles;
uint8 _availability;
uint8 _interests;
uint8 _level;
};
/// Holds settings for a guild in the finder system. Saved to database.
struct LFGuildSettings : public LFGuildPlayer
{
public:
LFGuildSettings() : LFGuildPlayer(), _listed(false), _team(TEAM_ALLIANCE) {}
LFGuildSettings(bool listed, TeamId team) : LFGuildPlayer(), _listed(listed), _team(team) {}
LFGuildSettings(bool listed, TeamId team, ObjectGuid const& guid, uint8 role, uint8 availability, uint8 interests, uint8 level) :
LFGuildPlayer(guid, role, availability, interests, level), _listed(listed), _team(team) {}
LFGuildSettings(bool listed, TeamId team, ObjectGuid const& guid, uint8 role, uint8 availability, uint8 interests, uint8 level, std::string& comment) :
LFGuildPlayer(guid, role, availability, interests, level, comment), _listed(listed), _team(team) {}
bool IsListed() const { return _listed; }
void SetListed(bool state) { _listed = state; }
TeamId GetTeam() const { return _team; }
private:
bool _listed;
TeamId _team;
};
typedef std::unordered_map<ObjectGuid /* guildGuid */, LFGuildSettings> LFGuildStore;
class GuildFinderMgr
{
private:
GuildFinderMgr();
~GuildFinderMgr();
LFGuildStore _guildSettings;
std::unordered_map<ObjectGuid /*guildGUID*/, std::unordered_map<ObjectGuid /*playerGUID*/, MembershipRequest>> _membershipRequestsByGuild;
std::unordered_map<ObjectGuid /*playerGUID*/, std::unordered_map<ObjectGuid /*guildGUID*/, MembershipRequest>> _membershipRequestsByPlayer;
void LoadGuildSettings();
void LoadMembershipRequests();
public:
void LoadFromDB();
/**
* @brief Stores guild settings and begins an asynchronous database insert
* @param guildGuid The guild's database guid.
* @param LFGuildSettings The guild's settings storage.
*/
void SetGuildSettings(ObjectGuid const& guildGuid, LFGuildSettings const& settings);
/**
* @brief Returns settings for a guild.
* @param guildGuid The guild's database guid.
*/
LFGuildSettings const& GetGuildSettings(ObjectGuid const& guildGuid) { return _guildSettings[guildGuid]; }
/**
* @brief Files a membership request to a guild
* @param guildGuid The guild's database GUID.
* @param MembershipRequest An object storing all data related to the request.
*/
void AddMembershipRequest(ObjectGuid const& guildGuid, MembershipRequest const& request);
/**
* @brief Removes all membership request from a player.
* @param playerId The player's database guid whose application shall be deleted.
*/
void RemoveAllMembershipRequestsFromPlayer(ObjectGuid const& playerId);
/**
* @brief Removes a membership request to a guild.
* @param playerId The player's database guid whose application shall be deleted.
* @param guildId The guild's database guid
*/
void RemoveMembershipRequest(ObjectGuid const& playerId, ObjectGuid const& guildId);
/// Wipes everything related to a guild. Used when that guild is disbanded
void DeleteGuild(ObjectGuid const& guildId);
/**
* @brief Returns a set of membership requests for a guild
* @param guildGuid The guild's database guid.
*/
std::unordered_map<ObjectGuid, MembershipRequest> const* GetAllMembershipRequestsForGuild(ObjectGuid const& guildGuid)
{
auto itr = _membershipRequestsByGuild.find(guildGuid);
return itr != _membershipRequestsByGuild.end() ? &itr->second : nullptr;
}
/**
* @brief Returns a list of membership requests for a player.
* @param playerGuid The player's database guid.
*/
std::vector<MembershipRequest const*> GetAllMembershipRequestsForPlayer(ObjectGuid const& playerGuid);
/**
* @brief Returns a store of guilds matching the settings provided, using bitmask operators.
* @param settings The player's finder settings
* @param teamId The player's faction (TEAM_ALLIANCE or TEAM_HORDE)
*/
std::vector<LFGuildSettings const*> GetGuildsMatchingSetting(LFGuildPlayer& settings, TeamId faction);
/// Provided a player guid and a guild guid, determines if a pending request is filed with these keys.
bool HasRequest(ObjectGuid const& playerId, ObjectGuid const& guildId);
/// Counts the amount of pending membership requests, given the player's db guid.
uint8 CountRequestsFromPlayer(ObjectGuid const& playerId);
static void SendApplicantListUpdate(Guild* guild);
static void SendMembershipRequestListUpdate(Player* player);
static GuildFinderMgr* instance();
};
#define sGuildFinderMgr GuildFinderMgr::instance()
#endif // __TRINITY_GUILDFINDER_H

2
src/server/game/Handlers/CharacterHandler.cpp
View File

@@ -40,7 +40,6 @@
#include "GitRevision.h"
#include "Group.h"
#include "Guild.h"
#include "GuildFinderMgr.h"
#include "GuildMgr.h"
#include "Item.h"
#include "Language.h"
@@ -963,7 +962,6 @@ void WorldSession::HandleCharDeleteOpcode(WorldPackets::Character::CharDelete& c
sLog->outCharDump(dump.c_str(), accountId, charDelete.Guid.GetCounter(), name.c_str());
}
sGuildFinderMgr->RemoveAllMembershipRequestsFromPlayer(charDelete.Guid);
sCalendarMgr->RemoveAllPlayerEventsAndInvites(charDelete.Guid);
Player::DeleteFromDB(charDelete.Guid, accountId);

240
src/server/game/Handlers/GuildFinderHandler.cpp
View File

@@ -1,240 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "CharacterCache.h"
#include "WorldSession.h"
#include "GameTime.h"
#include "Guild.h"
#include "GuildFinderMgr.h"
#include "GuildFinderPackets.h"
#include "GuildMgr.h"
#include "Object.h"
#include "Player.h"
#include "SharedDefines.h"
#include "World.h"
#include "WorldPacket.h"
void WorldSession::HandleGuildFinderAddRecruit(WorldPackets::GuildFinder::LFGuildAddRecruit& lfGuildAddRecruit)
{
if (sGuildFinderMgr->CountRequestsFromPlayer(GetPlayer()->GetGUID()) >= 10)
return;
if (!lfGuildAddRecruit.GuildGUID.IsGuild())
return;
if (!(lfGuildAddRecruit.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildAddRecruit.ClassRoles > GUILDFINDER_ALL_ROLES)
return;
if (!(lfGuildAddRecruit.Availability & AVAILABILITY_ALWAYS) || lfGuildAddRecruit.Availability > AVAILABILITY_ALWAYS)
return;
if (!(lfGuildAddRecruit.PlayStyle & ALL_INTERESTS) || lfGuildAddRecruit.PlayStyle > ALL_INTERESTS)
return;
MembershipRequest request = MembershipRequest(GetPlayer()->GetGUID(), lfGuildAddRecruit.GuildGUID, lfGuildAddRecruit.Availability,
lfGuildAddRecruit.ClassRoles, lfGuildAddRecruit.PlayStyle, lfGuildAddRecruit.Comment, GameTime::GetGameTime());
sGuildFinderMgr->AddMembershipRequest(lfGuildAddRecruit.GuildGUID, request);
}
void WorldSession::HandleGuildFinderBrowse(WorldPackets::GuildFinder::LFGuildBrowse& lfGuildBrowse)
{
if (!(lfGuildBrowse.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildBrowse.ClassRoles > GUILDFINDER_ALL_ROLES)
return;
if (!(lfGuildBrowse.Availability & AVAILABILITY_ALWAYS) || lfGuildBrowse.Availability > AVAILABILITY_ALWAYS)
return;
if (!(lfGuildBrowse.PlayStyle & ALL_INTERESTS) || lfGuildBrowse.PlayStyle > ALL_INTERESTS)
return;
if (lfGuildBrowse.CharacterLevel > int32(sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL)) || lfGuildBrowse.CharacterLevel < 1)
return;
Player* player = GetPlayer();
LFGuildPlayer settings(player->GetGUID(), lfGuildBrowse.ClassRoles, lfGuildBrowse.Availability, lfGuildBrowse.PlayStyle, ANY_FINDER_LEVEL);
std::vector<LFGuildSettings const*> guildList = sGuildFinderMgr->GetGuildsMatchingSetting(settings, player->GetTeamId());
WorldPackets::GuildFinder::LFGuildBrowseResult lfGuildBrowseResult;
lfGuildBrowseResult.Post.resize(guildList.size());
for (std::size_t i = 0; i < guildList.size(); ++i)
{
LFGuildSettings const* guildSettings = guildList[i];
WorldPackets::GuildFinder::LFGuildBrowseData& guildData = lfGuildBrowseResult.Post[i];
Guild* guild = ASSERT_NOTNULL(sGuildMgr->GetGuildByGuid(guildSettings->GetGUID()));
guildData.GuildName = guild->GetName();
guildData.GuildGUID = guild->GetGUID();
guildData.GuildVirtualRealm = GetVirtualRealmAddress();
guildData.GuildMembers = guild->GetMembersCount();
guildData.GuildAchievementPoints = guild->GetAchievementMgr().GetAchievementPoints();
guildData.PlayStyle = guildSettings->GetInterests();
guildData.Availability = guildSettings->GetAvailability();
guildData.ClassRoles = guildSettings->GetClassRoles();
guildData.LevelRange = guildSettings->GetLevel();
guildData.EmblemStyle = guild->GetEmblemInfo().GetStyle();
guildData.EmblemColor = guild->GetEmblemInfo().GetColor();
guildData.BorderStyle = guild->GetEmblemInfo().GetBorderStyle();
guildData.BorderColor = guild->GetEmblemInfo().GetBorderColor();
guildData.Background = guild->GetEmblemInfo().GetBackgroundColor();
guildData.Comment = guildSettings->GetComment();
guildData.Cached = 0;
guildData.MembershipRequested = sGuildFinderMgr->HasRequest(player->GetGUID(), guild->GetGUID());
}
player->SendDirectMessage(lfGuildBrowseResult.Write());
}
void WorldSession::HandleGuildFinderDeclineRecruit(WorldPackets::GuildFinder::LFGuildDeclineRecruit& lfGuildDeclineRecruit)
{
if (!GetPlayer()->GetGuild())
return;
if (!lfGuildDeclineRecruit.RecruitGUID.IsPlayer())
return;
sGuildFinderMgr->RemoveMembershipRequest(lfGuildDeclineRecruit.RecruitGUID, GetPlayer()->GetGuild()->GetGUID());
}
void WorldSession::HandleGuildFinderGetApplications(WorldPackets::GuildFinder::LFGuildGetApplications& /*lfGuildGetApplications*/)
{
std::vector<MembershipRequest const*> applicatedGuilds = sGuildFinderMgr->GetAllMembershipRequestsForPlayer(GetPlayer()->GetGUID());
WorldPackets::GuildFinder::LFGuildApplications lfGuildApplications;
lfGuildApplications.Application.resize(applicatedGuilds.size());
lfGuildApplications.NumRemaining = 10 - sGuildFinderMgr->CountRequestsFromPlayer(GetPlayer()->GetGUID());
for (std::size_t i = 0; i < applicatedGuilds.size(); ++i)
{
MembershipRequest const* application = applicatedGuilds[i];
WorldPackets::GuildFinder::LFGuildApplicationData& applicationData = lfGuildApplications.Application[i];
Guild* guild = ASSERT_NOTNULL(sGuildMgr->GetGuildByGuid(application->GetGuildGuid()));
LFGuildSettings const& guildSettings = sGuildFinderMgr->GetGuildSettings(application->GetGuildGuid());
applicationData.GuildGUID = application->GetGuildGuid();
applicationData.GuildVirtualRealm = GetVirtualRealmAddress();
applicationData.GuildName = guild->GetName();
applicationData.ClassRoles = guildSettings.GetClassRoles();
applicationData.PlayStyle = guildSettings.GetInterests();
applicationData.Availability = guildSettings.GetAvailability();
applicationData.SecondsSinceCreated = GameTime::GetGameTime() - application->GetSubmitTime();
applicationData.SecondsUntilExpiration = application->GetExpiryTime() - GameTime::GetGameTime();
applicationData.Comment = application->GetComment();
}
GetPlayer()->SendDirectMessage(lfGuildApplications.Write());
}
void WorldSession::HandleGuildFinderGetGuildPost(WorldPackets::GuildFinder::LFGuildGetGuildPost& /*lfGuildGetGuildPost*/)
{
Player* player = GetPlayer();
Guild* guild = player->GetGuild();
if (!guild) // Player must be in guild
return;
WorldPackets::GuildFinder::LFGuildPost lfGuildPost;
if (guild->GetLeaderGUID() == player->GetGUID())
{
LFGuildSettings const& settings = sGuildFinderMgr->GetGuildSettings(guild->GetGUID());
lfGuildPost.Post = boost::in_place();
lfGuildPost.Post->Active = settings.IsListed();
lfGuildPost.Post->PlayStyle = settings.GetInterests();
lfGuildPost.Post->Availability = settings.GetAvailability();
lfGuildPost.Post->ClassRoles = settings.GetClassRoles();
lfGuildPost.Post->LevelRange = settings.GetLevel();
lfGuildPost.Post->Comment = settings.GetComment();
}
player->SendDirectMessage(lfGuildPost.Write());
}
// Lists all recruits for a guild - Misses times
void WorldSession::HandleGuildFinderGetRecruits(WorldPackets::GuildFinder::LFGuildGetRecruits& /*lfGuildGetRecruits*/)
{
Player* player = GetPlayer();
Guild* guild = player->GetGuild();
if (!guild)
return;
time_t now = GameTime::GetGameTime();
WorldPackets::GuildFinder::LFGuildRecruits lfGuildRecruits;
lfGuildRecruits.UpdateTime = now;
if (std::unordered_map<ObjectGuid, MembershipRequest> const* recruitsList = sGuildFinderMgr->GetAllMembershipRequestsForGuild(guild->GetGUID()))
{
lfGuildRecruits.Recruits.resize(recruitsList->size());
std::size_t i = 0;
for (auto const& recruitRequestPair : *recruitsList)
{
WorldPackets::GuildFinder::LFGuildRecruitData& recruitData = lfGuildRecruits.Recruits[i++];
recruitData.RecruitGUID = recruitRequestPair.first;
recruitData.RecruitVirtualRealm = GetVirtualRealmAddress();
recruitData.Comment = recruitRequestPair.second.GetComment();
recruitData.ClassRoles = recruitRequestPair.second.GetClassRoles();
recruitData.PlayStyle = recruitRequestPair.second.GetInterests();
recruitData.Availability = recruitRequestPair.second.GetAvailability();
recruitData.SecondsSinceCreated = now - recruitRequestPair.second.GetSubmitTime();
recruitData.SecondsUntilExpiration = recruitRequestPair.second.GetExpiryTime() - now;
if (CharacterCacheEntry const* charInfo = sCharacterCache->GetCharacterCacheByGuid(recruitRequestPair.first))
{
recruitData.Name = charInfo->Name;
recruitData.CharacterClass = charInfo->Class;
recruitData.CharacterGender = charInfo->Sex;
recruitData.CharacterLevel = charInfo->Level;
}
}
}
player->SendDirectMessage(lfGuildRecruits.Write());
}
void WorldSession::HandleGuildFinderRemoveRecruit(WorldPackets::GuildFinder::LFGuildRemoveRecruit& lfGuildRemoveRecruit)
{
if (!lfGuildRemoveRecruit.GuildGUID.IsGuild())
return;
sGuildFinderMgr->RemoveMembershipRequest(GetPlayer()->GetGUID(), lfGuildRemoveRecruit.GuildGUID);
}
// Sent any time a guild master sets an option in the interface and when listing / unlisting his guild
void WorldSession::HandleGuildFinderSetGuildPost(WorldPackets::GuildFinder::LFGuildSetGuildPost& lfGuildSetGuildPost)
{
// Level sent is zero if untouched, force to any (from interface). Idk why
if (!lfGuildSetGuildPost.LevelRange)
lfGuildSetGuildPost.LevelRange = ANY_FINDER_LEVEL;
if (!(lfGuildSetGuildPost.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildSetGuildPost.ClassRoles > GUILDFINDER_ALL_ROLES)
return;
if (!(lfGuildSetGuildPost.Availability & AVAILABILITY_ALWAYS) || lfGuildSetGuildPost.Availability > AVAILABILITY_ALWAYS)
return;
if (!(lfGuildSetGuildPost.PlayStyle & ALL_INTERESTS) || lfGuildSetGuildPost.PlayStyle > ALL_INTERESTS)
return;
if (!(lfGuildSetGuildPost.LevelRange & ALL_GUILDFINDER_LEVELS) || lfGuildSetGuildPost.LevelRange > ALL_GUILDFINDER_LEVELS)
return;
Player* player = GetPlayer();
if (!player->GetGuildId()) // Player must be in guild
return;
Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId());
if (!guild)
return;
// Player must be guild master
if (guild->GetLeaderGUID() != player->GetGUID())
return;
LFGuildSettings settings(lfGuildSetGuildPost.Active, player->GetTeamId(), guild->GetGUID(), lfGuildSetGuildPost.ClassRoles,
lfGuildSetGuildPost.Availability, lfGuildSetGuildPost.PlayStyle, lfGuildSetGuildPost.LevelRange, lfGuildSetGuildPost.Comment);
sGuildFinderMgr->SetGuildSettings(guild->GetGUID(), settings);
}

1
src/server/game/Server/Packets/AllPackets.h
View File

@@ -46,7 +46,6 @@
#include "EquipmentSetPackets.h"
#include "GameObjectPackets.h"
#include "GarrisonPackets.h"
#include "GuildFinderPackets.h"
#include "GuildPackets.h"
#include "HotfixPackets.h"
#include "InspectPackets.h"

174
src/server/game/Server/Packets/GuildFinderPackets.cpp
View File

@@ -1,174 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "GuildFinderPackets.h"
#include "PacketUtilities.h"
void WorldPackets::GuildFinder::LFGuildAddRecruit::Read()
{
_worldPacket >> GuildGUID;
_worldPacket >> PlayStyle;
_worldPacket >> Availability;
_worldPacket >> ClassRoles;
Comment = _worldPacket.ReadString(_worldPacket.ReadBits(10));
}
void WorldPackets::GuildFinder::LFGuildBrowse::Read()
{
_worldPacket >> PlayStyle;
_worldPacket >> Availability;
_worldPacket >> ClassRoles;
_worldPacket >> CharacterLevel;
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildBrowseData const& guildData)
{
data.WriteBits(guildData.GuildName.length(), 7);
data.WriteBits(guildData.Comment.length(), 10);
data << guildData.GuildGUID;
data << uint32(guildData.GuildVirtualRealm);
data << int32(guildData.GuildMembers);
data << int32(guildData.GuildAchievementPoints);
data << int32(guildData.PlayStyle);
data << int32(guildData.Availability);
data << int32(guildData.ClassRoles);
data << int32(guildData.LevelRange);
data << int32(guildData.EmblemStyle);
data << int32(guildData.EmblemColor);
data << int32(guildData.BorderStyle);
data << int32(guildData.BorderColor);
data << int32(guildData.Background);
data << int8(guildData.Cached);
data << int8(guildData.MembershipRequested);
data.WriteString(guildData.GuildName);
data.WriteString(guildData.Comment);
return data;
}
WorldPacket const* WorldPackets::GuildFinder::LFGuildBrowseResult::Write()
{
_worldPacket << uint32(Post.size());
for (LFGuildBrowseData const& guildData : Post)
_worldPacket << guildData;
return &_worldPacket;
}
void WorldPackets::GuildFinder::LFGuildDeclineRecruit::Read()
{
_worldPacket >> RecruitGUID;
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildApplicationData const& application)
{
data << application.GuildGUID;
data << uint32(application.GuildVirtualRealm);
data << int32(application.ClassRoles);
data << int32(application.PlayStyle);
data << int32(application.Availability);
data << uint32(application.SecondsSinceCreated);
data << uint32(application.SecondsUntilExpiration);
data.WriteBits(application.GuildName.length(), 7);
data.WriteBits(application.Comment.length(), 10);
data.FlushBits();
data.WriteString(application.GuildName);
data.WriteString(application.Comment);
return data;
}
WorldPacket const* WorldPackets::GuildFinder::LFGuildApplications::Write()
{
_worldPacket << int32(NumRemaining);
_worldPacket << uint32(Application.size());
for (LFGuildApplicationData const& application : Application)
_worldPacket << application;
return &_worldPacket;
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::GuildPostData const& post)
{
data.WriteBit(post.Active);
data.WriteBits(post.Comment.length(), 10);
data << int32(post.PlayStyle);
data << int32(post.Availability);
data << int32(post.ClassRoles);
data << int32(post.LevelRange);
data << post.SecondsRemaining;
data.WriteString(post.Comment);
return data;
}
WorldPacket const* WorldPackets::GuildFinder::LFGuildPost::Write()
{
_worldPacket.WriteBit(Post.is_initialized());
_worldPacket.FlushBits();
if (Post)
_worldPacket << *Post;
return &_worldPacket;
}
void WorldPackets::GuildFinder::LFGuildGetRecruits::Read()
{
_worldPacket >> LastUpdate;
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildRecruitData const& recruit)
{
data << recruit.RecruitGUID;
data << uint32(recruit.RecruitVirtualRealm);
data << int32(recruit.CharacterClass);
data << int32(recruit.CharacterGender);
data << int32(recruit.CharacterLevel);
data << int32(recruit.ClassRoles);
data << int32(recruit.PlayStyle);
data << int32(recruit.Availability);
data << uint32(recruit.SecondsSinceCreated);
data << uint32(recruit.SecondsUntilExpiration);
data.WriteBits(recruit.Name.length(), 6);
data.WriteBits(recruit.Comment.length(), 10);
data.FlushBits();
data.WriteString(recruit.Name);
data.WriteString(recruit.Comment);
return data;
}
WorldPacket const* WorldPackets::GuildFinder::LFGuildRecruits::Write()
{
_worldPacket << uint32(Recruits.size());
_worldPacket << UpdateTime;
for (LFGuildRecruitData const& recruit : Recruits)
_worldPacket << recruit;
return &_worldPacket;
}
void WorldPackets::GuildFinder::LFGuildRemoveRecruit::Read()
{
_worldPacket >> GuildGUID;
}
void WorldPackets::GuildFinder::LFGuildSetGuildPost::Read()
{
_worldPacket >> PlayStyle;
_worldPacket >> Availability;
_worldPacket >> ClassRoles;
_worldPacket >> LevelRange;
Active = _worldPacket.ReadBit();
Comment = _worldPacket.ReadString(_worldPacket.ReadBits(10));
}

239
src/server/game/Server/Packets/GuildFinderPackets.h
View File

@@ -1,239 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GuildFinderPackets_h__
#define GuildFinderPackets_h__
#include "Packet.h"
#include "ObjectGuid.h"
#include "Optional.h"
#include "PacketUtilities.h"
namespace WorldPackets
{
namespace GuildFinder
{
class LFGuildAddRecruit final : public ClientPacket
{
public:
LFGuildAddRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_ADD_RECRUIT, std::move(packet)) { }
void Read() override;
ObjectGuid GuildGUID;
int32 Availability = 0;
int32 ClassRoles = 0;
int32 PlayStyle = 0;
std::string Comment;
};
class LFGuildApplicationsListChanged final : public ServerPacket
{
public:
LFGuildApplicationsListChanged() : ServerPacket(SMSG_LF_GUILD_APPLICATIONS_LIST_CHANGED, 0) { }
WorldPacket const* Write() override { return &_worldPacket; }
};
class LFGuildApplicantListChanged final : public ServerPacket
{
public:
LFGuildApplicantListChanged() : ServerPacket(SMSG_LF_GUILD_APPLICANT_LIST_CHANGED, 0) { }
WorldPacket const* Write() override { return &_worldPacket; }
};
class LFGuildBrowse final : public ClientPacket
{
public:
LFGuildBrowse(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_BROWSE, std::move(packet)) { }
void Read() override;
int32 CharacterLevel = 0;
int32 Availability = 0;
int32 ClassRoles = 0;
int32 PlayStyle = 0;
};
struct LFGuildBrowseData
{
std::string GuildName;
ObjectGuid GuildGUID;
uint32 GuildVirtualRealm = 0;
int32 GuildMembers = 0;
int32 GuildAchievementPoints = 0;
int32 PlayStyle = 0;
int32 Availability = 0;
int32 ClassRoles = 0;
int32 LevelRange = 0;
int32 EmblemStyle = 0;
int32 EmblemColor = 0;
int32 BorderStyle = 0;
int32 BorderColor = 0;
int32 Background = 0;
std::string Comment;
int8 Cached = 0;
int8 MembershipRequested = 0;
};
class LFGuildBrowseResult final : public ServerPacket
{
public:
LFGuildBrowseResult() : ServerPacket(SMSG_LF_GUILD_BROWSE) { }
WorldPacket const* Write() override;
std::vector<LFGuildBrowseData> Post;
};
class LFGuildDeclineRecruit final : public ClientPacket
{
public:
LFGuildDeclineRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_DECLINE_RECRUIT, std::move(packet)) { }
void Read() override;
ObjectGuid RecruitGUID;
};
class LFGuildGetApplications final : public ClientPacket
{
public:
LFGuildGetApplications(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_APPLICATIONS, std::move(packet)) { }
void Read() override { }
};
struct LFGuildApplicationData
{
ObjectGuid GuildGUID;
uint32 GuildVirtualRealm = 0;
std::string GuildName;
int32 ClassRoles = 0;
int32 PlayStyle = 0;
int32 Availability = 0;
uint32 SecondsSinceCreated = 0;
uint32 SecondsUntilExpiration = 0;
std::string Comment;
};
class LFGuildApplications final : public ServerPacket
{
public:
LFGuildApplications() : ServerPacket(SMSG_LF_GUILD_APPLICATIONS) { }
WorldPacket const* Write() override;
std::vector<LFGuildApplicationData> Application;
int32 NumRemaining = 0;
};
class LFGuildGetGuildPost final : public ClientPacket
{
public:
LFGuildGetGuildPost(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_GUILD_POST, std::move(packet)) { }
void Read() override { }
};
struct GuildPostData
{
bool Active = false;
int32 PlayStyle = 0;
int32 Availability = 0;
int32 ClassRoles = 0;
int32 LevelRange = 0;
Duration<Seconds> SecondsRemaining;
std::string Comment;
};
class LFGuildPost final : public ServerPacket
{
public:
LFGuildPost() : ServerPacket(SMSG_LF_GUILD_POST, 1 + 1 + 4 + 4 + 4 + 4 + 4 + 255) { }
WorldPacket const* Write() override;
Optional<GuildPostData> Post;
};
class LFGuildGetRecruits final : public ClientPacket
{
public:
LFGuildGetRecruits(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_RECRUITS, std::move(packet)) { }
void Read() override;
Timestamp<> LastUpdate;
};
struct LFGuildRecruitData
{
ObjectGuid RecruitGUID;
std::string Name;
uint32 RecruitVirtualRealm = 0;
std::string Comment;
int32 CharacterClass = 0;
int32 CharacterGender = 0;
int32 CharacterLevel = 0;
int32 ClassRoles = 0;
int32 PlayStyle = 0;
int32 Availability = 0;
uint32 SecondsSinceCreated = 0;
uint32 SecondsUntilExpiration = 0;
};
class LFGuildRecruits final : public ServerPacket
{
public:
LFGuildRecruits() : ServerPacket(SMSG_LF_GUILD_RECRUITS) { }
WorldPacket const* Write() override;
std::vector<LFGuildRecruitData> Recruits;
Timestamp<> UpdateTime;
};
class LFGuildRemoveRecruit final : public ClientPacket
{
public:
LFGuildRemoveRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_REMOVE_RECRUIT, std::move(packet)) { }
void Read() override;
ObjectGuid GuildGUID;
};
class LFGuildSetGuildPost final : public ClientPacket
{
public:
LFGuildSetGuildPost(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_SET_GUILD_POST, std::move(packet)) { }
void Read() override;
int32 Availability = 0;
int32 PlayStyle = 0;
int32 ClassRoles = 0;
int32 LevelRange = 0;
bool Active = false;
std::string Comment;
};
}
}
#endif // GuildFinderPackets_h__

15
src/server/game/Server/Protocol/Opcodes.cpp
View File

@@ -514,14 +514,6 @@ void OpcodeTable::Initialize()
DEFINE_HANDLER(CMSG_LFG_LIST_LEAVE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
DEFINE_HANDLER(CMSG_LFG_LIST_SEARCH, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
DEFINE_HANDLER(CMSG_LFG_LIST_UPDATE_REQUEST, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
DEFINE_HANDLER(CMSG_LF_GUILD_ADD_RECRUIT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderAddRecruit);
DEFINE_HANDLER(CMSG_LF_GUILD_BROWSE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderBrowse);
DEFINE_HANDLER(CMSG_LF_GUILD_DECLINE_RECRUIT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderDeclineRecruit);
DEFINE_HANDLER(CMSG_LF_GUILD_GET_APPLICATIONS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderGetApplications);
DEFINE_HANDLER(CMSG_LF_GUILD_GET_GUILD_POST, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderGetGuildPost);
DEFINE_HANDLER(CMSG_LF_GUILD_GET_RECRUITS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderGetRecruits);
DEFINE_HANDLER(CMSG_LF_GUILD_REMOVE_RECRUIT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderRemoveRecruit);
DEFINE_HANDLER(CMSG_LF_GUILD_SET_GUILD_POST, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderSetGuildPost);
DEFINE_HANDLER(CMSG_LIST_INVENTORY, STATUS_LOGGEDIN, PROCESS_INPLACE, &WorldSession::HandleListInventoryOpcode);
DEFINE_HANDLER(CMSG_LIVE_REGION_ACCOUNT_RESTORE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
DEFINE_HANDLER(CMSG_LIVE_REGION_CHARACTER_COPY, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
@@ -1508,13 +1500,6 @@ void OpcodeTable::Initialize()
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_SLOT_INVALID, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_TELEPORT_DENIED, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_UPDATE_STATUS, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICANT_LIST_CHANGED, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICATIONS, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICATIONS_LIST_CHANGED, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_BROWSE, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_COMMAND_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_POST, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_RECRUITS, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_CHARACTER_COPY_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);

21
src/server/game/Server/WorldSession.h
View File

@@ -392,18 +392,6 @@ namespace WorldPackets
class GuildSetAchievementTracking;
}
namespace GuildFinder
{
class LFGuildAddRecruit;
class LFGuildBrowse;
class LFGuildDeclineRecruit;
class LFGuildGetApplications;
class LFGuildGetGuildPost;
class LFGuildGetRecruits;
class LFGuildRemoveRecruit;
class LFGuildSetGuildPost;
}
namespace Hotfix
{
class DBQueryBulk;
@@ -1360,15 +1348,6 @@ class TC_GAME_API WorldSession
void HandleGuildChallengeUpdateRequest(WorldPackets::Guild::GuildChallengeUpdateRequest& packet);
void HandleDeclineGuildInvites(WorldPackets::Guild::DeclineGuildInvites& packet);
void HandleGuildFinderAddRecruit(WorldPackets::GuildFinder::LFGuildAddRecruit& lfGuildAddRecruit);
void HandleGuildFinderBrowse(WorldPackets::GuildFinder::LFGuildBrowse& lfGuildBrowse);
void HandleGuildFinderDeclineRecruit(WorldPackets::GuildFinder::LFGuildDeclineRecruit& lfGuildDeclineRecruit);
void HandleGuildFinderGetApplications(WorldPackets::GuildFinder::LFGuildGetApplications& lfGuildGetApplications);
void HandleGuildFinderGetGuildPost(WorldPackets::GuildFinder::LFGuildGetGuildPost& lfGuildGetGuildPost);
void HandleGuildFinderGetRecruits(WorldPackets::GuildFinder::LFGuildGetRecruits& lfGuildGetRecruits);
void HandleGuildFinderRemoveRecruit(WorldPackets::GuildFinder::LFGuildRemoveRecruit& lfGuildRemoveRecruit);
void HandleGuildFinderSetGuildPost(WorldPackets::GuildFinder::LFGuildSetGuildPost& lfGuildSetGuildPost);
void HandleEnableTaxiNodeOpcode(WorldPackets::Taxi::EnableTaxiNode& enableTaxiNode);
void HandleTaxiNodeStatusQueryOpcode(WorldPackets::Taxi::TaxiNodeStatusQuery& taxiNodeStatusQuery);
void HandleTaxiQueryAvailableNodesOpcode(WorldPackets::Taxi::TaxiQueryAvailableNodes& taxiQueryAvailableNodes);

3
src/server/game/World/World.cpp
View File

@@ -55,7 +55,6 @@
#include "GitRevision.h"
#include "GridNotifiersImpl.h"
#include "GroupMgr.h"
#include "GuildFinderMgr.h"
#include "GuildMgr.h"
#include "InstanceSaveMgr.h"
#include "IPLocation.h"
@@ -2123,8 +2122,6 @@ void World::SetInitialWorldSettings()
TC_LOG_INFO("server.loading", "Loading Guilds...");
sGuildMgr->LoadGuilds();
sGuildFinderMgr->LoadFromDB();
TC_LOG_INFO("server.loading", "Loading ArenaTeams...");
sArenaTeamMgr->LoadArenaTeams();