diff options
Diffstat (limited to 'src/being/playerrelations.h')
| -rw-r--r-- | src/being/playerrelations.h | 285 |
1 files changed, 285 insertions, 0 deletions
diff --git a/src/being/playerrelations.h b/src/being/playerrelations.h new file mode 100644 index 000000000..f7e9eba60 --- /dev/null +++ b/src/being/playerrelations.h @@ -0,0 +1,285 @@ +/* + * The ManaPlus Client + * Copyright (C) 2008-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * 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 + * 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/>. + */ + +#ifndef BEING_PLAYERRELATIONS_H +#define BEING_PLAYERRELATIONS_H + +#include "utils/stringvector.h" + +#include <list> +#include <map> + +#include "localconsts.h" + +class Being; + +struct PlayerRelation final +{ + static const unsigned int EMOTE = (1 << 0); + static const unsigned int SPEECH_FLOAT = (1 << 1); + static const unsigned int SPEECH_LOG = (1 << 2); + static const unsigned int WHISPER = (1 << 3); + static const unsigned int TRADE = (1 << 4); + static const unsigned int INVISIBLE = (1 << 5); + static const unsigned int BLACKLIST = (1 << 6); + static const unsigned int ENEMY = (1 << 7); + + static const unsigned int RELATIONS_NR = 7; + static const unsigned int RELATION_PERMISSIONS[RELATIONS_NR]; + + static const unsigned int DEFAULT = EMOTE + | SPEECH_FLOAT + | SPEECH_LOG + | WHISPER + | TRADE; + enum Relation + { + NEUTRAL = 0, + FRIEND = 1, + DISREGARDED = 2, + IGNORED = 3, + ERASED = 4, + BLACKLISTED = 5, + ENEMY2 = 6 + }; + + explicit PlayerRelation(const Relation relation); + + A_DELETE_COPY(PlayerRelation) + + Relation mRelation; // bitmask for all of the above +}; + + +/** + * Ignore strategy: describes how we should handle ignores. + */ +class PlayerIgnoreStrategy +{ + public: + std::string mDescription; + std::string mShortName; + + PlayerIgnoreStrategy() : + mDescription(), + mShortName() + { + } + + A_DELETE_COPY(PlayerIgnoreStrategy) + + virtual ~PlayerIgnoreStrategy() + { } + + /** + * Handle the ignoring of the indicated action by the indicated player. + */ + virtual void ignore(Being *const being, + const unsigned int flags) const = 0; +}; + +class PlayerRelationsListener +{ + public: + PlayerRelationsListener() + { } + + virtual ~PlayerRelationsListener() + { } + + virtual void updatedPlayer(const std::string &name) = 0; + + virtual void updateAll() = 0; +}; + +/** + * Player relations class, represents any particular relations and/or + * preferences the user of the local client has wrt other players (identified + * by std::string). + */ +class PlayerRelationsManager final +{ + public: + PlayerRelationsManager(); + + A_DELETE_COPY(PlayerRelationsManager) + + ~PlayerRelationsManager(); + + /** + * Initialise player relations manager (load config file etc.) + */ + void init(); + + /** + * Load configuration from our config file, or substitute defaults. + */ + void load(const bool oldConfig = false); + + /** + * Save configuration to our config file. + */ + void store() const; + + /** + * Determines whether the player in question is being ignored, filtered by + * the specified flags. + */ + unsigned int checkPermissionSilently(const std::string &player_name, + const unsigned int flags) + const A_WARN_UNUSED; + + /** + * 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. + */ + bool hasPermission(const Being *const being, + const unsigned int flags) const A_WARN_UNUSED; + + bool hasPermission(const std::string &being, + const unsigned int flags) const A_WARN_UNUSED; + + /** + * Updates the relationship with this player. + */ + void setRelation(const std::string &name, + const PlayerRelation::Relation relation); + + /** + * Updates the relationship with this player. + */ + PlayerRelation::Relation getRelation(const std::string &name) + const A_WARN_UNUSED; + + /** + * Deletes the information recorded for a player. + */ + void removePlayer(const std::string &name); + + /** + * Retrieves the default permissions. + */ + unsigned int getDefault() const A_WARN_UNUSED; + + /** + * Sets the default permissions. + */ + void setDefault(const unsigned int permissions); + + /** + * Retrieves all known player ignore strategies. + * + * The player ignore strategies are allocated statically and must + * not be deleted. + */ + std::vector<PlayerIgnoreStrategy *> *getPlayerIgnoreStrategies() + A_WARN_UNUSED; + + /** + * Return the current player ignore strategy. + * + * \return A player ignore strategy, or nullptr + */ + const PlayerIgnoreStrategy *getPlayerIgnoreStrategy() const + A_WARN_UNUSED + { return mIgnoreStrategy; } + + /** + * Sets the strategy to call when ignoring players. + */ + void setPlayerIgnoreStrategy(PlayerIgnoreStrategy *const strategy) + { mIgnoreStrategy = strategy; } + + /** + * For a given ignore strategy short name, find the appropriate index + * in the ignore strategies vector. + * + * \param The short name of the ignore strategy to look up + * \return The appropriate index, or -1 + */ + int getPlayerIgnoreStrategyIndex(const std::string &shortname) + A_WARN_UNUSED; + + /** + * Retrieves a sorted vector of all players for which we have any + * relations recorded. + */ + StringVect *getPlayers() const A_WARN_UNUSED; + + StringVect *getPlayersByRelation(const PlayerRelation::Relation rel) + const A_WARN_UNUSED; + + /** + * Removes all recorded player info. + */ + void clear(); + + /** + * Do we persist our `ignore' setup? + */ + bool getPersistIgnores() const + { return mPersistIgnores; } + + void ignoreTrade(const std::string &name); + + bool isGoodName(Being *const being) const A_WARN_UNUSED; + + bool isGoodName(const std::string &name) const A_WARN_UNUSED; + + /** + * Change the `ignore persist' flag. + * + * @param value Whether to persist ignores + */ + void setPersistIgnores(const bool value) + { mPersistIgnores = value; } + + void addListener(PlayerRelationsListener *const listener) + { mListeners.push_back(listener); } + + void removeListener(PlayerRelationsListener *const listener) + { mListeners.remove(listener); } + + bool checkBadRelation(const std::string &name) const A_WARN_UNUSED; + + private: + void signalUpdate(const std::string &name); + + bool mPersistIgnores; // If NOT set, we delete the + // ignored data upon reloading + unsigned int mDefaultPermissions; + + bool checkName(const std::string &name) const A_WARN_UNUSED; + + PlayerIgnoreStrategy *mIgnoreStrategy; + std::map<std::string, PlayerRelation *> mRelations; + std::list<PlayerRelationsListener *> mListeners; + std::vector<PlayerIgnoreStrategy *> mIgnoreStrategies; +}; + + +extern PlayerRelationsManager player_relations; // singleton representation + // of player relations + + +#endif // BEING_PLAYERRELATIONS_H |