move being related files into being dir.

1 files changed, 1063 insertions, 0 deletions

diff --git a/src/being/being.h b/src/being/being.h
new file mode 100644
index 000000000..29b735956
--- /dev/null
+++ b/src/being/being.h
@@ -0,0 +1,1063 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-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_BEING_H
+#define BEING_BEING_H
+
+#include "equipment.h"
+
+#include "resources/beinginfo.h"
+
+#include <guichan/color.hpp>
+
+#include <SDL_types.h>
+
+#include <map>
+#include <set>
+
+#include "localconsts.h"
+
+static const unsigned int FIRST_IGNORE_EMOTE = 14;
+static const unsigned int STATUS_EFFECTS = 32;
+
+static const unsigned int SPEECH_TIME = 500;
+static const unsigned int SPEECH_MIN_TIME = 200;
+static const unsigned int SPEECH_MAX_TIME = 800;
+
+static const int DEFAULT_BEING_WIDTH = 32;
+static const int DEFAULT_BEING_HEIGHT = 32;
+
+class AnimatedSprite;
+class BeingCacheEntry;
+class Being;
+class FlashText;
+class Guild;
+class Inventory;
+class ItemInfo;
+class Item;
+class Particle;
+class Party;
+class SpeechBubble;
+class Text;
+
+struct Position;
+
+extern volatile int cur_time;
+
+enum Gender
+{
+    GENDER_MALE = 0,
+    GENDER_FEMALE = 1,
+    GENDER_UNSPECIFIED = 2,
+    GENDER_OTHER = 3
+};
+
+
+struct NextSoundInfo
+{
+    NextSoundInfo() :
+        sound(nullptr),
+        x(0),
+        y(0),
+        time(0)
+    {
+    }
+
+    const SoundInfo *sound;
+    int x;
+    int y;
+    int time;
+};
+
+class Being : public ActorSprite, public ConfigListener
+{
+    public:
+        friend class BeingEquipBackend;
+        friend class LocalPlayer;
+
+        enum FLAGS
+        {
+            FLAG_SHOP = 1,
+            FLAG_AWAY = 2,
+            FLAG_INACTIVE = 4,
+            FLAG_GENDER_OTHER = 32,
+            FLAG_GM = 64,
+            FLAG_GENDER_MALE = 128,
+            FLAG_SPECIAL = 128 + 64
+        };
+
+        /**
+         * Action the being is currently performing
+         * WARNING: Has to be in sync with the same enum in the Being class
+         * of the server!
+         */
+        enum Action
+        {
+            STAND = 0,
+            MOVE,
+            ATTACK,
+            SIT,
+            DEAD,
+            HURT,
+            SPAWN
+        };
+
+        enum Speech
+        {
+            NO_SPEECH = 0,
+            TEXT_OVERHEAD,
+            NO_NAME_IN_BUBBLE,
+            NAME_IN_BUBBLE
+        };
+
+        enum AttackType
+        {
+            HIT = 0x00,
+            CRITICAL = 0x0a,
+            MULTI = 0x08,
+            REFLECT = 0x04,
+            FLEE = 0x0b,
+            SKILL = 0xff,
+            MISS = 0xffff   // pseudo value for miss attacks
+        };
+
+        enum Reachable
+        {
+            REACH_UNKNOWN = 0,
+            REACH_YES = 1,
+            REACH_NO = 2
+        };
+
+        /**
+         * Directions, to be used as bitmask values
+         */
+        enum BeingDirection
+        {
+            DOWN = 1,
+            LEFT = 2,
+            UP = 4,
+            RIGHT = 8
+        };
+
+        /**
+         * Constructor.
+         *
+         * @param id      a unique being id
+         * @param subtype partly determines the type of the being
+         * @param map     the map the being is on
+         */
+        Being(const int id, const Type type, const uint16_t subtype,
+              Map *const map);
+
+        A_DELETE_COPY(Being)
+
+        virtual ~Being();
+
+        Type getType() const A_WARN_UNUSED
+        { return mType; }
+
+        /**
+         * Removes all path nodes from this being.
+         */
+        void clearPath();
+
+        /**
+         * Returns the time spent in the current action.
+         */
+        int getActionTime() const A_WARN_UNUSED
+        { return mActionTime; }
+
+        /**
+         * Set the current action time.
+         * @see Ea::BeingHandler that set it to tick time.
+         */
+        void setActionTime(const int actionTime)
+        { mActionTime = actionTime; }
+
+        /**
+         * Makes this being take the next tile of its path.
+         * TODO: Used by eAthena only?
+         */
+        virtual void nextTile();
+
+        /**
+         * Get the current X pixel offset.
+         * TODO: Used by eAthena only?
+         */
+        int getXOffset() const A_WARN_UNUSED
+        { return getOffset(LEFT, RIGHT); }
+
+        /**
+         * Get the current Y pixel offset.
+         * TODO: Used by eAthena only?
+         */
+        int getYOffset() const A_WARN_UNUSED
+        { return getOffset(UP, DOWN); }
+
+        /**
+         * Creates a path for the being from current position to ex and ey
+         */
+        void setDestination(const int dstX, const int dstY);
+
+        /**
+         * Returns the destination for this being.
+         */
+        const Vector &getDestination() const A_WARN_UNUSED
+        { return mDest; }
+
+        /**
+         * Returns the tile x coord
+         */
+        int getTileX() const A_WARN_UNUSED
+        { return mX; }
+
+        /**
+         * Returns the tile y coord
+         */
+        int getTileY() const A_WARN_UNUSED
+        { return mY; }
+
+        /**
+         * Sets the tile x and y coord
+         */
+        void setTileCoords(const int x, const int y)
+        { mX = x; mY = y; }
+
+        /**
+         * Puts a "speech balloon" above this being for the specified amount
+         * of time.
+         *
+         * @param text The text that should appear.
+         * @param time The amount of time the text should stay in milliseconds.
+         */
+        void setSpeech(const std::string &text,
+                       const std::string &channel = "",
+                       int time = 0);
+
+        /**
+         * Puts a damage bubble above this being.
+         *
+         * @param attacker the attacking being
+         * @param damage the amount of damage recieved (0 means miss)
+         * @param type the attack type
+         * @param id skill id
+         */
+        void takeDamage(Being *const attacker, const int damage,
+                        const AttackType type, const int attackId = 1);
+
+        /**
+         * Handles an attack of another being by this being.
+         *
+         * @param victim the victim being
+         * @param damage the amount of damage dealt (0 means miss)
+         * @param type the attack type
+         */
+        void handleAttack(Being *const victim, const int damage,
+                          const int attackId = 1);
+
+        virtual void handleSkill(Being *const victim, const int damage,
+                                 const int skillId, const int skillLevel);
+
+        const ItemInfo *getEquippedWeapon() const A_WARN_UNUSED
+        { return mEquippedWeapon; }
+
+        /**
+         * Returns the name of the being.
+         */
+        const std::string &getName() const A_WARN_UNUSED
+        { return mName; }
+
+        /**
+         * Sets the name for the being.
+         *
+         * @param name The name that should appear.
+         */
+        void setName(const std::string &name);
+
+        bool getShowName() const A_WARN_UNUSED
+        { return mShowName; }
+
+        void setShowName(const bool doShowName);
+
+        /**
+         * Sets the name of the party the being is in. Shown in BeingPopup.
+         */
+        void setPartyName(const std::string &name)
+        { mPartyName = name; }
+
+        const std::string &getPartyName() const A_WARN_UNUSED
+        { return mPartyName; }
+
+        const std::string &getGuildName() const A_WARN_UNUSED
+        { return mGuildName; }
+
+        /**
+         * Sets the name of the primary guild the being is in. Shown in
+         * BeingPopup (eventually).
+         */
+        void setGuildName(const std::string &name);
+
+        void setGuildPos(const std::string &pos);
+
+        /**
+         * Adds a guild to the being.
+         */
+        void addGuild(Guild *const guild);
+
+        /**
+         * Removers a guild from the being.
+         */
+        void removeGuild(const int id);
+
+        /**
+         * Returns a pointer to the specified guild that the being is in.
+         */
+        Guild *getGuild(const std::string &guildName) const A_WARN_UNUSED;
+
+        /**
+         * Returns a pointer to the specified guild that the being is in.
+         */
+        Guild *getGuild(const int id) const A_WARN_UNUSED;
+
+        /**
+         * Returns a pointer to the specified guild that the being is in.
+         */
+        Guild *getGuild() const A_WARN_UNUSED;
+
+        /**
+         * Returns all guilds the being is in.
+         */
+        const std::map<int, Guild*> &getGuilds() const A_WARN_UNUSED
+        { return mGuilds; }
+
+        /**
+         * Removes all guilds the being is in.
+         */
+        void clearGuilds();
+
+        /**
+         * Get number of guilds the being belongs to.
+         */
+        int16_t getNumberOfGuilds() const A_WARN_UNUSED
+        { return static_cast<int16_t>(mGuilds.size()); }
+
+        bool isInParty() const A_WARN_UNUSED
+        { return mParty; }
+
+        void setParty(Party *const party);
+
+        void setGuild(Guild *const guild);
+
+        void updateGuild();
+
+        Party *getParty() const A_WARN_UNUSED
+        { return mParty; }
+
+        int getSpritesCount() const A_WARN_UNUSED
+        { return static_cast<int>(size()); }
+
+        /**
+         * Sets visible equipments for this being.
+         */
+        void setSprite(const unsigned int slot, const int id,
+                       std::string color = "",
+                       const unsigned char colorId = 1,
+                       const bool isWeapon = false,
+                       const bool isTempSprite = false);
+
+        void setSpriteID(const unsigned int slot, const int id);
+
+        void setSpriteColor(const unsigned int slot,
+                            const std::string &color = "");
+
+        /**
+         * Get the number of hairstyles implemented
+         */
+        static int getNumOfHairstyles() A_WARN_UNUSED
+        { return mNumberOfHairstyles; }
+
+        /**
+         * Get the number of races implemented
+         */
+        static int getNumOfRaces() A_WARN_UNUSED
+        { return mNumberOfRaces; }
+
+        /**
+         * Get the number of layers used to draw the being
+         */
+        int getNumberOfLayers() const A_WARN_UNUSED
+        { return CompoundSprite::getNumberOfLayers(); }
+
+        /**
+         * Performs being logic.
+         */
+        virtual void logic() override;
+
+        /**
+         * Draws the speech text above the being.
+         */
+        void drawSpeech(const int offsetX, const int offsetY);
+
+        /**
+         * Draws the emotion picture above the being.
+         */
+        void drawEmotion(Graphics *const graphics, const int offsetX,
+                         const int offsetY);
+
+        uint16_t getSubType() const
+        { return mSubType; }
+
+         /**
+          * Set Being's subtype (mostly for view for monsters and NPCs)
+          */
+        void setSubtype(const uint16_t subtype, const uint8_t look);
+
+        const BeingInfo *getInfo() const A_WARN_UNUSED
+        { return mInfo; }
+
+        TargetCursorSize getTargetCursorSize() const A_WARN_UNUSED;
+
+        int getTargetOffsetX() const A_WARN_UNUSED
+        {
+            if (!mInfo)
+                return 0;
+            return mInfo->getTargetOffsetX();
+        }
+
+        int getTargetOffsetY() const A_WARN_UNUSED
+        {
+            if (!mInfo)
+                return 0;
+            return mInfo->getTargetOffsetY();
+        }
+
+        /**
+         * Gets the way the object is blocked by other objects.
+         */
+        virtual unsigned char getWalkMask() const A_WARN_UNUSED
+        {
+            if (!mInfo)
+                return 0;
+            return mInfo->getWalkMask();
+        }
+
+        /**
+         * Gets the way the monster blocks pathfinding for other objects
+         */
+        Map::BlockType getBlockType() const A_WARN_UNUSED
+        {
+            if (!mInfo)
+                return Map::BLOCKTYPE_NONE;
+            return mInfo->getBlockType();
+        }
+
+        /**
+         * Sets the walk speed.
+         * in pixels per second for eAthena,
+         * in tiles per second for Manaserv.
+         */
+        void setWalkSpeed(const Vector &speed)
+        { mWalkSpeed = speed; }
+
+        /**
+         * Gets the walk speed.
+         * in pixels per second for eAthena,
+         * in tiles per second for Manaserv (0.1 precision).
+         */
+        Vector getWalkSpeed() const A_WARN_UNUSED
+        { return mWalkSpeed; }
+
+        /**
+         * Sets the attack speed.
+         * @todo In what unit?
+         */
+        void setAttackSpeed(const int speed)
+        { mAttackSpeed = speed; }
+
+        /**
+         * Gets the attack speed.
+         * @todo In what unit?
+         */
+        int getAttackSpeed() const A_WARN_UNUSED
+        { return mAttackSpeed; }
+
+        /**
+         * Sets the current action.
+         */
+        virtual void setAction(const Action &action, const int attackType = 0);
+
+        /**
+         * Get the being's action currently performed.
+         */
+        Action getCurrentAction() const A_WARN_UNUSED
+        { return mAction; }
+
+        /**
+         * Returns whether this being is still alive.
+         */
+        bool isAlive() const A_WARN_UNUSED
+        { return mAction != DEAD; }
+
+        /**
+         * Returns the current direction.
+         */
+        uint8_t getDirection() const A_WARN_UNUSED
+        { return mDirection; }
+
+        /**
+         * Sets the current direction.
+         */
+        virtual void setDirection(const uint8_t direction);
+
+        virtual void setDirectionDelayed(const uint8_t direction)
+        { mDirectionDelayed = direction; }
+
+        uint8_t getDirectionDelayed() const A_WARN_UNUSED
+        { return mDirectionDelayed; }
+
+        /**
+         * Returns the direction the being is facing.
+         */
+        SpriteDirection getSpriteDirection() const A_WARN_UNUSED
+        { return static_cast<SpriteDirection>(mSpriteDirection); }
+
+        void setPosition(const Vector &pos);
+
+        /**
+         * Overloaded method provided for convenience.
+         *
+         * @see setPosition(const Vector &pos)
+         */
+        inline void setPosition(const float x, const float y,
+                                const float z = 0.0f)
+        { setPosition(Vector(x, y, z)); }
+
+        /**
+         * Returns the horizontal size of the current base sprite of the being.
+         */
+        virtual int getWidth() const override A_WARN_UNUSED
+        { return std::max(CompoundSprite::getWidth(), DEFAULT_BEING_WIDTH); }
+
+        /**
+         * Returns the vertical size of the current base sprite of the being.
+         */
+        virtual int getHeight() const override A_WARN_UNUSED
+        { return std::max(CompoundSprite::getHeight(), DEFAULT_BEING_HEIGHT); }
+
+        /**
+         * Returns the being's pixel radius used to detect collisions.
+         */
+        virtual int getCollisionRadius() const A_WARN_UNUSED
+        { return 16; }
+
+        /**
+         * Shoots a missile particle from this being, to target being
+         */
+        void fireMissile(Being *const target,
+                         const std::string &particle) const;
+
+        /**
+         * Returns the path this being is following. An empty path is returned
+         * when this being isn't following any path currently.
+         */
+        const Path &getPath() const A_WARN_UNUSED
+        { return mPath; }
+
+        int getDistance() const A_WARN_UNUSED
+        { return mDistance; }
+
+        void setDistance(const int n)
+        { mDistance = n; }
+
+        /**
+         * Set the Emoticon type and time displayed above
+         * the being.
+         */
+        void setEmote(const uint8_t emotion, const int emote_time);
+
+        void setState(const uint8_t state);
+
+        virtual void drawSprites(Graphics *const  graphics,
+                                 int posX, int posY) const override;
+
+        virtual void drawSpritesSDL(Graphics *const graphics,
+                                    int posX, int posY) const override;
+
+        void drawHpBar(Graphics *const graphics, const int x, const int y,
+                       const int maxHP, const int hp, const int damage,
+                       const int color1, const int color2, const int width,
+                       const int height) const;
+
+        static void load();
+
+        virtual void optionChanged(const std::string &value) override;
+
+        void flashName(const int time);
+
+        int getDamageTaken() const A_WARN_UNUSED
+        { return mDamageTaken; }
+
+        void setDamageTaken(const int damage)
+        { mDamageTaken = damage; }
+
+        void updateName();
+
+        void setLevel(const int n)
+        { mLevel = n; }
+
+        virtual int getLevel() const A_WARN_UNUSED
+        { return mLevel; }
+
+        void setIsReachable(const int n)
+        { mIsReachable = n; }
+
+        int isReachable() const A_WARN_UNUSED
+        { return mIsReachable; }
+
+        static void reReadConfig();
+
+        static BeingCacheEntry* getCacheEntry(const int id) A_WARN_UNUSED;
+
+        void addToCache() const;
+
+        bool updateFromCache();
+
+        /**
+         * Sets the gender of this being.
+         */
+        virtual void setGender(const Gender gender);
+
+        Gender getGender() const A_WARN_UNUSED
+        { return mGender; }
+
+        /**
+         * Return sprite sit action for current environment.
+         */
+        std::string getSitAction() const A_WARN_UNUSED;
+
+        std::string getMoveAction() const A_WARN_UNUSED;
+
+        std::string getDeadAction() const A_WARN_UNUSED;
+
+        std::string getStandAction() const A_WARN_UNUSED;
+
+        std::string getSpawnAction() const A_WARN_UNUSED;
+
+        std::string getWeaponAttackAction(const ItemInfo *const weapon) const;
+
+        std::string getAttackAction(const Attack *const attack) const;
+
+        /**
+         * Whether or not this player is a GM.
+         */
+        bool isGM() const A_WARN_UNUSED
+        { return mIsGM; }
+
+        /**
+         * Triggers whether or not to show the name as a GM name.
+         */
+        void setGM(const bool gm);
+
+        bool canTalk() const A_WARN_UNUSED
+        { return mType == NPC; }
+
+        void talkTo() const;
+
+        bool draw(Graphics *const graphics,
+                  const int offsetX, const int offsetY) const override;
+
+        bool drawSpriteAt(Graphics *const graphics,
+                          const int x, const int y) const;
+
+        void setMoveTime()
+        { mMoveTime = cur_time; }
+
+        void setAttackTime()
+        { mAttackTime = cur_time; }
+
+        void setTalkTime()
+        { mTalkTime = cur_time; }
+
+        void setTestTime()
+        { mTestTime = cur_time; }
+
+        void setOtherTime()
+        { mOtherTime = cur_time; }
+
+        unsigned int getMoveTime() const
+        { return mMoveTime; }
+
+        unsigned int getAttackTime() const
+        { return mAttackTime; }
+
+        unsigned int getTalkTime() const
+        { return mTalkTime; }
+
+        unsigned int getTestTime() const
+        { return mTestTime; }
+
+        unsigned int getOtherTime() const
+        { return mOtherTime; }
+
+        void resetCounters();
+
+        virtual void updateColors();
+
+        void setEnemy(const bool n)
+        { mEnemy = n; }
+
+        const std::string &getIp() const A_WARN_UNUSED
+        { return mIp; }
+
+        void setIp(std::string ip)
+        { mIp = ip; }
+
+        unsigned int getPvpRank() const A_WARN_UNUSED
+        { return mPvpRank; }
+
+        void setPvpRank(const unsigned int rank)
+        { mPvpRank = rank; }
+
+        void setHP(const int n);
+
+        void setMaxHP(const int hp);
+
+        int getHP() const A_WARN_UNUSED
+        { return mHP; }
+
+        uint8_t calcDirection(const int dstX,
+                              const int dstY) const A_WARN_UNUSED;
+
+        uint8_t calcDirection() const A_WARN_UNUSED;
+
+        void setAttackDelay(const int n)
+        { mAttackDelay = n; }
+
+        int getAttackDelay() const A_WARN_UNUSED
+        { return mAttackDelay; }
+
+        int getMinHit() const A_WARN_UNUSED
+        { return mMinHit; }
+
+        void setMinHit(const int n)
+        { mMinHit = n; }
+
+        int getMaxHit() const A_WARN_UNUSED
+        { return mMaxHit; }
+
+        void setMaxHit(const int n)
+        { mMaxHit = n; }
+
+        int getCriticalHit() const A_WARN_UNUSED
+        { return mCriticalHit; }
+
+        void setCriticalHit(const int n)
+        { mCriticalHit = n; }
+
+        void updateHit(const int amount);
+
+        Equipment *getEquipment() A_WARN_UNUSED;
+
+        void undressItemById(const int id);
+
+        int getGoodStatus() const A_WARN_UNUSED
+        { return mGoodStatus; }
+
+        void setGoodStatus(const int n)
+        { mGoodStatus = n; }
+
+        std::string getGenderSign() const A_WARN_UNUSED;
+
+        std::string getGenderSignWithSpace() const A_WARN_UNUSED;
+
+        void updateComment();
+
+        const std::string getComment() const A_WARN_UNUSED
+        { return mComment; }
+
+        void setComment(std::string n)
+        { mComment = n; }
+
+        static void clearCache();
+
+        static std::string loadComment(const std::string &name,
+                                       const int type) A_WARN_UNUSED;
+
+        static void saveComment(const std::string &name,
+                                const std::string &comment, const int type);
+
+        bool isAdvanced() const A_WARN_UNUSED
+        { return mAdvanced; }
+
+        void setAdvanced(const bool n)
+        { mAdvanced = n; addToCache(); }
+
+        bool isShopEnabled() const A_WARN_UNUSED
+        { return mShop; }
+
+        void enableShop(const bool b)
+        { mShop = b; }
+
+        /**
+         * Sets the attack range.
+         */
+        void setAttackRange(const int range)
+        { mAttackRange = range; }
+
+        void attack(Being *target = nullptr, bool keep = false,
+                    bool dontChangeEquipment = false);
+
+        void attack2(Being *target = nullptr, bool keep = false,
+                     bool dontChangeEquipment = false);
+
+        void updatePercentHP();
+
+        void setRaceName(std::string name)
+        { mRaceName = name; }
+
+        std::string getRaceName() const A_WARN_UNUSED
+        { return mRaceName; }
+
+        int getSpriteID(const int slot) const A_WARN_UNUSED;
+
+        void setHairStyle(const unsigned int slot, const int id);
+
+        void setHairColor(const unsigned int slot,
+                          const unsigned char color);
+
+        void setHairColor(const unsigned char color)
+        { mHairColor = color; }
+
+        unsigned char getHairColor() const A_WARN_UNUSED
+        { return mHairColor; }
+
+        void recalcSpritesOrder();
+
+        int getHitEffect(const Being *const attacker,
+                         const AttackType type,
+                         const int attackId) const A_WARN_UNUSED;
+
+        Cursor::Cursor getHoverCursor() const A_WARN_UNUSED
+        { return mInfo ? mInfo->getHoverCursor() : Cursor::CURSOR_POINTER; }
+
+        void addAfkEffect();
+
+        void removeAfkEffect();
+
+        void updateAwayEffect();
+
+        void addSpecialEffect(const int effect);
+
+        void removeSpecialEffect();
+
+        void addEffect(const std::string &name);
+
+        void addPet(const int id);
+
+        void removePet();
+
+        void updatePets();
+
+        Being *getPet()
+        { return mPet; }
+
+        void setPet(Being *const pet)
+        { mPet = pet; }
+
+        void setOwner(Being *const owner)
+        { mOwner = owner; }
+
+        void playSfx(const SoundInfo &sound, Being *const being,
+                     const bool main, const int x, const int y);
+
+        int getLook()
+        { return mLook; }
+
+        void setLook(const int look);
+
+        static uint8_t genderToInt(const Gender sex) A_WARN_UNUSED;
+
+        static Gender intToGender(uint8_t sex) A_WARN_UNUSED;
+
+        NextSoundInfo mNextSound;
+
+    protected:
+        /**
+         * Sets the new path for this being.
+         */
+        void setPath(const Path &path);
+
+        /**
+         * Updates name's location.
+         */
+        virtual void updateCoords();
+
+        void showName();
+
+        static int getDefaultEffectId(const int type);
+
+        BeingInfo *mInfo;
+        AnimatedSprite *mEmotionSprite;
+        AnimatedSprite* mAnimationEffect;
+
+        std::string mSpriteAction;
+        std::string mName;              /**< Name of character */
+        std::string mRaceName;
+        std::string mPartyName;
+        std::string mGuildName;
+        std::string mSpeech;
+
+        /**
+         * Holds a text object when the being displays it's name, 0 otherwise
+         */
+        FlashText *mDispName;
+        const gcn::Color *mNameColor;
+
+        /** Engine-related infos about weapon. */
+        const ItemInfo *mEquippedWeapon;
+
+        static int mNumberOfHairstyles; /** Number of hair styles in use */
+        static int mNumberOfRaces; /** Number of races in use */
+
+        Path mPath;
+        Text *mText;
+        const gcn::Color *mTextColor;
+
+        Vector mDest;  /**< destination coordinates. */
+
+        StringVect mSpriteColors;
+        std::vector<int> mSpriteIDs;
+        std::vector<int> mSpriteColorsIds;
+
+        // Character guild information
+        std::map<int, Guild*> mGuilds;
+        Party *mParty;
+
+        int mActionTime;      /**< Time spent in current action */
+        int mEmotionTime;     /**< Time until emotion disappears */
+
+        /** Time until the last speech sentence disappears */
+        int mSpeechTime;
+        int mAttackSpeed;     /**< Attack speed */
+
+        int mLevel;
+        int mAttackRange;
+        Gender mGender;
+        Action mAction;       /**< Action the being is performing */
+        uint16_t mSubType;      /**< Subtype (graphical view, basically) */
+        uint8_t mDirection;               /**< Facing direction */
+        uint8_t mDirectionDelayed;        /**< Facing direction */
+        uint8_t mSpriteDirection;         /**< Facing direction */
+        bool mShowName;
+        bool mIsGM;
+
+    private:
+        /**
+         * Calculates the offset in the given directions.
+         * If walking in direction 'neg' the value is negated.
+         * TODO: Used by eAthena only?
+         */
+        int getOffset(const signed char pos,
+                      const signed char neg) const A_WARN_UNUSED;
+
+        int searchSlotValue(const std::vector<int> &slotRemap,
+                            const int val) const A_WARN_UNUSED;
+
+        void searchSlotValueItr(std::vector<int>::iterator &it, int &idx,
+                                std::vector<int> &slotRemap,
+                                const int val) const;
+
+        void dumpSprites() const;
+
+        const Type mType;
+
+        /** Speech Bubble components */
+        SpeechBubble *mSpeechBubble;
+
+        /**
+         * Walk speed for x and y movement values.
+         * In pixels per second for eAthena,
+         * In pixels per ticks for Manaserv.
+         * @see MILLISECONDS_IN_A_TICK
+         */
+        Vector mWalkSpeed;
+        std::string mIp;
+        int *mSpriteRemap;
+        int *mSpriteHide;
+        std::string mComment;
+        Being *mPet;
+        Being *mOwner;
+        Particle *mSpecialParticle;
+
+        int mX, mY;   /**< Position in tile */
+
+        int mDamageTaken;
+        int mHP;
+        int mMaxHP;
+        int mDistance;
+        int mIsReachable; /**< 0 - unknown, 1 - reachable, 2 - not reachable*/
+        int mGoodStatus;
+
+        static int mUpdateConfigTime;
+        static unsigned int mConfLineLim;
+        static int mSpeechType;
+        static bool mHighlightMapPortals;
+        static bool mHighlightMonsterAttackRange;
+        static bool mLowTraffic;
+        static bool mDrawHotKeys;
+        static bool mShowBattleEvents;
+        static bool mShowMobHP;
+        static bool mShowOwnHP;
+        static bool mShowGender;
+        static bool mShowLevel;
+        static bool mShowPlayersStatus;
+        static bool mEnableReorderSprites;
+        static bool mHideErased;
+        static bool mMoveNames;
+        static int mAwayEffect;
+
+        unsigned int mMoveTime;
+        unsigned int mAttackTime;
+        unsigned int mTalkTime;
+        unsigned int mOtherTime;
+        unsigned int mTestTime;
+        int mAttackDelay;
+        int mMinHit;
+        int mMaxHit;
+        int mCriticalHit;
+        unsigned int mPvpRank;
+        unsigned int mNumber;
+        int mPetId;
+        int mLook;
+        unsigned char mHairColor;
+        bool mErased;
+        bool mEnemy;
+        bool mGotComment;
+        bool mAdvanced;
+        bool mShop;
+        bool mAway;
+        bool mInactive;
+};
+
+extern std::list<BeingCacheEntry*> beingInfoCache;
+
+#endif  // BEING_BEING_H