diff options
Diffstat (limited to 'src/being/localplayer.h')
| -rw-r--r-- | src/being/localplayer.h | 652 |
1 files changed, 652 insertions, 0 deletions
diff --git a/src/being/localplayer.h b/src/being/localplayer.h new file mode 100644 index 000000000..4f57df0d7 --- /dev/null +++ b/src/being/localplayer.h @@ -0,0 +1,652 @@ +/* + * 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_LOCALPLAYER_H +#define BEING_LOCALPLAYER_H + +#include "depricatedlistener.h" + +#include "being/actorspritelistener.h" +#include "being/being.h" + +#include "gui/userpalette.h" + +#include <guichan/actionlistener.hpp> + +#include <memory> +#include <vector> + +#include "localconsts.h" + +class ChatTab; +class FloorItem; +class ImageSet; +class Item; +class Map; +class OkDialog; + +class AwayListener final : public gcn::ActionListener +{ + public: + void action(const gcn::ActionEvent &event) override; +}; + +/** + * 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 final : public Being, + public ActorSpriteListener, + public DepricatedListener +{ + public: + /** + * Constructor. + */ + explicit LocalPlayer(const int id = 65535, const int subtype = 0); + + A_DELETE_COPY(LocalPlayer) + + /** + * Destructor. + */ + ~LocalPlayer(); + + virtual void logic() override; + + void slowLogic(); + + virtual void setAction(const Action &action, + const int attackType = 0) override; + + /** + * Compute the next pathnode location when walking using keyboard. + * used by nextTile(). + */ + Position getNextWalkPosition(const unsigned char dir) + const A_WARN_UNUSED; + + /** + * 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() override + { nextTile(0); } + + virtual void nextTile(unsigned char dir); + + bool pickUp(FloorItem *const item); + + /** + * Called when an ActorSprite has been destroyed. + * @param actorSprite the ActorSprite being destroyed. + */ + void actorSpriteDestroyed(const ActorSprite &actorSprite) override; + + /** + * Gets the attack range. + */ + int getAttackRange() const A_WARN_UNUSED; + + int getAttackRange2() const A_WARN_UNUSED; + + void attack(Being *const target = nullptr, const bool keep = false, + const bool dontChangeEquipment = false); + + void attack2(Being *const target = nullptr, const bool keep = false, + const bool dontChangeEquipment = false); + + void setGMLevel(const int level); + + int getGMLevel() const A_WARN_UNUSED + { return mGMLevel; } + + void stopAttack(const bool keepAttack = false); + + void untarget(); + + /** + * Returns the current target of the player. Returns 0 if no being is + * currently targeted. + */ + Being *getTarget() const A_WARN_UNUSED; + + /** + * Sets the target being of the player. + */ + void setTarget(Being *const target); + + /** + * Sets a new destination for this being to walk to. + */ + virtual void setDestination(const int x, const int y); + + /** + * Sets a new direction to keep walking in. + */ + void setWalkingDir(const unsigned char dir); + + /** + * Gets the walking direction + */ + unsigned char getWalkingDir() const A_WARN_UNUSED + { return mWalkingDir; } + + /** + * Sets going to being to attack + */ + void setGotoTarget(Being *const target); + + /** + * Returns whether the target is in range to attack + */ + bool withinAttackRange(const Being *const target, + const bool fixDistance = false, + const int addRange = 0) const A_WARN_UNUSED; + + /** + * Stops the player dead in his tracks + */ + void stopWalking(const bool sendToServer = true); + + bool toggleSit() const; + + bool updateSit() const; + + static bool emote(const uint8_t emotion); + + /** + * Shows item pickup notifications. + */ + void pickedUp(const ItemInfo &itemInfo, const int amount, + const unsigned char color, const int floorItemId, + const unsigned char fail); + + int getLevel() const override A_WARN_UNUSED; + + /** 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 A_WARN_UNUSED + { return mPathSetByMouse; } + + int getInvertDirection() const A_WARN_UNUSED + { return mInvertDirection; } + + void setInvertDirection(const int n) + { mInvertDirection = n; } + + void invertDirection(); + + int getAttackWeaponType() const A_WARN_UNUSED + { return mAttackWeaponType; } + + int getAttackType() const A_WARN_UNUSED + { return mAttackType; } + + int getFollowMode() const A_WARN_UNUSED + { return mFollowMode; } + + int getImitationMode() const A_WARN_UNUSED + { return mImitationMode; } + + void changeAttackWeaponType(); + + void changeAttackType(); + + void changeFollowMode(); + + void changeImitationMode(); + + void changePickUpType(); + + int getCrazyMoveType() const A_WARN_UNUSED + { return mCrazyMoveType; } + + int getPickUpType() const A_WARN_UNUSED + { return mPickUpType; } + + int getQuickDropCounter() const A_WARN_UNUSED + { return mQuickDropCounter; } + + void setQuickDropCounter(const int n); + + void changeQuickDropCounter(); + + int getMoveState() const A_WARN_UNUSED + { return mMoveState; } + + void setMoveState(const int n) + { mMoveState = n; } + + void switchMagicAttack(); + + void switchPvpAttack(); + + int getMagicAttackType() const A_WARN_UNUSED + { return mMagicAttackType; } + + int getPvpAttackType() const A_WARN_UNUSED + { return mPvpAttackType; } + + int getMoveToTargetType() const A_WARN_UNUSED + { return mMoveToTargetType; } + + int getDisableGameModifiers() const A_WARN_UNUSED + { return mDisableGameModifiers; } + + std::string getPingTime() const A_WARN_UNUSED; + + void tryPingRequest(); + + void changeMoveToTargetType(); + + void switchGameModifiers(); + + void magicAttack() const; + + void specialMove(const unsigned char direction); + + void moveByDirection(const unsigned char dir); + + bool pickUpItems(int pickUpType = 0); + + void changeCrazyMoveType(); + + void crazyMove(); + + void moveTo(const int x, const int y); + + void move(const int dX, const int dY); + + void moveToTarget(int dist = -1); + + void moveToHome(); + + void debugMsg(const std::string &str) const; + + bool isReachable(Being *const being, + const int maxCost = 0) A_WARN_UNUSED; + + bool isReachable(const int x, const int y, + const bool allowCollision) const A_WARN_UNUSED; + + void setHome(); + + void pingRequest(); + + void pingResponse(); + + void changeAwayMode(); + + void setAway(const std::string &message); + + void setPseudoAway(const std::string &message); + + bool getAway() const A_WARN_UNUSED + { return mAwayMode; } + + bool getPseudoAway() const A_WARN_UNUSED + { return mPseudoAwayMode; } + + void setHalfAway(const bool n) + { mInactive = n; } + + bool getHalfAway() const A_WARN_UNUSED + { return mInactive; } + + void afkRespond(ChatTab *const tab, const std::string &nick); + + bool navigateTo(const int x, const int y); + + void navigateTo(const Being *const being); + + void navigateClean(); + + void imitateEmote(const Being *const being, + const unsigned char emote) const; + + void imitateAction(const Being *const being, + const Being::Action &action); + + void imitateDirection(const Being *const being, + const unsigned char dir); + + void imitateOutfit(Being *const player, const int sprite = -1) const; + + void followMoveTo(const Being *const being, const int x, const int y); + + void followMoveTo(const Being *const being, const int x1, const int y1, + const int x2, const int y2); + + bool allowAction() A_WARN_UNUSED; + + void setRealPos(const int x, const int y); + + bool isServerBuggy() const A_WARN_UNUSED + { return mIsServerBuggy; } + + void fixPos(const int maxDist = 1); + + /** + * Sets the map the being is on + */ + void setMap(Map *const map); + + void addMessageToQueue(const std::string &message, + const int color = UserPalette::EXP_INFO); + + /** + * Called when a option (set with config.addListener()) is changed + */ + void optionChanged(const std::string &value) override; + + void processEvent(Channels channel, + const DepricatedEvent &event) override; + + /** + * set a following player. + */ + void setFollow(const std::string &player); + + /** + * set an imitation player. + */ + void setImitate(const std::string &player); + + /** + * setting the next destination of the following, in case of warp + */ + void setNextDest(const int x, const int y); + + int getNextDestX() const A_WARN_UNUSED + { return mNextDestX; } + + int getNextDestY() const A_WARN_UNUSED + { return mNextDestY; } + + void respawn(); + + const FloorItem *getPickUpTarget() const A_WARN_UNUSED + { return mPickUpTarget; } + + void unSetPickUpTarget() + { mPickUpTarget = nullptr; } + + /** + * Stop following a player. + */ + void cancelFollow(); + + /** + * Get the playername followed by the current player. + */ + const std::string &getFollow() const A_WARN_UNUSED + { return mPlayerFollowed; } + + /** + * Get the playername imitated by the current player. + */ + const std::string &getImitate() const A_WARN_UNUSED + { return mPlayerImitated; } + + /** + * Tells the engine whether to check + * if the Player Name is to be displayed. + */ + void setCheckNameSetting(const bool checked) + { mUpdateName = checked; } + + /** + * Gets if the engine has to check + * if the Player Name is to be displayed. + */ + bool getCheckNameSetting() const A_WARN_UNUSED + { return mUpdateName; } + + void fixAttackTarget(); + + void updateNavigateList(); + + int getPathLength(const Being *const being) const A_WARN_UNUSED; + + void targetMoved() const; + + void setLastHitFrom(const std::string &n) + { mLastHitFrom = n; } + + void waitFor(const std::string &nick); + + void checkNewName(Being *const being); + + void resetYellowBar(); + + unsigned char getWalkMask() const override A_WARN_UNUSED; + + void saveHomes(); + + void removeHome(); + + void stopAdvert(); + + bool checAttackPermissions(const Being *const target) + const A_WARN_UNUSED; + + void updateStatus() const; + + void setTestParticle(const std::string &fileName, + bool updateHash = true); + + std::string getInvertDirectionString(); + + std::string getCrazyMoveTypeString(); + + std::string getMoveToTargetTypeString(); + + std::string getFollowModeString(); + + std::string getAttackWeaponTypeString(); + + std::string getAttackTypeString(); + + std::string getQuickDropCounterString(); + + std::string getPickUpTypeString(); + + std::string getDebugPathString() const; + + std::string getMagicAttackString(); + + std::string getPvpAttackString(); + + std::string getImitationModeString(); + + std::string getAwayModeString(); + + std::string getCameraModeString() const; + + std::string getGameModifiersString(); + + protected: + void updateCoords() override; + + + virtual void handleStatusEffect(StatusEffect *const effect, + const int effectId); + + void startWalking(const unsigned char dir); + + void changeEquipmentBeforeAttack(const Being *const target) const; + + static void tryMagic(const std::string &spell, const int baseMagic, + const int schoolMagic, const int mana); + + const char *getVarItem(const char *const *const arr, + const unsigned index, + const unsigned sz) const A_WARN_UNUSED; + + void changeMode(unsigned *const var, const unsigned limit, + const char *const conf, + std::string (LocalPlayer::*const func)(), + const unsigned def = 0, + const bool save = true); + + void crazyMove1(); + void crazyMove2(); + void crazyMove3(); + void crazyMove4(); + void crazyMove5(); + void crazyMove6(); + void crazyMove7(); + void crazyMove8(); + void crazyMove9(); + void crazyMoveA(); + + void loadHomes(); + + 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; + // 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; + + 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; + + int mLastAction; // Time stamp of the last action, -1 if none. + + 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; + int mPingTime; + int mAfkTime; + int mActivityTime; + int mNavigateX; + int mNavigateY; + int mNavigateId; + int mCrossX; + int mCrossY; + int mOldX; + int mOldY; + int mOldTileX; + int mOldTileY; + Path mNavigatePath; + + std::string mLastHitFrom; + std::string mWaitFor; + int mAdvertTime; + Particle *mTestParticle; + std::string mTestParticleName; + int mTestParticleTime; + unsigned long mTestParticleHash; + unsigned char mWalkingDir; // The direction the player is walking in. + /** Whether or not the name settings have changed */ + bool mUpdateName; + bool mBlockAdvert; + bool mTargetDeadPlayers; + bool mServerAttack; + bool mEnableAdvert; + bool mTradebot; + bool mTargetOnlyReachable; + bool mDisableGameModifiers; + bool mIsServerBuggy; + bool mSyncPlayerMove; + bool mDrawPath; + bool mAttackMoving; + bool mAttackNext; + bool mShowJobExp; + bool mNextStep; + // temporary disable crazy moves in moves + bool mDisableCrazyMove; + bool mGoingToTarget; + // Whether or not to continue to attack + bool mKeepAttacking; + // Tells if the path was set using mouse + bool mPathSetByMouse; + bool mWaitPing; + bool mAwayMode; + bool mPseudoAwayMode; + bool mShowNavigePath; +}; + +extern LocalPlayer *player_node; + +#endif // BEING_LOCALPLAYER_H |