ReputationMgr.cpp

Go to the documentation of this file.

/*
 * 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 "ReputationMgr.h"
#include "DatabaseEnv.h"
#include "DBCStores.h"
#include "Log.h"
#include "MapUtils.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
 
uint32 const ReputationRankStrIndex[MAX_REPUTATION_RANK] =
{
    LANG_REP_HATED,    LANG_REP_HOSTILE, LANG_REP_UNFRIENDLY, LANG_REP_NEUTRAL,
    LANG_REP_FRIENDLY, LANG_REP_HONORED, LANG_REP_REVERED,    LANG_REP_EXALTED
};
 
std::set<int32> const ReputationMgr::ReputationRankThresholds =
{
    -42000,
    // Hated
    -6000,
    // Hostile
    -3000,
    // Unfriendly
    0,
    // Neutral
    3000,
    // Friendly
    9000,
    // Honored
    21000,
    // Revered
    42000,
    // Exalted
    43000
};
 
const int32 ReputationMgr::Reputation_Cap = 42999;
const int32 ReputationMgr::Reputation_Bottom = -42000;
 
ReputationRank ReputationMgr::ReputationToRank(FactionEntry const* /*factionEntry*/, int32 standing)
{
    auto itr = ReputationRankThresholds.begin();
    auto end = ReputationRankThresholds.end();
    int32 rank = -1;
    while (itr != end && standing >= *itr)
    {
        ++rank;
        ++itr;
    }
 
    return ReputationRank(rank);
}
 
FactionState const* ReputationMgr::GetState(FactionEntry const* factionEntry) const
{
    return factionEntry->CanHaveReputation() ? GetState(factionEntry->ReputationIndex) : nullptr;
}
 
bool ReputationMgr::IsAtWar(uint32 faction_id) const
{
    FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
 
    if (!factionEntry)
    {
        TC_LOG_ERROR("misc", "ReputationMgr::IsAtWar: Can't get AtWar flag of {} for unknown faction (faction id) #{}.", _player->GetName(), faction_id);
        return 0;
    }
 
    return IsAtWar(factionEntry);
}
 
bool ReputationMgr::IsAtWar(FactionEntry const* factionEntry) const
{
    if (!factionEntry)
        return false;
 
    if (FactionState const* factionState = GetState(factionEntry))
        return factionState->Flags.HasFlag(ReputationFlags::AtWar);
    return false;
}
 
bool ReputationMgr::IsReputationAllowedForTeam(TeamId team, uint32 factionId) const
{
    // @hack some quests give reputation to Alliance-only AND Horde-only factions, but DBC data does not allow to identify faction-only reputations
    if (team == TEAM_HORDE && (
        factionId == 1037 || // Alliance Vanguard
        factionId == 946))   // Honor Hold
        return false;
 
    if (team == TEAM_ALLIANCE &&
        factionId == 947)    // Thrallmar
        return false;
 
    return true;
}
 
int32 ReputationMgr::GetReputation(uint32 faction_id) const
{
    FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
 
    if (!factionEntry)
    {
        TC_LOG_ERROR("misc", "ReputationMgr::GetReputation: Can't get reputation of {} for unknown faction (faction id) #{}.", _player->GetName(), faction_id);
        return 0;
    }
 
    return GetReputation(factionEntry);
}
 
int32 ReputationMgr::GetBaseReputation(FactionEntry const* factionEntry) const
{
    int32 dataIndex = GetFactionDataIndexForRaceAndClass(factionEntry);
    if (dataIndex < 0)
        return 0;
 
    return factionEntry->ReputationBase[dataIndex];
}
 
int32 ReputationMgr::GetMinReputation(FactionEntry const* /*factionEntry*/) const
{
    return Reputation_Bottom;
}
 
int32 ReputationMgr::GetMaxReputation(FactionEntry const* /*factionEntry*/) const
{
    return Reputation_Cap;
}
 
int32 ReputationMgr::GetReputation(FactionEntry const* factionEntry) const
{
    // Faction without recorded reputation. Just ignore.
    if (!factionEntry)
        return 0;
 
    if (FactionState const* state = GetState(factionEntry))
        return GetBaseReputation(factionEntry) + state->Standing;
 
    return 0;
}
 
ReputationRank ReputationMgr::GetRank(FactionEntry const* factionEntry) const
{
    int32 reputation = GetReputation(factionEntry);
    return ReputationToRank(factionEntry, reputation);
}
 
ReputationRank ReputationMgr::GetBaseRank(FactionEntry const* factionEntry) const
{
    int32 reputation = GetBaseReputation(factionEntry);
    return ReputationToRank(factionEntry, reputation);
}
 
std::string ReputationMgr::GetReputationRankName(FactionEntry const* factionEntry) const
{
    ReputationRank rank = GetRank(factionEntry);
    return sObjectMgr->GetTrinityString(ReputationRankStrIndex[rank], _player->GetSession()->GetSessionDbcLocale());
}
 
ReputationRank const* ReputationMgr::GetForcedRankIfAny(FactionTemplateEntry const* factionTemplateEntry) const
{
    return GetForcedRankIfAny(factionTemplateEntry->Faction);
}
 
ReputationRank const* ReputationMgr::GetForcedRankIfAny(uint32 factionId) const
{
    return Trinity::Containers::MapGetValuePtr(_forcedReactions, factionId);
}
 
void ReputationMgr::ApplyForceReaction(uint32 faction_id, ReputationRank rank, bool apply)
{
    if (apply)
        _forcedReactions[faction_id] = rank;
    else
        _forcedReactions.erase(faction_id);
}
 
ReputationFlags ReputationMgr::GetDefaultStateFlags(FactionEntry const* factionEntry) const
{
    int32 dataIndex = GetFactionDataIndexForRaceAndClass(factionEntry);
    if (dataIndex < 0)
        return ReputationFlags::None;
 
    return static_cast<ReputationFlags>(factionEntry->ReputationFlags[dataIndex]);
}
 
void ReputationMgr::SendForceReactions()
{
    WorldPacket data;
    data.Initialize(SMSG_SET_FORCED_REACTIONS, 4+_forcedReactions.size()*(4+4));
    data << uint32(_forcedReactions.size());
    for (ForcedReactions::const_iterator itr = _forcedReactions.begin(); itr != _forcedReactions.end(); ++itr)
    {
        data << uint32(itr->first);                         // faction_id (Faction.dbc)
        data << uint32(itr->second);                        // reputation rank
    }
    _player->SendDirectMessage(&data);
}
 
void ReputationMgr::SendState(FactionState const* faction)
{
    uint32 count = faction ? 1 : 0;
 
    WorldPacket data(SMSG_SET_FACTION_STANDING, 17);
    data << float(0);
    data << uint8(_sendFactionIncreased);
    _sendFactionIncreased = false; // Reset
 
    size_t p_count = data.wpos();
    data << uint32(count);
 
    if (faction)
    {
        data << uint32(faction->ReputationListID);
        data << uint32(faction->Standing);
    }
 
    for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
    {
        if (itr->second.needSend)
        {
            itr->second.needSend = false;
            if (!faction || itr->second.ReputationListID != faction->ReputationListID)
            {
                data << uint32(itr->second.ReputationListID);
                data << uint32(itr->second.Standing);
                ++count;
            }
        }
    }
 
    data.put<uint32>(p_count, count);
    _player->SendDirectMessage(&data);
}
 
void ReputationMgr::SendInitialReputations()
{
    uint8 count = 128;
    WorldPacket data(SMSG_INITIALIZE_FACTIONS, 4 + count * 5);
    data << uint32(count);
 
    RepListID a = 0;
 
    for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
    {
        // fill in absent fields
        for (; a != itr->first; ++a)
        {
            data << uint8(0);
            data << uint32(0);
        }
 
        // fill in encountered data
        data << uint8(itr->second.Flags.AsUnderlyingType());
        data << uint32(itr->second.Standing);
 
        itr->second.needSend = false;
 
        ++a;
    }
 
    // fill in absent fields
    for (; a != count; ++a)
    {
        data << uint8(0);
        data << uint32(0);
    }
 
    _player->SendDirectMessage(&data);
}
 
void ReputationMgr::SendVisible(FactionState const* faction) const
{
    if (_player->GetSession()->PlayerLoading())
        return;
 
    // make faction visible in reputation list at client
    WorldPacket data(SMSG_SET_FACTION_VISIBLE, 4);
    data << faction->ReputationListID;
    _player->SendDirectMessage(&data);
}
 
void ReputationMgr::Initialize()
{
    _factions.clear();
    _visibleFactionCount = 0;
    _honoredFactionCount = 0;
    _reveredFactionCount = 0;
    _exaltedFactionCount = 0;
    _sendFactionIncreased = false;
 
    for (unsigned int i = 1; i < sFactionStore.GetNumRows(); i++)
    {
        FactionEntry const* factionEntry = sFactionStore.LookupEntry(i);
 
        if (factionEntry && (factionEntry->ReputationIndex >= 0))
        {
            FactionState newFaction;
            newFaction.ID = factionEntry->ID;
            newFaction.ReputationListID = factionEntry->ReputationIndex;
            newFaction.Standing = 0;
            newFaction.Flags = GetDefaultStateFlags(factionEntry);
            newFaction.needSend = true;
            newFaction.needSave = true;
 
            if (newFaction.Flags.HasFlag(ReputationFlags::Visible))
                ++_visibleFactionCount;
 
            UpdateRankCounters(REP_HOSTILE, GetBaseRank(factionEntry));
 
            _factions[newFaction.ReputationListID] = newFaction;
        }
    }
}
 
bool ReputationMgr::SetReputation(FactionEntry const* factionEntry, int32 standing, bool incremental, bool spillOverOnly)
{
    sScriptMgr->OnPlayerReputationChange(_player, factionEntry->ID, standing, incremental);
    bool res = false;
    // if spillover definition exists in DB, override DBC
    if (RepSpilloverTemplate const* repTemplate = sObjectMgr->GetRepSpilloverTemplate(factionEntry->ID))
    {
        for (uint32 i = 0; i < MAX_SPILLOVER_FACTIONS; ++i)
        {
            if (repTemplate->faction[i])
            {
                if (_player->GetReputationRank(repTemplate->faction[i]) <= ReputationRank(repTemplate->faction_rank[i]))
                {
                    // bonuses are already given, so just modify standing by rate
                    int32 spilloverRep = int32(standing * repTemplate->faction_rate[i]);
                    SetOneFactionReputation(sFactionStore.AssertEntry(repTemplate->faction[i]), spilloverRep, incremental);
                }
            }
        }
    }
    else
    {
        float spillOverRepOut = float(standing);
        // check for sub-factions that receive spillover
        SimpleFactionsList const* flist = GetFactionTeamList(factionEntry->ID);
        // if has no sub-factions, check for factions with same parent
        if (!flist && factionEntry->ParentFactionID && factionEntry->ParentFactionMod[1] != 0.0f)
        {
            spillOverRepOut *= factionEntry->ParentFactionMod[1];
            if (FactionEntry const* parent = sFactionStore.LookupEntry(factionEntry->ParentFactionID))
            {
                FactionStateList::iterator parentState = _factions.find(parent->ReputationIndex);
                // some team factions have own reputation standing, in this case do not spill to other sub-factions
                if (parentState != _factions.end() && parentState->second.Flags.HasFlag(ReputationFlags::HeaderShowsBar))
                {
                    SetOneFactionReputation(parent, int32(spillOverRepOut), incremental);
                }
                else    // spill to "sister" factions
                {
                    flist = GetFactionTeamList(factionEntry->ParentFactionID);
                }
            }
        }
        if (flist)
        {
            // Spillover to affiliated factions
            for (SimpleFactionsList::const_iterator itr = flist->begin(); itr != flist->end(); ++itr)
            {
                if (FactionEntry const* factionEntryCalc = sFactionStore.LookupEntry(*itr))
                {
                    if (factionEntryCalc == factionEntry || GetRank(factionEntryCalc) > ReputationRank(factionEntryCalc->ParentFactionCap[0]))
                        continue;
                    int32 spilloverRep = int32(spillOverRepOut * factionEntryCalc->ParentFactionMod[0]);
                    if (spilloverRep != 0 || !incremental)
                        res = SetOneFactionReputation(factionEntryCalc, spilloverRep, incremental);
                }
            }
        }
    }
 
    // spillover done, update faction itself
    FactionStateList::iterator faction = _factions.find(factionEntry->ReputationIndex);
    if (faction != _factions.end())
    {
        // if we update spillover only, do not update main reputation (rank exceeds creature reward rate)
        if (!spillOverOnly)
            res = SetOneFactionReputation(factionEntry, standing, incremental);
 
        // only this faction gets reported to client, even if it has no own visible standing
        SendState(&faction->second);
    }
    return res;
}
 
bool ReputationMgr::SetOneFactionReputation(FactionEntry const* factionEntry, int32 standing, bool incremental)
{
    FactionStateList::iterator itr = _factions.find(factionEntry->ReputationIndex);
    if (itr != _factions.end())
    {
        int32 BaseRep = GetBaseReputation(factionEntry);
 
        if (incremental)
        {
            // int32 *= float cause one point loss?
            standing = int32(floor((float)standing * sWorld->getRate(RATE_REPUTATION_GAIN) + 0.5f));
            standing += itr->second.Standing + BaseRep;
        }
 
        if (standing > GetMaxReputation(factionEntry))
            standing = GetMaxReputation(factionEntry);
        else if (standing < GetMinReputation(factionEntry))
            standing = GetMinReputation(factionEntry);
 
        ReputationRank old_rank = ReputationToRank(factionEntry, itr->second.Standing + BaseRep);
        ReputationRank new_rank = ReputationToRank(factionEntry, standing);
 
        itr->second.Standing = standing - BaseRep;
        itr->second.needSend = true;
        itr->second.needSave = true;
 
        SetVisible(&itr->second);
 
        if (new_rank <= REP_HOSTILE)
            SetAtWar(&itr->second, true);
        else if (new_rank > old_rank)
            SetAtWar(&itr->second, false);
 
        if (new_rank > old_rank)
            _sendFactionIncreased = true;
 
        UpdateRankCounters(old_rank, new_rank);
 
        _player->ReputationChanged(factionEntry);
        _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS,          factionEntry->ID);
        _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION,         factionEntry->ID);
        _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION, factionEntry->ID);
        _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION, factionEntry->ID);
        _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION, factionEntry->ID);
 
        return true;
    }
    return false;
}
 
void ReputationMgr::SetVisible(FactionTemplateEntry const*factionTemplateEntry)
{
    if (!factionTemplateEntry->Faction)
        return;
 
    if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplateEntry->Faction))
        // Never show factions of the opposing team
        if (!(factionEntry->ReputationRaceMask[1] & _player->GetRaceMask() && factionEntry->ReputationBase[1] == Reputation_Bottom))
            SetVisible(factionEntry);
}
 
void ReputationMgr::SetVisible(FactionEntry const* factionEntry)
{
    if (factionEntry->ReputationIndex < 0)
        return;
 
    FactionStateList::iterator itr = _factions.find(factionEntry->ReputationIndex);
    if (itr == _factions.end())
        return;
 
    SetVisible(&itr->second);
}
 
void ReputationMgr::SetVisible(FactionState* faction)
{
    // always invisible or hidden faction can't be make visible
    if (faction->Flags.HasFlag(ReputationFlags::Hidden))
        return;
 
    if (faction->Flags.HasFlag(ReputationFlags::Header) && !faction->Flags.HasFlag(ReputationFlags::HeaderShowsBar))
        return;
 
    // already set
    if (faction->Flags.HasFlag(ReputationFlags::Visible))
        return;
 
    faction->Flags |= ReputationFlags::Visible;
    faction->needSend = true;
    faction->needSave = true;
 
    ++_visibleFactionCount;
 
    SendVisible(faction);
}
 
void ReputationMgr::SetAtWar(RepListID repListID, bool on)
{
    FactionStateList::iterator itr = _factions.find(repListID);
    if (itr == _factions.end())
        return;
 
    // always invisible or hidden faction can't change war state
    if (itr->second.Flags.HasFlag(ReputationFlags::Hidden | ReputationFlags::Header))
        return;
 
    SetAtWar(&itr->second, on);
}
 
void ReputationMgr::SetAtWar(FactionState* faction, bool atWar) const
{
    // Do not allow to declare war to our own faction. But allow for rival factions (eg Aldor vs Scryer).
    if (atWar && faction->Flags.HasFlag(ReputationFlags::Peaceful) && GetRank(sFactionStore.AssertEntry(faction->ID)) > REP_HATED)
        return;
 
    // already set
    if (faction->Flags.HasFlag(ReputationFlags::AtWar) == atWar)
        return;
 
    if (atWar)
        faction->Flags |= ReputationFlags::AtWar;
    else
        faction->Flags &= ~ReputationFlags::AtWar;
 
    faction->needSend = true;
    faction->needSave = true;
}
 
void ReputationMgr::SetInactive(RepListID repListID, bool on)
{
    FactionStateList::iterator itr = _factions.find(repListID);
    if (itr == _factions.end())
        return;
 
    SetInactive(&itr->second, on);
}
 
void ReputationMgr::SetInactive(FactionState* faction, bool inactive) const
{
    // always invisible or hidden faction can't be inactive
    if (faction->Flags.HasFlag(ReputationFlags::Hidden | ReputationFlags::Header) || !faction->Flags.HasFlag(ReputationFlags::Visible))
        return;
 
    // already set
    if (faction->Flags.HasFlag(ReputationFlags::Inactive) == inactive)
        return;
 
    if (inactive)
        faction->Flags |= ReputationFlags::Inactive;
    else
        faction->Flags &= ~ReputationFlags::Inactive;
 
    faction->needSend = true;
    faction->needSave = true;
}
 
void ReputationMgr::LoadFromDB(PreparedQueryResult result)
{
    // Set initial reputations (so everything is nifty before DB data load)
    Initialize();
 
    //QueryResult* result = CharacterDatabase.PQuery("SELECT faction, standing, flags FROM character_reputation WHERE guid = '{}'", GetGUID().GetCounter());
 
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
 
            FactionEntry const* factionEntry = sFactionStore.LookupEntry(fields[0].GetUInt16());
            if (factionEntry && (factionEntry->ReputationIndex >= 0))
            {
                FactionState* faction = &_factions[factionEntry->ReputationIndex];
 
                // update standing to current
                faction->Standing = fields[1].GetInt32();
 
                // update counters
                int32 BaseRep = GetBaseReputation(factionEntry);
                ReputationRank old_rank = ReputationToRank(factionEntry, BaseRep);
                ReputationRank new_rank = ReputationToRank(factionEntry, BaseRep + faction->Standing);
                UpdateRankCounters(old_rank, new_rank);
 
                EnumFlag<ReputationFlags> dbFactionFlags = static_cast<ReputationFlags>(fields[2].GetUInt16());
 
                if (dbFactionFlags.HasFlag(ReputationFlags::Visible))
                    SetVisible(faction);                                    // have internal checks for forced invisibility
 
                if (dbFactionFlags.HasFlag(ReputationFlags::Inactive))
                    SetInactive(faction, true);                             // have internal checks for visibility requirement
 
                if (dbFactionFlags.HasFlag(ReputationFlags::AtWar))    // DB at war
                    SetAtWar(faction, true);                                // have internal checks for ReputationFlags::Peaceful
                else                                                        // DB not at war
                {
                    // allow remove if visible (and then not FACTION_FLAG_INVISIBLE_FORCED or FACTION_FLAG_HIDDEN)
                    if (faction->Flags.HasFlag(ReputationFlags::Visible))
                        SetAtWar(faction, false);                           // have internal checks for ReputationFlags::Peaceful
                }
 
                // set atWar for hostile
                if (GetRank(factionEntry) <= REP_HOSTILE)
                    SetAtWar(faction, true);
 
                // reset changed flag if values similar to saved in DB
                if (faction->Flags == dbFactionFlags)
                {
                    faction->needSend = false;
                    faction->needSave = false;
                }
            }
        }
        while (result->NextRow());
    }
}
 
void ReputationMgr::SaveToDB(CharacterDatabaseTransaction trans)
{
    for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
    {
        if (itr->second.needSave)
        {
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_REPUTATION_BY_FACTION);
            stmt->setUInt32(0, _player->GetGUID().GetCounter());
            stmt->setUInt16(1, uint16(itr->second.ID));
            trans->Append(stmt);
 
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_REPUTATION_BY_FACTION);
            stmt->setUInt32(0, _player->GetGUID().GetCounter());
            stmt->setUInt16(1, uint16(itr->second.ID));
            stmt->setInt32(2, itr->second.Standing);
            stmt->setUInt16(3, itr->second.Flags.AsUnderlyingType());
            trans->Append(stmt);
 
            itr->second.needSave = false;
        }
    }
}
 
void ReputationMgr::UpdateRankCounters(ReputationRank old_rank, ReputationRank new_rank)
{
    if (old_rank >= REP_EXALTED)
        --_exaltedFactionCount;
    if (old_rank >= REP_REVERED)
        --_reveredFactionCount;
    if (old_rank >= REP_HONORED)
        --_honoredFactionCount;
 
    if (new_rank >= REP_EXALTED)
        ++_exaltedFactionCount;
    if (new_rank >= REP_REVERED)
        ++_reveredFactionCount;
    if (new_rank >= REP_HONORED)
        ++_honoredFactionCount;
}
 
int32 ReputationMgr::GetFactionDataIndexForRaceAndClass(FactionEntry const* factionEntry) const
{
    if (!factionEntry)
        return -1;
 
    uint32 raceMask = _player->GetRaceMask();
    uint32 classMask = _player->GetClassMask();
    for (int32 i = 0; i < 4; i++)
    {
        if ((factionEntry->ReputationRaceMask[i] & raceMask || (!factionEntry->ReputationRaceMask[i] && factionEntry->ReputationClassMask[i] != 0))
            && (factionEntry->ReputationClassMask[i] & classMask || factionEntry->ReputationClassMask[i] == 0))
 
            return i;
    }
 
    return -1;
}