PlayerRelationsManager Class Reference

#include <playerrelations.h>

Public Member Functions
	PlayerRelationsManager ()
	~PlayerRelationsManager ()
void	init ()
void	load ()
void	store () const
unsigned int	checkPermissionSilently (const std::string &player_name, const unsigned int flags) const
bool	hasPermission (const Being *const being, const unsigned int flags) const
bool	hasPermission (const std::string &being, const unsigned int flags) const
void	setRelation (const std::string &name, const RelationT relation)
RelationT	getRelation (const std::string &name) const
void	removePlayer (const std::string &name)
unsigned int	getDefault () const
void	setDefault (const unsigned int permissions)
std::vector< PlayerIgnoreStrategy * > *	getPlayerIgnoreStrategies ()
const PlayerIgnoreStrategy *	getPlayerIgnoreStrategy () const
void	setPlayerIgnoreStrategy (PlayerIgnoreStrategy *const strategy)
int	getPlayerIgnoreStrategyIndex (const std::string &shortname)
StringVect *	getPlayers () const
StringVect *	getPlayersByRelation (const RelationT rel) const
void	clear ()
bool	getPersistIgnores () const
void	ignoreTrade (const std::string &name) const
bool	isGoodName (Being *const being) const
bool	isGoodName (const std::string &name) const
void	setPersistIgnores (const bool value)
void	addListener (PlayerRelationsListener *const listener)
void	removeListener (PlayerRelationsListener *const listener)
bool	checkBadRelation (const std::string &name) const

Private Member Functions
void	signalUpdate (const std::string &name)

Static Private Member Functions
static bool	checkName (const std::string &name)

Private Attributes
bool	mPersistIgnores
unsigned int	mDefaultPermissions
PlayerIgnoreStrategy *	mIgnoreStrategy
std::map< std::string, PlayerRelation * >	mRelations
std::list< PlayerRelationsListener * >	mListeners
std::vector< PlayerIgnoreStrategy * >	mIgnoreStrategies

Detailed Description

Player relations class, represents any particular relations and/or preferences the user of the local client has wrt other players (identified by std::string).

Definition at line 47 of file playerrelations.h.

Constructor & Destructor Documentation

PlayerRelationsManager()

PlayerRelationsManager::PlayerRelationsManager

(

)

Definition at line 151 of file playerrelations.cpp.

                                               :
    mPersistIgnores(false),
    mDefaultPermissions(PlayerRelation::DEFAULT),
    mIgnoreStrategy(nullptr),
    mRelations(),
    mListeners(),
    mIgnoreStrategies()
{
}

~PlayerRelationsManager()

PlayerRelationsManager::~PlayerRelationsManager

(

)

Definition at line 161 of file playerrelations.cpp.

{
    delete_all(mIgnoreStrategies);
 
    FOR_EACH (PlayerRelationsCIter, it, mRelations)
        delete it->second;
    mRelations.clear();
}

References delete_all(), FOR_EACH, mIgnoreStrategies, and mRelations.

Member Function Documentation

addListener()

void PlayerRelationsManager::addListener ( PlayerRelationsListener *const  listener )

inline

Definition at line 186 of file playerrelations.h.

        { mListeners.push_back(listener); }

References anonymous_namespace{itemlinkhandler.cpp}::listener, and mListeners.

Referenced by Setup_Relations::action(), SocialWindow::postInit(), and Setup_Relations::Setup_Relations().

checkBadRelation()

bool PlayerRelationsManager::checkBadRelation

(

const std::string &

name

)

const

Definition at line 460 of file playerrelations.cpp.

{
    if (name.empty())
        return true;
 
    const RelationT relation = getRelation(name);
 
    if (relation == Relation::IGNORED ||
        relation == Relation::DISREGARDED ||
        relation == Relation::BLACKLISTED ||
        relation == Relation::ERASED ||
        relation == Relation::ENEMY2)
    {
        return true;
    }
    return false;
}

References Relation::BLACKLISTED, Relation::DISREGARDED, Relation::ENEMY2, Relation::ERASED, getRelation(), and Relation::IGNORED.

Referenced by LocalPlayer::checAttackPermissions().

checkName()

bool PlayerRelationsManager::checkName ( const std::string &  name )

staticprivate

Definition at line 635 of file playerrelations.cpp.

{
    const size_t size = name.size();
    const std::string check = config.getStringValue("unsecureChars");
    const std::string lastChar = name.substr(size - 1, 1);
 
    if (name.substr(0, 1) == " " ||
        lastChar == " " ||
        lastChar == "." ||
        name.find("  ") != std::string::npos)
    {
        return false;
    }
    else if (check.empty())
    {
        return true;
    }
    else if (name.find_first_of(check) != std::string::npos)
    {
        return false;
    }
    else
    {
        return true;
    }
}

References config, Configuration::getStringValue(), and EmoteDB::size().

Referenced by isGoodName().

checkPermissionSilently()

unsigned int PlayerRelationsManager::checkPermissionSilently	(	const std::string &	player_name,
		const unsigned int	flags
	)		const

Determines whether the player in question is being ignored, filtered by the specified flags.

Definition at line 277 of file playerrelations.cpp.

{
    const std::map<std::string, PlayerRelation *>::const_iterator
        it = mRelations.find(player_name);
    if (it == mRelations.end())
    {
        return mDefaultPermissions & flags;
    }
 
    const PlayerRelation *const r = (*it).second;
    unsigned int permissions = PlayerRelation::RELATION_PERMISSIONS[
        CAST_S32(r->mRelation)];
 
    switch (r->mRelation)
    {
        case Relation::NEUTRAL:
            permissions = mDefaultPermissions;
            break;
 
        case Relation::FRIEND:
            permissions |= mDefaultPermissions;  // widen
            break;
 
        case Relation::DISREGARDED:
        case Relation::IGNORED:
        case Relation::ERASED:
        case Relation::BLACKLISTED:
        case Relation::ENEMY2:
        default:
            permissions &= mDefaultPermissions;  // narrow
            break;
    }
 
    return permissions & flags;
}

References Relation::BLACKLISTED, CAST_S32, Relation::DISREGARDED, Relation::ENEMY2, Relation::ERASED, Relation::FRIEND, Relation::IGNORED, mDefaultPermissions, PlayerRelation::mRelation, mRelations, Relation::NEUTRAL, and PlayerRelation::RELATION_PERMISSIONS.

Referenced by hasPermission(), EAthena::ChatRecv::processBeingChat(), and TmwAthena::ChatRecv::processBeingChat().

clear()

void PlayerRelationsManager::clear

(

)

Removes all recorded player info.

Definition at line 170 of file playerrelations.cpp.

{
    StringVect *const names = getPlayers();
    FOR_EACHP (StringVectCIter, it, names)
        removePlayer(*it);
    delete names;
}

References FOR_EACHP, getPlayers(), and removePlayer().

Referenced by init(), and load().

getDefault()

unsigned int PlayerRelationsManager::getDefault

(

)

const

Retrieves the default permissions.

Definition at line 430 of file playerrelations.cpp.

{
    return mDefaultPermissions;
}

References mDefaultPermissions.

Referenced by PopupMenu::addBuySell(), PopupMenu::addBuySellDefault(), Setup_Relations::apply(), Setup_Relations::externalUpdated(), and Setup_Relations::updatedPlayer().

getPersistIgnores()

bool PlayerRelationsManager::getPersistIgnores ( ) const

inline

Do we persist our ‘ignore’ setup?

Definition at line 169 of file playerrelations.h.

        { return mPersistIgnores; }

References mPersistIgnores.

getPlayerIgnoreStrategies()

std::vector< PlayerIgnoreStrategy * > * PlayerRelationsManager::getPlayerIgnoreStrategies

(

)

Retrieves all known player ignore strategies.

The player ignore strategies are allocated statically and must not be deleted.

Definition at line 577 of file playerrelations.cpp.

{
    if (mIgnoreStrategies.empty())
    {
        // not initialised yet?
        mIgnoreStrategies.push_back(new PIS_emote(FIRST_IGNORE_EMOTE,
                                    // TRANSLATORS: ignore strategi
                                    _("Floating '...' bubble"),
                                    PLAYER_IGNORE_STRATEGY_EMOTE0));
        mIgnoreStrategies.push_back(new PIS_emote(FIRST_IGNORE_EMOTE + 1,
                                    // TRANSLATORS: ignore strategi
                                    _("Floating bubble"),
                                    "emote1"));
        mIgnoreStrategies.push_back(new PIS_nothing);
        mIgnoreStrategies.push_back(new PIS_dotdotdot);
        mIgnoreStrategies.push_back(new PIS_blinkname);
    }
    return &mIgnoreStrategies;
}

References _, FIRST_IGNORE_EMOTE, mIgnoreStrategies, and PLAYER_IGNORE_STRATEGY_EMOTE0.

Referenced by Setup_Relations::action(), IgnoreChoicesListModel::getElementAt(), getPlayerIgnoreStrategyIndex(), load(), and Setup_Relations::reset().

getPlayerIgnoreStrategy()

const PlayerIgnoreStrategy* PlayerRelationsManager::getPlayerIgnoreStrategy ( ) const

inline

Return the current player ignore strategy.

Returns

A player ignore strategy, or nullptr

Definition at line 130 of file playerrelations.h.

        { return mIgnoreStrategy; }

References mIgnoreStrategy.

Referenced by Setup_Relations::reset(), Setup_Relations::Setup_Relations(), and Setup_Relations::updateAll().

getPlayerIgnoreStrategyIndex()

int PlayerRelationsManager::getPlayerIgnoreStrategyIndex

(

const std::string &

shortname

)

For a given ignore strategy short name, find the appropriate index in the ignore strategies vector.

Parameters

The	short name of the ignore strategy to look up

Returns

The appropriate index, or -1

Definition at line 182 of file playerrelations.cpp.

{
    const STD_VECTOR<PlayerIgnoreStrategy *> *const strategies
        = getPlayerIgnoreStrategies();
 
    if (strategies == nullptr)
        return -1;
 
    const size_t sz = strategies->size();
    for (size_t i = 0; i < sz; i++)
    {
        if ((*strategies)[i]->mShortName == name)
            return CAST_S32(i);
    }
 
    return -1;
}

References CAST_S32, and getPlayerIgnoreStrategies().

Referenced by load(), Setup_Relations::Setup_Relations(), and Setup_Relations::updateAll().

getPlayers()

StringVect * PlayerRelationsManager::getPlayers

(

)

const

Retrieves a sorted vector of all players for which we have any relations recorded.

Definition at line 374 of file playerrelations.cpp.

{
    StringVect *const retval = new StringVect;
 
    FOR_EACH (PlayerRelationsCIter, it, mRelations)
    {
        if (it->second != nullptr)
            retval->push_back(it->first);
    }
 
    std::sort(retval->begin(), retval->end(), playersRelSorter);
 
    return retval;
}

References FOR_EACH, mRelations, and anonymous_namespace{playerrelations.cpp}::playersRelSorter.

Referenced by clear(), and PlayerTableModel::playerRelationsUpdated().

getPlayersByRelation()

StringVect * PlayerRelationsManager::getPlayersByRelation

(

const RelationT

rel

)

const

Definition at line 389 of file playerrelations.cpp.

{
    StringVect *const retval = new StringVect;
 
    FOR_EACH (PlayerRelationsCIter, it, mRelations)
    {
        if ((it->second != nullptr) &&
            it->second->mRelation == rel)
        {
            retval->push_back(it->first);
        }
    }
 
    std::sort(retval->begin(), retval->end(), playersRelSorter);
 
    return retval;
}

References FOR_EACH, mRelations, and anonymous_namespace{playerrelations.cpp}::playersRelSorter.

Referenced by SocialFriendsTab::getPlayersAvatars().

getRelation()

RelationT PlayerRelationsManager::getRelation

(

const std::string &

name

)

const

Updates the relationship with this player.

Definition at line 416 of file playerrelations.cpp.

{
    const std::map<std::string, PlayerRelation *>::const_iterator
        it = mRelations.find(name);
    if (it != mRelations.end())
        return (*it).second->mRelation;
 
    return Relation::NEUTRAL;
}

References mRelations, and Relation::NEUTRAL.

Referenced by PopupMenu::addPlayerRelation(), Actions::changeRelation(), LocalPlayer::checAttackPermissions(), checkBadRelation(), ActorManager::findMostDamagedPlayer(), WhoIsOnline::handlerPlayerRelation(), ActorManager::heal(), ChatWindow::ignoreAllWhispers(), ignoreTrade(), PlayerTableModel::playerRelationsUpdated(), Actions::reportRelation(), Being::showName(), and Being::updateColors().

hasPermission() [1/2]

bool PlayerRelationsManager::hasPermission	(	const Being *const	being,
		const unsigned int	flags
	)		const

Tests whether the player in question is being ignored for any of the actions in the specified flags. If so, trigger appropriate side effects if requested by the player.

Definition at line 314 of file playerrelations.cpp.

{
    if (being == nullptr)
        return false;
 
    if (being->getType() == ActorType::Player)
    {
        return static_cast<unsigned int>(hasPermission(
            being->getName(), flags)) == flags;
    }
    return true;
}

References Being::getName(), Being::getType(), and ActorType::Player.

Referenced by EAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processBeingChat(), Ea::BeingRecv::processBeingEmotion(), Ea::TradeRecv::processTradeRequestContinue(), TmwAthena::TradeRecv::processTradeResponse(), Ea::TradeRecv::processTradeResponseContinue(), EAthena::ChatRecv::processWhisperContinue(), and TmwAthena::ChatRecv::processWhisperContinue().

hasPermission() [2/2]

bool PlayerRelationsManager::hasPermission	(	const std::string &	being,
		const unsigned int	flags
	)		const

Definition at line 328 of file playerrelations.cpp.

{
    if (actorManager == nullptr)
        return false;
 
    const unsigned int rejections = flags
        & ~checkPermissionSilently(name, flags);
    const bool permitted = (rejections == 0);
 
    if (!permitted)
    {
        // execute `ignore' strategy, if possible
        if (mIgnoreStrategy != nullptr)
        {
            Being *const b = actorManager->findBeingByName(
                name, ActorType::Player);
 
            if ((b != nullptr) && b->getType() == ActorType::Player)
                mIgnoreStrategy->ignore(b, rejections);
        }
    }
 
    return permitted;
}

References actorManager, checkPermissionSilently(), ActorManager::findBeingByName(), Being::getType(), PlayerIgnoreStrategy::ignore(), mIgnoreStrategy, and ActorType::Player.

ignoreTrade()

void PlayerRelationsManager::ignoreTrade

(

const std::string &

name

)

const

Definition at line 443 of file playerrelations.cpp.

{
    if (name.empty())
        return;
 
    const RelationT relation = getRelation(name);
 
    if (relation == Relation::IGNORED ||
        relation == Relation::DISREGARDED ||
        relation == Relation::BLACKLISTED ||
        relation == Relation::ERASED)
    {
        return;
    }
    playerRelations.setRelation(name, Relation::BLACKLISTED);
}

References Relation::BLACKLISTED, Relation::DISREGARDED, Relation::ERASED, getRelation(), Relation::IGNORED, playerRelations, and setRelation().

Referenced by ShopWindow::action(), and RequestTradeListener::action().

init()

void PlayerRelationsManager::init

(

)

Initialise player relations manager (load config file etc.)

Definition at line 227 of file playerrelations.cpp.

{
    load();
 
    if (!mPersistIgnores)
    {
        clear();  // Yes, we still keep them around in the config file
                  // until the next update.
    }
 
    FOR_EACH (PlayerRelationListenersCIter, it, mListeners)
        (*it)->updateAll();
}

References clear(), FOR_EACH, load(), mListeners, and mPersistIgnores.

Referenced by Client::stateConnectServer1().

isGoodName() [1/2]

bool PlayerRelationsManager::isGoodName

(

Being *const

being

)

const

Definition at line 612 of file playerrelations.cpp.

{
    if (being == nullptr)
        return false;
    if (being->getGoodStatus() != -1)
        return being->getGoodStatus() == 1;
 
    const std::string &name = being->getName();
    const size_t size = name.size();
 
    if (size < 3)
        return true;
 
    const std::map<std::string, PlayerRelation *>::const_iterator
        it = mRelations.find(name);
    if (it != mRelations.end())
        return true;
 
    const bool status = checkName(name);
    being->setGoodStatus(status ? 1 : 0);
    return status;
}

References checkName(), Being::getGoodStatus(), Being::getName(), mRelations, Being::setGoodStatus(), and EmoteDB::size().

Referenced by ChatWindow::addWhisperTab(), TradeWindow::initTrade(), BeingPopup::show(), and Being::showName().

isGoodName() [2/2]

bool PlayerRelationsManager::isGoodName

(

const std::string &

name

)

const

Definition at line 597 of file playerrelations.cpp.

{
    const size_t size = name.size();
 
    if (size < 3)
        return true;
 
    const std::map<std::string, PlayerRelation *>::const_iterator
        it = mRelations.find(name);
    if (it != mRelations.end())
        return true;
 
    return checkName(name);
}

References checkName(), mRelations, and EmoteDB::size().

load()

void PlayerRelationsManager::load

(

)

Load configuration from our config file, or substitute defaults.

Definition at line 201 of file playerrelations.cpp.

{
    Configuration *const cfg = &serverConfig;
    clear();
 
    mPersistIgnores = (cfg->getValue(PERSIST_IGNORE_LIST, 1) != 0);
    mDefaultPermissions = CAST_S32(cfg->getValue(DEFAULT_PERMISSIONS,
                                           mDefaultPermissions));
 
    const std::string ignore_strategy_name = cfg->getValue(
        PLAYER_IGNORE_STRATEGY, DEFAULT_IGNORE_STRATEGY);
    const int ignore_strategy_index = getPlayerIgnoreStrategyIndex(
        ignore_strategy_name);
 
    if (ignore_strategy_index >= 0)
    {
        setPlayerIgnoreStrategy((*getPlayerIgnoreStrategies())
                                [ignore_strategy_index]);
    }
 
    cfg->getList<std::pair<std::string, PlayerRelation *>,
                   std::map<std::string, PlayerRelation *> *>
        ("player",  &(mRelations), &player_conf_serialiser);
}

References CAST_S32, clear(), DEFAULT_IGNORE_STRATEGY, DEFAULT_PERMISSIONS, ConfigurationObject::getList(), getPlayerIgnoreStrategies(), getPlayerIgnoreStrategyIndex(), ConfigurationObject::getValue(), mDefaultPermissions, mPersistIgnores, mRelations, PERSIST_IGNORE_LIST, player_conf_serialiser, PLAYER_IGNORE_STRATEGY, serverConfig, and setPlayerIgnoreStrategy().

Referenced by init().

removeListener()

void PlayerRelationsManager::removeListener ( PlayerRelationsListener *const  listener )

inline

Definition at line 189 of file playerrelations.h.

        { mListeners.remove(listener); }

References anonymous_namespace{itemlinkhandler.cpp}::listener, and mListeners.

Referenced by Setup_Relations::action(), Setup_Relations::~Setup_Relations(), and SocialWindow::~SocialWindow().

removePlayer()

void PlayerRelationsManager::removePlayer

(

const std::string &

name

)

Deletes the information recorded for a player.

Definition at line 408 of file playerrelations.cpp.

{
    delete mRelations[name];
    mRelations.erase(name);
    signalUpdate(name);
}

References mRelations, and signalUpdate().

Referenced by Setup_Relations::action(), and clear().

setDefault()

void PlayerRelationsManager::setDefault

(

const unsigned int

permissions

)

Sets the default permissions.

Definition at line 435 of file playerrelations.cpp.

{
    mDefaultPermissions = permissions;
 
    store();
    signalUpdate("");
}

References mDefaultPermissions, signalUpdate(), and store().

Referenced by Setup_Relations::apply().

setPersistIgnores()

void PlayerRelationsManager::setPersistIgnores ( const bool  value )

inline

Change the ‘ignore persist’ flag.

Parameters

value

Whether to persist ignores

Definition at line 183 of file playerrelations.h.

        { mPersistIgnores = value; }

References mPersistIgnores.

setPlayerIgnoreStrategy()

void PlayerRelationsManager::setPlayerIgnoreStrategy ( PlayerIgnoreStrategy *const  strategy )

inline

Sets the strategy to call when ignoring players.

Definition at line 138 of file playerrelations.h.

        { mIgnoreStrategy = strategy; }

References mIgnoreStrategy.

Referenced by Setup_Relations::action(), and load().

setRelation()

void PlayerRelationsManager::setRelation	(	const std::string &	name,
		const RelationT	relation
	)

Updates the relationship with this player.

Definition at line 354 of file playerrelations.cpp.

{
    if (localPlayer == nullptr ||
        (relation != Relation::NEUTRAL &&
        localPlayer->getName() == player_name))
    {
        return;
    }
 
    PlayerRelation *const r = mRelations[player_name];
    if (r == nullptr)
        mRelations[player_name] = new PlayerRelation(relation);
    else
        r->mRelation = relation;
 
    signalUpdate(player_name);
    store();
}

References Being::getName(), localPlayer, PlayerRelation::mRelation, mRelations, Relation::NEUTRAL, signalUpdate(), and store().

Referenced by Actions::changeRelation(), ChatWindow::ignoreAllWhispers(), ignoreTrade(), and PlayerTableModel::updateModelInRow().

signalUpdate()

void PlayerRelationsManager::signalUpdate ( const std::string &  name )

private

Definition at line 259 of file playerrelations.cpp.

{
    FOR_EACH (PlayerRelationListenersCIter, it, mListeners)
        (*it)->updatedPlayer(name);
 
    if (actorManager != nullptr)
    {
        Being *const being = actorManager->findBeingByName(
            name, ActorType::Player);
 
        if (being != nullptr &&
            being->getType() == ActorType::Player)
        {
            being->updateColors();
        }
    }
}

References actorManager, ActorManager::findBeingByName(), FOR_EACH, Being::getType(), mListeners, ActorType::Player, and Being::updateColors().

Referenced by removePlayer(), setDefault(), and setRelation().

store()

void PlayerRelationsManager::store

(

)

const

Save configuration to our config file.

Definition at line 241 of file playerrelations.cpp.

{
    serverConfig.setList<std::map<std::string,
        PlayerRelation *>::const_iterator,
        std::pair<std::string, PlayerRelation *>,
        std::map<std::string, PlayerRelation *> *>
        ("player", mRelations.begin(), mRelations.end(),
        &player_conf_serialiser);
 
    serverConfig.setValue(DEFAULT_PERMISSIONS, mDefaultPermissions);
    serverConfig.setValue(PERSIST_IGNORE_LIST, mPersistIgnores);
    serverConfig.setValue(PLAYER_IGNORE_STRATEGY,
        mIgnoreStrategy != nullptr ? mIgnoreStrategy->mShortName :
        DEFAULT_IGNORE_STRATEGY);
 
    serverConfig.write();
}

References DEFAULT_IGNORE_STRATEGY, DEFAULT_PERMISSIONS, mDefaultPermissions, mIgnoreStrategy, mPersistIgnores, mRelations, PlayerIgnoreStrategy::mShortName, PERSIST_IGNORE_LIST, player_conf_serialiser, PLAYER_IGNORE_STRATEGY, serverConfig, ConfigurationObject::setList(), Configuration::setValue(), and Configuration::write().

Referenced by Setup_Relations::apply(), setDefault(), and setRelation().

Field Documentation

mDefaultPermissions

unsigned int PlayerRelationsManager::mDefaultPermissions

private

Definition at line 199 of file playerrelations.h.

Referenced by checkPermissionSilently(), getDefault(), load(), setDefault(), and store().

mIgnoreStrategies

std::vector<PlayerIgnoreStrategy *> PlayerRelationsManager::mIgnoreStrategies

private

Definition at line 206 of file playerrelations.h.

Referenced by getPlayerIgnoreStrategies(), and ~PlayerRelationsManager().

mIgnoreStrategy

PlayerIgnoreStrategy* PlayerRelationsManager::mIgnoreStrategy

private

Definition at line 203 of file playerrelations.h.

Referenced by getPlayerIgnoreStrategy(), hasPermission(), setPlayerIgnoreStrategy(), and store().

mListeners

std::list<PlayerRelationsListener *> PlayerRelationsManager::mListeners

private

Definition at line 205 of file playerrelations.h.

Referenced by addListener(), init(), removeListener(), and signalUpdate().

mPersistIgnores

bool PlayerRelationsManager::mPersistIgnores

private

Definition at line 197 of file playerrelations.h.

Referenced by getPersistIgnores(), init(), load(), setPersistIgnores(), and store().

mRelations

std::map<std::string, PlayerRelation *> PlayerRelationsManager::mRelations

private

Definition at line 204 of file playerrelations.h.

Referenced by checkPermissionSilently(), getPlayers(), getPlayersByRelation(), getRelation(), isGoodName(), load(), removePlayer(), setRelation(), store(), and ~PlayerRelationsManager().

---

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

• src/being/playerrelations.h (986a3bf)
• src/being/playerrelations.cpp (986a3bf)