SHARE
TWEET

Untitled

a guest Sep 21st, 2018 90 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /**
  2.  * The Forgotten Server - a free and open-source MMORPG server emulator
  3.  * Copyright (C) 2018  Mark Samman <mark.samman@gmail.com>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License along
  16.  * with this program; if not, write to the Free Software Foundation, Inc.,
  17.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18.  */
  19.  
  20. #ifndef FS_PLAYER_H_4083D3D3A05B4EDE891B31BB720CD06F
  21. #define FS_PLAYER_H_4083D3D3A05B4EDE891B31BB720CD06F
  22.  
  23. #include "creature.h"
  24. #include "container.h"
  25. #include "cylinder.h"
  26. #include "outfit.h"
  27. #include "enums.h"
  28. #include "vocation.h"
  29. #include "protocolgame.h"
  30. #include "ioguild.h"
  31. #include "party.h"
  32. #include "inbox.h"
  33. #include "depotchest.h"
  34. #include "depotlocker.h"
  35. #include "guild.h"
  36. #include "groups.h"
  37. #include "town.h"
  38. #include "mounts.h"
  39.  
  40. class House;
  41. class NetworkMessage;
  42. class Weapon;
  43. class ProtocolGame;
  44. class Npc;
  45. class Party;
  46. class SchedulerTask;
  47. class Bed;
  48. class Guild;
  49.  
  50. enum skillsid_t {
  51.     SKILLVALUE_LEVEL = 0,
  52.     SKILLVALUE_TRIES = 1,
  53.     SKILLVALUE_PERCENT = 2,
  54. };
  55.  
  56. enum fightMode_t : uint8_t {
  57.     FIGHTMODE_ATTACK = 1,
  58.     FIGHTMODE_BALANCED = 2,
  59.     FIGHTMODE_DEFENSE = 3,
  60. };
  61.  
  62. enum pvpMode_t : uint8_t {
  63.     PVP_MODE_DOVE = 0,
  64.     PVP_MODE_WHITE_HAND = 1,
  65.     PVP_MODE_YELLOW_HAND = 2,
  66.     PVP_MODE_RED_FIST = 3,
  67. };
  68.  
  69. enum tradestate_t : uint8_t {
  70.     TRADE_NONE,
  71.     TRADE_INITIATED,
  72.     TRADE_ACCEPT,
  73.     TRADE_ACKNOWLEDGE,
  74.     TRADE_TRANSFER,
  75. };
  76.  
  77. enum attackHand_t : uint8_t {
  78.     HAND_LEFT,
  79.     HAND_RIGHT,
  80.    
  81. };
  82.  
  83. struct VIPEntry {
  84.     VIPEntry(uint32_t guid, std::string name, std::string description, uint32_t icon, bool notify) :
  85.         guid(guid), name(std::move(name)), description(std::move(description)), icon(icon), notify(notify) {}
  86.  
  87.     uint32_t guid;
  88.     std::string name;
  89.     std::string description;
  90.     uint32_t icon;
  91.     bool notify;
  92. };
  93.  
  94. struct OpenContainer {
  95.     Container* container;
  96.     uint16_t index;
  97. };
  98.  
  99. struct OutfitEntry {
  100.     constexpr OutfitEntry(uint16_t lookType, uint8_t addons) : lookType(lookType), addons(addons) {}
  101.  
  102.     uint16_t lookType;
  103.     uint8_t addons;
  104. };
  105.  
  106. struct Skill {
  107.     uint64_t tries = 0;
  108.     uint16_t level = 8;
  109.     uint8_t percent = 0;
  110. };
  111.  
  112. using MuteCountMap = std::map<uint32_t, uint32_t>;
  113.  
  114. static constexpr int32_t PLAYER_MAX_SPEED = 1500;
  115. static constexpr int32_t PLAYER_MIN_SPEED = 10;
  116.  
  117. class Player final : public Creature, public Cylinder
  118. {
  119.     public:
  120.         explicit Player(ProtocolGame_ptr p);
  121.         ~Player();
  122.  
  123.         // non-copyable
  124.         Player(const Player&) = delete;
  125.         Player& operator=(const Player&) = delete;
  126.  
  127.         Player* getPlayer() override {
  128.             return this;
  129.         }
  130.         const Player* getPlayer() const override {
  131.             return this;
  132.         }
  133.  
  134.         void setID() override {
  135.             if (id == 0) {
  136.                 id = playerAutoID++;
  137.             }
  138.         }
  139.  
  140.         static MuteCountMap muteCountMap;
  141.  
  142.         const std::string& getName() const override {
  143.             return name;
  144.         }
  145.         void setName(std::string name) {
  146.             this->name = std::move(name);
  147.         }
  148.         const std::string& getNameDescription() const override {
  149.             return name;
  150.         }
  151.         std::string getDescription(int32_t lookDistance) const override;
  152.  
  153.         CreatureType_t getType() const override {
  154.             return CREATURETYPE_PLAYER;
  155.         }
  156.  
  157.         uint8_t getCurrentMount() const;
  158.         void setCurrentMount(uint8_t mountId);
  159.         bool isMounted() const {
  160.             return defaultOutfit.lookMount != 0;
  161.         }
  162.         bool toggleMount(bool mount);
  163.         bool tameMount(uint8_t mountId);
  164.         bool untameMount(uint8_t mountId);
  165.         bool hasMount(const Mount* mount) const;
  166.         void dismount();
  167.  
  168.         void sendFYIBox(const std::string& message) {
  169.             if (client) {
  170.                 client->sendFYIBox(message);
  171.             }
  172.         }
  173.  
  174.         void setGUID(uint32_t guid) {
  175.             this->guid = guid;
  176.         }
  177.         uint32_t getGUID() const {
  178.             return guid;
  179.         }
  180.         bool canSeeInvisibility() const override {
  181.             return hasFlag(PlayerFlag_CanSenseInvisibility) || group->access;
  182.         }
  183.  
  184.         void removeList() override;
  185.         void addList() override;
  186.         void kickPlayer(bool displayEffect);
  187.  
  188.         static uint64_t getExpForLevel(int32_t lv) {
  189.             lv--;
  190.             return ((50ULL * lv * lv * lv) - (150ULL * lv * lv) + (400ULL * lv)) / 3ULL;
  191.         }
  192.  
  193.         uint16_t getStaminaMinutes() const {
  194.             return staminaMinutes;
  195.         }
  196.  
  197.         bool addOfflineTrainingTries(skills_t skill, uint64_t tries);
  198.  
  199.         void addOfflineTrainingTime(int32_t addTime) {
  200.             offlineTrainingTime = std::min<int32_t>(12 * 3600 * 1000, offlineTrainingTime + addTime);
  201.         }
  202.         void removeOfflineTrainingTime(int32_t removeTime) {
  203.             offlineTrainingTime = std::max<int32_t>(0, offlineTrainingTime - removeTime);
  204.         }
  205.         int32_t getOfflineTrainingTime() const {
  206.             return offlineTrainingTime;
  207.         }
  208.  
  209.         int32_t getOfflineTrainingSkill() const {
  210.             return offlineTrainingSkill;
  211.         }
  212.         void setOfflineTrainingSkill(int32_t skill) {
  213.             offlineTrainingSkill = skill;
  214.         }
  215.  
  216.         uint64_t getBankBalance() const {
  217.             return bankBalance;
  218.         }
  219.         void setBankBalance(uint64_t balance) {
  220.             bankBalance = balance;
  221.         }
  222.  
  223.         Guild* getGuild() const {
  224.             return guild;
  225.         }
  226.         void setGuild(Guild* guild);
  227.  
  228.         const GuildRank* getGuildRank() const {
  229.             return guildRank;
  230.         }
  231.         void setGuildRank(const GuildRank* newGuildRank) {
  232.             guildRank = newGuildRank;
  233.         }
  234.  
  235.         bool isGuildMate(const Player* player) const;
  236.  
  237.         const std::string& getGuildNick() const {
  238.             return guildNick;
  239.         }
  240.         void setGuildNick(std::string nick) {
  241.             guildNick = nick;
  242.         }
  243.  
  244.         bool isInWar(const Player* player) const;
  245.         bool isInWarList(uint32_t guildId) const;
  246.  
  247.         void setLastWalkthroughAttempt(int64_t walkthroughAttempt) {
  248.             lastWalkthroughAttempt = walkthroughAttempt;
  249.         }
  250.         void setLastWalkthroughPosition(Position walkthroughPosition) {
  251.             lastWalkthroughPosition = walkthroughPosition;
  252.         }
  253.  
  254.         Inbox* getInbox() const {
  255.             return inbox;
  256.         }
  257.  
  258.         uint16_t getClientIcons() const;
  259.  
  260.         const GuildWarVector& getGuildWarVector() const {
  261.             return guildWarVector;
  262.         }
  263.  
  264.         Vocation* getVocation() const {
  265.             return vocation;
  266.         }
  267.  
  268.         OperatingSystem_t getOperatingSystem() const {
  269.             return operatingSystem;
  270.         }
  271.         void setOperatingSystem(OperatingSystem_t clientos) {
  272.             operatingSystem = clientos;
  273.         }
  274.  
  275.         uint16_t getProtocolVersion() const {
  276.             if (!client) {
  277.                 return 0;
  278.             }
  279.  
  280.             return client->getVersion();
  281.         }
  282.  
  283.         bool hasSecureMode() const {
  284.             return secureMode;
  285.         }
  286.  
  287.         void setParty(Party* party) {
  288.             this->party = party;
  289.         }
  290.         Party* getParty() const {
  291.             return party;
  292.         }
  293.         PartyShields_t getPartyShield(const Player* player) const;
  294.         bool isInviting(const Player* player) const;
  295.         bool isPartner(const Player* player) const;
  296.         void sendPlayerPartyIcons(Player* player);
  297.         bool addPartyInvitation(Party* party);
  298.         void removePartyInvitation(Party* party);
  299.         void clearPartyInvitations();
  300.  
  301.         GuildEmblems_t getGuildEmblem(const Player* player) const;
  302.  
  303.         uint64_t getSpentMana() const {
  304.             return manaSpent;
  305.         }
  306.  
  307.         bool hasFlag(PlayerFlags value) const {
  308.             return (group->flags & value) != 0;
  309.         }
  310.  
  311.         BedItem* getBedItem() {
  312.             return bedItem;
  313.         }
  314.         void setBedItem(BedItem* b) {
  315.             bedItem = b;
  316.         }
  317.  
  318.         void addBlessing(uint8_t blessing) {
  319.             blessings |= blessing;
  320.         }
  321.         void removeBlessing(uint8_t blessing) {
  322.             blessings &= ~blessing;
  323.         }
  324.         bool hasBlessing(uint8_t value) const {
  325.             return (blessings & (static_cast<uint8_t>(1) << value)) != 0;
  326.         }
  327.  
  328.         bool isOffline() const {
  329.             return (getID() == 0);
  330.         }
  331.         void disconnect() {
  332.             if (client) {
  333.                 client->disconnect();
  334.             }
  335.         }
  336.         uint32_t getIP() const;
  337.  
  338.         void addContainer(uint8_t cid, Container* container);
  339.         void closeContainer(uint8_t cid);
  340.         void setContainerIndex(uint8_t cid, uint16_t index);
  341.  
  342.         Container* getContainerByID(uint8_t cid);
  343.         int8_t getContainerID(const Container* container) const;
  344.         uint16_t getContainerIndex(uint8_t cid) const;
  345.  
  346.         bool canOpenCorpse(uint32_t ownerId) const;
  347.  
  348.         void addStorageValue(const uint32_t key, const int32_t value, const bool isLogin = false);
  349.         bool getStorageValue(const uint32_t key, int32_t& value) const;
  350.         void genReservedStorageRange();
  351.  
  352.         void setGroup(Group* newGroup) {
  353.             group = newGroup;
  354.         }
  355.         Group* getGroup() const {
  356.             return group;
  357.         }
  358.  
  359.         void setInMarket(bool value) {
  360.             inMarket = value;
  361.         }
  362.         bool isInMarket() const {
  363.             return inMarket;
  364.         }
  365.  
  366.         void setLastDepotId(int16_t newId) {
  367.             lastDepotId = newId;
  368.         }
  369.         int16_t getLastDepotId() const {
  370.             return lastDepotId;
  371.         }
  372.  
  373.         void resetIdleTime() {
  374.             idleTime = 0;
  375.         }
  376.  
  377.         bool isInGhostMode() const override {
  378.             return ghostMode;
  379.         }
  380.         void switchGhostMode() {
  381.             ghostMode = !ghostMode;
  382.         }
  383.  
  384.         uint32_t getAccount() const {
  385.             return accountNumber;
  386.         }
  387.         AccountType_t getAccountType() const {
  388.             return accountType;
  389.         }
  390.         uint32_t getLevel() const {
  391.             return level;
  392.         }
  393.         uint32_t getPoints() const {
  394.             return points;
  395.         }
  396.         uint8_t getLevelPercent() const {
  397.             return levelPercent;
  398.         }
  399.         uint32_t getMagicLevel() const {
  400.             return std::max<int32_t>(0, magLevel + varStats[STAT_MAGICPOINTS]);
  401.         }
  402.         uint32_t getBaseMagicLevel() const {
  403.             return magLevel;
  404.         }
  405.         uint8_t getMagicLevelPercent() const {
  406.             return magLevelPercent;
  407.         }
  408.         uint8_t getSoul() const {
  409.             return soul;
  410.         }
  411.         bool isAccessPlayer() const {
  412.             return group->access;
  413.         }
  414.         bool isPremium() const;
  415.         void setPremiumDays(int32_t v);
  416.  
  417.         uint16_t getHelpers() const;
  418.  
  419.         bool setVocation(uint16_t vocId);
  420.         uint16_t getVocationId() const {
  421.             return vocation->getId();
  422.         }
  423.  
  424.         PlayerSex_t getSex() const {
  425.             return sex;
  426.         }
  427.         void setSex(PlayerSex_t);
  428.         uint64_t getExperience() const {
  429.             return experience;
  430.         }
  431.  
  432.         time_t getLastLoginSaved() const {
  433.             return lastLoginSaved;
  434.         }
  435.  
  436.         time_t getLastLogout() const {
  437.             return lastLogout;
  438.         }
  439.  
  440.         const Position& getLoginPosition() const {
  441.             return loginPosition;
  442.         }
  443.         const Position& getTemplePosition() const {
  444.             return town->getTemplePosition();
  445.         }
  446.         Town* getTown() const {
  447.             return town;
  448.         }
  449.         void setTown(Town* town) {
  450.             this->town = town;
  451.         }
  452.  
  453.         void clearModalWindows();
  454.         bool hasModalWindowOpen(uint32_t modalWindowId) const;
  455.         void onModalWindowHandled(uint32_t modalWindowId);
  456.  
  457.         bool isPushable() const override;
  458.         uint32_t isMuted() const;
  459.         void addMessageBuffer();
  460.         void removeMessageBuffer();
  461.  
  462.         bool removeItemOfType(uint16_t itemId, uint32_t amount, int32_t subType, bool ignoreEquipped = false) const;
  463.  
  464.         uint32_t getCapacity() const{
  465.         if (hasFlag(PlayerFlag_CannotPickupItem)) {
  466.                 return 0;
  467.             } else if (hasFlag(PlayerFlag_HasInfiniteCapacity)) {
  468.                 return std::numeric_limits<uint32_t>::max();
  469.             }
  470.             return capacity;
  471.         }
  472.  
  473.         uint32_t getFreeCapacity() const {
  474.             if (hasFlag(PlayerFlag_CannotPickupItem)) {
  475.                 return 0;
  476.             } else if (hasFlag(PlayerFlag_HasInfiniteCapacity)) {
  477.                 return std::numeric_limits<uint32_t>::max();
  478.             } else {
  479.                 return std::max<int32_t>(0, capacity - inventoryWeight);
  480.             }
  481.         }
  482.  
  483.         int32_t getMaxHealth() const override {
  484.             return std::max<int32_t>(1, healthMax + varStats[STAT_MAXHITPOINTS]);
  485.         }
  486.         uint32_t getMana() const {
  487.             return mana;
  488.         }
  489.         uint32_t getMaxMana() const {
  490.             return std::max<int32_t>(0, manaMax + varStats[STAT_MAXMANAPOINTS]);
  491.         }
  492.  
  493.         Item* getInventoryItem(slots_t slot) const;
  494.  
  495.         bool isItemAbilityEnabled(slots_t slot) const {
  496.             return inventoryAbilities[slot];
  497.         }
  498.         void setItemAbility(slots_t slot, bool enabled) {
  499.             inventoryAbilities[slot] = enabled;
  500.         }
  501.  
  502.         void setVarSkill(skills_t skill, int32_t modifier) {
  503.             varSkills[skill] += modifier;
  504.         }
  505.  
  506.         void setVarSpecialSkill(SpecialSkills_t skill, int32_t modifier) {
  507.             varSpecialSkills[skill] += modifier;
  508.         }
  509.  
  510.         void setVarStats(stats_t stat, int32_t modifier);
  511.         int32_t getDefaultStats(stats_t stat) const;
  512.  
  513.         void addConditionSuppressions(uint32_t conditions);
  514.         void removeConditionSuppressions(uint32_t conditions);
  515.  
  516.         DepotChest* getDepotChest(uint32_t depotId, bool autoCreate);
  517.         DepotLocker* getDepotLocker(uint32_t depotId);
  518.         void onReceiveMail() const;
  519.         bool isNearDepotBox() const;
  520.  
  521.         bool canSee(const Position& pos) const override;
  522.         bool canSeeCreature(const Creature* creature) const override;
  523.  
  524.         bool canWalkthrough(const Creature* creature) const;
  525.         bool canWalkthroughEx(const Creature* creature) const;
  526.  
  527.         RaceType_t getRace() const override {
  528.             return RACE_BLOOD;
  529.         }
  530.  
  531.         uint64_t getMoney() const;
  532.  
  533.         //safe-trade functions
  534.         void setTradeState(tradestate_t state) {
  535.             tradeState = state;
  536.         }
  537.         tradestate_t getTradeState() const {
  538.             return tradeState;
  539.         }
  540.         Item* getTradeItem() {
  541.             return tradeItem;
  542.         }
  543.  
  544.         //shop functions
  545.         void setShopOwner(Npc* owner, int32_t onBuy, int32_t onSell) {
  546.             shopOwner = owner;
  547.             purchaseCallback = onBuy;
  548.             saleCallback = onSell;
  549.         }
  550.  
  551.         Npc* getShopOwner(int32_t& onBuy, int32_t& onSell) {
  552.             onBuy = purchaseCallback;
  553.             onSell = saleCallback;
  554.             return shopOwner;
  555.         }
  556.  
  557.         const Npc* getShopOwner(int32_t& onBuy, int32_t& onSell) const {
  558.             onBuy = purchaseCallback;
  559.             onSell = saleCallback;
  560.             return shopOwner;
  561.         }
  562.  
  563.         //V.I.P. functions
  564.         void notifyStatusChange(Player* loginPlayer, VipStatus_t status);
  565.         bool removeVIP(uint32_t vipGuid);
  566.         bool addVIP(uint32_t vipGuid, const std::string& vipName, VipStatus_t status);
  567.         bool addVIPInternal(uint32_t vipGuid);
  568.         bool editVIP(uint32_t vipGuid, const std::string& description, uint32_t icon, bool notify);
  569.  
  570.         //follow functions
  571.         bool setFollowCreature(Creature* creature) override;
  572.         void goToFollowCreature() override;
  573.  
  574.         //follow events
  575.         void onFollowCreature(const Creature* creature) override;
  576.  
  577.         //walk events
  578.         void onWalk(Direction& dir) override;
  579.         void onWalkAborted() override;
  580.         void onWalkComplete() override;
  581.  
  582.         void stopWalk();
  583.         void openShopWindow(Npc* npc, const std::list<ShopInfo>& shop);
  584.         bool closeShopWindow(bool sendCloseShopWindow = true);
  585.         bool updateSaleShopList(const Item* item);
  586.         bool hasShopItemForSale(uint32_t itemId, uint8_t subType) const;
  587.  
  588.         void setChaseMode(bool mode);
  589.         void setFightMode(fightMode_t mode) {
  590.             fightMode = mode;
  591.         }
  592.         void setSecureMode(bool mode) {
  593.             secureMode = mode;
  594.         }
  595.  
  596.         //combat functions
  597.         bool setAttackedCreature(Creature* creature) override;
  598.         bool isImmune(CombatType_t type) const override;
  599.         bool isImmune(ConditionType_t type) const override;
  600.         bool hasShield() const;
  601.         bool isAttackable() const override;
  602.         static bool lastHitIsPlayer(Creature* lastHitCreature);
  603.  
  604.         void changeHealth(int32_t healthChange, bool sendHealthChange = true) override;
  605.         void changeMana(int32_t manaChange);
  606.         void changeSoul(int32_t soulChange);
  607.  
  608.         bool isPzLocked() const {
  609.             return pzLocked;
  610.         }
  611.         BlockType_t blockHit(Creature* attacker, CombatType_t combatType, int32_t& damage,
  612.                                      bool checkDefense = false, bool checkArmor = false, bool field = false) override;
  613.         void doAttacking(uint32_t interval) override;
  614.         bool hasExtraSwing() override {
  615.             return lastAttack > 0 && ((OTSYS_TIME() - lastAttack) >= getAttackSpeed());
  616.         }
  617.  
  618.         uint16_t getSpecialSkill(uint8_t skill) const {
  619.             return std::max<int32_t>(0, varSpecialSkills[skill]);
  620.         }
  621.         uint16_t getSkillLevel(uint8_t skill) const {
  622.             return std::max<int32_t>(0, skills[skill].level + varSkills[skill]);
  623.         }
  624.         uint16_t getBaseSkill(uint8_t skill) const {
  625.             return skills[skill].level;
  626.         }
  627.         uint8_t getSkillPercent(uint8_t skill) const {
  628.             return skills[skill].percent;
  629.         }
  630.  
  631.         bool getAddAttackSkill() const {
  632.             return addAttackSkillPoint;
  633.         }
  634.         BlockType_t getLastAttackBlockType() const {
  635.             return lastAttackBlockType;
  636.         }
  637.  
  638.         //NEW! DUAL WIELD SYSTEM
  639.         void switchAttackHand() {
  640.             lastAttackHand = lastAttackHand == HAND_LEFT ? HAND_RIGHT : HAND_LEFT;
  641.            
  642.         }
  643.  
  644.         //NEW! DUAL WIELD SYSTEM
  645.         slots_t getAttackHand() const {
  646.             return lastAttackHand == HAND_LEFT ? CONST_SLOT_LEFT : CONST_SLOT_RIGHT;
  647.            
  648.         }
  649.  
  650.         //NEW! DUAL WIELD SYSTEM
  651.         void switchBlockSkillAdvance() {
  652.             blockSkillAdvance = !blockSkillAdvance;
  653.            
  654.         }
  655.        
  656.         //NEW! DUAL WIELD SYSTEM
  657.         bool getBlockSkillAdvance() {
  658.             return blockSkillAdvance;
  659.            
  660.         }
  661.  
  662.         //NEW! DUAL WIELD SYSTEM
  663.         bool isDualWielding() const;
  664.  
  665.         //NEW! CONFIG LUA (not implemented)
  666.         //uint32_t getAttackSpeed(Player * player) const;
  667.  
  668.         Item* getWeapon(slots_t slot, bool ignoreAmmo) const;
  669.         Item* getWeapon(bool ignoreAmmo = false) const;
  670.         WeaponType_t getWeaponType() const;
  671.         int32_t getWeaponSkill(const Item* item) const;
  672.         void getShieldAndWeapon(const Item*& shield, const Item*& weapon) const;
  673.  
  674.         void drainHealth(Creature* attacker, int32_t damage) override;
  675.         void drainMana(Creature* attacker, int32_t manaLoss);
  676.         void addManaSpent(uint64_t amount);
  677.         void addSkillAdvance(skills_t skill, uint64_t count);
  678.  
  679.         int32_t getArmor() const override;
  680.         int32_t getDefense() const override;
  681.         float getAttackFactor() const override;
  682.         float getDefenseFactor() const override;
  683.  
  684.         void addInFightTicks(bool pzlock = false);
  685.  
  686.         uint64_t getGainedExperience(Creature* attacker) const override;
  687.  
  688.         //combat event functions
  689.         void onAddCondition(ConditionType_t type) override;
  690.         void onAddCombatCondition(ConditionType_t type) override;
  691.         void onEndCondition(ConditionType_t type) override;
  692.         void onCombatRemoveCondition(Condition* condition) override;
  693.         void onAttackedCreature(Creature* target) override;
  694.         void onAttacked() override;
  695.         void onAttackedCreatureDrainHealth(Creature* target, int32_t points) override;
  696.         void onTargetCreatureGainHealth(Creature* target, int32_t points) override;
  697.         bool onKilledCreature(Creature* target, bool lastHit = true) override;
  698.         void onGainExperience(uint64_t gainExp, Creature* target) override;
  699.         void onGainSharedExperience(uint64_t gainExp, Creature* source);
  700.         void onAttackedCreatureBlockHit(BlockType_t blockType) override;
  701.         void onBlockHit() override;
  702.         void onChangeZone(ZoneType_t zone) override;
  703.         void onAttackedCreatureChangeZone(ZoneType_t zone) override;
  704.         void onIdleStatus() override;
  705.         void onPlacedCreature() override;
  706.  
  707.         LightInfo getCreatureLight() const override;
  708.  
  709.         Skulls_t getSkull() const override;
  710.         Skulls_t getSkullClient(const Creature* creature) const override;
  711.         int64_t getSkullTicks() const { return skullTicks; }
  712.         void setSkullTicks(int64_t ticks) { skullTicks = ticks; }
  713.  
  714.         bool hasAttacked(const Player* attacked) const;
  715.         void addAttacked(const Player* attacked);
  716.         void removeAttacked(const Player* attacked);
  717.         void clearAttacked();
  718.         void addUnjustifiedDead(const Player* attacked);
  719.         void sendCreatureSkull(const Creature* creature) const {
  720.             if (client) {
  721.                 client->sendCreatureSkull(creature);
  722.             }
  723.         }
  724.         void checkSkullTicks(int32_t ticks);
  725.  
  726.         bool canWear(uint32_t lookType, uint8_t addons) const;
  727.         void addOutfit(uint16_t lookType, uint8_t addons);
  728.         bool removeOutfit(uint16_t lookType);
  729.         bool removeOutfitAddon(uint16_t lookType, uint8_t addons);
  730.         bool getOutfitAddons(const Outfit& outfit, uint8_t& addons) const;
  731.  
  732.         bool canLogout();
  733.  
  734.         size_t getMaxVIPEntries() const;
  735.         size_t getMaxDepotItems() const;
  736.  
  737.         //tile
  738.         //send methods
  739.         void sendAddTileItem(const Tile* tile, const Position& pos, const Item* item) {
  740.             if (client) {
  741.                 int32_t stackpos = tile->getStackposOfItem(this, item);
  742.                 if (stackpos != -1) {
  743.                     client->sendAddTileItem(pos, stackpos, item);
  744.                 }
  745.             }
  746.         }
  747.         void sendUpdateTileItem(const Tile* tile, const Position& pos, const Item* item) {
  748.             if (client) {
  749.                 int32_t stackpos = tile->getStackposOfItem(this, item);
  750.                 if (stackpos != -1) {
  751.                     client->sendUpdateTileItem(pos, stackpos, item);
  752.                 }
  753.             }
  754.         }
  755.         void sendRemoveTileThing(const Position& pos, int32_t stackpos) {
  756.             if (stackpos != -1 && client) {
  757.                 client->sendRemoveTileThing(pos, stackpos);
  758.             }
  759.         }
  760.         void sendUpdateTile(const Tile* tile, const Position& pos) {
  761.             if (client) {
  762.                 client->sendUpdateTile(tile, pos);
  763.             }
  764.         }
  765.  
  766.         void sendChannelMessage(const std::string& author, const std::string& text, SpeakClasses type, uint16_t channel) {
  767.             if (client) {
  768.                 client->sendChannelMessage(author, text, type, channel);
  769.             }
  770.         }
  771.         void sendChannelEvent(uint16_t channelId, const std::string& playerName, ChannelEvent_t channelEvent) {
  772.             if (client) {
  773.                 client->sendChannelEvent(channelId, playerName, channelEvent);
  774.             }
  775.         }
  776.         void sendCreatureAppear(const Creature* creature, const Position& pos, bool isLogin) {
  777.             if (client) {
  778.                 client->sendAddCreature(creature, pos, creature->getTile()->getStackposOfCreature(this, creature), isLogin);
  779.             }
  780.         }
  781.         void sendCreatureMove(const Creature* creature, const Position& newPos, int32_t newStackPos, const Position& oldPos, int32_t oldStackPos, bool teleport) {
  782.             if (client) {
  783.                 client->sendMoveCreature(creature, newPos, newStackPos, oldPos, oldStackPos, teleport);
  784.             }
  785.         }
  786.         void sendCreatureTurn(const Creature* creature) {
  787.             if (client && canSeeCreature(creature)) {
  788.                 int32_t stackpos = creature->getTile()->getStackposOfCreature(this, creature);
  789.                 if (stackpos != -1) {
  790.                     client->sendCreatureTurn(creature, stackpos);
  791.                 }
  792.             }
  793.         }
  794.         void sendCreatureSay(const Creature* creature, SpeakClasses type, const std::string& text, const Position* pos = nullptr) {
  795.             if (client) {
  796.                 client->sendCreatureSay(creature, type, text, pos);
  797.             }
  798.         }
  799.         void sendPrivateMessage(const Player* speaker, SpeakClasses type, const std::string& text) {
  800.             if (client) {
  801.                 client->sendPrivateMessage(speaker, type, text);
  802.             }
  803.         }
  804.         void sendCreatureSquare(const Creature* creature, SquareColor_t color) {
  805.             if (client) {
  806.                 client->sendCreatureSquare(creature, color);
  807.             }
  808.         }
  809.         void sendCreatureChangeOutfit(const Creature* creature, const Outfit_t& outfit) {
  810.             if (client) {
  811.                 client->sendCreatureOutfit(creature, outfit);
  812.             }
  813.         }
  814.         void sendCreatureChangeVisible(const Creature* creature, bool visible) {
  815.             if (!client) {
  816.                 return;
  817.             }
  818.  
  819.             if (creature->getPlayer()) {
  820.                 if (visible) {
  821.                     client->sendCreatureOutfit(creature, creature->getCurrentOutfit());
  822.                 } else {
  823.                     static Outfit_t outfit;
  824.                     client->sendCreatureOutfit(creature, outfit);
  825.                 }
  826.             } else if (canSeeInvisibility()) {
  827.                 client->sendCreatureOutfit(creature, creature->getCurrentOutfit());
  828.             } else {
  829.                 int32_t stackpos = creature->getTile()->getStackposOfCreature(this, creature);
  830.                 if (stackpos == -1) {
  831.                     return;
  832.                 }
  833.  
  834.                 if (visible) {
  835.                     client->sendAddCreature(creature, creature->getPosition(), stackpos, false);
  836.                 } else {
  837.                     client->sendRemoveTileThing(creature->getPosition(), stackpos);
  838.                 }
  839.             }
  840.         }
  841.         void sendCreatureLight(const Creature* creature) {
  842.             if (client) {
  843.                 client->sendCreatureLight(creature);
  844.             }
  845.         }
  846.         void sendCreatureWalkthrough(const Creature* creature, bool walkthrough) {
  847.             if (client) {
  848.                 client->sendCreatureWalkthrough(creature, walkthrough);
  849.             }
  850.         }
  851.         void sendCreatureShield(const Creature* creature) {
  852.             if (client) {
  853.                 client->sendCreatureShield(creature);
  854.             }
  855.         }
  856.         void sendCreatureType(uint32_t creatureId, uint8_t creatureType) {
  857.             if (client) {
  858.                 client->sendCreatureType(creatureId, creatureType);
  859.             }
  860.         }
  861.         void sendCreatureHelpers(uint32_t creatureId, uint16_t helpers) {
  862.             if (client) {
  863.                 client->sendCreatureHelpers(creatureId, helpers);
  864.             }
  865.         }
  866.         void sendSpellCooldown(uint8_t spellId, uint32_t time) {
  867.             if (client) {
  868.                 client->sendSpellCooldown(spellId, time);
  869.             }
  870.         }
  871.         void sendSpellGroupCooldown(SpellGroup_t groupId, uint32_t time) {
  872.             if (client) {
  873.                 client->sendSpellGroupCooldown(groupId, time);
  874.             }
  875.         }
  876.         void sendModalWindow(const ModalWindow& modalWindow);
  877.  
  878.         //container
  879.         void sendAddContainerItem(const Container* container, const Item* item);
  880.         void sendUpdateContainerItem(const Container* container, uint16_t slot, const Item* newItem);
  881.         void sendRemoveContainerItem(const Container* container, uint16_t slot);
  882.         void sendContainer(uint8_t cid, const Container* container, bool hasParent, uint16_t firstIndex) {
  883.             if (client) {
  884.                 client->sendContainer(cid, container, hasParent, firstIndex);
  885.             }
  886.         }
  887.  
  888.         //inventory
  889.         void sendInventoryItem(slots_t slot, const Item* item) {
  890.             if (client) {
  891.                 client->sendInventoryItem(slot, item);
  892.             }
  893.         }
  894.         void sendItems() {
  895.             if (client) {
  896.                 client->sendItems();
  897.             }
  898.         }
  899.  
  900.         //event methods
  901.         void onUpdateTileItem(const Tile* tile, const Position& pos, const Item* oldItem,
  902.                                       const ItemType& oldType, const Item* newItem, const ItemType& newType) override;
  903.         void onRemoveTileItem(const Tile* tile, const Position& pos, const ItemType& iType,
  904.                                       const Item* item) override;
  905.  
  906.         void onCreatureAppear(Creature* creature, bool isLogin) override;
  907.         void onRemoveCreature(Creature* creature, bool isLogout) override;
  908.         void onCreatureMove(Creature* creature, const Tile* newTile, const Position& newPos,
  909.                                     const Tile* oldTile, const Position& oldPos, bool teleport) override;
  910.  
  911.         void onAttackedCreatureDisappear(bool isLogout) override;
  912.         void onFollowCreatureDisappear(bool isLogout) override;
  913.  
  914.         //container
  915.         void onAddContainerItem(const Item* item);
  916.         void onUpdateContainerItem(const Container* container, const Item* oldItem, const Item* newItem);
  917.         void onRemoveContainerItem(const Container* container, const Item* item);
  918.  
  919.         void onCloseContainer(const Container* container);
  920.         void onSendContainer(const Container* container);
  921.         void autoCloseContainers(const Container* container);
  922.  
  923.         //inventory
  924.         void onUpdateInventoryItem(Item* oldItem, Item* newItem);
  925.         void onRemoveInventoryItem(Item* item);
  926.  
  927.         void sendCancelMessage(const std::string& msg) const {
  928.             if (client) {
  929.                 client->sendTextMessage(TextMessage(MESSAGE_STATUS_SMALL, msg));
  930.             }
  931.         }
  932.         void sendCancelMessage(ReturnValue message) const;
  933.         void sendCancelTarget() const {
  934.             if (client) {
  935.                 client->sendCancelTarget();
  936.             }
  937.         }
  938.         void sendCancelWalk() const {
  939.             if (client) {
  940.                 client->sendCancelWalk();
  941.             }
  942.         }
  943.         void sendChangeSpeed(const Creature* creature, uint32_t newSpeed) const {
  944.             if (client) {
  945.                 client->sendChangeSpeed(creature, newSpeed);
  946.             }
  947.         }
  948.         void sendCreatureHealth(const Creature* creature) const {
  949.             if (client) {
  950.                 client->sendCreatureHealth(creature);
  951.             }
  952.         }
  953.         void sendDistanceShoot(const Position& from, const Position& to, unsigned char type) const {
  954.             if (client) {
  955.                 client->sendDistanceShoot(from, to, type);
  956.             }
  957.         }
  958.         void sendHouseWindow(House* house, uint32_t listId) const;
  959.         void sendCreatePrivateChannel(uint16_t channelId, const std::string& channelName) {
  960.             if (client) {
  961.                 client->sendCreatePrivateChannel(channelId, channelName);
  962.             }
  963.         }
  964.         void sendClosePrivate(uint16_t channelId);
  965.         void sendIcons() const {
  966.             if (client) {
  967.                 client->sendIcons(getClientIcons());
  968.             }
  969.         }
  970.         void sendMagicEffect(const Position& pos, uint8_t type) const {
  971.             if (client) {
  972.                 client->sendMagicEffect(pos, type);
  973.             }
  974.         }
  975.         void sendPing();
  976.         void sendPingBack() const {
  977.             if (client) {
  978.                 client->sendPingBack();
  979.             }
  980.         }
  981.         void sendStats();
  982.         void sendBasicData() const {
  983.             if (client) {
  984.                 client->sendBasicData();
  985.             }
  986.         }
  987.         void sendSkills() const {
  988.             if (client) {
  989.                 client->sendSkills();
  990.             }
  991.         }
  992.         void sendTextMessage(MessageClasses mclass, const std::string& message) const {
  993.             if (client) {
  994.                 client->sendTextMessage(TextMessage(mclass, message));
  995.             }
  996.         }
  997.         void sendTextMessage(const TextMessage& message) const {
  998.             if (client) {
  999.                 client->sendTextMessage(message);
  1000.             }
  1001.         }
  1002.         void sendReLoginWindow(uint8_t unfairFightReduction) const {
  1003.             if (client) {
  1004.                 client->sendReLoginWindow(unfairFightReduction);
  1005.             }
  1006.         }
  1007.         void sendTextWindow(Item* item, uint16_t maxlen, bool canWrite) const {
  1008.             if (client) {
  1009.                 client->sendTextWindow(windowTextId, item, maxlen, canWrite);
  1010.             }
  1011.         }
  1012.         void sendTextWindow(uint32_t itemId, const std::string& text) const {
  1013.             if (client) {
  1014.                 client->sendTextWindow(windowTextId, itemId, text);
  1015.             }
  1016.         }
  1017.         void sendToChannel(const Creature* creature, SpeakClasses type, const std::string& text, uint16_t channelId) const {
  1018.             if (client) {
  1019.                 client->sendToChannel(creature, type, text, channelId);
  1020.             }
  1021.         }
  1022.         void sendShop(Npc* npc) const {
  1023.             if (client) {
  1024.                 client->sendShop(npc, shopItemList);
  1025.             }
  1026.         }
  1027.         void sendSaleItemList() const {
  1028.             if (client) {
  1029.                 client->sendSaleItemList(shopItemList);
  1030.             }
  1031.         }
  1032.         void sendCloseShop() const {
  1033.             if (client) {
  1034.                 client->sendCloseShop();
  1035.             }
  1036.         }
  1037.         void sendMarketEnter(uint32_t depotId) const {
  1038.             if (client) {
  1039.                 client->sendMarketEnter(depotId);
  1040.             }
  1041.         }
  1042.         void sendMarketLeave() {
  1043.             inMarket = false;
  1044.             if (client) {
  1045.                 client->sendMarketLeave();
  1046.             }
  1047.         }
  1048.         void sendMarketBrowseItem(uint16_t itemId, const MarketOfferList& buyOffers, const MarketOfferList& sellOffers) const {
  1049.             if (client) {
  1050.                 client->sendMarketBrowseItem(itemId, buyOffers, sellOffers);
  1051.             }
  1052.         }
  1053.         void sendMarketBrowseOwnOffers(const MarketOfferList& buyOffers, const MarketOfferList& sellOffers) const {
  1054.             if (client) {
  1055.                 client->sendMarketBrowseOwnOffers(buyOffers, sellOffers);
  1056.             }
  1057.         }
  1058.         void sendMarketBrowseOwnHistory(const HistoryMarketOfferList& buyOffers, const HistoryMarketOfferList& sellOffers) const {
  1059.             if (client) {
  1060.                 client->sendMarketBrowseOwnHistory(buyOffers, sellOffers);
  1061.             }
  1062.         }
  1063.         void sendMarketDetail(uint16_t itemId) const {
  1064.             if (client) {
  1065.                 client->sendMarketDetail(itemId);
  1066.             }
  1067.         }
  1068.         void sendMarketAcceptOffer(const MarketOfferEx& offer) const {
  1069.             if (client) {
  1070.                 client->sendMarketAcceptOffer(offer);
  1071.             }
  1072.         }
  1073.         void sendMarketCancelOffer(const MarketOfferEx& offer) const {
  1074.             if (client) {
  1075.                 client->sendMarketCancelOffer(offer);
  1076.             }
  1077.         }
  1078.         void sendTradeItemRequest(const std::string& traderName, const Item* item, bool ack) const {
  1079.             if (client) {
  1080.                 client->sendTradeItemRequest(traderName, item, ack);
  1081.             }
  1082.         }
  1083.         void sendTradeClose() const {
  1084.             if (client) {
  1085.                 client->sendCloseTrade();
  1086.             }
  1087.         }
  1088.         void sendWorldLight(LightInfo lightInfo) {
  1089.             if (client) {
  1090.                 client->sendWorldLight(lightInfo);
  1091.             }
  1092.         }
  1093.         void sendChannelsDialog() {
  1094.             if (client) {
  1095.                 client->sendChannelsDialog();
  1096.             }
  1097.         }
  1098.         void sendOpenPrivateChannel(const std::string& receiver) {
  1099.             if (client) {
  1100.                 client->sendOpenPrivateChannel(receiver);
  1101.             }
  1102.         }
  1103.         void sendOutfitWindow() {
  1104.             if (client) {
  1105.                 client->sendOutfitWindow();
  1106.             }
  1107.         }
  1108.         void sendCloseContainer(uint8_t cid) {
  1109.             if (client) {
  1110.                 client->sendCloseContainer(cid);
  1111.             }
  1112.         }
  1113.  
  1114.         void sendChannel(uint16_t channelId, const std::string& channelName, const UsersMap* channelUsers, const InvitedMap* invitedUsers) {
  1115.             if (client) {
  1116.                 client->sendChannel(channelId, channelName, channelUsers, invitedUsers);
  1117.             }
  1118.         }
  1119.         void sendTutorial(uint8_t tutorialId) {
  1120.             if (client) {
  1121.                 client->sendTutorial(tutorialId);
  1122.             }
  1123.         }
  1124.         void sendAddMarker(const Position& pos, uint8_t markType, const std::string& desc) {
  1125.             if (client) {
  1126.                 client->sendAddMarker(pos, markType, desc);
  1127.             }
  1128.         }
  1129.         void sendQuestLog() {
  1130.             if (client) {
  1131.                 client->sendQuestLog();
  1132.             }
  1133.         }
  1134.         void sendQuestLine(const Quest* quest) {
  1135.             if (client) {
  1136.                 client->sendQuestLine(quest);
  1137.             }
  1138.         }
  1139.         void sendEnterWorld() {
  1140.             if (client) {
  1141.                 client->sendEnterWorld();
  1142.             }
  1143.         }
  1144.         void sendFightModes() {
  1145.             if (client) {
  1146.                 client->sendFightModes();
  1147.             }
  1148.         }
  1149.         void sendNetworkMessage(const NetworkMessage& message) {
  1150.             if (client) {
  1151.                 client->writeToOutputBuffer(message);
  1152.             }
  1153.         }
  1154.  
  1155.         void receivePing() {
  1156.             lastPong = OTSYS_TIME();
  1157.         }
  1158.  
  1159.         void onThink(uint32_t interval) override;
  1160.  
  1161.         void postAddNotification(Thing* thing, const Cylinder* oldParent, int32_t index, cylinderlink_t link = LINK_OWNER) override;
  1162.         void postRemoveNotification(Thing* thing, const Cylinder* newParent, int32_t index, cylinderlink_t link = LINK_OWNER) override;
  1163.  
  1164.         void setNextAction(int64_t time) {
  1165.             if (time > nextAction) {
  1166.                 nextAction = time;
  1167.             }
  1168.         }
  1169.         bool canDoAction() const {
  1170.             return nextAction <= OTSYS_TIME();
  1171.         }
  1172.         uint32_t getNextActionTime() const;
  1173.  
  1174.         Item* getWriteItem(uint32_t& windowTextId, uint16_t& maxWriteLen);
  1175.         void setWriteItem(Item* item, uint16_t maxWriteLen = 0);
  1176.  
  1177.         House* getEditHouse(uint32_t& windowTextId, uint32_t& listId);
  1178.         void setEditHouse(House* house, uint32_t listId = 0);
  1179.  
  1180.         void learnInstantSpell(const std::string& spellName);
  1181.         void forgetInstantSpell(const std::string& spellName);
  1182.         bool hasLearnedInstantSpell(const std::string& spellName) const;
  1183.  
  1184.     private:
  1185.         uint32_t autoLootGoldStorageID;
  1186.         std::forward_list<Condition*> getMuteConditions() const;
  1187.  
  1188.         void checkTradeState(const Item* item);
  1189.         bool hasCapacity(const Item* item, uint32_t count) const;
  1190.  
  1191.         void gainExperience(uint64_t gainExp, Creature* source);
  1192.         void addExperience(Creature* source, uint64_t exp, bool sendText = false);
  1193.         void removeExperience(uint64_t exp, bool sendText = false);
  1194.  
  1195.         void updateInventoryWeight();
  1196.  
  1197.         void setNextWalkActionTask(SchedulerTask* task);
  1198.         void setNextWalkTask(SchedulerTask* task);
  1199.         void setNextActionTask(SchedulerTask* task);
  1200.  
  1201.         void death(Creature* lastHitCreature) override;
  1202.         bool dropCorpse(Creature* lastHitCreature, Creature* mostDamageCreature, bool lastHitUnjustified, bool mostDamageUnjustified) override;
  1203.         Item* getCorpse(Creature* lastHitCreature, Creature* mostDamageCreature) override;
  1204.  
  1205.         //cylinder implementations
  1206.         ReturnValue queryAdd(int32_t index, const Thing& thing, uint32_t count,
  1207.                 uint32_t flags, Creature* actor = nullptr) const override;
  1208.         ReturnValue queryMaxCount(int32_t index, const Thing& thing, uint32_t count, uint32_t& maxQueryCount,
  1209.                 uint32_t flags) const override;
  1210.         ReturnValue queryRemove(const Thing& thing, uint32_t count, uint32_t flags) const override;
  1211.         Cylinder* queryDestination(int32_t& index, const Thing& thing, Item** destItem,
  1212.                 uint32_t& flags) override;
  1213.  
  1214.         void addThing(Thing*) override {}
  1215.         void addThing(int32_t index, Thing* thing) override;
  1216.  
  1217.         void updateThing(Thing* thing, uint16_t itemId, uint32_t count) override;
  1218.         void replaceThing(uint32_t index, Thing* thing) override;
  1219.  
  1220.         void removeThing(Thing* thing, uint32_t count) override;
  1221.  
  1222.         int32_t getThingIndex(const Thing* thing) const override;
  1223.         size_t getFirstIndex() const override;
  1224.         size_t getLastIndex() const override;
  1225.         uint32_t getItemTypeCount(uint16_t itemId, int32_t subType = -1) const override;
  1226.         std::map<uint32_t, uint32_t>& getAllItemTypeCount(std::map<uint32_t, uint32_t>& countMap) const override;
  1227.         Thing* getThing(size_t index) const override;
  1228.  
  1229.         void internalAddThing(Thing* thing) override;
  1230.         void internalAddThing(uint32_t index, Thing* thing) override;
  1231.  
  1232.         std::unordered_set<uint32_t> attackedSet;
  1233.         std::unordered_set<uint32_t> VIPList;
  1234.  
  1235.         std::map<uint8_t, OpenContainer> openContainers;
  1236.         std::map<uint32_t, DepotLocker*> depotLockerMap;
  1237.         std::map<uint32_t, DepotChest*> depotChests;
  1238.         std::map<uint32_t, int32_t> storageMap;
  1239.  
  1240.         std::vector<OutfitEntry> outfits;
  1241.         GuildWarVector guildWarVector;
  1242.  
  1243.         std::list<ShopInfo> shopItemList;
  1244.  
  1245.         std::forward_list<Party*> invitePartyList;
  1246.         std::forward_list<uint32_t> modalWindows;
  1247.         std::forward_list<std::string> learnedInstantSpellList;
  1248.         std::forward_list<Condition*> storedConditionList; // TODO: This variable is only temporarily used when logging in, get rid of it somehow
  1249.  
  1250.         std::string name;
  1251.         std::string guildNick;
  1252.  
  1253.         Skill skills[SKILL_LAST + 1];
  1254.         LightInfo itemsLight;
  1255.         Position loginPosition;
  1256.         Position lastWalkthroughPosition;
  1257.  
  1258.         time_t lastLoginSaved = 0;
  1259.         time_t lastLogout = 0;
  1260.  
  1261.         uint64_t experience = 0;
  1262.         uint64_t manaSpent = 0;
  1263.         uint64_t lastAttack = 0;
  1264.         uint64_t bankBalance = 0;
  1265.         uint64_t lastQuestlogUpdate = 0;
  1266.         int64_t lastFailedFollow = 0;
  1267.         int64_t skullTicks = 0;
  1268.         int64_t lastWalkthroughAttempt = 0;
  1269.         int64_t lastToggleMount = 0;
  1270.         int64_t lastPing;
  1271.         int64_t lastPong;
  1272.         int64_t nextAction = 0;
  1273.  
  1274.         BedItem* bedItem = nullptr;
  1275.         Guild* guild = nullptr;
  1276.         const GuildRank* guildRank = nullptr;
  1277.         Group* group = nullptr;
  1278.         Inbox* inbox;
  1279.         Item* tradeItem = nullptr;
  1280.         Item* inventory[CONST_SLOT_LAST + 1] = {};
  1281.         Item* writeItem = nullptr;
  1282.         House* editHouse = nullptr;
  1283.         Npc* shopOwner = nullptr;
  1284.         Party* party = nullptr;
  1285.         Player* tradePartner = nullptr;
  1286.         ProtocolGame_ptr client;
  1287.         SchedulerTask* walkTask = nullptr;
  1288.         Town* town = nullptr;
  1289.         Vocation* vocation = nullptr;
  1290.  
  1291.         uint32_t inventoryWeight = 0;
  1292.         uint32_t capacity = 40000;
  1293.         uint32_t damageImmunities = 0;
  1294.         uint32_t conditionImmunities = 0;
  1295.         uint32_t conditionSuppressions = 0;
  1296.         uint32_t level = 1;
  1297.         uint32_t points = 0;
  1298.         uint32_t magLevel = 0;
  1299.         uint32_t actionTaskEvent = 0;
  1300.         uint32_t nextStepEvent = 0;
  1301.         uint32_t walkTaskEvent = 0;
  1302.         uint32_t MessageBufferTicks = 0;
  1303.         uint32_t lastIP = 0;
  1304.         uint32_t accountNumber = 0;
  1305.         uint32_t guid = 0;
  1306.         uint32_t windowTextId = 0;
  1307.         uint32_t editListId = 0;
  1308.         uint32_t mana = 0;
  1309.         uint32_t manaMax = 0;
  1310.         int32_t varSkills[SKILL_LAST + 1] = {};
  1311.         int32_t varSpecialSkills[SPECIALSKILL_LAST + 1] = {};
  1312.         int32_t varStats[STAT_LAST + 1] = {};
  1313.         int32_t purchaseCallback = -1;
  1314.         int32_t saleCallback = -1;
  1315.         int32_t MessageBufferCount = 0;
  1316.         int32_t premiumDays = 0;
  1317.         int32_t bloodHitCount = 0;
  1318.         int32_t shieldBlockCount = 0;
  1319.         int32_t offlineTrainingSkill = -1;
  1320.         int32_t offlineTrainingTime = 0;
  1321.         int32_t idleTime = 0;
  1322.  
  1323.         uint16_t lastStatsTrainingTime = 0;
  1324.         uint16_t staminaMinutes = 2520;
  1325.         uint16_t maxWriteLen = 0;
  1326.         int16_t lastDepotId = -1;
  1327.  
  1328.         uint8_t soul = 0;
  1329.         uint8_t blessings = 0;
  1330.         uint8_t levelPercent = 0;
  1331.         uint8_t magLevelPercent = 0;
  1332.  
  1333.         PlayerSex_t sex = PLAYERSEX_FEMALE;
  1334.         OperatingSystem_t operatingSystem = CLIENTOS_NONE;
  1335.         BlockType_t lastAttackBlockType = BLOCK_NONE;
  1336.         tradestate_t tradeState = TRADE_NONE;
  1337.         fightMode_t fightMode = FIGHTMODE_ATTACK;
  1338.         AccountType_t accountType = ACCOUNT_TYPE_NORMAL;
  1339.  
  1340.         //NEW! DUAL WIELD SYSTEM
  1341.         attackHand_t lastAttackHand;
  1342.  
  1343.         //NEW! DUAL WIELD SYSTEM
  1344.         bool blockSkillAdvance;
  1345.  
  1346.         bool chaseMode = false;
  1347.         bool secureMode = false;
  1348.         bool inMarket = false;
  1349.         bool wasMounted = false;
  1350.         bool ghostMode = false;
  1351.         bool pzLocked = false;
  1352.         bool isConnecting = false;
  1353.         bool addAttackSkillPoint = false;
  1354.         bool inventoryAbilities[CONST_SLOT_LAST + 1] = {};
  1355.  
  1356.         static uint32_t playerAutoID;
  1357.  
  1358.         void updateItemsLight(bool internal = false);
  1359.         int32_t getStepSpeed() const override {
  1360.             return std::max<int32_t>(PLAYER_MIN_SPEED, std::min<int32_t>(PLAYER_MAX_SPEED, getSpeed()));
  1361.         }
  1362.  
  1363.         //CHANGED! SKILL POINTS SYSTEM - DEXTERITY WALK SPEED
  1364.         void updateBaseSpeed() {
  1365.             if (!hasFlag(PlayerFlag_SetMaxSpeed)) {
  1366.                 //increase walk speed in 1 = increase baseSpeed in 2
  1367.                 baseSpeed = vocation->getBaseSpeed() + (2 * (level - 1)) + ((skills[SKILL_DEXTERITY].level - 8) / 2);
  1368.             }
  1369.             else {
  1370.                 baseSpeed = PLAYER_MAX_SPEED;
  1371.             }
  1372.         }
  1373.  
  1374.  
  1375.         bool isPromoted() const;
  1376.  
  1377.         //CHANGED! SKILL POINTS SYSTEM - DEXTERITY AND DUAL WIELD ATTACK SPEED
  1378.         uint32_t getAttackSpeed() const {
  1379.             if (isDualWielding()) {
  1380.                 return 1000;
  1381.             }
  1382.             else {
  1383.                 return 2000 - ((skills[SKILL_DEXTERITY].level - 8) * 5);
  1384.             }
  1385.         }
  1386.  
  1387.         static uint8_t getPercentLevel(uint64_t count, uint64_t nextLevelCount);
  1388.         double getLostPercent() const;
  1389.         uint64_t getLostExperience() const override {
  1390.             return skillLoss ? static_cast<uint64_t>(experience * getLostPercent()) : 0;
  1391.         }
  1392.         uint32_t getDamageImmunities() const override {
  1393.             return damageImmunities;
  1394.         }
  1395.         uint32_t getConditionImmunities() const override {
  1396.             return conditionImmunities;
  1397.         }
  1398.         uint32_t getConditionSuppressions() const override {
  1399.             return conditionSuppressions;
  1400.         }
  1401.         uint16_t getLookCorpse() const override;
  1402.         void getPathSearchParams(const Creature* creature, FindPathParams& fpp) const override;
  1403.  
  1404.         friend class Game;
  1405.         friend class Npc;
  1406.         friend class LuaScriptInterface;
  1407.         friend class Map;
  1408.         friend class Actions;
  1409.         friend class IOLoginData;
  1410.         friend class ProtocolGame;
  1411. };
  1412.  
  1413. #endif
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top