Beispiel #1
0
	// Guild-Level-System
	static bool HandleGuildLInfoCommand(ChatHandler* handler, char const* /*args*/)
	{
		Guild* guild = handler->GetSession()->GetPlayer()->GetGuild();

		if (guild)
		{
			handler->PSendSysMessage(LANG_GUILD_INFO_LEVEL, guild->GetLevel());

			if (guild->GetLevel() >= GUILD_MAX_LEVEL)
				handler->PSendSysMessage(LANG_GUILD_INFO_XP_INFO, 0, 0);
			else
				handler->PSendSysMessage(LANG_GUILD_INFO_XP_INFO, guild->GetCurrentXP(), guild->GetXpForNextLevel());

			handler->PSendSysMessage("Active Bonus:");

			if (guild->GetLevel() > 0)
			{
				if (guild->HasLevelForBonus(GUILD_BONUS_GOLD_BANK_1))
					handler->PSendSysMessage("Gold Bonus [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_GOLD_BANK_2))
					handler->PSendSysMessage("Gold Bonus [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_XP_1))
					handler->PSendSysMessage("Experience Bonus [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_XP_2))
					handler->PSendSysMessage("Experience Bonus [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_FOR_REPAIR_1))
					handler->PSendSysMessage("Cheaper Repair Bonus [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_FOR_REPAIR_2))
					handler->PSendSysMessage("Cheaper Repair Bonus [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_MOUNT_SPEED_1))
					handler->PSendSysMessage("Mount Speed [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_MOUNT_SPEED_2))
					handler->PSendSysMessage("Mount Speed Bonus [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_HONOR_1))
					handler->PSendSysMessage("Bonus Honor [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_HONOR_2))
					handler->PSendSysMessage("Bonus Honor [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_REPUTATION_1))
					handler->PSendSysMessage("Reputation Bonus [Rank 1]");
				if (guild->HasLevelForBonus(GUILD_BONUS_REPUTATION_2))
					handler->PSendSysMessage("Reputation Bonus [Rank 2]");
				if (guild->HasLevelForBonus(GUILD_BONUS_FAST_SPIRIT))
					handler->PSendSysMessage("Fast Ghost");
			}
			else handler->PSendSysMessage("None");
			return true;
		}
		else
		{
			handler->PSendSysMessage("You are not in a guild");
			return false;
		}
	}
Beispiel #2
0
void WorldSession::HandleGuildDisbandOpcode(WorldPacket& /*recvPacket*/)
{
    DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_DISBAND");

    Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId());
    if (!guild)
    {
        SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
        return;
    }

    if (GetPlayer()->GetObjectGuid() != guild->GetLeaderGuid())
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
        return;
    }

    // do not delete guilds that level are higher than undeletable
    if (guild->GetMemberSize() == 1 && guild->GetLevel() >= sWorld.getConfig(CONGIG_UINT32_GUILD_UNDELETABLE_LEVEL))
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_UNDELETABLE_DUE_TO_LEVEL);
        return;
    }

    guild->Disband();
    delete guild;

    DEBUG_LOG("WORLD: Guild Successfully Disbanded");
}
Beispiel #3
0
void WorldSession::HandleGuildLeaveOpcode(WorldPacket& /*recvPacket*/)
{
    DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_LEAVE");

    Guild* guild = sGuildMgr.GetGuildById(_player->GetGuildId());
    if (!guild)
    {
        SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
        return;
    }

    if (_player->GetObjectGuid() == guild->GetLeaderGuid() && guild->GetMemberSize() > 1)
    {
        SendGuildCommandResult(GUILD_QUIT_S, "", ERR_GUILD_LEADER_LEAVE);
        return;
    }

    // do not delete guilds that level are higher than undeletable
    if (guild->GetMemberSize() == 1 && guild->GetLevel() >= sWorld.getConfig(CONGIG_UINT32_GUILD_UNDELETABLE_LEVEL))
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_UNDELETABLE_DUE_TO_LEVEL);
        return;
    }

    sCalendarMgr.RemoveGuildCalendar(_player->GetObjectGuid(), guild->GetId());

    if (_player->GetObjectGuid() == guild->GetLeaderGuid())
    {
        guild->Disband();
        delete guild;
        return;
    }

    SendGuildCommandResult(GUILD_QUIT_S, guild->GetName(), ERR_PLAYER_NO_MORE_IN_GUILD);

    if (guild->DelMember(_player->GetObjectGuid()))
    {
        guild->Disband();
        delete guild;
        return;
    }

    // Put record into guild log
    guild->LogGuildEvent(GUILD_EVENT_LOG_LEAVE_GUILD, _player->GetObjectGuid());

    guild->BroadcastEvent(GE_LEFT, _player->GetObjectGuid(), _player->GetName());
}
Beispiel #4
0
    static bool HandleGuildInfoCommand(ChatHandler* handler, char const* args)
    {
        Guild* guild = nullptr;

        if (args && args[0] != '\0')
        {
            if (isNumeric(args))
                guild = sGuildMgr->GetGuildById(strtoull(args, nullptr, 10));
            else
                guild = sGuildMgr->GetGuildByName(args);
        }
        else if (Player* target = handler->getSelectedPlayerOrSelf())
            guild = target->GetGuild();

        if (!guild)
            return false;

        // Display Guild Information
        handler->PSendSysMessage(LANG_GUILD_INFO_NAME, guild->GetName().c_str(), std::to_string(guild->GetId()).c_str()); // Guild Id + Name

        std::string guildMasterName;
        if (ObjectMgr::GetPlayerNameByGUID(guild->GetLeaderGUID(), guildMasterName))
            handler->PSendSysMessage(LANG_GUILD_INFO_GUILD_MASTER, guildMasterName.c_str(), guild->GetLeaderGUID().ToString().c_str()); // Guild Master

        // Format creation date
        char createdDateStr[20];
        time_t createdDate = guild->GetCreatedDate();
        tm localTm;
        strftime(createdDateStr, 20, "%Y-%m-%d %H:%M:%S", localtime_r(&createdDate, &localTm));

        handler->PSendSysMessage(LANG_GUILD_INFO_CREATION_DATE, createdDateStr); // Creation Date
        handler->PSendSysMessage(LANG_GUILD_INFO_MEMBER_COUNT, guild->GetMembersCount()); // Number of Members
        handler->PSendSysMessage(LANG_GUILD_INFO_BANK_GOLD, std::to_string(guild->GetBankMoney() / 100 / 100).c_str()); // Bank Gold (in gold coins)
        handler->PSendSysMessage(LANG_GUILD_INFO_LEVEL, guild->GetLevel()); // Level
        handler->PSendSysMessage(LANG_GUILD_INFO_MOTD, guild->GetMOTD().c_str()); // Message of the Day
        handler->PSendSysMessage(LANG_GUILD_INFO_EXTRA_INFO, guild->GetInfo().c_str()); // Extra Information
        return true;
    }
void WorldSession::HandleGuildFinderBrowse(WorldPacket& recvPacket)
{
    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_LF_GUILD_BROWSE");

    uint32 classRoles = 0;
    uint32 availability = 0;
    uint32 guildInterests = 0;
    uint32 playerLevel = 0; // Raw player level (1-90), do they use MAX_FINDER_LEVEL when on level 90 ?

	recvPacket >> playerLevel >> availability >> classRoles >> guildInterests;

    Player* player = GetPlayer();

    LFGuildPlayer settings(player->GetGUIDLow(), classRoles, availability, guildInterests, ANY_FINDER_LEVEL);
    LFGuildStore guildList = sGuildFinderMgr->GetGuildsMatchingSetting(settings, player->GetTeamId());
    uint32 guildCount = guildList.size();

    if (guildCount == 0)
    {
        WorldPacket packet(SMSG_LF_GUILD_BROWSE_UPDATED);
        packet.WriteBits(0, 18);
        player->SendDirectMessage(&packet);
        return;
    }

    bool returned = false;

    if (!(classRoles & GUILDFINDER_ALL_ROLES) || classRoles > GUILDFINDER_ALL_ROLES)
        returned = true;
    if (!(availability & ALL_WEEK) || availability > ALL_WEEK)
        returned = true;
    if (!(guildInterests & ALL_INTERESTS) || guildInterests > ALL_INTERESTS)
        returned = true;
    if (playerLevel > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) || playerLevel < 1)
        returned = true;

    if (returned)
    {
        WorldPacket packet(SMSG_LF_GUILD_BROWSE_UPDATED);
        packet.WriteBits(0, 18);
        player->SendDirectMessage(&packet);
        return;
    }

    ByteBuffer bufferData;
    WorldPacket data(SMSG_LF_GUILD_BROWSE_UPDATED);

    data.WriteBits(guildCount, 18);

    for (LFGuildStore::const_iterator itr = guildList.begin(); itr != guildList.end(); ++itr)
    {
        LFGuildSettings guildSettings = itr->second;
        Guild* guild = sGuildMgr->GetGuildById(itr->first);

        ObjectGuid guildGUID = ObjectGuid(guild->GetGUID());

		data.WriteBit(guildGUID[6]);
		data.WriteBit(guildGUID[5]);
        data.WriteBit(guildGUID[4]);
        data.WriteBit(guildGUID[0]);
        data.WriteBit(guildGUID[1]);
        data.WriteBits(guildSettings.GetComment().size(), 10);
        data.WriteBit(guildGUID[3]);

		data.WriteBits(guild->GetName().size(), 7);

        data.WriteBit(guildGUID[7]);
        data.WriteBit(guildGUID[2]);

		bufferData.WriteByteSeq(guildGUID[3]);
		bufferData << uint32(guild->GetEmblemInfo().GetStyle());
		bufferData << uint8(sGuildFinderMgr->HasRequest(player->GetGUIDLow(), guild->GetGUID()));

		bufferData.WriteByteSeq(guildGUID[0]);

		bufferData << uint32(guild->GetAchievementMgr().GetAchievementPoints());

		bufferData.WriteByteSeq(guildGUID[2]);

		bufferData << uint32(guildSettings.GetInterests());
		bufferData << int32(guild->GetEmblemInfo().GetBackgroundColor());
		bufferData << guild->GetLevel();
		bufferData << uint32(guildSettings.GetAvailability());
		bufferData << uint32(guildSettings.GetClassRoles());

		bufferData.WriteByteSeq(guildGUID[5]);
		bufferData << uint32(0);                                                              // Unk

		if (guild->GetName().size() > 0)
			bufferData.append(guild->GetName().c_str(), guild->GetName().size());

		bufferData << uint32(0);                                                              // Unk
		bufferData << uint32(guild->GetEmblemInfo().GetBorderStyle());
		bufferData.WriteByteSeq(guildGUID[7]);
		bufferData << uint32(guild->GetEmblemInfo().GetColor());
		bufferData.WriteByteSeq(guildGUID[6]);
		bufferData << uint32(0);                                                              // Unk

		if (guildSettings.GetComment().size() > 0)
			bufferData.append(guildSettings.GetComment().c_str(), guildSettings.GetComment().size());

		bufferData << uint32(guild->GetEmblemInfo().GetBorderColor());
		bufferData << uint32(guild->GetMembersCount());

        bufferData.WriteByteSeq(guildGUID[1]);
        bufferData.WriteByteSeq(guildGUID[4]);

    }

    data.FlushBits();
    data.append(bufferData);

    player->SendDirectMessage(&data);
}
Beispiel #6
0
void WorldSession::HandleGuildFinderBrowse(WorldPacket& recvPacket)
{
    TC_LOG_DEBUG("network", "WORLD: Received CMSG_LF_GUILD_BROWSE");

    uint32 classRoles = 0;
    uint32 availability = 0;
    uint32 guildInterests = 0;
    uint32 playerLevel = 0;

    recvPacket >> playerLevel >> guildInterests >> availability >> classRoles;

    Player* player = GetPlayer();

    LFGuildPlayer settings(player->GetGUIDLow(), classRoles, availability, guildInterests, ANY_FINDER_LEVEL);
    LFGuildStore guildList = sGuildFinderMgr->GetGuildsMatchingSetting(settings, player->GetTeamId());
    uint32 guildCount = guildList.size();

    if (guildCount == 0)
    {
        WorldPacket packet(SMSG_LF_GUILD_BROWSE_UPDATED);
        packet.WriteBits(0, 18);
        packet.FlushBits();
        player->SendDirectMessage(&packet);
        return;
    }

    bool returned = false;

    if (!(classRoles & GUILDFINDER_ALL_ROLES) || classRoles > GUILDFINDER_ALL_ROLES)
        returned = true;
    if (!(availability & ALL_WEEK) || availability > ALL_WEEK)
        returned = true;
    if (!(guildInterests & ALL_INTERESTS) || guildInterests > ALL_INTERESTS)
        returned = true;
    if (playerLevel > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) || playerLevel < 1)
        returned = true;

    if (returned)
    {
        WorldPacket packet(SMSG_LF_GUILD_BROWSE_UPDATED);
        packet.WriteBits(0, 18);
        packet.FlushBits();
        player->SendDirectMessage(&packet);
        return;
    }

    ByteBuffer bufferData;
    WorldPacket data(SMSG_LF_GUILD_BROWSE_UPDATED);

    data.WriteBits(guildCount, 18);

    for (LFGuildStore::const_iterator itr = guildList.begin(); itr != guildList.end(); ++itr)
    {
        LFGuildSettings guildSettings = itr->second;
        Guild* guild = sGuildMgr->GetGuildById(itr->first);

        ObjectGuid guildGUID = ObjectGuid(guild->GetGUID());

        data.WriteBitSeq<4>(guildGUID);
        data.WriteBits(guild->GetName().size(), 7);
        data.WriteBitSeq<0, 1>(guildGUID);
        data.WriteBits(guildSettings.GetComment().size(), 10);
        data.WriteBitSeq<2, 7, 3, 6, 5>(guildGUID);

        bufferData << uint8(sGuildFinderMgr->HasRequest(player->GetGUIDLow(), guild->GetGUID()));
        bufferData << uint32(guild->GetLevel());
        bufferData << uint32(guildSettings.GetInterests());
        bufferData << uint32(0);                                                                    // Unk
        bufferData << uint32(guild->GetEmblemInfo().GetBorderStyle());
        bufferData.WriteByteSeq<1, 4>(guildGUID);
        bufferData << uint32(guild->GetEmblemInfo().GetStyle());
        bufferData.WriteByteSeq<3>(guildGUID);
        bufferData << uint32(50397223);                                                             // Unk Flags
        bufferData << uint32(guild->GetEmblemInfo().GetColor());
        bufferData.WriteString(guild->GetName());
        bufferData << uint32(guildSettings.GetClassRoles());
        bufferData << uint32(guildSettings.GetAvailability());
        bufferData.WriteString(guildSettings.GetComment());
        bufferData.WriteByteSeq<6, 7>(guildGUID);
        bufferData << uint8(0);                                                                     // Cached
        bufferData.WriteByteSeq<5, 0>(guildGUID);
        bufferData << uint32(guild->GetEmblemInfo().GetBorderColor());
        bufferData << uint32(guild->GetMembersCount());
        bufferData << uint32(guild->GetAchievementMgr().GetAchievementPoints());
        bufferData.WriteByteSeq<2>(guildGUID);
        bufferData << int32(guild->GetEmblemInfo().GetBackgroundColor());
    }

    data.FlushBits();
    data.append(bufferData);

    player->SendDirectMessage(&data);
}
Beispiel #7
0
void WorldSession::HandleGuildInviteOpcode(WorldPacket& recvPacket)
{
    DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_INVITE");

    std::string Invitedname, plname;
    Player* player = NULL;

    Invitedname = recvPacket.ReadString(recvPacket.ReadBits(7));

    if (normalizePlayerName(Invitedname))
        player = ObjectAccessor::FindPlayerByName(Invitedname.c_str());

    if (!player)
    {
        SendGuildCommandResult(GUILD_INVITE_S, Invitedname, ERR_GUILD_PLAYER_NOT_FOUND_S);
        return;
    }

    Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId());
    if (!guild)
    {
        SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
        return;
    }

    // OK result but not send invite
    if (player->GetSocial()->HasIgnore(GetPlayer()->GetObjectGuid()))
        return;

    // not let enemies sign guild charter
    if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeam() != GetPlayer()->GetTeam())
    {
        SendGuildCommandResult(GUILD_INVITE_S, Invitedname, ERR_GUILD_NOT_ALLIED);
        return;
    }

    if (player->GetGuildId())
    {
        plname = player->GetName();
        SendGuildCommandResult(GUILD_INVITE_S, plname, ERR_ALREADY_IN_GUILD_S);
        return;
    }

    if (player->GetGuildIdInvited())
    {
        plname = player->GetName();
        SendGuildCommandResult(GUILD_INVITE_S, plname, ERR_ALREADY_INVITED_TO_GUILD_S);
        return;
    }

    if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_INVITE))
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
        return;
    }

    DEBUG_LOG("Player %s Invited %s to Join his Guild", GetPlayer()->GetName(), Invitedname.c_str());

    player->SetGuildIdInvited(GetPlayer()->GetGuildId());
    // Put record into guildlog
    guild->LogGuildEvent(GUILD_EVENT_LOG_INVITE_PLAYER, GetPlayer()->GetObjectGuid(), player->GetObjectGuid());

    ObjectGuid oldGuild = player->GetGuildGuid();
    ObjectGuid newGuild = guild->GetObjectGuid();
    std::string oldGuildName = player->GetGuildName();
    std::string newGuildName = guild->GetName();

    WorldPacket data(SMSG_GUILD_INVITE, 4 * 6 + 10);          // guess size
    data << uint32(guild->GetLevel());
    data << uint32(guild->GetBorderStyle());
    data << uint32(guild->GetBorderColor());
    data << uint32(guild->GetEmblemStyle());
    data << uint32(guild->GetBackgroundColor());
    data << uint32(guild->GetEmblemColor());

    data.WriteGuidMask<3, 2>(newGuild);
    data.WriteBits(oldGuildName.length(), 8);
    data.WriteGuidMask<1>(newGuild);
    data.WriteGuidMask<6, 4, 1, 5, 7, 2>(oldGuild);
    data.WriteGuidMask<7, 0, 6>(newGuild);
    data.WriteBits(newGuildName.length(), 8);
    data.WriteGuidMask<3, 0>(oldGuild);
    data.WriteGuidMask<5>(newGuild);
    data.WriteBits(strlen(_player->GetName()), 7);
    data.WriteGuidMask<4>(newGuild);

    data.WriteGuidBytes<1>(newGuild);
    data.WriteGuidBytes<3>(oldGuild);
    data.WriteGuidBytes<6>(newGuild);
    data.WriteGuidBytes<2, 1>(oldGuild);
    data.WriteGuidBytes<0>(newGuild);

    data.WriteStringData(oldGuildName);

    data.WriteGuidBytes<7, 2>(newGuild);

    data.WriteStringData(_player->GetName());

    data.WriteGuidBytes<7, 6, 5, 0>(oldGuild);
    data.WriteGuidBytes<4>(newGuild);

    data.WriteStringData(newGuildName);

    data.WriteGuidBytes<5, 3>(newGuild);
    data.WriteGuidBytes<4>(oldGuild);

    player->GetSession()->SendPacket(&data);

    DEBUG_LOG("WORLD: Sent (SMSG_GUILD_INVITE)");
}
Beispiel #8
0
void WorldSession::HandleGuildRemoveOpcode(WorldPacket& recvPacket)
{
    DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_REMOVE");

    std::string plName;
    ObjectGuid targetGuid;
    recvPacket.ReadGuidMask<6, 5, 4, 0, 1, 3, 7, 2>(targetGuid);
    recvPacket.ReadGuidBytes<2, 6, 5, 7, 1, 4, 3, 0>(targetGuid);

    Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId());
    if (!guild)
    {
        SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
        return;
    }

    if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_REMOVE))
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
        return;
    }

    if (!sObjectMgr.GetPlayerNameByGUID(targetGuid, plName))
        return;

    MemberSlot* slot = guild->GetMemberSlot(targetGuid);
    if (!slot)
    {
        SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
        return;
    }

    if (slot->RankId == GR_GUILDMASTER)
    {
        SendGuildCommandResult(GUILD_QUIT_S, "", ERR_GUILD_LEADER_LEAVE);
        return;
    }

    // do not allow to kick player with same or higher rights
    if (GetPlayer()->GetRank() >= slot->RankId)
    {
        SendGuildCommandResult(GUILD_QUIT_S, plName, ERR_GUILD_RANK_TOO_HIGH_S);
        return;
    }

    // do not delete guilds that level are higher than undeletable
    if (guild->GetMemberSize() == 1 && guild->GetLevel() >= sWorld.getConfig(CONGIG_UINT32_GUILD_UNDELETABLE_LEVEL))
    {
        SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_UNDELETABLE_DUE_TO_LEVEL);
        return;
    }

    // possible last member removed, do cleanup, and no need events
    if (guild->DelMember(slot->guid))
    {
        guild->Disband();
        delete guild;
        return;
    }

    // Put record into guild log
    guild->LogGuildEvent(GUILD_EVENT_LOG_UNINVITE_PLAYER, GetPlayer()->GetObjectGuid(), slot->guid);

    guild->BroadcastEvent(GE_REMOVED, plName.c_str(), _player->GetName());
}
void WorldSession::HandleGuildFinderBrowse(WorldPacket& recvPacket)
{
    TC_LOG_DEBUG("network", "WORLD: Received CMSG_LF_GUILD_BROWSE");
    uint32 classRoles = 0;
    uint32 availability = 0;
    uint32 guildInterests = 0;
    uint32 playerLevel = 0; // Raw player level (1-85), do they use MAX_FINDER_LEVEL when on level 85 ?

    recvPacket >> classRoles >> availability >> guildInterests >> playerLevel;

    if (!(classRoles & GUILDFINDER_ALL_ROLES) || classRoles > GUILDFINDER_ALL_ROLES)
        return;
    if (!(availability & AVAILABILITY_ALWAYS) || availability > AVAILABILITY_ALWAYS)
        return;
    if (!(guildInterests & ALL_INTERESTS) || guildInterests > ALL_INTERESTS)
        return;
    if (playerLevel > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) || playerLevel < 1)
        return;

    Player* player = GetPlayer();

    LFGuildPlayer settings(player->GetGUIDLow(), classRoles, availability, guildInterests, ANY_FINDER_LEVEL);
    LFGuildStore guildList = sGuildFinderMgr->GetGuildsMatchingSetting(settings, player->GetTeamId());
    uint32 guildCount = guildList.size();

    if (guildCount == 0)
    {
        WorldPacket packet(SMSG_LF_GUILD_BROWSE_UPDATED, 0);
        player->SendDirectMessage(&packet);
        return;
    }

    ByteBuffer bufferData(65 * guildCount);
    WorldPacket data(SMSG_LF_GUILD_BROWSE_UPDATED, 3 + guildCount * 65); // Estimated size
    data.WriteBits(guildCount, 19);

    for (LFGuildStore::const_iterator itr = guildList.begin(); itr != guildList.end(); ++itr)
    {
        LFGuildSettings guildSettings = itr->second;
        Guild* guild = sGuildMgr->GetGuildById(itr->first);

        ObjectGuid guildGUID = ObjectGuid(guild->GetGUID());

        data.WriteBit(guildGUID[7]);
        data.WriteBit(guildGUID[5]);
        data.WriteBits(guild->GetName().size(), 8);
        data.WriteBit(guildGUID[0]);
        data.WriteBits(guildSettings.GetComment().size(), 11);
        data.WriteBit(guildGUID[4]);
        data.WriteBit(guildGUID[1]);
        data.WriteBit(guildGUID[2]);
        data.WriteBit(guildGUID[6]);
        data.WriteBit(guildGUID[3]);

        bufferData << uint32(guild->GetEmblemInfo().GetColor());
        bufferData << uint32(guild->GetEmblemInfo().GetBorderStyle()); // Guessed
        bufferData << uint32(guild->GetEmblemInfo().GetStyle());

        bufferData.WriteString(guildSettings.GetComment());

        bufferData << uint8(0); // Unk

        bufferData.WriteByteSeq(guildGUID[5]);

        bufferData << uint32(guildSettings.GetInterests());

        bufferData.WriteByteSeq(guildGUID[6]);
        bufferData.WriteByteSeq(guildGUID[4]);

        bufferData << uint32(guild->GetLevel());

        bufferData.WriteString(guild->GetName());

        bufferData << uint32(guild->GetAchievementMgr().GetAchievementPoints());

        bufferData.WriteByteSeq(guildGUID[7]);

        bufferData << uint8(sGuildFinderMgr->HasRequest(player->GetGUIDLow(), guild->GetGUID())); // Request pending

        bufferData.WriteByteSeq(guildGUID[2]);
        bufferData.WriteByteSeq(guildGUID[0]);

        bufferData << uint32(guildSettings.GetAvailability());

        bufferData.WriteByteSeq(guildGUID[1]);

        bufferData << uint32(guild->GetEmblemInfo().GetBackgroundColor());
        bufferData << uint32(0); // Unk Int 2 (+ 128) // Always 0 or 1
        bufferData << uint32(guild->GetEmblemInfo().GetBorderColor());
        bufferData << uint32(guildSettings.GetClassRoles());

        bufferData.WriteByteSeq(guildGUID[3]);
        bufferData << uint32(guild->GetMembersCount());
    }

    data.FlushBits();
    data.append(bufferData);

    player->SendDirectMessage(&data);
}
Beispiel #10
0
    //Guild-Level-System
    static bool HandleGuildInfoCommand(ChatHandler* handler, char const* /*args*/)
    {
        Guild* guild = handler->GetSession()->GetPlayer()->GetGuild();

        if (guild)
        {
            handler->PSendSysMessage(LANG_GUILDINFO_LEVEL, guild->GetLevel());

            if (guild->GetLevel() >= GUILD_MAX_LEVEL)
                handler->PSendSysMessage(LANG_GUILDINFO_XP_INFO, 0, 0);
            else
                handler->PSendSysMessage(LANG_GUILDINFO_XP_INFO, guild->GetCurrentXP(), guild->GetXpForNextLevel());

            handler->PSendSysMessage("Active Bonus:");

            if (guild->GetLevel() > 0)
            {
                if (guild->HasLevelForBonus(GUILD_BONUS_GOLD_1) && !guild->HasLevelForBonus(GUILD_BONUS_GOLD_2))
                    handler->PSendSysMessage("Gold bonus [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_XP_1) && !guild->HasLevelForBonus(GUILD_BONUS_XP_2))
                    handler->PSendSysMessage("Bonus Experience [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_SCHNELLER_GEIST))
                    handler->PSendSysMessage("Faster Ghost");
                if (guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_1) && !guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_2) && !guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_3))
                    handler->PSendSysMessage("Cheaper Repairs [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_GOLD_2))
                    handler->PSendSysMessage("Gold bonus [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_REITTEMPO_1) && !guild->HasLevelForBonus(GUILD_BONUS_REITTEMPO_2))
                    handler->PSendSysMessage("Mount Speed [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_RUF_1) && !guild->HasLevelForBonus(GUILD_BONUS_RUF_2))
                    handler->PSendSysMessage("Reputation [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_XP_2))
                    handler->PSendSysMessage("Bonus Experience [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_2) && !guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_3))
                    handler->PSendSysMessage("Cheaper Repairs [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_REPERATUR_3))
                    handler->PSendSysMessage("Cheaper Repairs [Rank 3]");
                if (guild->HasLevelForBonus(GUILD_BONUS_REITTEMPO_2))
                    handler->PSendSysMessage("Mount Speed [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_RUF_2))
                    handler->PSendSysMessage("Reputation [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_EHRE_1) && !guild->HasLevelForBonus(GUILD_BONUS_EHRE_2))
                    handler->PSendSysMessage("Bonus Honor [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_EHRE_2))
                    handler->PSendSysMessage("Bonus Honor [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_MAIL_1) && !guild->HasLevelForBonus(GUILD_BONUS_MAIL_2))
                    handler->PSendSysMessage("Bonus Mail [Rank 1]");
                if (guild->HasLevelForBonus(GUILD_BONUS_MAIL_2))
                    handler->PSendSysMessage("Bonus Mail [Rank 2]");
                if (guild->HasLevelForBonus(GUILD_BONUS_DURATION))
                    handler->PSendSysMessage("Flask duration");
                if (guild->HasLevelForBonus(GUILD_BONUS_VAULT))
                    handler->PSendSysMessage("Mobile Guild Vault");
                if (guild->HasLevelForBonus(GUILD_BONUS_MOUNT_GRFLY))
                    handler->PSendSysMessage("Ground and Fly Mount");
                if (guild->HasLevelForBonus(GUILD_BONUS_MOUNT_GROUND_FLY))
                    handler->PSendSysMessage("Ground/Fly mount");
            }
            else
                handler->PSendSysMessage("None");

            return true;
        }
        else
        {
            handler->PSendSysMessage("You are not in a guild");
            return false;
        }
    }