CreatureTextMgr Class Reference

#include "CreatureTextMgr.h"

Public Member Functions
	~CreatureTextMgr ()
void	LoadCreatureTexts ()
void	LoadCreatureTextLocales ()
void	LoadCreatureTextOptions ()
CreatureTextMap const &	GetTextMap () const
CreatureTextOptions const *	GetTextOptions (uint32 entry, uint8 group) const
void	SendSound (Creature *source, uint32 sound, ChatMsg msgType, WorldObject const *target, CreatureTextRange range, TeamId teamId, bool gmOnly)
void	SendEmote (Unit *source, uint32 emote)
uint32	SendChat (Creature *source, uint8 textGroup, WorldObject const *target=nullptr, ChatMsg msgType=CHAT_MSG_ADDON, Language language=LANG_ADDON, CreatureTextRange range=TEXT_RANGE_NORMAL, uint32 sound=0, TeamId teamId=TEAM_NEUTRAL, bool gmOnly=false, Player *srcPlr=nullptr)
bool	TextExist (uint32 sourceEntry, uint8 textGroup)
std::string	GetLocalizedChatString (uint32 entry, uint8 gender, uint8 textGroup, uint32 id, LocaleConstant locale) const
template<class Builder >
void	SendChatPacket (WorldObject *source, Builder const &builder, ChatMsg msgType, WorldObject const *target=nullptr, CreatureTextRange range=TEXT_RANGE_NORMAL, TeamId teamId=TEAM_NEUTRAL, bool gmOnly=false) const

Static Public Member Functions
static CreatureTextMgr *	instance ()

Private Member Functions
	CreatureTextMgr ()
void	SendNonChatPacket (WorldObject *source, WorldPacket const *data, ChatMsg msgType, WorldObject const *target, CreatureTextRange range, TeamId teamId, bool gmOnly) const
float	GetRangeForChatType (ChatMsg msgType) const

Private Attributes
CreatureTextMap	mTextMap
LocaleCreatureTextMap	mLocaleTextMap
CreatureTextOptionsContainer	mTextOptionsMap

Detailed Description

Constructor & Destructor Documentation

CreatureTextMgr()

CreatureTextMgr::CreatureTextMgr ( )

inlineprivate

{ }

~CreatureTextMgr()

CreatureTextMgr::~CreatureTextMgr ( )

inline

{ }

Member Function Documentation

GetLocalizedChatString()

std::string CreatureTextMgr::GetLocalizedChatString	(	uint32	entry,
		uint8	gender,
		uint8	textGroup,
		uint32	id,
		LocaleConstant	locale
	)		const

{
    CreatureTextMap::const_iterator mapitr = mTextMap.find(entry);
    if (mapitr == mTextMap.end())
        return "";
 
    CreatureTextHolder::const_iterator holderItr = mapitr->second.find(textGroup);
    if (holderItr == mapitr->second.end())
        return "";
 
    CreatureTextGroup::const_iterator groupItr = holderItr->second.begin();
    for (; groupItr != holderItr->second.end(); ++groupItr)
        if (groupItr->id == id)
            break;
 
    if (groupItr == holderItr->second.end())
        return "";
 
    if (locale > MAX_LOCALES)
        locale = DEFAULT_LOCALE;
 
    std::string baseText = "";
 
    BroadcastText const* bct = sObjectMgr->GetBroadcastText(groupItr->BroadcastTextId);
    if (bct)
        baseText = bct->GetText(locale, gender);
    else
        baseText = groupItr->text;
 
    if (locale != DEFAULT_LOCALE && !bct)
    {
        LocaleCreatureTextMap::const_iterator locItr = mLocaleTextMap.find(CreatureTextId(entry, uint32(textGroup), id));
        if (locItr != mLocaleTextMap.end())
            ObjectMgr::GetLocaleString(locItr->second.Text, locale, baseText);
    }
 
    return baseText;
}

References DEFAULT_LOCALE, ObjectMgr::GetLocaleString(), BroadcastText::GetText(), MAX_LOCALES, mLocaleTextMap, mTextMap, and sObjectMgr.

GetRangeForChatType()

float CreatureTextMgr::GetRangeForChatType ( ChatMsg  msgType ) const

private

{
    float dist = sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY);
    switch (msgType)
    {
        case CHAT_MSG_MONSTER_YELL:
            dist = sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_YELL);
            break;
        case CHAT_MSG_MONSTER_EMOTE:
        case CHAT_MSG_RAID_BOSS_EMOTE:
            dist = sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE);
            break;
        default:
            break;
    }
 
    return dist;
}

References CHAT_MSG_MONSTER_EMOTE, CHAT_MSG_MONSTER_YELL, CHAT_MSG_RAID_BOSS_EMOTE, CONFIG_LISTEN_RANGE_SAY, CONFIG_LISTEN_RANGE_TEXTEMOTE, CONFIG_LISTEN_RANGE_YELL, and sWorld.

Referenced by SendChatPacket(), and SendNonChatPacket().

GetTextMap()

CreatureTextMap const & CreatureTextMgr::GetTextMap ( ) const

inline

{ return mTextMap; }

References mTextMap.

GetTextOptions()

CreatureTextOptions const * CreatureTextMgr::GetTextOptions	(	uint32	entry,
		uint8	group
	)		const

{
    auto entryItr = mTextOptionsMap.find(entry);
    if (entryItr == mTextOptionsMap.end())
        return nullptr;
 
    auto groupItr = entryItr->second.find(group);
    if (groupItr == entryItr->second.end())
        return nullptr;
 
    return &groupItr->second;
}

References mTextOptionsMap.

Referenced by SendChat().

instance()

CreatureTextMgr * CreatureTextMgr::instance ( )

static

{
    static CreatureTextMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadCreatureTextLocales()

void CreatureTextMgr::LoadCreatureTextLocales

(

)

{
    uint32 oldMSTime = getMSTime();
 
    mLocaleTextMap.clear(); // for reload case
 
    QueryResult result = WorldDatabase.Query("SELECT CreatureId, GroupId, ID, Locale, Text FROM creature_text_locale");
 
    if (!result)
        return;
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 CreatureId           = fields[0].Get<uint32>();
        uint32 GroupId              = fields[1].Get<uint8>();
        uint32 ID                   = fields[2].Get<uint8>();
 
        LocaleConstant locale = GetLocaleByName(fields[3].Get<std::string>());
        if (locale == LOCALE_enUS)
            continue;
 
        CreatureTextLocale& data = mLocaleTextMap[CreatureTextId(CreatureId, GroupId, ID)];
        ObjectMgr::AddLocaleString(fields[4].Get<std::string>(), locale, data.Text);
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Creature Text Locale in {} ms", uint32(mLocaleTextMap.size()), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References ObjectMgr::AddLocaleString(), Field::Get(), GetLocaleByName(), getMSTime(), GetMSTimeDiffToNow(), LOCALE_enUS, LOG_INFO, mLocaleTextMap, CreatureTextLocale::Text, and WorldDatabase.

LoadCreatureTextOptions()

void CreatureTextMgr::LoadCreatureTextOptions

(

)

{
    uint32 oldMSTime = getMSTime();
 
    mTextOptionsMap.clear();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_TEXT_OPTIONS);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 creature text options. DB table `creature_text_options` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
        uint32 creatureId   = fields[0].Get<uint32>();
        uint8  groupId      = fields[1].Get<uint8>();
 
        CreatureTextOptions options;
        options.cooldown     = fields[2].Get<uint32>();
        options.triggerChance = fields[3].Get<uint8>();
        options.playerOnly   = fields[4].Get<bool>();
 
        if (options.triggerChance > 100)
        {
            LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {} in table `creature_text_options` has TriggerChance {} > 100. Setting to 100.", creatureId, groupId, options.triggerChance);
            options.triggerChance = 100;
        }
 
        mTextOptionsMap[creatureId][groupId] = options;
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Creature Text Options in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References CreatureTextOptions::cooldown, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, mTextOptionsMap, WORLD_SEL_CREATURE_TEXT_OPTIONS, and WorldDatabase.

LoadCreatureTexts()

void CreatureTextMgr::LoadCreatureTexts

(

)

{
    uint32 oldMSTime = getMSTime();
 
    mTextMap.clear(); // for reload case
    //all currently used temp texts are NOT reset
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_TEXT);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 ceature texts. DB table `creature_texts` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 textCount = 0;
 
    do
    {
        Field* fields = result->Fetch();
        CreatureTextEntry temp;
 
        temp.entry           = fields[0].Get<uint32>();
        temp.group           = fields[1].Get<uint8>();
        temp.id              = fields[2].Get<uint8>();
        temp.text            = fields[3].Get<std::string>();
        temp.type            = ChatMsg(fields[4].Get<uint8>());
        temp.lang            = Language(fields[5].Get<uint8>());
        temp.probability     = fields[6].Get<float>();
        temp.emote           = Emote(fields[7].Get<uint32>());
        temp.duration        = fields[8].Get<uint32>();
        temp.sound           = fields[9].Get<uint32>();
        temp.BroadcastTextId = fields[10].Get<uint32>();
        temp.TextRange       = CreatureTextRange(fields[11].Get<uint8>());
 
        if (temp.sound)
        {
            if (!sSoundEntriesStore.LookupEntry(temp.sound))
            {
                LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {} in table `creature_texts` has Sound {} but sound does not exist.", temp.entry, temp.group, temp.sound);
                temp.sound = 0;
            }
        }
        if (!GetLanguageDescByID(temp.lang))
        {
            LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {} in table `creature_texts` using Language {} but Language does not exist.", temp.entry, temp.group, uint32(temp.lang));
            temp.lang = LANG_UNIVERSAL;
        }
        if (temp.type >= MAX_CHAT_MSG_TYPE)
        {
            LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {} in table `creature_texts` has Type {} but this Chat Type does not exist.", temp.entry, temp.group, uint32(temp.type));
            temp.type = CHAT_MSG_SAY;
        }
        if (temp.emote)
        {
            if (!sEmotesStore.LookupEntry(temp.emote))
            {
                LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {} in table `creature_texts` has Emote {} but emote does not exist.", temp.entry, temp.group, uint32(temp.emote));
                temp.emote = EMOTE_ONESHOT_NONE;
            }
        }
        if (temp.BroadcastTextId)
        {
            if (!sObjectMgr->GetBroadcastText(temp.BroadcastTextId))
            {
                LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {}, Id {} in table `creature_text` has non-existing or incompatible BroadcastTextId {}.", temp.entry, temp.group, temp.id, temp.BroadcastTextId);
                temp.BroadcastTextId = 0;
            }
        }
        if (temp.TextRange > TEXT_RANGE_WORLD)
        {
            LOG_ERROR("sql.sql", "CreatureTextMgr: Entry {}, Group {}, Id {} in table `creature_text` has incorrect TextRange {}.", temp.entry, temp.group, temp.id, temp.TextRange);
            temp.TextRange = TEXT_RANGE_NORMAL;
        }
 
        //add the text into our entry's group
        mTextMap[temp.entry][temp.group].push_back(temp);
 
        ++textCount;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Creature Texts For {} Creatures in {} ms", textCount, mTextMap.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References CreatureTextEntry::BroadcastTextId, CHAT_MSG_SAY, CreatureTextEntry::duration, CreatureTextEntry::emote, EMOTE_ONESHOT_NONE, CreatureTextEntry::entry, Field::Get(), GetLanguageDescByID(), getMSTime(), GetMSTimeDiffToNow(), CreatureTextEntry::group, CreatureTextEntry::id, CreatureTextEntry::lang, LANG_UNIVERSAL, LOG_ERROR, LOG_INFO, LOG_WARN, MAX_CHAT_MSG_TYPE, mTextMap, CreatureTextEntry::probability, sEmotesStore, sObjectMgr, CreatureTextEntry::sound, sSoundEntriesStore, CreatureTextEntry::text, TEXT_RANGE_NORMAL, TEXT_RANGE_WORLD, CreatureTextEntry::TextRange, CreatureTextEntry::type, WORLD_SEL_CREATURE_TEXT, and WorldDatabase.

SendChat()

uint32 CreatureTextMgr::SendChat	(	Creature *	source,
		uint8	textGroup,
		WorldObject const *	target = nullptr,
		ChatMsg	msgType = CHAT_MSG_ADDON,
		Language	language = LANG_ADDON,
		CreatureTextRange	range = TEXT_RANGE_NORMAL,
		uint32	sound = 0,
		TeamId	teamId = TEAM_NEUTRAL,
		bool	gmOnly = false,
		Player *	srcPlr = nullptr
	)

{
    if (!source)
        return 0;
 
    CreatureTextMap::const_iterator sList = mTextMap.find(source->GetEntry());
    if (sList == mTextMap.end())
    {
        LOG_ERROR("sql.sql", "CreatureTextMgr: Could not find Text for Creature({}) Entry {} in 'creature_text' table. Ignoring.", source->GetName(), source->GetEntry());
        return 0;
    }
 
    CreatureTextHolder const& textHolder = sList->second;
    CreatureTextHolder::const_iterator itr = textHolder.find(textGroup);
    if (itr == textHolder.end())
    {
        LOG_ERROR("sql.sql", "CreatureTextMgr: Could not find TextGroup {} for Creature {} ({}). Ignoring.",
            uint32(textGroup), source->GetName(), source->GetGUID().ToString());
        return 0;
    }
 
    CreatureTextGroup const& textGroupContainer = itr->second;  //has all texts in the group
 
    // Check creature_text_options for this group
    CreatureTextOptions const* options = GetTextOptions(source->GetEntry(), textGroup);
    if (options)
    {
        if (options->playerOnly && (!target || !target->IsPlayer()))
            return 0;
 
        if (options->triggerChance < 100 && !roll_chance_i(options->triggerChance))
            return 0;
 
        if (options->cooldown > 0 && source->IsTextOnCooldown(textGroup))
            return 0;
    }
 
    CreatureTextRepeatIds repeatGroup = source->GetTextRepeatGroup(textGroup);//has all textIDs from the group that were already said
    CreatureTextGroup tempGroup;//will use this to talk after sorting repeatGroup
 
    for (CreatureTextGroup::const_iterator giter = textGroupContainer.begin(); giter != textGroupContainer.end(); ++giter)
        if (std::find(repeatGroup.begin(), repeatGroup.end(), giter->id) == repeatGroup.end())
            tempGroup.push_back(*giter);
 
    if (tempGroup.empty())
    {
        source->ClearTextRepeatGroup(textGroup);
        tempGroup = textGroupContainer;
    }
 
    auto iter = Acore::Containers::SelectRandomWeightedContainerElement(tempGroup, [](CreatureTextEntry const& t) -> double
    {
        return t.probability;
    });
 
    ChatMsg finalType = (msgType == CHAT_MSG_ADDON) ? iter->type : msgType;
    Language finalLang = (language == LANG_ADDON) ? iter->lang : language;
    uint32 finalSound = sound ? sound : iter->sound;
 
    if (range == TEXT_RANGE_NORMAL)
        range = iter->TextRange;
 
    if (finalSound)
        SendSound(source, finalSound, finalType, target, range, teamId, gmOnly);
 
    Unit* finalSource = source;
    if (srcPlr)
        finalSource = srcPlr;
 
    if (iter->emote)
        SendEmote(finalSource, iter->emote);
 
    if (srcPlr)
    {
        PlayerTextBuilder builder(source, finalSource, finalSource->getGender(), finalType, iter->group, iter->id, finalLang, target);
        SendChatPacket(finalSource, builder, finalType, target, range, teamId, gmOnly);
    }
    else
    {
        CreatureTextBuilder builder(finalSource, finalSource->getGender(), finalType, iter->group, iter->id, finalLang, target);
        SendChatPacket(finalSource, builder, finalType, target, range, teamId, gmOnly);
    }
 
    source->SetTextRepeatId(textGroup, iter->id);
 
    // Set cooldown if creature_text_options specifies one
    if (options && options->cooldown > 0)
        source->SetTextCooldown(textGroup, options->cooldown);
 
    return iter->duration;
}

References CHAT_MSG_ADDON, Creature::ClearTextRepeatGroup(), CreatureTextOptions::cooldown, Object::GetEntry(), Unit::getGender(), Object::GetGUID(), WorldObject::GetName(), GetTextOptions(), Creature::GetTextRepeatGroup(), Object::IsPlayer(), Creature::IsTextOnCooldown(), LANG_ADDON, LOG_ERROR, mTextMap, CreatureTextOptions::playerOnly, CreatureTextEntry::probability, roll_chance_i(), Acore::Containers::SelectRandomWeightedContainerElement(), SendChatPacket(), SendEmote(), SendSound(), Creature::SetTextCooldown(), Creature::SetTextRepeatId(), TEXT_RANGE_NORMAL, ObjectGuid::ToString(), and CreatureTextOptions::triggerChance.

SendChatPacket()

template<class Builder >

void CreatureTextMgr::SendChatPacket	(	WorldObject *	source,
		Builder const &	builder,
		ChatMsg	msgType,
		WorldObject const *	target = nullptr,
		CreatureTextRange	range = TEXT_RANGE_NORMAL,
		TeamId	teamId = TEAM_NEUTRAL,
		bool	gmOnly = false
	)		const

{
    if (!source)
        return;
 
    CreatureTextLocalizer<Builder> localizer(builder, msgType);
 
    switch (msgType)
    {
        case CHAT_MSG_MONSTER_WHISPER:
        case CHAT_MSG_RAID_BOSS_WHISPER:
            {
                if (range == TEXT_RANGE_NORMAL) // ignores team and GM only
                {
                    if (!target || !target->IsPlayer())
                        return;
 
                    localizer(const_cast<Player*>(target->ToPlayer()));
                    return;
                }
                break;
            }
        default:
            break;
    }
 
    switch (range)
    {
        case TEXT_RANGE_AREA:
            {
                uint32 areaId = source->GetAreaId();
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if (itr->GetSource()->GetAreaId() == areaId && (teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        localizer(itr->GetSource());
                return;
            }
        case TEXT_RANGE_ZONE:
            {
                uint32 zoneId = source->GetZoneId();
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if (itr->GetSource()->GetZoneId() == zoneId && (teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        localizer(itr->GetSource());
                return;
            }
        case TEXT_RANGE_MAP:
            {
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if ((teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        localizer(itr->GetSource());
                return;
            }
        case TEXT_RANGE_WORLD:
            {
                WorldSessionMgr::SessionMap const& smap = sWorldSessionMgr->GetAllSessions();
                for (WorldSessionMgr::SessionMap::const_iterator itr = smap.begin(); itr != smap.end(); ++itr)
                    if (Player* player = itr->second->GetPlayer())
                        if ((teamId == TEAM_NEUTRAL || player->GetTeamId() == teamId) && (!gmOnly || player->IsGameMaster()))
                            localizer(player);
                return;
            }
        case TEXT_RANGE_NORMAL:
        default:
            break;
    }
 
    float dist = GetRangeForChatType(msgType);
    // xinef: hack for boss emote
    if (msgType == CHAT_MSG_RAID_BOSS_EMOTE && source->GetMap()->IsDungeon())
        dist = 250.0f;
 
    Acore::PlayerDistWorker<CreatureTextLocalizer<Builder> > worker(source, dist, localizer);
    Cell::VisitObjects(source, worker, dist);
}

References MapRefMgr::begin(), CHAT_MSG_MONSTER_WHISPER, CHAT_MSG_RAID_BOSS_EMOTE, CHAT_MSG_RAID_BOSS_WHISPER, MapRefMgr::end(), WorldObject::GetAreaId(), WorldObject::GetMap(), Map::GetPlayers(), GetRangeForChatType(), WorldObject::GetZoneId(), Map::IsDungeon(), Object::IsPlayer(), sWorldSessionMgr, TEAM_NEUTRAL, TEXT_RANGE_AREA, TEXT_RANGE_MAP, TEXT_RANGE_NORMAL, TEXT_RANGE_WORLD, TEXT_RANGE_ZONE, Object::ToPlayer(), and Cell::VisitObjects().

Referenced by SendChat().

SendEmote()

void CreatureTextMgr::SendEmote	(	Unit *	source,
		uint32	emote
	)

{
    if (!source)
        return;
 
    source->HandleEmoteCommand(emote);
}

References Unit::HandleEmoteCommand().

Referenced by SendChat().

SendNonChatPacket()

void CreatureTextMgr::SendNonChatPacket ( WorldObject *  source, WorldPacket const *  data, ChatMsg  msgType, WorldObject const *  target, CreatureTextRange  range, TeamId  teamId, bool  gmOnly  ) const

private

{
    float dist = GetRangeForChatType(msgType);
 
    switch (msgType)
    {
        case CHAT_MSG_MONSTER_WHISPER:
        case CHAT_MSG_RAID_BOSS_WHISPER:
            {
                if (range == TEXT_RANGE_NORMAL) // ignores team and GM only
                {
                    if (!target || !target->IsPlayer())
                        return;
 
                    target->ToPlayer()->SendDirectMessage(data);
                    return;
                }
                break;
            }
        default:
            break;
    }
 
    switch (range)
    {
        case TEXT_RANGE_AREA:
            {
                uint32 areaId = source->GetAreaId();
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if (itr->GetSource()->GetAreaId() == areaId && (teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        itr->GetSource()->SendDirectMessage(data);
                return;
            }
        case TEXT_RANGE_ZONE:
            {
                uint32 zoneId = source->GetZoneId();
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if (itr->GetSource()->GetZoneId() == zoneId && (teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        itr->GetSource()->SendDirectMessage(data);
                return;
            }
        case TEXT_RANGE_MAP:
            {
                Map::PlayerList const& players = source->GetMap()->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                    if ((teamId == TEAM_NEUTRAL || itr->GetSource()->GetTeamId() == teamId) && (!gmOnly || itr->GetSource()->IsGameMaster()))
                        itr->GetSource()->SendDirectMessage(data);
                return;
            }
        case TEXT_RANGE_WORLD:
            {
                WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
                for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
                    if (Player* player = itr->second->GetPlayer())
                        if ((teamId == TEAM_NEUTRAL || player->GetTeamId() == teamId) && (!gmOnly || player->IsGameMaster()))
                            player->SendDirectMessage(data);
                return;
            }
        case TEXT_RANGE_NORMAL:
        default:
            break;
    }
 
    source->SendMessageToSetInRange(data, dist, true);
}

References MapRefMgr::begin(), CHAT_MSG_MONSTER_WHISPER, CHAT_MSG_RAID_BOSS_WHISPER, MapRefMgr::end(), WorldObject::GetAreaId(), WorldObject::GetMap(), Map::GetPlayers(), GetRangeForChatType(), WorldObject::GetZoneId(), Object::IsPlayer(), Player::SendDirectMessage(), WorldObject::SendMessageToSetInRange(), sWorldSessionMgr, TEAM_NEUTRAL, TEXT_RANGE_AREA, TEXT_RANGE_MAP, TEXT_RANGE_NORMAL, TEXT_RANGE_WORLD, TEXT_RANGE_ZONE, and Object::ToPlayer().

Referenced by SendSound().

SendSound()

void CreatureTextMgr::SendSound	(	Creature *	source,
		uint32	sound,
		ChatMsg	msgType,
		WorldObject const *	target,
		CreatureTextRange	range,
		TeamId	teamId,
		bool	gmOnly
	)

{
    if (!sound || !source)
        return;
 
    SendNonChatPacket(source, WorldPackets::Misc::Playsound(sound).Write(), msgType, target, range, teamId, gmOnly);
}

References SendNonChatPacket().

Referenced by SendChat().

TextExist()

bool CreatureTextMgr::TextExist	(	uint32	sourceEntry,
		uint8	textGroup
	)

{
    if (!sourceEntry)
        return false;
 
    CreatureTextMap::const_iterator sList = mTextMap.find(sourceEntry);
    if (sList == mTextMap.end())
    {
        LOG_DEBUG("entities.unit", "CreatureTextMgr::TextExist: Could not find Text for Creature (entry {}) in 'creature_text' table.", sourceEntry);
        return false;
    }
 
    CreatureTextHolder const& textHolder = sList->second;
    CreatureTextHolder::const_iterator itr = textHolder.find(textGroup);
    if (itr == textHolder.end())
    {
        LOG_DEBUG("entities.unit", "CreatureTextMgr::TextExist: Could not find TextGroup {} for Creature (entry {}).", uint32(textGroup), sourceEntry);
        return false;
    }
 
    return true;
}

References LOG_DEBUG, and mTextMap.

Member Data Documentation

mLocaleTextMap

LocaleCreatureTextMap CreatureTextMgr::mLocaleTextMap

private

Referenced by GetLocalizedChatString(), and LoadCreatureTextLocales().

mTextMap

CreatureTextMap CreatureTextMgr::mTextMap

private

Referenced by GetLocalizedChatString(), GetTextMap(), LoadCreatureTexts(), SendChat(), and TextExist().

mTextOptionsMap

CreatureTextOptionsContainer CreatureTextMgr::mTextOptionsMap

private

Referenced by GetTextOptions(), and LoadCreatureTextOptions().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Texts/CreatureTextMgr.h
• azerothcore-wotlk/src/server/game/Texts/CreatureTextMgr.cpp