Nico/Viano-Core
1
0 Fork 0
Code Issues Pull Requests Actions 8 Packages Projects Releases Wiki Activity

Core/Guilds: updated guild challenge system

Browse Source 
* converted guild challenge packets to packet class
* moved guild challenge reward data to database
This commit is contained in:
Ovahlord committed 2019-10-14 00:56:48 +02:00
1 parent 52afc1e171
commit 8d29de88a2
14 files changed
+197 -181
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

sql/updates/world/custom/custom_2019_10_14_00_world.sql
+16
View File
@@ -0,0 +1,16 @@
DROP TABLE IF EXISTS `guild_challenges`;
CREATE TABLE `guild_challenges`
(
`ChallengeType` MEDIUMINT(1) UNSIGNED NOT NULL DEFAULT 0,
`ChallengeCount` MEDIUMINT(5) UNSIGNED DEFAULT 1,
`Experience` MEDIUMINT(10) UNSIGNED DEFAULT 0,
`Gold` MEDIUMINT(10) UNSIGNED DEFAULT 0,
`GoldMaxLevel` MEDIUMINT(10) UNSIGNED DEFAULT 0,
PRIMARY KEY (`ChallengeType`)
);
INSERT INTO `guild_challenges` (`ChallengeType`, `ChallengeCount`, `Experience`, `Gold`, `GoldMaxLevel`) VALUES
(0, 0, 0, 0, 0),
(1, 7, 300000, 125, 250),
(2, 1, 3000000, 500, 1000),
(3, 3, 1500000, 250, 500);
src/server/game/Guilds/Guild.cpp
+48 -74
View File
@@ -1403,8 +1403,7 @@ Guild::Guild():
memset(&m_bankEventLog, 0, (GUILD_BANK_MAX_TABS + 1) * sizeof(LogHolder*));
m_achievementMgr = new AchievementMgr<Guild>(this);
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPE; i++)
_currChallengeCount[i] = 0;
InitializeGuildChallengeRewards();
}
Guild::~Guild()
@@ -1456,8 +1455,7 @@ bool Guild::Create(Player* pLeader, std::string const& name)
_todayExperience = 0;
_CreateLogHolders();
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPE; i++)
_currChallengeCount[i] = 0;
InitializeGuildChallengeRewards();
TC_LOG_DEBUG("guild", "GUILD: creating guild [%s] for leader %s (%u)",
name.c_str(), pLeader->GetName().c_str(), m_leaderGuid.GetCounter());
@@ -2422,34 +2420,18 @@ void Guild::HandleGuildPartyRequest(WorldSession* session)
void Guild::HandleGuildRequestChallengeUpdate(WorldSession* session)
{
WorldPacket data(SMSG_GUILD_CHALLENGE_UPDATED, 80);
WorldPackets::Guild::GuildChallengeUpdate update;
data << uint32(0);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_XP));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_XP));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_XP));
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
{
update.CurrentCount[i] = _currChallengeCount[i];
update.MaxCount[i] = _maxChallengeCount[i];
update.Gold[i] = _challengeGold[i];
update.MaxLevelGold[i] = _challengeGoldMaxLevel[i];
update.Xp[i] = _challengeXp[i];
}
data << uint32(0);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_GOLD) * 2);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_GOLD) * 2);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_GOLD) * 2);
data << uint32(0);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_NEEDED));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_NEEDED));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_NEEDED));
data << uint32(0);
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_GOLD));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_GOLD));
data << uint32(sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_GOLD));
data << uint32(0);
data << uint32(_currChallengeCount[GUILD_CHALLENGE_TYPE_DUNGEON]);
data << uint32(_currChallengeCount[GUILD_CHALLENGE_TYPE_RAID]);
data << uint32(_currChallengeCount[GUILD_CHALLENGE_TYPE_RATED_BG]);
session->SendPacket(&data);
session->SendPacket(update.Write());
}
void Guild::SendEventLog(WorldSession* session) const
@@ -3905,51 +3887,22 @@ void Guild::SendGuildRanksUpdate(ObjectGuid setterGuid, ObjectGuid targetGuid, u
void Guild::CompleteChallenge(uint8 challengeType, Player* source)
{
/*
source is used to complete guild level achievement (UpdateAchievementCriteria need a player)
*/
uint32 countNeeded = 0;
uint32 gold = 0;
uint32 xp = 0;
switch (challengeType)
{
case GUILD_CHALLENGE_TYPE_DUNGEON:
gold = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_GOLD);
xp = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_XP);
countNeeded = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_DUNGEON_NEEDED);
break;
case GUILD_CHALLENGE_TYPE_RAID:
gold = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_GOLD);
xp = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_XP);
countNeeded = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RAID_NEEDED);
break;
case GUILD_CHALLENGE_TYPE_RATED_BG:
gold = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_GOLD);
xp = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_XP);
countNeeded = sWorld->getIntConfig(CONFIG_GUILD_CHALLENGE_RATEDBG_NEEDED);
break;
default:
return;
}
if (_currChallengeCount[challengeType] >= countNeeded)
if (_currChallengeCount[challengeType] >= _maxChallengeCount[challengeType])
return;
_currChallengeCount[challengeType] += 1;
_currChallengeCount[challengeType]++;
uint32 gold = GetLevel() >= sWorld->getIntConfig(CONFIG_GUILD_MAX_LEVEL) ? _challengeGoldMaxLevel[challengeType] : _challengeGold[challengeType];
uint32 xp = GetLevel() >= sWorld->getIntConfig(CONFIG_GUILD_MAX_LEVEL) ? _challengeXp[challengeType] : 0;
if (GetLevel() >= sWorld->getIntConfig(CONFIG_GUILD_MAX_LEVEL))
gold *= 2;
WorldPackets::Guild::GuildChallengeCompleted completed;
// Send notification
WorldPacket data(SMSG_GUILD_CHALLENGE_COMPLETED, 20);
data << uint32(challengeType);
data << gold;
data << uint32(_currChallengeCount[challengeType]);
data << xp;
data << countNeeded;
BroadcastPacket(&data);
completed.ChallengeType = challengeType;
completed.GoldAwarded = gold;
completed.CurrentCount = _currChallengeCount[challengeType];
completed.XpAwarded = xp;
completed.MaxCount = _maxChallengeCount[challengeType];
BroadcastPacket(completed.Write());
UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE_TYPE, challengeType, 0, 0, nullptr, source);
UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_GUILD_CHALLENGE, 0, 0, 0, nullptr, source);
@@ -3959,7 +3912,7 @@ void Guild::CompleteChallenge(uint8 challengeType, Player* source)
SaveToDB(); // Save xp
SQLTransaction trans = CharacterDatabase.BeginTransaction();
_ModifyBankMoney(trans, uint64(gold * 10000), true);
_ModifyBankMoney(trans, uint64(gold * 100), true);
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_CHALLENGE);
stmt->setUInt32(0, _currChallengeCount[GUILD_CHALLENGE_TYPE_DUNGEON]);
@@ -4087,8 +4040,7 @@ void Guild::ResetTimes(bool weekly)
if (weekly)
{
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPE; i++)
_currChallengeCount[i] = 0;
InitializeGuildChallengeRewards();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_RESET_CHALLENGE);
stmt->setInt32(0, m_id);
@@ -4243,3 +4195,25 @@ void Guild::SendRecipesOfMember(Player const* player, uint32 skillLineId, Object
}
player->SendDirectMessage(packet.Write());
}
void Guild::InitializeGuildChallengeRewards()
{
// Initializing all possible fields so we wont end up with uninitialized fields in case of bad database data
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
{
_currChallengeCount[i] = 0;
_maxChallengeCount[i] = 0;
_challengeGold[i] = 0;
_challengeGoldMaxLevel[i] = 0;
_challengeXp[i] = 0;
}
// Assigning loaded guild challenge database data to guild data
for (GuildChallenge challenge : sGuildMgr->GetGuildChallengeData())
{
_maxChallengeCount[challenge.ChallengeType] = challenge.ChallengeCount;
_challengeGold[challenge.ChallengeType] = challenge.Gold;
_challengeGoldMaxLevel[challenge.ChallengeType] = challenge.GoldMaxLevel;
_challengeXp[challenge.ChallengeType] = challenge.Experience;
}
}
src/server/game/Guilds/Guild.h
+8 -3
View File
@@ -276,7 +276,7 @@ enum GuildChallengeTypes
GUILD_CHALLENGE_TYPE_DUNGEON = 1,
GUILD_CHALLENGE_TYPE_RAID = 2,
GUILD_CHALLENGE_TYPE_RATED_BG = 3,
MAX_GUILD_CHALLENGE_TYPE,
MAX_GUILD_CHALLENGE_TYPES
};
// Emblem info
@@ -898,6 +898,8 @@ public:
void SendMembersForRecipe(Player const* player, uint32 skillLineId, uint32 spellId, uint32 uniqueBit);
void SendRecipesOfMember(Player const* player, uint32 skillLineId, ObjectGuid memberGuid);
void InitializeGuildChallengeRewards();
protected:
ObjectGuid::LowType m_id;
std::string m_name;
@@ -924,8 +926,11 @@ protected:
uint64 _experience;
uint64 _todayExperience;
uint8 _currChallengeCount[MAX_GUILD_CHALLENGE_TYPE];
uint32 _currChallengeCount[MAX_GUILD_CHALLENGE_TYPES];
uint32 _maxChallengeCount[MAX_GUILD_CHALLENGE_TYPES];
uint32 _challengeGold[MAX_GUILD_CHALLENGE_TYPES];
uint32 _challengeGoldMaxLevel[MAX_GUILD_CHALLENGE_TYPES];
uint32 _challengeXp[MAX_GUILD_CHALLENGE_TYPES];
private:
inline uint8 _GetRanksSize() const { return uint8(m_ranks.size()); }
src/server/game/Guilds/GuildMgr.cpp
+38
View File
@@ -596,6 +596,44 @@ void GuildMgr::LoadGuildProfessionData()
}
}
void GuildMgr::LoadGuildChallenges()
{
uint32 oldMSTime = getMSTime();
// 0 1 2 3 4
QueryResult result = WorldDatabase.Query("SELECT ChallengeType, ChallengeCount, Experience, Gold, GoldMaxLevel FROM guild_challenges");
if (!result)
{
TC_LOG_ERROR("server.loading", ">> Loaded 0 guild challenge definitions. DB table `guild_challenges` is empty.");
return;
}
uint32 count = 0;
do
{
GuildChallenge challenge;
Field* fields = result->Fetch();
challenge.ChallengeType = fields[0].GetInt32();
challenge.ChallengeCount = fields[1].GetInt32();
challenge.Experience = fields[2].GetInt32();
challenge.Gold = fields[3].GetInt32();
challenge.GoldMaxLevel = fields[4].GetInt32();
if (challenge.ChallengeType >= MAX_GUILD_CHALLENGE_TYPES)
{
TC_LOG_ERROR("server.loading", "Guild challenge type %u is invalid. Skipped.", challenge.ChallengeType);
continue;
}
GuildChallenges.push_back(challenge);
++count;
} while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u guild challenge definitions in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
void GuildMgr::ResetTimes(bool week)
{
CharacterDatabase.Execute(CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_RESET_TODAY_EXPERIENCE));
src/server/game/Guilds/GuildMgr.h
+12
View File
@@ -41,6 +41,15 @@ struct GuildProfession
bool AutoLearn;
};
struct GuildChallenge
{
int32 ChallengeType;
int32 ChallengeCount;
int32 Experience;
int32 Gold;
int32 GoldMaxLevel;
};
class TC_GAME_API GuildMgr
{
private:
@@ -61,6 +70,7 @@ public:
void LoadGuildXpForLevel();
void LoadGuildRewards();
void LoadGuildProfessionData();
void LoadGuildChallenges();
void LoadGuilds();
void AddGuild(Guild* guild);
@@ -73,6 +83,7 @@ public:
uint32 GetXPForGuildLevel(uint8 level) const;
std::vector<GuildReward> const& GetGuildRewards() const { return GuildRewards; }
std::vector<GuildProfession> const& GetGuildProfessionData(uint32 skillId) { return GuildProfessionStore[skillId]; }
std::vector<GuildChallenge> const& GetGuildChallengeData() const { return GuildChallenges; }
void ResetTimes(bool week);
protected:
@@ -83,6 +94,7 @@ protected:
GuildProfessionMap GuildProfessionStore;
std::vector<uint64> GuildXPperLevel;
std::vector<GuildReward> GuildRewards;
std::vector<GuildChallenge> GuildChallenges;
};
#define sGuildMgr GuildMgr::instance()
src/server/game/Handlers/GuildHandler.cpp
+1 -58
View File
@@ -591,7 +591,7 @@ void WorldSession::HandleGuildRequestPartyState(WorldPacket& recvPacket)
guild->HandleGuildPartyRequest(this);
}
void WorldSession::HandleGuildRequestChallengeUpdate(WorldPacket& /*recvPacket*/)
void WorldSession::HandleGuildRequestChallengeUpdate(WorldPackets::Guild::GuildChallengeUpdateRequest& /*packet*/)
{
if (Guild* guild = _player->GetGuild())
guild->HandleGuildRequestChallengeUpdate(this);
@@ -926,60 +926,3 @@ void WorldSession::HandleGuildQueryMemberRecipe(WorldPackets::Guild::GuildQueryM
if (guild->IsMember(_player->GetGUID()) && guild->IsMember(packet.GuildMember))
guild->SendRecipesOfMember(_player, packet.SkillLineID, packet.GuildMember);
}
/*
void WorldSession::HandleGuildChallengeRequest(WorldPacket& recvPacket)
{
uint8 counter = 4;
if (Guild* pGuild = GetPlayer()->GetGuild())
{
if (Guild::ChallengesMgr* challengesMgr = pGuild->GetChallengesMgr())
{
// First check if it's time to reset the challenges.
time_t thisTime = time(nullptr);
if (pGuild->GetChallengesMgr()->CompletedFirstChallenge(pGuild->GetId()) && pGuild->GetChallengesMgr()->GetFirstCompletedChallengeTime(pGuild->GetId()) + WEEK <= thisTime)
pGuild->GetChallengesMgr()->ResetWeeklyChallenges();
WorldPacket data(SMSG_GUILD_CHALLENGE_UPDATED, 5 * 4 * 4);
//Guild Experience Reward block
data << uint32(0); //in the block its always 1
data << challengesMgr->GetXPRewardForType(CHALLENGE_TYPE_DUNGEON); //dungeon
data << challengesMgr->GetXPRewardForType(CHALLENGE_TYPE_RAID); //raid
data << challengesMgr->GetXPRewardForType(CHALLENGE_TYPE_RATEDBG); //rated BG
//Gold Bonus block
data << uint32(0); //in the block its always 1
data << challengesMgr->GetGoldBonusForType(CHALLENGE_TYPE_DUNGEON); //dungeon
data << challengesMgr->GetGoldBonusForType(CHALLENGE_TYPE_RAID); //raid
data << challengesMgr->GetGoldBonusForType(CHALLENGE_TYPE_RATEDBG); //rated BG
//Total Count block
data << uint32(0); //in the block its always 1
data << challengesMgr->GetTotalCountFor(CHALLENGE_TYPE_DUNGEON); //dungeon
data << challengesMgr->GetTotalCountFor(CHALLENGE_TYPE_RAID); //raid
data << challengesMgr->GetTotalCountFor(CHALLENGE_TYPE_RATEDBG); //rated BG
//Completion Gold Reward block
data << uint32(0); //in the block its always 1
data << challengesMgr->GetGoldRewardForType(CHALLENGE_TYPE_DUNGEON); //dungeon
data << challengesMgr->GetGoldRewardForType(CHALLENGE_TYPE_RAID); //raid
data << challengesMgr->GetGoldRewardForType(CHALLENGE_TYPE_RATEDBG); //rated BG
//Current Count block
data << uint32(0); //in the block its always 1
data << challengesMgr->GetCurrentCountFor(CHALLENGE_TYPE_DUNGEON); //dungeon
data << challengesMgr->GetCurrentCountFor(CHALLENGE_TYPE_RAID); //raid
data << challengesMgr->GetCurrentCountFor(CHALLENGE_TYPE_RATEDBG); //rated BG
SendPacket(&data);
}
return;
}
}
*/
src/server/game/Server/Packets/GuildPackets.cpp
+31
View File
@@ -524,3 +524,34 @@ WorldPacket const* WorldPackets::Guild::GuildRewardList::Write()
return &_worldPacket;
}
WorldPacket const* WorldPackets::Guild::GuildChallengeUpdate::Write()
{
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
_worldPacket << int32(Xp[i]);
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
_worldPacket << int32(MaxLevelGold[i]);
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
_worldPacket << int32(MaxCount[i]);
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
_worldPacket << int32(Gold[i]);
for (uint8 i = 0; i < MAX_GUILD_CHALLENGE_TYPES; i++)
_worldPacket << int32(CurrentCount[i]);
return &_worldPacket;
}
WorldPacket const* WorldPackets::Guild::GuildChallengeCompleted::Write()
{
_worldPacket << int32(ChallengeType);
_worldPacket << int32(GoldAwarded);
_worldPacket << int32(CurrentCount);
_worldPacket << int32(XpAwarded);
_worldPacket << int32(MaxCount);
return &_worldPacket;
}
src/server/game/Server/Packets/GuildPackets.h
+36
View File
@@ -434,6 +434,42 @@ namespace WorldPackets
std::vector<GuildRewardItem> RewardItems;
int32 Version = 0;
};
class GuildChallengeUpdateRequest final : public ClientPacket
{
public:
GuildChallengeUpdateRequest(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_REQUEST_CHALLENGE_UPDATE, std::move(packet)) { }
void Read() override { }
};
class GuildChallengeUpdate final : public ServerPacket
{
public:
GuildChallengeUpdate() : ServerPacket(SMSG_GUILD_CHALLENGE_UPDATE, 80) { }
WorldPacket const* Write() override;
int32 Xp[MAX_GUILD_CHALLENGE_TYPES];
int32 CurrentCount[MAX_GUILD_CHALLENGE_TYPES];
int32 MaxCount[MAX_GUILD_CHALLENGE_TYPES];
int32 Gold[MAX_GUILD_CHALLENGE_TYPES];
int32 MaxLevelGold[MAX_GUILD_CHALLENGE_TYPES];
};
class GuildChallengeCompleted final : public ServerPacket
{
public:
GuildChallengeCompleted() : ServerPacket(SMSG_GUILD_CHALLENGE_COMPLETED, 20) { }
WorldPacket const* Write() override;
int32 MaxCount = 0;
int32 ChallengeType = 0;
int32 GoldAwarded = 0;
int32 XpAwarded = 0;
int32 CurrentCount = 0;
};
}
}
src/server/game/Server/Protocol/Opcodes.cpp
+1 -1
View File
@@ -892,7 +892,7 @@ void OpcodeTable::Initialize()
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_MONEY_WITHDRAWN, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_QUERY_TEXT_RESULT, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_COMPLETED, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_UPDATED, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_UPDATE, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHANGE_NAME_RESULT, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_COMMAND_RESULT, STATUS_NEVER, CONNECTION_TYPE_REALM);
DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_COMMAND_RESULT_2, STATUS_NEVER, CONNECTION_TYPE_REALM);
src/server/game/Server/Protocol/Opcodes.h
+1 -1
View File
@@ -833,7 +833,7 @@ enum OpcodeServer
SMSG_GUILD_BANK_QUERY_TEXT_RESULT = 0x75A3,
SMSG_GUILD_CANCEL = 0x0000,
SMSG_GUILD_CHALLENGE_COMPLETED = 0x39A3,
SMSG_GUILD_CHALLENGE_UPDATED = 0x18B1,
SMSG_GUILD_CHALLENGE_UPDATE = 0x18B1,
SMSG_GUILD_CHANGE_NAME_RESULT = 0x3CB1,
SMSG_GUILD_COMMAND_RESULT = 0x7DB3,
SMSG_GUILD_COMMAND_RESULT_2 = 0x2707,
src/server/game/Server/WorldSession.h
+2 -2
View File
@@ -121,6 +121,7 @@ namespace WorldPackets
class GuildQueryRecipes;
class GuildQueryMembersForRecipe;
class GuildQueryMemberRecipes;
class GuildChallengeUpdateRequest;
class RequestGuildRewardsList;
}
}
@@ -741,12 +742,11 @@ class TC_GAME_API WorldSession
void HandleGuildAchievementMembers(WorldPacket& recvPacket);
void HandleGuildSwitchRank(WorldPacket& recvPacket);
void HandleGuildRenameRequest(WorldPacket& recvPacket);
void HandleGuildChallengeRequest(WorldPacket& recvPacket);
void SendGuildCancelInvite(std::string unkString, uint8 unkByte);
void HandleGuildRenameCallback(std::string newName, PreparedQueryResult result);
void HandleAutoDeclineGuildInvites(WorldPacket& recvPacket);
void HandleGuildSwitchRankOpcode(WorldPacket& recvPacket);
void HandleGuildRequestChallengeUpdate(WorldPacket& recvPacket);
void HandleGuildRequestChallengeUpdate(WorldPackets::Guild::GuildChallengeUpdateRequest& packet);
void HandleGuildXPQueryOpcode(WorldPackets::Guild::GuildXPQuery& packet);
// Guild Finder
src/server/game/World/World.cpp
+3 -9
View File
@@ -1519,15 +1519,6 @@ void World::LoadConfigSettings(bool reload)
m_int_configs[CONFIG_GUILD_REPUTATION_QUEST_DIVIDER] = sConfigMgr->GetIntDefault("Guild.ReputationQuestDivider", 450);
m_int_configs[CONFIG_GUILD_DAILY_XP_CAP] = sConfigMgr->GetIntDefault("Guild.DailyXPCap", 7807500);
m_int_configs[CONFIG_GUILD_WEEKLY_REP_CAP] = sConfigMgr->GetIntDefault("Guild.WeeklyReputationCap", 4375);
m_int_configs[CONFIG_GUILD_CHALLENGE_DUNGEON_XP] = sConfigMgr->GetIntDefault("Guild.Challenge.DungeonXP", 300000);
m_int_configs[CONFIG_GUILD_CHALLENGE_DUNGEON_GOLD] = sConfigMgr->GetIntDefault("Guild.Challenge.DungeonGold", 125);
m_int_configs[CONFIG_GUILD_CHALLENGE_DUNGEON_NEEDED] = sConfigMgr->GetIntDefault("Guild.Challenge.DungeonsNedeed", 7);
m_int_configs[CONFIG_GUILD_CHALLENGE_RAID_XP] = sConfigMgr->GetIntDefault("Guild.Challenge.RaidXP", 3000000);
m_int_configs[CONFIG_GUILD_CHALLENGE_RAID_GOLD] = sConfigMgr->GetIntDefault("Guild.Challenge.RaidGold", 500);
m_int_configs[CONFIG_GUILD_CHALLENGE_RAID_NEEDED] = sConfigMgr->GetIntDefault("Guild.Challenge.RaidsNedeed", 1);
m_int_configs[CONFIG_GUILD_CHALLENGE_RATEDBG_XP] = sConfigMgr->GetIntDefault("Guild.Challenge.RatedBattlegroundXP", 1500000);
m_int_configs[CONFIG_GUILD_CHALLENGE_RATEDBG_GOLD] = sConfigMgr->GetIntDefault("Guild.Challenge.RatedBattlegroundGold", 250);
m_int_configs[CONFIG_GUILD_CHALLENGE_RATEDBG_NEEDED] = sConfigMgr->GetIntDefault("Guild.Challenge.RatedBattlegroundsNedeed", 3);
// misc
m_bool_configs[CONFIG_PDUMP_NO_PATHS] = sConfigMgr->GetBoolDefault("PlayerDump.DisallowPaths", true);
@@ -2043,6 +2034,9 @@ void World::SetInitialWorldSettings()
TC_LOG_INFO("server.loading", "Initializing Guild Profession Data Store...");
sGuildMgr->LoadGuildProfessionData();
TC_LOG_INFO("server.loading", "Loading Guild Challenges...");
sGuildMgr->LoadGuildChallenges();
TC_LOG_INFO("server.loading", "Loading Guilds...");
sGuildMgr->LoadGuilds();
src/server/game/World/World.h
-9
View File
@@ -386,15 +386,6 @@ enum WorldIntConfigs
CONFIG_GUILD_WEEKLY_REP_CAP,
CONFIG_GUILD_XP_REWARD_ARENA,
CONFIG_GUILD_REPUTATION_QUEST_DIVIDER,
CONFIG_GUILD_CHALLENGE_DUNGEON_XP,
CONFIG_GUILD_CHALLENGE_DUNGEON_GOLD,
CONFIG_GUILD_CHALLENGE_DUNGEON_NEEDED,
CONFIG_GUILD_CHALLENGE_RAID_XP,
CONFIG_GUILD_CHALLENGE_RAID_GOLD,
CONFIG_GUILD_CHALLENGE_RAID_NEEDED,
CONFIG_GUILD_CHALLENGE_RATEDBG_XP,
CONFIG_GUILD_CHALLENGE_RATEDBG_GOLD,
CONFIG_GUILD_CHALLENGE_RATEDBG_NEEDED,
CONFIG_PACKET_SPOOF_POLICY,
CONFIG_PACKET_SPOOF_BANMODE,
CONFIG_PACKET_SPOOF_BANDURATION,
src/server/worldserver/worldserver.conf.dist
-24
View File
@@ -4058,30 +4058,6 @@ Guild.ReputationQuestDivider = 450
Guild.WeeklyReputationCap = 4375
#
# Guild.Challenge
# Description: defines the required challenge completions and reward amount for completing guild challenges
# Default: 300000 - (DungeonXP)
# 125 - (DungeonGold)
# 7 - (DungeonsNeeded)
# 3000000 - (RaidXP)
# 125 - (RaidGold)
# 1 - (RaidsNeeded)
# 1500000 - (RatedBattlegroundXP)
# 250 - (RatedBattlegroundGold)
# 3 - (RatedBattlegroundsNedeed)
#
Guild.Challenge.DungeonXP = 300000
Guild.Challenge.DungeonGold = 125
Guild.Challenge.DungeonsNedeed = 7
Guild.Challenge.RaidXP = 3000000
Guild.Challenge.RaidGold = 500
Guild.Challenge.RaidsNedeed = 1
Guild.Challenge.RatedBattlegroundXP = 1500000
Guild.Challenge.RatedBattlegroundGold = 250
Guild.Challenge.RatedBattlegroundsNedeed = 3
#
###################################################################################################