/* * The ManaPlus Client * Copyright (C) 2004-2009 The Mana World Development Team * Copyright (C) 2009-2010 The Mana Developers * Copyright (C) 2011 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 LOCALPLAYER_H #define LOCALPLAYER_H #include "actorspritelistener.h" #include "being.h" #include "client.h" #include "game.h" #include "listener.h" #include "gui/userpalette.h" #include <guichan/actionlistener.hpp> #include <memory> #include <vector> #ifdef __GNUC__ #define A_UNUSED __attribute__ ((unused)) #else #define A_UNUSED #endif class ChatTab; class FloorItem; class ImageSet; class Item; class Map; class OkDialog; struct SkillInfo; class AwayListener : public gcn::ActionListener { public: void action(const gcn::ActionEvent &event); }; /** * Reasons an item can fail to be picked up. */ enum { PICKUP_OKAY = 0, PICKUP_BAD_ITEM, PICKUP_TOO_HEAVY, PICKUP_TOO_FAR, PICKUP_INV_FULL, PICKUP_STACK_FULL, PICKUP_DROP_STEAL }; /** * The local player character. */ class LocalPlayer : public Being, public ActorSpriteListener, public Mana::Listener { public: /** * Constructor. */ LocalPlayer(int id = 65535, int subtype = 0); /** * Destructor. */ ~LocalPlayer(); virtual void logic(); virtual void setAction(Action action, int attackType = 0); /** * Compute the next pathnode location when walking using keyboard. * used by nextTile(). */ Position getNextWalkPosition(unsigned char dir); /** * Adds a new tile to the path when walking. * @note Eathena * Also, when specified, it picks up an item at the end of a path * or attack target. */ virtual void nextTile() { nextTile(0); } virtual void nextTile(unsigned char dir); /** * Check the player has permission to invite users to specific guild */ bool checkInviteRights(const std::string &guildName); /** * Invite a player to join guild */ void inviteToGuild(Being *being); // void clearInventory(); // void setInvItem(int index, int id, int amount); bool pickUp(FloorItem *item); /** * Called when an ActorSprite has been destroyed. * @param actorSprite the ActorSprite being destroyed. */ void actorSpriteDestroyed(const ActorSprite &actorSprite); /** * Gets the attack range. */ int getAttackRange(); int getAttackRange2(); void attack(Being *target = NULL, bool keep = false, bool dontChangeEquipment = false); void attack2(Being *target = NULL, bool keep = false, bool dontChangeEquipment = false); void setGMLevel(int level); int getGMLevel() { return mGMLevel; } void stopAttack(); void untarget(); /** * Returns the current target of the player. Returns 0 if no being is * currently targeted. */ Being *getTarget() const; /** * Sets the target being of the player. */ void setTarget(Being *target); /** * Sets a new destination for this being to walk to. */ virtual void setDestination(int x, int y); /** * Sets a new direction to keep walking in. */ void setWalkingDir(unsigned char dir); /** * Gets the walking direction */ unsigned char getWalkingDir() const { return mWalkingDir; } /** * Sets going to being to attack */ void setGotoTarget(Being *target); /** * Returns whether the target is in range to attack */ bool withinAttackRange(Being *target, bool fixDistance = false, int addRange = 0); /** * Stops the player dead in his tracks */ void stopWalking(bool sendToServer = true); bool toggleSit(); bool updateSit(); bool emote(Uint8 emotion); /** * Shows item pickup notifications. */ void pickedUp(const ItemInfo &itemInfo, int amount, unsigned char color, int floorItemId, unsigned char fail); int getLevel() const; int getTargetTime(); // int getSkillPoints() const // { return mSkillPoints; } // void setSkillPoints(int points); /** Tells that the path has been set by mouse. */ void pathSetByMouse() { mPathSetByMouse = true; } /** Tells if the path has been set by mouse. */ bool isPathSetByMouse() const { return mPathSetByMouse; } int getInvertDirection() { return mInvertDirection; } void setInvertDirection(int n) { mInvertDirection = n; } void invertDirection(); int getAttackWeaponType() { return mAttackWeaponType; } int getAttackType() { return mAttackType; } int getFollowMode() { return mFollowMode; } int getImitationMode() { return mImitationMode; } void changeAttackWeaponType(); void changeAttackType(); void changeFollowMode(); void changeImitationMode(); void changePickUpType(); int getCrazyMoveType() { return mCrazyMoveType ; } int getPickUpType() { return mPickUpType ; } int getQuickDropCounter() { return mQuickDropCounter ; } void changeQuickDropCounter(); int getMoveState() { return mMoveState ; } void setMoveState(int n) { mMoveState = n ; } void switchMagicAttack(); void switchPvpAttack(); int getMagicAttackType() { return mMagicAttackType ; } int getPvpAttackType() { return mPvpAttackType ; } int getMoveToTargetType() { return mMoveToTargetType ; } int getDisableGameModifiers() { return mDisableGameModifiers ; } int getPingTime() { return mPingTime ; } void tryPingRequest(); void changeMoveToTargetType(); void switchGameModifiers(); void magicAttack(); void specialMove(unsigned char direction); void moveByDirection(unsigned char dir); bool pickUpItems(int pickUpType = 0); void changeCrazyMoveType(); void crazyMove(); void moveTo(int x, int y); void move(int dX, int dY); void moveToTarget(unsigned int dist = -1); void moveToHome(); void debugMsg(std::string str); // int getSkillLv(int id); bool isReachable(int x, int y, int maxCost = 0); bool isReachable(Being *being, int maxCost = 0); void setHome(); void pingRequest(); void pingResponse(); void changeAwayMode(); void setAway(const std::string &message); void setPseudoAway(const std::string &message); bool getAway() { return mAwayMode; } bool getPseudoAway() { return mPseudoAwayMode; } void setHalfAway(bool n) { mInactive = n; } bool getHalfAway() { return mInactive; } void afkRespond(ChatTab *tab, const std::string &nick); bool navigateTo(int x, int y); void navigateTo(Being *being); void navigateClean(); void updateCoords(); void imitateEmote(Being* being, unsigned char emote); void imitateAction(Being *being, Being::Action action); void imitateDirection(Being *being, unsigned char dir); void imitateOutfit(Being *player, int sprite = -1); void followMoveTo(Being *being, int x, int y); void followMoveTo(Being *being, int x1, int y1, int x2, int y2); bool allowAction(); bool allowMove(); void setRealPos(int x, int y); bool isServerBuggy() { return mIsServerBuggy; } void fixPos(int maxDist = 1); /** * Sets the map the being is on */ void setMap(Map *map); void addMessageToQueue(const std::string &message, int color = UserPalette::EXP_INFO); /** * Called when a option (set with config.addListener()) is changed */ void optionChanged(const std::string &value); void processEvent(Mana::Channels channel, const Mana::Event &event); /** * set a following player. */ void setFollow(std::string player); /** * set an imitation player. */ void setImitate(std::string player); /** * setting the next destination of the following, in case of warp */ void setNextDest(int x, int y); int getNextDestX() const { return mNextDestX; } int getNextDestY() const { return mNextDestY; } void respawn(); FloorItem *getPickUpTarget() { return mPickUpTarget; } void unSetPickUpTarget() { mPickUpTarget = 0; } /** * Stop following a player. */ void cancelFollow(); /** * Get the playername followed by the current player. */ std::string getFollow() const { return mPlayerFollowed; } /** * Get the playername imitated by the current player. */ std::string getImitate() const { return mPlayerImitated; } /** * Tells the engine whether to check * if the Player Name is to be displayed. */ void setCheckNameSetting(bool checked) { mUpdateName = checked; } /** * Gets if the engine has to check * if the Player Name is to be displayed. */ bool getCheckNameSetting() const { return mUpdateName; } void fixAttackTarget(); void updateNavigateList(); int getPathLength(Being* being); void targetMoved(); void setLastHitFrom(std::string n) { mLastHitFrom = n; } void waitFor(std::string nick); void checkNewName(Being *being); void resetYellowBar(); virtual unsigned char getWalkMask() const; void saveHomes(); void removeHome(); void stopAdvert(); bool checAttackPermissions(Being *target); protected: /** Whether or not the name settings have changed */ bool mUpdateName; virtual void handleStatusEffect(StatusEffect *effect, int effectId); void startWalking(unsigned char dir); void changeEquipmentBeforeAttack(Being* target); void tryMagic(std::string spell, int baseMagic, int schoolMagic, int mana); void crazyMove1(); void crazyMove2(); void crazyMove3(); void crazyMove4(); void crazyMove5(); void crazyMove6(); void crazyMove7(); void crazyMove8(); void crazyMove9(); void crazyMoveA(); void loadHomes(); bool mInStorage; /**< Whether storage is currently accessible */ int mTargetTime; /** How long the being has been targeted **/ int mLastTarget; /** Time stamp of last targeting action, -1 if none. */ int mGMLevel; //move type unsigned int mInvertDirection; //crazy move type unsigned int mCrazyMoveType; //crazy move state unsigned int mCrazyMoveState; //attack weapon type unsigned int mAttackWeaponType; //quick drop counter unsigned int mQuickDropCounter; //move state. used if mInvertDirection == 2 unsigned int mMoveState; //temporary disable crazy moves in moves bool mDisableCrazyMove; //pick up type 1x1, normal aka 2x1, forward aka 2x3, 3x3, 3x3 + 1 unsigned int mPickUpType; //magic attack type unsigned int mMagicAttackType; //pvp attack type unsigned int mPvpAttackType; //type how move to target unsigned int mMoveToTargetType; unsigned int mAttackType; unsigned int mFollowMode; unsigned int mImitationMode; bool mDisableGameModifiers; int mLastTargetX; int mLastTargetY; std::map<std::string, Vector> mHomes; Being *mTarget; /** Follow system **/ std::string mPlayerFollowed; std::string mPlayerImitated; int mNextDestX; int mNextDestY; FloorItem *mPickUpTarget; bool mGoingToTarget; bool mKeepAttacking; /** Whether or not to continue to attack */ int mLastAction; /**< Time stamp of the last action, -1 if none.*/ unsigned char mWalkingDir; /**< The direction the player is walking in. */ bool mPathSetByMouse; /**< Tells if the path was set using mouse */ std::vector<int> mStatusEffectIcons; int mLocalWalkTime; /**< Timestamp used to control keyboard walk messages flooding */ typedef std::pair<std::string, int> MessagePair; /** Queued messages*/ std::list<MessagePair> mMessages; int mMessageTime; AwayListener *mAwayListener; OkDialog *mAwayDialog; int mPingSendTick; bool mWaitPing; int mPingTime; int mAfkTime; bool mAwayMode; bool mPseudoAwayMode; bool mShowNavigePath; bool mIsServerBuggy; bool mSyncPlayerMove; bool mDrawPath; bool mAttackMoving; bool mShowJobExp; int mActivityTime; int mNavigateX; int mNavigateY; int mNavigateId; int mCrossX; int mCrossY; int mOldX; int mOldY; int mOldTileX; int mOldTileY; Path mNavigatePath; bool mTargetDeadPlayers; bool mServerAttack; std::string mLastHitFrom; std::string mWaitFor; int mAdvertTime; bool mBlockAdvert; bool mEnableAdvert; bool mTradebot; bool mTargetOnlyReachable; bool mNextStep; }; extern LocalPlayer *player_node; #endif