localplayer.h

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  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 "being/being.h"
 
#include "enums/being/pickup.h"
#include "enums/being/visiblename.h"
 
#include "enums/simpletypes/allowsort.h"
#include "enums/simpletypes/keep.h"
 
#include "listeners/actorspritelistener.h"
#include "listeners/attributelistener.h"
#include "listeners/playerdeathlistener.h"
 
#include "localconsts.h"
 
class AwayListener;
class ChatTab;
class FloorItem;
class Map;
class OkDialog;
 
class LocalPlayer final : public Being,
                          public ActorSpriteListener,
                          public AttributeListener,
                          public PlayerDeathListener
{
    public:
        LocalPlayer(const BeingId id,
                    const BeingTypeId subType);
 
        A_DELETE_COPY(LocalPlayer)
 
        
        ~LocalPlayer() override final;
 
        void logic() override final;
 
        void slowLogic();
 
        void setAction(const BeingActionT &action,
                       const int attackId) override final;
 
        Position getNextWalkPosition(const unsigned char dir)
                                     const A_WARN_UNUSED;
 
        void nextTile() override final;
 
        bool pickUp(FloorItem *const item);
 
        void actorSpriteDestroyed(const ActorSprite &actorSprite)
                                  override final;
 
        int getAttackRange() const A_WARN_UNUSED;
 
        int getAttackRange2() const A_WARN_UNUSED;
 
        void attack(Being *const target,
                    const bool keep,
                    const bool dontChangeEquipment);
 
        void attack2(Being *const target,
                     const bool keep,
                     const bool dontChangeEquipment);
 
        void setGroupId(const int id) override final;
 
        void stopAttack(const bool keepAttack);
 
        void untarget();
 
        Being *getTarget() const A_WARN_UNUSED;
 
        void setTarget(Being *const target);
 
        Being *setNewTarget(const ActorTypeT type,
                            const AllowSort allowSort);
 
        void setDestination(const int x, const int y);
 
        void setWalkingDir(const unsigned char dir);
 
        unsigned char getWalkingDir() const noexcept2 A_WARN_UNUSED
        { return mWalkingDir; }
 
        void setGotoTarget(Being *const target);
 
        bool withinAttackRange(const Being *const target,
                               const bool fixDistance,
                               const int addRange) const A_WARN_UNUSED;
 
        void stopWalking(const bool sendToServer);
 
        bool toggleSit() const;
 
        bool updateSit() const;
 
        static bool emote(const uint8_t emotion);
 
        void pickedUp(const ItemInfo &itemInfo,
                      const int amount,
                      const ItemColor color,
                      const BeingId floorItemId,
                      const PickupT fail);
 
        int getLevel() const override final A_WARN_UNUSED;
 
        void pathSetByMouse()
        { mPathSetByMouse = true; }
 
        bool isPathSetByMouse() const noexcept2 A_WARN_UNUSED
        { return mPathSetByMouse; }
 
        unsigned int getMoveState() const noexcept2 A_WARN_UNUSED
        { return mMoveState; }
 
        void setMoveState(const unsigned int n) noexcept2
        { mMoveState = n; }
 
        std::string getPingTime() const A_WARN_UNUSED;
 
        void tryPingRequest();
 
#ifdef TMWA_SUPPORT
        void magicAttack() const;
#endif  // TMWA_SUPPORT
 
        void specialMove(const unsigned char direction);
 
        void moveByDirection(const unsigned char dir);
 
        bool pickUpItems(int pickUpType);
 
        void move(const int dX, const int dY);
 
        void moveToTarget(int dist);
 
        void moveToHome();
 
        bool isReachable(Being *const being,
                         const int maxCost) 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 setAway(const std::string &message) const;
 
        static void setPseudoAway(const std::string &message);
 
        void setHalfAway(const bool n)
        { mInactive = n; }
 
        bool getHalfAway() const noexcept2 A_WARN_UNUSED
        { return mInactive; }
 
        void afkRespond(ChatTab *const tab, const std::string &nick);
 
        static void setAfkMessage(std::string message);
 
        bool navigateTo(const int x, const int y);
 
        void navigateClean();
 
        void imitateEmote(const Being *const being,
                          const unsigned char action) const;
 
        void imitateAction(const Being *const being,
                           const BeingActionT &action);
 
        void imitateDirection(const Being *const being,
                              const unsigned char dir);
 
        void imitateOutfit(const Being *const player,
                           const int sprite) 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 noexcept2 A_WARN_UNUSED
        { return mIsServerBuggy; }
 
        void fixPos();
 
        void setTileCoords(const int x,
                           const int y) restrict2 override final;
 
        void setMap(Map *const map) override final;
 
        void addMessageToQueue(const std::string &message,
                               const UserColorIdT color);
 
        void optionChanged(const std::string &value) override final;
 
        void playerDeath() override final;
 
        void setFollow(const std::string &player);
 
        void setImitate(const std::string &player);
 
        void setNextDest(const int x, const int y);
 
        int getNextDestX() const noexcept2 A_WARN_UNUSED
        { return mNextDestX; }
 
        int getNextDestY() const noexcept2 A_WARN_UNUSED
        { return mNextDestY; }
 
        void respawn();
 
        const FloorItem *getPickUpTarget() const noexcept2 A_WARN_UNUSED
        { return mPickUpTarget; }
 
        void unSetPickUpTarget()
        { mPickUpTarget = nullptr; }
 
        void cancelFollow();
 
        const std::string &getFollow() const noexcept2 A_WARN_UNUSED
        { return mPlayerFollowed; }
 
        const std::string &getImitate() const noexcept2 A_WARN_UNUSED
        { return mPlayerImitated; }
 
        void setCheckNameSetting(const bool checked)
        { mUpdateName = checked; }
 
        bool getCheckNameSetting() const noexcept2 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);
 
        unsigned char getBlockWalkMask() const override final
                                       A_CONST A_WARN_UNUSED;
 
        void saveHomes();
 
        void removeHome();
 
        void stopAdvert();
 
        void addXpMessage(const int64_t change);
 
        void addHomunXpMessage(const int change);
 
        void addJobMessage(const int64_t change);
 
        void addHpMessage(const int change);
 
        void addSpMessage(const int change);
 
        static bool checAttackPermissions(const Being *const target)
                                          A_WARN_UNUSED;
 
        void updateStatus() const;
 
        void setTestParticle(const std::string &fileName,
                             const bool updateHash);
 
        int getLastAttackX() const override final
        { return mTarget != nullptr ? mTarget->mX : mLastAttackX; }
 
        int getLastAttackY() const override final
        { return mTarget != nullptr ? mTarget->mY : mLastAttackY; }
 
        void attributeChanged(const AttributesT id,
                              const int64_t oldVal,
                              const int64_t newVal) override final;
 
        void updateMusic() const;
 
        void setAfkTime(const int v) noexcept2
        { mAfkTime = v; }
 
        void setAwayDialog(OkDialog *const dialog)
        { mAwayDialog = dialog; }
 
        AwayListener *getAwayListener() const noexcept2 A_WARN_UNUSED
        { return mAwayListener; }
 
        void setRename(const bool r) noexcept2
        { mAllowRename = r; }
 
        bool getRename() const noexcept2
        { return mAllowRename; }
 
        bool canMove() const;
 
        void freezeMoving(const int timeWaitTicks);
 
        void failMove(const int x,
                      const int y);
 
    protected:
        void updateCoords() override final;
 
        void handleStatusEffect(const StatusEffect *const effect,
                                const int32_t effectId,
                                const Enable newStatus,
                                const IsStart start) override final;
 
        void startWalking(const unsigned char dir);
 
        void changeEquipmentBeforeAttack(const Being *const target) const;
 
#ifdef TMWA_SUPPORT
        static void tryMagic(const std::string &spell,
                             const int baseMagic,
                             const int schoolMagic,
                             const int mana);
#endif  // TMWA_SUPPORT
 
        void loadHomes();
 
        // move state. used if mMoveType == 2
        unsigned int mMoveState;
 
        int mLastTargetX;
        int mLastTargetY;
 
        std::map<std::string, Vector> mHomes;
 
        Being *mTarget;
 
        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<int32_t> mStatusEffectIcons;
 
        typedef std::pair<std::string, UserColorIdT> MessagePair;
        std::list<MessagePair> mMessages;
        int mMessageTime;
        AwayListener *mAwayListener;
        OkDialog *mAwayDialog;
 
        int mPingSendTick;
        time_t mPingTime;
        time_t mAfkTime;
        time_t mActivityTime;
        int mNavigateX;
        int mNavigateY;
        BeingId mNavigateId;
        int mCrossX;
        int mCrossY;
        int mOldX;
        int mOldY;
        int mOldTileX;
        int mOldTileY;
        Path mNavigatePath;
 
        std::string mLastHitFrom;
        std::string mWaitFor;
        time_t mAdvertTime;
        Particle *mTestParticle;
        std::string mTestParticleName;
        time_t mTestParticleTime;
        unsigned long mTestParticleHash;
        int mSyncPlayerMoveDistance;
        int mUnfreezeTime;
        unsigned char mWalkingDir;  // The direction the player is walking in.
        bool mUpdateName;
        bool mBlockAdvert;
        bool mTargetDeadPlayers;
        Keep mServerAttack;
        VisibleName::Type mVisibleNames;
        bool mEnableAdvert;
        bool mTradebot;
        bool mTargetOnlyReachable;
        bool mIsServerBuggy;
        bool mSyncPlayerMove;
        bool mDrawPath;
        bool mAttackMoving;
        bool mAttackNext;
        bool mShowJobExp;
        bool mShowServerPos;
        bool mNextStep;
        // temporary disable crazy moves in moves
        bool mGoingToTarget;
        // Whether or not to continue to attack
        bool mKeepAttacking;
        // Tells if the path was set using mouse
        bool mPathSetByMouse;
        bool mWaitPing;
        bool mShowNavigePath;
        bool mAllowRename;
        bool mFreezed;
};
 
extern LocalPlayer *localPlayer;
 
#endif  // BEING_LOCALPLAYER_H