ReputationMgr Class Reference

#include <ReputationMgr.h>

Public Member Functions
	ReputationMgr (Player *owner)
	~ReputationMgr ()
void	SaveToDB (SQLTransaction &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
ReputationRank const *	GetForcedRankIfAny (uint32 factionId) const
bool	SetReputation (FactionEntry const *factionEntry, int32 standing)
bool	ModifyReputation (FactionEntry const *factionEntry, int32 standing)
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, int32 standing, bool incremental)
	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 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, int32 standing, bool incremental)
void	SetVisible (FactionState *faction)
void	SetAtWar (FactionState *faction, bool atWar) const
void	SetInactive (FactionState *faction, bool inactive) const
void	SendVisible (FactionState const *faction, bool visible=true) 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

Constructor & Destructor Documentation

ReputationMgr::ReputationMgr ( Player *  owner )

inlineexplicit

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

ReputationMgr::~ReputationMgr ( )

inline

{ }

Member Function Documentation

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

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

ReputationRank ReputationMgr::GetBaseRank

(

FactionEntry const *

factionEntry

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

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->ReputationRaceMask[i] & raceMask ||
 (factionEntry->ReputationRaceMask[i] == 0 &&
 factionEntry->ReputationClassMask[i] != 0)) &&
 (factionEntry->ReputationClassMask[i] & classMask ||
 factionEntry->ReputationClassMask[i] == 0))

 return factionEntry->ReputationBase[i];
 }

 // in faction.dbc exist factions with (RepListId >=0, listed in character reputation list) with all BaseRepRaceMask[i] == 0
 return 0;
}

Here is the caller graph for this function:

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->ReputationRaceMask[i] & raceMask ||
 (factionEntry->ReputationRaceMask[i] == 0 &&
 factionEntry->ReputationClassMask[i] != 0)) &&
 (factionEntry->ReputationClassMask[i] & classMask ||
 factionEntry->ReputationClassMask[i] == 0))

 return factionEntry->ReputationFlags[i];
 }
 return 0;
}

Here is the caller graph for this function:

uint8 ReputationMgr::GetExaltedFactionCount ( ) const

inline

{ return _exaltedFactionCount; }

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

inline

 {
 return GetForcedRankIfAny(factionTemplateEntry->Faction);
 }

ReputationRank const* ReputationMgr::GetForcedRankIfAny ( uint32  factionId ) const

inline

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

uint8 ReputationMgr::GetHonoredFactionCount ( ) const

inline

{ return _honoredFactionCount; }

ReputationRank ReputationMgr::GetRank

(

FactionEntry const *

factionEntry

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 %s for unknown faction (faction id) #%u.", _player->GetName().c_str(), faction_id);
 return 0;
 }

 return GetReputation(factionEntry);
}

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

inline

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

uint8 ReputationMgr::GetReveredFactionCount ( ) const

inline

{ return _reveredFactionCount; }

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

inline

 {
 return factionEntry->CanHaveReputation() ? GetState(factionEntry->ReputationIndex) : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

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

FactionStateList const& ReputationMgr::GetStateList ( ) const

inline

{ return _factions; }

uint8 ReputationMgr::GetVisibleFactionCount ( ) const

inline

{ return _visibleFactionCount; }

void ReputationMgr::Initialize ( void  )

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->CanHaveReputation())
 {
 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 & FACTION_FLAG_VISIBLE)
 ++_visibleFactionCount;

 UpdateRankCounters(REP_HOSTILE, GetBaseRank(factionEntry));

 _factions[newFaction.ReputationListID] = newFaction;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 %s for unknown faction (faction id) #%u.", _player->GetName().c_str(), faction_id);
 return false;
 }

 return IsAtWar(factionEntry);
}

bool ReputationMgr::IsAtWar

(

FactionEntry const *

factionEntry

)

const

{
 if (!factionEntry)
 return false;

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

Here is the call graph for this function:

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 = '%u'", GetGUIDLow());

 if (result)
 {
 do
 {
 Field* fields = result->Fetch();

 FactionEntry const* factionEntry = sFactionStore.LookupEntry(fields[0].GetUInt16());
 if (factionEntry && factionEntry->CanHaveReputation())
 {
 FactionState* faction = &_factions[factionEntry->ReputationIndex];

 // update standing to current
 faction->Standing = fields[1].GetInt32();

 // 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].GetUInt16();

 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
 SetAtWar(faction, true); // 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;
 }
 }
 }
 while (result->NextRow());
 }
}

Here is the call graph for this function:

bool ReputationMgr::ModifyReputation ( FactionEntry const *  factionEntry, int32  standing  )

inline

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

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

Here is the caller graph for this function:

void ReputationMgr::SaveToDB

(

SQLTransaction &

trans

)

{
 for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
 {
 if (itr->second.needSave)
 {
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_REPUTATION_BY_FACTION);
 stmt->setUInt64(0, _player->GetGUID().GetCounter());
 stmt->setUInt16(1, uint16(itr->second.ID));
 trans->Append(stmt);

 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_REPUTATION_BY_FACTION);
 stmt->setUInt64(0, _player->GetGUID().GetCounter());
 stmt->setUInt16(1, uint16(itr->second.ID));
 stmt->setInt32(2, itr->second.Standing);
 stmt->setUInt16(3, uint16(itr->second.Flags));
 trans->Append(stmt);

 itr->second.needSave = false;
 }
 }
}

Here is the call graph for this function:

void ReputationMgr::SendForceReactions

(

)

{
 WorldPackets::Reputation::SetForcedReactions setForcedReactions;
 setForcedReactions.Reactions.resize(_forcedReactions.size());

 std::size_t i = 0;
 for (ForcedReactions::const_iterator itr = _forcedReactions.begin(); itr != _forcedReactions.end(); ++itr)
 {
 WorldPackets::Reputation::ForcedReaction& forcedReaction = setForcedReactions.Reactions[i++];
 forcedReaction.Faction = int32(itr->first);
 forcedReaction.Reaction = int32(itr->second);
 }

 _player->SendDirectMessage(setForcedReactions.Write());
}

Here is the call graph for this function:

void ReputationMgr::SendInitialReputations

(

)

Todo:

faction bonus

{
 WorldPackets::Reputation::InitializeFactions initFactions;

 for (FactionStateList::iterator itr = _factions.begin(); itr != _factions.end(); ++itr)
 {
 initFactions.FactionFlags[itr->first] = itr->second.Flags;
 initFactions.FactionStandings[itr->first] = itr->second.Standing;
 itr->second.needSend = false;
 }

 _player->SendDirectMessage(initFactions.Write());
}

Here is the call graph for this function:

void ReputationMgr::SendState

(

FactionState const *

faction

)

{
 WorldPackets::Reputation::SetFactionStanding setFactionStanding;
 setFactionStanding.ReferAFriendBonus = 0.0f;
 setFactionStanding.BonusFromAchievementSystem = 0.0f;
 setFactionStanding.Faction.emplace_back(int32(faction->ReputationListID), 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)
 setFactionStanding.Faction.emplace_back(int32(itr->second.ReputationListID), itr->second.Standing);
 }
 }

 setFactionStanding.ShowVisual = _sendFactionIncreased;
 _player->SendDirectMessage(setFactionStanding.Write());

 _sendFactionIncreased = false; // Reset
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ReputationMgr::SendStates

(

)

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

Here is the call graph for this function:

void ReputationMgr::SendVisible ( FactionState const *  faction, bool  visible = true  ) const

private

{
 if (_player->GetSession()->PlayerLoading())
 return;

 // make faction visible/not visible in reputation list at client
 WorldPackets::Character::SetFactionVisible packet(visible);
 packet.FactionIndex = faction->ReputationListID;
 _player->SendDirectMessage(packet.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

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

{
 FactionStateList::iterator itr = _factions.find(repListID);
 if (itr == _factions.end())
 return;

 SetInactive(&itr->second, on);
}

Here is the caller graph for this function:

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

bool ReputationMgr::SetOneFactionReputation	(	FactionEntry const *	factionEntry,
		int32	standing,
		bool	incremental
	)

Public for chat command needs.

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

 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;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

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

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

private

{
 sScriptMgr->OnPlayerReputationChange(_player, factionEntry->ID, standing, incremental);
 bool res = false;
 // 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
 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
 std::vector<uint32> const* flist = GetFactionTeamList(factionEntry->ID);
 // if has no sub-factions, check for factions with same parent
 if (!flist && factionEntry->ParentFactionID && factionEntry->ParentFactionModOut != 0.0f)
 {
 spillOverRepOut *= factionEntry->ParentFactionModOut;
 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 & FACTION_FLAG_SPECIAL))
 {
 SetOneFactionReputation(parent, int32(spillOverRepOut), incremental);
 }
 else // spill to "sister" factions
 {
 flist = GetFactionTeamList(factionEntry->ParentFactionID);
 }
 }
 }
 if (flist)
 {
 // Spillover to affiliated factions
 for (std::vector<uint32>::const_iterator itr = flist->begin(); itr != flist->end(); ++itr)
 {
 if (FactionEntry const* factionEntryCalc = sFactionStore.LookupEntry(*itr))
 {
 if (factionEntryCalc == factionEntry || GetRank(factionEntryCalc) > ReputationRank(factionEntryCalc->ParentFactionCapIn))
 continue;
 int32 spilloverRep = int32(spillOverRepOut * factionEntryCalc->ParentFactionModIn);
 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())
 {
 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;
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

void ReputationMgr::SetVisible

(

FactionEntry const *

factionEntry

)

{
 if (!factionEntry->CanHaveReputation())
 return;

 FactionStateList::iterator itr = _factions.find(factionEntry->ReputationIndex);
 if (itr == _factions.end())
 return;

 SetVisible(&itr->second);
}

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the caller graph for this function:

Member Data Documentation

uint8 ReputationMgr::_exaltedFactionCount

private

FactionStateList ReputationMgr::_factions

private

ForcedReactions ReputationMgr::_forcedReactions

private

uint8 ReputationMgr::_honoredFactionCount

private

Player* ReputationMgr::_player

private

uint8 ReputationMgr::_reveredFactionCount

private

bool ReputationMgr::_sendFactionIncreased

private

uint8 ReputationMgr::_visibleFactionCount

private

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

static

const int32 ReputationMgr::Reputation_Bottom = -42000

static

const int32 ReputationMgr::Reputation_Cap = 42999

static

---

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

• src/server/game/Reputation/ReputationMgr.h
• src/server/game/Reputation/ReputationMgr.cpp