ReputationMgr Class Reference

#include "ReputationMgr.h"

Public Member Functions
	ReputationMgr (Player *owner)
	~ReputationMgr ()
void	SaveToDB (CharacterDatabaseTransaction trans)
void	LoadFromDB (PreparedQueryResult result)
uint8	GetVisibleFactionCount () const
uint8	GetHonoredFactionCount () const
uint8	GetReveredFactionCount () const
uint8	GetExaltedFactionCount () const
FactionStateList const &	GetStateList () const
FactionState const *	GetState (FactionEntry const *factionEntry) const
FactionState const *	GetState (RepListID id) const
bool	IsAtWar (uint32 faction_id) const
bool	IsAtWar (FactionEntry const *factionEntry) const
int32	GetReputation (uint32 faction_id) const
int32	GetReputation (FactionEntry const *factionEntry) const
int32	GetBaseReputation (FactionEntry const *factionEntry) const
ReputationRank	GetRank (FactionEntry const *factionEntry) const
ReputationRank	GetBaseRank (FactionEntry const *factionEntry) const
uint32	GetReputationRankStrIndex (FactionEntry const *factionEntry) const
ReputationRank const *	GetForcedRankIfAny (FactionTemplateEntry const *factionTemplateEntry) const
bool	SetReputation (FactionEntry const *factionEntry, float standing)
bool	ModifyReputation (FactionEntry const *factionEntry, float standing, bool noSpillOver=false, Optional< ReputationRank > repMaxCap={})
void	SetVisible (FactionTemplateEntry const *factionTemplateEntry)
void	SetVisible (FactionEntry const *factionEntry)
void	SetAtWar (RepListID repListID, bool on)
void	SetInactive (RepListID repListID, bool on)
void	ApplyForceReaction (uint32 faction_id, ReputationRank rank, bool apply)
bool	SetOneFactionReputation (FactionEntry const *factionEntry, float standing, bool incremental, Optional< ReputationRank > repMaxCap={ })
	Public for chat command needs. More...
void	SendInitialReputations ()
void	SendForceReactions ()
void	SendState (FactionState const *faction)
void	SendStates ()

Static Public Member Functions
static ReputationRank	ReputationToRank (int32 standing)
static int32	ReputationRankToStanding (ReputationRank rank)

Static Public Attributes
static const int32	PointsInRank [MAX_REPUTATION_RANK] = {36000, 3000, 3000, 3000, 6000, 12000, 21000, 1000}
static const int32	Reputation_Cap = 42999
static const int32	Reputation_Bottom = -42000

Private Member Functions
void	Initialize ()
uint32	GetDefaultStateFlags (FactionEntry const *factionEntry) const
bool	SetReputation (FactionEntry const *factionEntry, float standing, bool incremental, bool noSpillOver=false, Optional< ReputationRank > repMaxCap={ })
void	SetVisible (FactionState *faction)
void	SetAtWar (FactionState *faction, bool atWar) const
void	SetInactive (FactionState *faction, bool inactive) const
void	SendVisible (FactionState const *faction) const
void	UpdateRankCounters (ReputationRank old_rank, ReputationRank new_rank)

Private Attributes
Player *	_player
FactionStateList	_factions
ForcedReactions	_forcedReactions
uint8	_visibleFactionCount: 8
uint8	_honoredFactionCount: 8
uint8	_reveredFactionCount: 8
uint8	_exaltedFactionCount: 8
bool	_sendFactionIncreased

Detailed Description

Constructor & Destructor Documentation

ReputationMgr()

ReputationMgr::ReputationMgr ( Player *  owner )

inlineexplicit

                                          : _player(owner),
        _visibleFactionCount(0), _honoredFactionCount(0), _reveredFactionCount(0), _exaltedFactionCount(0), _sendFactionIncreased(false) {}

~ReputationMgr()

ReputationMgr::~ReputationMgr ( )

inline

{}

Member Function Documentation

ApplyForceReaction()

void ReputationMgr::ApplyForceReaction	(	uint32	faction_id,
		ReputationRank	rank,
		bool	apply
	)

{
    if (apply)
        _forcedReactions[faction_id] = rank;
    else
        _forcedReactions.erase(faction_id);
}

References _forcedReactions.

Referenced by AuraEffect::HandleForceReaction().

GetBaseRank()

ReputationRank ReputationMgr::GetBaseRank

(

FactionEntry const *

factionEntry

)

const

{
    int32 reputation = GetBaseReputation(factionEntry);
    return ReputationToRank(reputation);
}

References GetBaseReputation(), and ReputationToRank().

Referenced by Initialize().

GetBaseReputation()

int32 ReputationMgr::GetBaseReputation

(

FactionEntry const *

factionEntry

)

const

{
    if (!factionEntry)
        return 0;
 
    uint32 raceMask = _player->getRaceMask();
    uint32 classMask = _player->getClassMask();
    for (int i = 0; i < 4; i++)
    {
        if ((factionEntry->BaseRepRaceMask[i] & raceMask  ||
                (factionEntry->BaseRepRaceMask[i] == 0  &&
                 factionEntry->BaseRepClassMask[i] != 0)) &&
                (factionEntry->BaseRepClassMask[i] & classMask ||
                 factionEntry->BaseRepClassMask[i] == 0))
 
            return factionEntry->BaseRepValue[i];
    }
 
    // in faction.dbc exist factions with (RepListId >=0, listed in character reputation list) with all BaseRepRaceMask[i] == 0
    return 0;
}

References _player, FactionEntry::BaseRepClassMask, FactionEntry::BaseRepRaceMask, FactionEntry::BaseRepValue, Unit::getClassMask(), and Unit::getRaceMask().

Referenced by GetBaseRank(), GetReputation(), LoadFromDB(), and SetOneFactionReputation().

GetDefaultStateFlags()

uint32 ReputationMgr::GetDefaultStateFlags ( FactionEntry const *  factionEntry ) const

private

{
    if (!factionEntry)
        return 0;
 
    uint32 raceMask = _player->getRaceMask();
    uint32 classMask = _player->getClassMask();
    for (int i = 0; i < 4; i++)
    {
        if ((factionEntry->BaseRepRaceMask[i] & raceMask  ||
                (factionEntry->BaseRepRaceMask[i] == 0  &&
                 factionEntry->BaseRepClassMask[i] != 0)) &&
                (factionEntry->BaseRepClassMask[i] & classMask ||
                 factionEntry->BaseRepClassMask[i] == 0))
 
            return factionEntry->ReputationFlags[i];
    }
    return 0;
}

References _player, FactionEntry::BaseRepClassMask, FactionEntry::BaseRepRaceMask, Unit::getClassMask(), Unit::getRaceMask(), and FactionEntry::ReputationFlags.

Referenced by Initialize().

GetExaltedFactionCount()

uint8 ReputationMgr::GetExaltedFactionCount ( ) const

inline

{ return _exaltedFactionCount; }

References _exaltedFactionCount.

GetForcedRankIfAny()

ReputationRank const * ReputationMgr::GetForcedRankIfAny ( FactionTemplateEntry const *  factionTemplateEntry ) const

inline

    {
        ForcedReactions::const_iterator forceItr = _forcedReactions.find(factionTemplateEntry->faction);
        return forceItr != _forcedReactions.end() ? &forceItr->second : nullptr;
    }

References _forcedReactions, and FactionTemplateEntry::faction.

Referenced by Unit::_IsValidAttackTarget(), and Unit::GetReactionTo().

GetHonoredFactionCount()

uint8 ReputationMgr::GetHonoredFactionCount ( ) const

inline

{ return _honoredFactionCount; }

References _honoredFactionCount.

GetRank()

ReputationRank ReputationMgr::GetRank

(

FactionEntry const *

factionEntry

)

const

{
    int32 reputation = GetReputation(factionEntry);
    return ReputationToRank(reputation);
}

References GetReputation(), and ReputationToRank().

Referenced by Player::GetReputationRank(), GetReputationRankStrIndex(), character_commandscript::HandleCharacterReputationCommand(), LoadFromDB(), and SetReputation().

GetReputation() [1/2]

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;
}

References GetBaseReputation(), and GetState().

GetReputation() [2/2]

int32 ReputationMgr::GetReputation

(

uint32

faction_id

)

const

{
    FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
 
    if (!factionEntry)
    {
        LOG_ERROR("reputation", "ReputationMgr::GetReputation: Can't get reputation of {} for unknown faction (faction id) #{}.", _player->GetName(), faction_id);
        return 0;
    }
 
    return GetReputation(factionEntry);
}

References _player, WorldObject::GetName(), GetReputation(), LOG_ERROR, and sFactionStore.

Referenced by GetRank(), GetReputation(), Player::GetReputation(), character_commandscript::HandleCharacterReputationCommand(), spell_gen_oracle_wolvar_reputation::HandleDummy(), lookup_commandscript::HandleLookupFactionCommand(), modify_commandscript::HandleModifyRepCommand(), and AchievementMgr::UpdateAchievementCriteria().

GetReputationRankStrIndex()

uint32 ReputationMgr::GetReputationRankStrIndex ( FactionEntry const *  factionEntry ) const

inline

    {
        return ReputationRankStrIndex[GetRank(factionEntry)];
    };

References GetRank(), and ReputationRankStrIndex.

Referenced by lookup_commandscript::HandleLookupFactionCommand().

GetReveredFactionCount()

uint8 ReputationMgr::GetReveredFactionCount ( ) const

inline

{ return _reveredFactionCount; }

References _reveredFactionCount.

GetState() [1/2]

FactionState const * ReputationMgr::GetState ( FactionEntry const *  factionEntry ) const

inline

    {
        return factionEntry->CanHaveReputation() ? GetState(factionEntry->reputationListID) : nullptr;
    }

References FactionEntry::CanHaveReputation(), GetState(), and FactionEntry::reputationListID.

Referenced by Unit::_IsValidAttackTarget(), GetReputation(), GetState(), lookup_commandscript::HandleLookupFactionCommand(), modify_commandscript::HandleModifyRepCommand(), and IsAtWar().

GetState() [2/2]

FactionState const * ReputationMgr::GetState ( RepListID  id ) const

inline

    {
        FactionStateList::const_iterator repItr = _factions.find (id);
        return repItr != _factions.end() ? &repItr->second : nullptr;
    }

References _factions.

GetStateList()

FactionStateList const & ReputationMgr::GetStateList ( ) const

inline

{ return _factions; }

References _factions.

Referenced by character_commandscript::HandleCharacterReputationCommand().

GetVisibleFactionCount()

uint8 ReputationMgr::GetVisibleFactionCount ( ) const

inline

{ return _visibleFactionCount; }

References _visibleFactionCount.

Initialize()

void ReputationMgr::Initialize ( )

private

{
    _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->reputationListID >= 0))
        {
            FactionState newFaction;
            newFaction.ID = factionEntry->ID;
            newFaction.ReputationListID = factionEntry->reputationListID;
            newFaction.Standing = 0;
            newFaction.Flags = GetDefaultStateFlags(factionEntry);
            newFaction.needSend = true;
            newFaction.needSave = true;
            newFaction.roundedUp = false;
 
            if (newFaction.Flags & FACTION_FLAG_VISIBLE)
                ++_visibleFactionCount;
 
            UpdateRankCounters(REP_HOSTILE, GetBaseRank(factionEntry));
 
            _factions[newFaction.ReputationListID] = newFaction;
        }
    }
}

References _exaltedFactionCount, _factions, _honoredFactionCount, _reveredFactionCount, _sendFactionIncreased, _visibleFactionCount, FACTION_FLAG_VISIBLE, FactionState::Flags, GetBaseRank(), GetDefaultStateFlags(), FactionState::ID, FactionEntry::ID, FactionState::needSave, FactionState::needSend, REP_HOSTILE, FactionState::ReputationListID, FactionEntry::reputationListID, FactionState::roundedUp, sFactionStore, FactionState::Standing, and UpdateRankCounters().

Referenced by LoadFromDB().

IsAtWar() [1/2]

bool ReputationMgr::IsAtWar

(

FactionEntry const *

factionEntry

)

const

{
    if (!factionEntry)
        return false;
 
    if (FactionState const* factionState = GetState(factionEntry))
        return (factionState->Flags & FACTION_FLAG_AT_WAR);
    return false;
}

References FACTION_FLAG_AT_WAR, and GetState().

IsAtWar() [2/2]

bool ReputationMgr::IsAtWar

(

uint32

faction_id

)

const

{
    FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction_id);
 
    if (!factionEntry)
    {
        LOG_ERROR("reputation", "ReputationMgr::IsAtWar: Can't get AtWar flag of {} for unknown faction (faction id) #{}.", _player->GetName(), faction_id);
        return 0;
    }
 
    return IsAtWar(factionEntry);
}

References _player, WorldObject::GetName(), IsAtWar(), LOG_ERROR, and sFactionStore.

Referenced by Unit::GetReactionTo(), and IsAtWar().

LoadFromDB()

void ReputationMgr::LoadFromDB

(

PreparedQueryResult

result

)

{
    // Set initial reputations (so everything is nifty before DB data load)
    Initialize();
 
    //QueryResult* result = CharacterDatabase.Query("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].Get<uint16>());
            if (factionEntry && (factionEntry->reputationListID >= 0))
            {
                FactionState* faction = &_factions[factionEntry->reputationListID];
 
                // update standing to current
                faction->Standing = fields[1].Get<int32>();
 
                // update counters
                int32 BaseRep = GetBaseReputation(factionEntry);
                ReputationRank old_rank = ReputationToRank(BaseRep);
                ReputationRank new_rank = ReputationToRank(BaseRep + faction->Standing);
                UpdateRankCounters(old_rank, new_rank);
 
                uint32 dbFactionFlags = fields[2].Get<uint16>();
 
                if (dbFactionFlags & FACTION_FLAG_VISIBLE)
                    SetVisible(faction);                    // have internal checks for forced invisibility
 
                if (dbFactionFlags & FACTION_FLAG_INACTIVE)
                    SetInactive(faction, true);              // have internal checks for visibility requirement
 
                if (dbFactionFlags & FACTION_FLAG_AT_WAR)  // DB at war
                {
                    // Xinef: dont set at war for friendly hidden reputations
                    SetAtWar(faction, bool(!(dbFactionFlags & FACTION_FLAG_HIDDEN) || GetRank(factionEntry) < REP_NEUTRAL)); // have internal checks for FACTION_FLAG_PEACE_FORCED
                }
                else                                        // DB not at war
                {
                    // allow remove if visible (and then not FACTION_FLAG_INVISIBLE_FORCED or FACTION_FLAG_HIDDEN)
                    if (faction->Flags & FACTION_FLAG_VISIBLE)
                        SetAtWar(faction, false);            // have internal checks for FACTION_FLAG_PEACE_FORCED
                }
 
                // 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;
                }
 
                faction->roundedUp = false;
            }
        } while (result->NextRow());
    }
}

References _factions, FACTION_FLAG_AT_WAR, FACTION_FLAG_HIDDEN, FACTION_FLAG_INACTIVE, FACTION_FLAG_VISIBLE, FactionState::Flags, Field::Get(), GetBaseReputation(), GetRank(), Initialize(), FactionState::needSave, FactionState::needSend, REP_HOSTILE, REP_NEUTRAL, FactionEntry::reputationListID, ReputationToRank(), FactionState::roundedUp, SetAtWar(), SetInactive(), SetVisible(), sFactionStore, FactionState::Standing, and UpdateRankCounters().

Referenced by Player::LoadFromDB().

ModifyReputation()

bool ReputationMgr::ModifyReputation ( FactionEntry const *  factionEntry, float  standing, bool  noSpillOver = false, Optional< ReputationRank >  repMaxCap = {}  )

inline

                                                                                                                                           {})
    {
        return SetReputation(factionEntry, standing, true, noSpillOver, repMaxCap);
    }

Referenced by Spell::EffectReputation(), OutdoorPvPSI::HandleAreaTrigger(), and Player::RewardReputation().

ReputationRankToStanding()

int32 ReputationMgr::ReputationRankToStanding ( ReputationRank  rank )

static

{
    int32 standing = Reputation_Bottom;
    for (uint8 i = MIN_REPUTATION_RANK; i <= rank; ++i)
    {
        standing += PointsInRank[i];
    }
 
    return std::max(standing - 1, Reputation_Bottom);
}

References MIN_REPUTATION_RANK, PointsInRank, and Reputation_Bottom.

Referenced by SetOneFactionReputation().

ReputationToRank()

ReputationRank ReputationMgr::ReputationToRank ( int32  standing )

static

{
    int32 limit = Reputation_Cap + 1;
    for (int i = MAX_REPUTATION_RANK - 1; i >= MIN_REPUTATION_RANK; --i)
    {
        limit -= PointsInRank[i];
        if (standing >= limit)
            return ReputationRank(i);
    }
    return MIN_REPUTATION_RANK;
}

References MAX_REPUTATION_RANK, MIN_REPUTATION_RANK, PointsInRank, and Reputation_Cap.

Referenced by GetBaseRank(), GetRank(), LoadFromDB(), and SetOneFactionReputation().

SaveToDB()

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->SetData(0, _player->GetGUID().GetCounter());
            stmt->SetData(1, uint16(itr->second.ID));
            trans->Append(stmt);
 
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_REPUTATION_BY_FACTION);
            stmt->SetData(0, _player->GetGUID().GetCounter());
            stmt->SetData(1, uint16(itr->second.ID));
            stmt->SetData(2, itr->second.Standing);
            stmt->SetData(3, uint16(itr->second.Flags));
            trans->Append(stmt);
 
            itr->second.needSave = false;
        }
    }
}

References _factions, _player, CHAR_DEL_CHAR_REPUTATION_BY_FACTION, CHAR_INS_CHAR_REPUTATION_BY_FACTION, CharacterDatabase, ObjectGuid::GetCounter(), Object::GetGUID(), and PreparedStatementBase::SetData().

Referenced by Player::SaveToDB().

SendForceReactions()

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);
}

References _forcedReactions, _player, WorldPacket::Initialize(), Player::SendDirectMessage(), and SMSG_SET_FORCED_REACTIONS.

Referenced by AuraEffect::HandleForceReaction(), and Player::SendInitialPacketsBeforeAddToMap().

SendInitialReputations()

void ReputationMgr::SendInitialReputations

(

)

{
    WorldPacket data(SMSG_INITIALIZE_FACTIONS, (4 + 128 * 5));
    data << uint32 (0x00000080);
 
    RepListID a = 0;
 
    for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
    {
        // fill in absent fields
        for (; a != itr->first; a++)
        {
            data << uint8  (0x00);
            data << uint32 (0x00000000);
        }
 
        // fill in encountered data
        data << uint8  (itr->second.Flags);
        data << uint32 (itr->second.Standing);
 
        itr->second.needSend = false;
 
        ++a;
    }
 
    // fill in absent fields
    for (; a != 128; a++)
    {
        data << uint8  (0x00);
        data << uint32 (0x00000000);
    }
 
    _player->SendDirectMessage(&data);
}

References _factions, _player, Player::SendDirectMessage(), and SMSG_INITIALIZE_FACTIONS.

Referenced by Player::SendInitialPacketsBeforeAddToMap().

SendState()

void ReputationMgr::SendState

(

FactionState const *

faction

)

{
    uint32 count = 1;
 
    WorldPacket data(SMSG_SET_FACTION_STANDING, 17);
    data << float(0);
    data << uint8(_sendFactionIncreased);
    _sendFactionIncreased = false; // Reset
 
    std::size_t p_count = data.wpos();
    data << uint32(count);
 
    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 (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);
}

References _factions, _player, _sendFactionIncreased, ByteBuffer::put(), FactionState::ReputationListID, Player::SendDirectMessage(), SMSG_SET_FACTION_STANDING, FactionState::Standing, and ByteBuffer::wpos().

Referenced by modify_commandscript::HandleModifyRepCommand(), SendStates(), and SetReputation().

SendStates()

void ReputationMgr::SendStates

(

)

{
    for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
        SendState(&(itr->second));
}

References _factions, and SendState().

Referenced by WorldSession::HandlePlayerLoginFromDB(), and WorldSession::HandleSetFactionCheat().

SendVisible()

void ReputationMgr::SendVisible ( FactionState const *  faction ) const

private

{
    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);
}

References _player, Player::GetSession(), WorldSession::PlayerLoading(), FactionState::ReputationListID, Player::SendDirectMessage(), and SMSG_SET_FACTION_VISIBLE.

Referenced by SetVisible().

SetAtWar() [1/2]

void ReputationMgr::SetAtWar ( FactionState *  faction, bool  atWar  ) const

private

{
    // not allow declare war to own faction
    if (atWar && (faction->Flags & FACTION_FLAG_PEACE_FORCED))
        return;
 
    // already set
    if (((faction->Flags & FACTION_FLAG_AT_WAR) != 0) == atWar)
        return;
 
    if (atWar)
        faction->Flags |= FACTION_FLAG_AT_WAR;
    else
        faction->Flags &= ~FACTION_FLAG_AT_WAR;
 
    faction->needSend = true;
    faction->needSave = true;
}

References FACTION_FLAG_AT_WAR, FACTION_FLAG_PEACE_FORCED, FactionState::Flags, FactionState::needSave, and FactionState::needSend.

SetAtWar() [2/2]

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 & (FACTION_FLAG_INVISIBLE_FORCED | FACTION_FLAG_HIDDEN))
        return;
 
    SetAtWar(&itr->second, on);
}

References _factions, FACTION_FLAG_HIDDEN, FACTION_FLAG_INVISIBLE_FORCED, and SetAtWar().

Referenced by WorldSession::HandleSetFactionAtWar(), LoadFromDB(), SetAtWar(), and SetOneFactionReputation().

SetInactive() [1/2]

void ReputationMgr::SetInactive ( FactionState *  faction, bool  inactive  ) const

private

{
    // always invisible or hidden faction can't be inactive
    if (inactive && ((faction->Flags & (FACTION_FLAG_INVISIBLE_FORCED | FACTION_FLAG_HIDDEN)) || !(faction->Flags & FACTION_FLAG_VISIBLE)))
        return;
 
    // already set
    if (((faction->Flags & FACTION_FLAG_INACTIVE) != 0) == inactive)
        return;
 
    if (inactive)
        faction->Flags |= FACTION_FLAG_INACTIVE;
    else
        faction->Flags &= ~FACTION_FLAG_INACTIVE;
 
    faction->needSend = true;
    faction->needSave = true;
}

References FACTION_FLAG_HIDDEN, FACTION_FLAG_INACTIVE, FACTION_FLAG_INVISIBLE_FORCED, FACTION_FLAG_VISIBLE, FactionState::Flags, FactionState::needSave, and FactionState::needSend.

SetInactive() [2/2]

void ReputationMgr::SetInactive	(	RepListID	repListID,
		bool	on
	)

{
    FactionStateList::iterator itr = _factions.find(repListID);
    if (itr == _factions.end())
        return;
 
    SetInactive(&itr->second, on);
}

References _factions, and SetInactive().

Referenced by WorldSession::HandleSetFactionInactiveOpcode(), LoadFromDB(), and SetInactive().

SetOneFactionReputation()

bool ReputationMgr::SetOneFactionReputation	(	FactionEntry const *	factionEntry,
		float	standing,
		bool	incremental,
		Optional< ReputationRank >	repMaxCap = { }
	)

Public for chat command needs.

{
    FactionStateList::iterator itr = _factions.find(factionEntry->reputationListID);
    if (itr != _factions.end())
    {
        int32 BaseRep = GetBaseReputation(factionEntry);
 
        if (incremental)
        {
            stand *= sWorld->getRate(RATE_REPUTATION_GAIN);
        }
 
        int32 standing = 0;
        float stand2;
        if (fabs(modff(stand, &stand2)) < 1.f)
        {
            if (itr->second.roundedUp)
            {
                standing = static_cast<int32>(ceil(stand));
            }
            else
            {
                standing = static_cast<int32>(stand);
            }
 
            itr->second.roundedUp = !itr->second.roundedUp;
        }
 
        if (incremental)
        {
            standing += itr->second.Standing + BaseRep;
        }
 
        if (standing > Reputation_Cap)
            standing = Reputation_Cap;
        else if (standing < Reputation_Bottom)
            standing = Reputation_Bottom;
 
        ReputationRank old_rank = ReputationToRank(itr->second.Standing + BaseRep);
        ReputationRank new_rank = ReputationToRank(standing);
        if (repMaxCap && new_rank > *repMaxCap)
        {
            standing = ReputationRankToStanding(*repMaxCap);
            new_rank = *repMaxCap;
        }
 
        if (sScriptMgr->OnPlayerReputationChange(_player, factionEntry->ID, standing, incremental))
        {
            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);
 
            if (new_rank > old_rank)
                _sendFactionIncreased = true;
 
            if (new_rank != old_rank)
            {
                sScriptMgr->OnPlayerReputationRankChange(_player, factionEntry->ID, new_rank, old_rank, _sendFactionIncreased);
            }
 
            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;
}

References _factions, _player, _sendFactionIncreased, ACHIEVEMENT_CRITERIA_TYPE_GAIN_EXALTED_REPUTATION, ACHIEVEMENT_CRITERIA_TYPE_GAIN_HONORED_REPUTATION, ACHIEVEMENT_CRITERIA_TYPE_GAIN_REPUTATION, ACHIEVEMENT_CRITERIA_TYPE_GAIN_REVERED_REPUTATION, ACHIEVEMENT_CRITERIA_TYPE_KNOWN_FACTIONS, GetBaseReputation(), FactionEntry::ID, RATE_REPUTATION_GAIN, REP_HOSTILE, Reputation_Bottom, Reputation_Cap, Player::ReputationChanged(), FactionEntry::reputationListID, ReputationRankToStanding(), ReputationToRank(), SetAtWar(), SetVisible(), sScriptMgr, sWorld, Player::UpdateAchievementCriteria(), and UpdateRankCounters().

Referenced by modify_commandscript::HandleModifyRepCommand(), WorldSession::HandlePlayerLoginFromDB(), and SetReputation().

SetReputation() [1/2]

bool ReputationMgr::SetReputation ( FactionEntry const *  factionEntry, float  standing  )

inline

    {
        return SetReputation(factionEntry, standing, false);
    }

References SetReputation().

Referenced by spell_gen_oracle_wolvar_reputation::HandleDummy(), SetReputation(), and Player::SetReputation().

SetReputation() [2/2]

bool ReputationMgr::SetReputation ( FactionEntry const *  factionEntry, float  standing, bool  incremental, bool  noSpillOver = false, Optional< ReputationRank >  repMaxCap = { }  )

private

{
    bool res = false;
 
    if (!noSpillOver)
    {
        // if spillover definition exists in DB, override DBC
        if (const RepSpilloverTemplate* 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
                        float spilloverRep = standing * repTemplate->faction_rate[i];
                        SetOneFactionReputation(sFactionStore.LookupEntry(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->team && factionEntry->spilloverRateOut != 0.0f)
            {
                spillOverRepOut *= factionEntry->spilloverRateOut;
                if (FactionEntry const* parent = sFactionStore.LookupEntry(factionEntry->team))
                {
                    FactionStateList::iterator parentState = _factions.find(parent->reputationListID);
                    // some team factions have own reputation standing, in this case do not spill to other sub-factions
                    if (parentState != _factions.end() && (parentState->second.Flags & FACTION_FLAG_SPECIAL))
                    {
                        SetOneFactionReputation(parent, spillOverRepOut, incremental);
                    }
                    else // spill to "sister" factions
                    {
                        flist = GetFactionTeamList(factionEntry->team);
                    }
                }
            }
            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->spilloverMaxRankIn))
                            continue;
                        float spilloverRep = spillOverRepOut * factionEntryCalc->spilloverRateIn;
                        if (spilloverRep != 0 || !incremental)
                            res = SetOneFactionReputation(factionEntryCalc, spilloverRep, incremental);
                    }
                }
            }
        }
    }
 
    bool spillOverOnly = repMaxCap ? GetRank(factionEntry) > *repMaxCap : false;
 
    // spillover done, update faction itself
    FactionStateList::iterator faction = _factions.find(factionEntry->reputationListID);
    if (faction != _factions.end())
    {
        // Xinef: if we update spillover only, do not update main reputation (rank exceeds creature reward rate)
        if (!spillOverOnly)
        {
            res = SetOneFactionReputation(factionEntry, standing, incremental, repMaxCap);
        }
 
        // only this faction gets reported to client, even if it has no own visible standing
        SendState(&faction->second);
    }
    return res;
}

References _factions, _player, FACTION_FLAG_SPECIAL, GetFactionTeamList(), GetRank(), Player::GetReputationRank(), FactionEntry::ID, MAX_SPILLOVER_FACTIONS, FactionEntry::reputationListID, SendState(), SetOneFactionReputation(), sFactionStore, sObjectMgr, FactionEntry::spilloverRateOut, and FactionEntry::team.

SetVisible() [1/3]

void ReputationMgr::SetVisible

(

FactionEntry const *

factionEntry

)

{
    if (factionEntry->reputationListID < 0)
        return;
 
    FactionStateList::iterator itr = _factions.find(factionEntry->reputationListID);
    if (itr == _factions.end())
        return;
 
    SetVisible(&itr->second);
}

References _factions, FactionEntry::reputationListID, and SetVisible().

SetVisible() [2/3]

void ReputationMgr::SetVisible ( FactionState *  faction )

private

{
    // always invisible or hidden faction can't be make visible
    // except if faction has FACTION_FLAG_SPECIAL
    if (faction->Flags & (FACTION_FLAG_INVISIBLE_FORCED | FACTION_FLAG_HIDDEN) && !(faction->Flags & FACTION_FLAG_SPECIAL))
        return;
 
    // already set
    if (faction->Flags & FACTION_FLAG_VISIBLE)
        return;
 
    faction->Flags |= FACTION_FLAG_VISIBLE;
    faction->needSend = true;
    faction->needSave = true;
 
    ++_visibleFactionCount;
 
    SendVisible(faction);
}

References _visibleFactionCount, FACTION_FLAG_HIDDEN, FACTION_FLAG_INVISIBLE_FORCED, FACTION_FLAG_SPECIAL, FACTION_FLAG_VISIBLE, FactionState::Flags, FactionState::needSave, FactionState::needSend, and SendVisible().

SetVisible() [3/3]

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->BaseRepRaceMask[1] & _player->getRaceMask() && factionEntry->BaseRepValue[1] == Reputation_Bottom))
            SetVisible(factionEntry);
}

References _player, FactionTemplateEntry::faction, Unit::getRaceMask(), Reputation_Bottom, SetVisible(), and sFactionStore.

Referenced by Player::AddQuest(), WorldSession::HandleGossipHelloOpcode(), LoadFromDB(), SetOneFactionReputation(), and SetVisible().

UpdateRankCounters()

void ReputationMgr::UpdateRankCounters ( ReputationRank  old_rank, ReputationRank  new_rank  )

private

{
    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;
}

References _exaltedFactionCount, _honoredFactionCount, _reveredFactionCount, REP_EXALTED, REP_HONORED, and REP_REVERED.

Referenced by Initialize(), LoadFromDB(), and SetOneFactionReputation().

Member Data Documentation

_exaltedFactionCount

uint8 ReputationMgr::_exaltedFactionCount

private

Referenced by GetExaltedFactionCount(), Initialize(), and UpdateRankCounters().

_factions

FactionStateList ReputationMgr::_factions

private

Referenced by GetState(), GetStateList(), Initialize(), LoadFromDB(), SaveToDB(), SendInitialReputations(), SendState(), SendStates(), SetAtWar(), SetInactive(), SetOneFactionReputation(), SetReputation(), and SetVisible().

_forcedReactions

ForcedReactions ReputationMgr::_forcedReactions

private

Referenced by ApplyForceReaction(), GetForcedRankIfAny(), and SendForceReactions().

_honoredFactionCount

uint8 ReputationMgr::_honoredFactionCount

private

Referenced by GetHonoredFactionCount(), Initialize(), and UpdateRankCounters().

_player

Player* ReputationMgr::_player

private

Referenced by GetBaseReputation(), GetDefaultStateFlags(), GetReputation(), IsAtWar(), SaveToDB(), SendForceReactions(), SendInitialReputations(), SendState(), SendVisible(), SetOneFactionReputation(), SetReputation(), and SetVisible().

_reveredFactionCount

uint8 ReputationMgr::_reveredFactionCount

private

Referenced by GetReveredFactionCount(), Initialize(), and UpdateRankCounters().

_sendFactionIncreased

bool ReputationMgr::_sendFactionIncreased

private

Referenced by Initialize(), SendState(), and SetOneFactionReputation().

_visibleFactionCount

uint8 ReputationMgr::_visibleFactionCount

private

Referenced by GetVisibleFactionCount(), Initialize(), and SetVisible().

PointsInRank

const int32 ReputationMgr::PointsInRank = {36000, 3000, 3000, 3000, 6000, 12000, 21000, 1000}

static

Referenced by modify_commandscript::HandleModifyRepCommand(), ReputationRankToStanding(), and ReputationToRank().

Reputation_Bottom

const int32 ReputationMgr::Reputation_Bottom = -42000

static

Referenced by ReputationRankToStanding(), SetOneFactionReputation(), and SetVisible().

Reputation_Cap

const int32 ReputationMgr::Reputation_Cap = 42999

static

Referenced by ObjectMgr::LoadQuests(), ReputationToRank(), and SetOneFactionReputation().