summaryrefslogtreecommitdiff
path: root/src/being/localplayer.h
diff options
context:
space:
mode:
authorAndrei Karas <akaras@inbox.ru>2013-08-31 22:42:10 +0300
committerAndrei Karas <akaras@inbox.ru>2013-08-31 22:42:10 +0300
commit00cda69b883d6354f093be6ee39a7936cb798979 (patch)
treef1daa290abfb53180bd8420a45fe6dff1c7a2ab3 /src/being/localplayer.h
parent5919cdc663d5f60a8c5cc7e50ad0c43a18cf9829 (diff)
downloadmv-00cda69b883d6354f093be6ee39a7936cb798979.tar.gz
mv-00cda69b883d6354f093be6ee39a7936cb798979.tar.bz2
mv-00cda69b883d6354f093be6ee39a7936cb798979.tar.xz
mv-00cda69b883d6354f093be6ee39a7936cb798979.zip
move being related files into being dir.
Diffstat (limited to 'src/being/localplayer.h')
-rw-r--r--src/being/localplayer.h652
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