diff options
Diffstat (limited to 'src/being/being.h')
| -rw-r--r-- | src/being/being.h | 1063 |
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 |