diff options
Diffstat (limited to 'src/being.h')
| -rw-r--r-- | src/being.h | 770 |
1 files changed, 770 insertions, 0 deletions
diff --git a/src/being.h b/src/being.h new file mode 100644 index 000000000..09466f5af --- /dev/null +++ b/src/being.h @@ -0,0 +1,770 @@ +/* + * The Mana Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * + * This file is part of The Mana 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_H +#define BEING_H + +#ifdef __GNUC__ +#define _UNUSED_ __attribute__ ((unused)) +#else +#define _UNUSED_ +#endif + +#include "actorsprite.h" +#include "configlistener.h" +#include "map.h" +#include "particlecontainer.h" +#include "position.h" +#include "vector.h" + +#include <guichan/color.hpp> + +#include <SDL_types.h> + +#include <map> +#include <set> +#include <string> +#include <vector> + +#define FIRST_IGNORE_EMOTE 14 +#define STATUS_EFFECTS 32 + +#define SPEECH_TIME 500 +#define SPEECH_MAX_TIME 1000 + +class BeingCacheEntry; +class BeingInfo; +class FlashText; +class Guild; +class ItemInfo; +class Item; +class Particle; +class Party; +class Position; +class SpeechBubble; +class Text; + +extern volatile int cur_time; + +enum Gender +{ + GENDER_MALE = 0, + GENDER_FEMALE = 1, + GENDER_UNSPECIFIED = 2 +}; + +class Being : public ActorSprite, public ConfigListener +{ + public: + /** + * 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 + }; + + 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 + }; + + 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(int id, Type type, Uint16 subtype, Map *map); + + virtual ~Being(); + + Type getType() const + { return mType; } + + /** + * Removes all path nodes from this being. + */ + void clearPath(); + + /** + * Returns the time spent in the current action. + */ + int getActionTime() const + { return mActionTime; } + + /** + * Set the current action time. + * @see Ea::BeingHandler that set it to tick time. + */ + void setActionTime(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 + { return getOffset(LEFT, RIGHT); } + + /** + * Get the current Y pixel offset. + * TODO: Used by eAthena only? + */ + int getYOffset() const + { return getOffset(UP, DOWN); } + + /** + * Creates a path for the being from current position to ex and ey + */ + void setDestination(int ex, int ey); + + /** + * Returns the destination for this being. + */ + const Vector &getDestination() const + { return mDest; } + + /** + * Returns the tile x coord + */ + int getTileX() const + { return mX; } + + /** + * Returns the tile y coord + */ + int getTileY() const + { return mY; } + + /** + * Sets the tile x and y coord + */ + void setTileCoords(int x, 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, int time = 500); + + /** + * 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 + */ + void takeDamage(Being *attacker, int damage, AttackType type); + + /** + * 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 + */ + virtual void handleAttack(Being *victim, int damage, AttackType type); + + /** + * Returns the name of the being. + */ + const std::string &getName() const + { return mName; } + + /** + * Sets the name for the being. + * + * @param name The name that should appear. + */ + void setName(const std::string &name); + + bool getShowName() const + { return mShowName; } + + void setShowName(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 + { return mPartyName; } + + const std::string &getGuildName() const + { 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 *guild); + + /** + * Removers a guild from the being. + */ + void removeGuild(int id); + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild(const std::string &guildName) const; + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild(int id) const; + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild() const; + + /** + * Returns all guilds the being is in. + */ + const std::map<int, Guild*> &getGuilds() const + { return mGuilds; } + + /** + * Removes all guilds the being is in. + */ + void clearGuilds(); + + /** + * Get number of guilds the being belongs to. + */ + short getNumberOfGuilds() const + { return static_cast<short>(mGuilds.size()); } + + bool isInParty() const + { return mParty != NULL; } + + void setParty(Party *party); + + void setGuild(Guild *guild); + + void updateGuild(); + + Party *getParty() const + { return mParty; } + + int getSpritesCount() + { return static_cast<int>(size()); } + + /** + * Sets visible equipments for this being. + */ + void setSprite(unsigned int slot, int id, + const std::string &color = "", bool isWeapon = false); + + void setSpriteID(unsigned int slot, int id); + + void setSpriteColor(unsigned int slot, const std::string &color = ""); + + /** + * Get the number of hairstyles implemented + */ + static int getNumOfHairstyles() + { return mNumberOfHairstyles; } + + /** + * Get the number of layers used to draw the being + */ + int getNumberOfLayers() const; + + /** + * Performs being logic. + */ + virtual void logic(); + + /** + * Draws the speech text above the being. + */ + void drawSpeech(int offsetX, int offsetY); + + /** + * Draws the emotion picture above the being. + */ + void drawEmotion(Graphics *graphics, int offsetX, int offsetY); + + Uint16 getSubType() const + { return mSubType; } + + /** + * Set Being's subtype (mostly for view for monsters and NPCs) + */ + void setSubtype(Uint16 subtype); + + const BeingInfo *getInfo() const + { return mInfo; } + + TargetCursorSize getTargetCursorSize() const; + + int getTargetOffsetX() const; + + int getTargetOffsetY() const; + + /** + * Gets the way the object is blocked by other objects. + */ + unsigned char getWalkMask() const; + + /** + * Gets the way the monster blocks pathfinding for other objects + */ + Map::BlockType getBlockType() const; + + /** + * Sets the walk speed. + * in pixels per second for eAthena, + * in tiles per second for Manaserv. + */ + void setWalkSpeed(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 + { return mWalkSpeed; } + + /** + * Sets the attack speed. + * @todo In what unit? + */ + void setAttackSpeed(int speed) + { mAttackSpeed = speed; } + + /** + * Gets the attack speed. + * @todo In what unit? + */ + int getAttackSpeed() const + { return mAttackSpeed; } + + /** + * Sets the current action. + */ + virtual void setAction(Action action, int attackType = 0); + + /** + * Get the being's action currently performed. + */ + Action getCurrentAction() const + { return mAction; } + + /** + * Returns whether this being is still alive. + */ + bool isAlive() const + { return mAction != DEAD; } + + /** + * Returns the current direction. + */ + Uint8 getDirection() const + { return mDirection; } + + /** + * Sets the current direction. + */ + virtual void setDirection(Uint8 direction); + + /** + * Returns the direction the being is facing. + */ + SpriteDirection getSpriteDirection() const + { return SpriteDirection(mSpriteDirection); } + + void setPosition(const Vector &pos); + + /** + * Overloaded method provided for convenience. + * + * @see setPosition(const Vector &pos) + */ + inline void setPosition(float x, float y, 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; + + /** + * Returns the vertical size of the current base sprite of the being. + */ + virtual int getHeight() const; + + /** + * Returns the being's pixel radius used to detect collisions. + */ + virtual int getCollisionRadius() const; + + /** + * Shoots a missile particle from this being, to target being + */ + void fireMissile(Being *target, const std::string &particle); + + /** + * 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 + { return mPath; } + + int getDistance() + { return mDistance; } + + void setDistance(int n) + { mDistance = n; } + + /** + * Set the Emoticon type and time displayed above + * the being. + */ + void setEmote(Uint8 emotion, int emote_time) + { + mEmotion = emotion; + mEmotionTime = emote_time; + } + + /** + * Get the current Emoticon type displayed above + * the being. + */ + int getEmotion() const + { return mEmotion; } + + virtual void drawSprites(Graphics* graphics, int posX, int posY) const; + + virtual void drawSpritesSDL(Graphics* graphics, + int posX, int posY) const; + + void drawHpBar(Graphics *graphics, int x, int y, + int width, int height) const; + + static void load(); + + virtual void optionChanged(const std::string &value); + + void flashName(int time); + + int getDamageTaken() const + { return mDamageTaken; } + + void setDamageTaken(int damage) + { mDamageTaken = damage; } + + void updateName(); + + void setLevel(int n) + { mLevel = n; } + + virtual int getLevel() const + { return mLevel; } + + void setIsReachable(int n) + { mIsReachable = n; } + + int isReachable() + { return mIsReachable; } + + static void reReadConfig(); + + static BeingCacheEntry* getCacheEntry(int id); + + void addToCache(); + + bool updateFromCache(); + + /** + * Sets the gender of this being. + */ + virtual void setGender(Gender gender); + + Gender getGender() const + { return mGender; } + + /** + * Whether or not this player is a GM. + */ + bool isGM() const + { return mIsGM; } + + /** + * Triggers whether or not to show the name as a GM name. + */ + void setGM(bool gm); + + bool canTalk(); + + void talkTo(); + + static bool isTalking(); + + bool draw(Graphics *graphics, int offsetX, int offsetY) const; + + bool drawSpriteAt(Graphics *graphics, int x, 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(bool n) + { mEnemy = n; } + + const std::string &getIp() const + { return mIp; } + + void setIp(std::string ip) + { mIp = ip; } + + unsigned int getPvpRank() const + { return mPvpRank; } + + void setPvpRank(unsigned int rank) + { mPvpRank = rank; } + + void setHP(int n); + + void setMaxHP(int hp); + + int getHP() + { return mHP; } + + protected: + /** + * Sets the new path for this being. + */ + void setPath(const Path &path); + + /** + * Updates name's location. + */ + virtual void updateCoords(); + + void recalcSpritesOrder(); + + void showName(); + + BeingInfo *mInfo; + + int mActionTime; /**< Time spent in current action */ + + int mEmotion; /**< Currently showing emotion */ + int mEmotionTime; /**< Time until emotion disappears */ + /** Time until the last speech sentence disappears */ + int mSpeechTime; + + int mAttackType; + int mAttackSpeed; /**< Attack speed */ + + Action mAction; /**< Action the being is performing */ + Uint16 mSubType; /**< Subtype (graphical view, basically) */ + + Uint8 mDirection; /**< Facing direction */ + Uint8 mSpriteDirection; /**< Facing direction */ + std::string mName; /**< Name of character */ + std::string mPartyName; + std::string mGuildName; + + /** + * Holds a text object when the being displays it's name, 0 otherwise + */ + FlashText *mDispName; + const gcn::Color *mNameColor; + bool mShowName; + + /** Engine-related infos about weapon. */ + const ItemInfo *mEquippedWeapon; + + static int mNumberOfHairstyles; /** Number of hair styles in use */ + + Path mPath; + std::string mSpeech; + Text *mText; + const gcn::Color *mTextColor; + + int mLevel; + Vector mDest; /**< destination coordinates. */ + + std::vector<int> mSpriteIDs; + std::vector<std::string> mSpriteColors; + Gender mGender; + + // Character guild information + std::map<int, Guild*> mGuilds; + Party *mParty; + + 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(char pos, char neg) const; + + int searchSlotValue(std::vector<int> &slotRemap, int val); + + void searchSlotValueItr(std::vector<int>::iterator &it, int &idx, + std::vector<int> &slotRemap, int val); + + 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; + + int mX, mY; /**< Position in tile */ + + int mDamageTaken; + int mHP; + int mMaxHP; + int mDistance; + int mIsReachable; /**< 0 - unknown, 1 - reachable, 2 - not reachable*/ + + 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; +// std::string mDisplayName; + + unsigned int mMoveTime; + unsigned int mAttackTime; + unsigned int mTalkTime; + unsigned int mTestTime; + unsigned int mOtherTime; + bool mErased; + bool mEnemy; + std::string mIp; + unsigned int mPvpRank; + int *mSpriteRemap; +}; + +extern std::list<BeingCacheEntry*> beingInfoCache; + +#endif |