Jump to content
  • 0
Havokz

Programação [Ajuda] Chamando uma variável da source em Lua

Question

Havokz    0
Havokz
Posted (edited)

Base:

The Forgotten Server 1.3 (GustavoContreiras) , Versão: 10.98.

Qual é a sua pergunta?

Olá amigos,

Tenho as seguintes linhas dentro do meu arquivo  Player.h, na source

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

E gostaria de chamar essa função getSkillPoints dentro de um script LUA

tentei chamar a função usando player:getSkillPoints() em um talkaction só pra testar se estava me voltando algum valor. Mas a resposta que tive no distro foi esta:

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

 

Tenho que adicionar alguma LIB pra conseguir isso?

 

Você tem o código disponível? Se tiver poste-o na caixa de código que está dentro do spoiler abaixo:

Player.h

Spoiler

/**
 * The Forgotten Server - a free and open-source MMORPG server emulator
 * Copyright (C) 2018  Mark Samman <[email protected]>
 *
 * 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
 * (at your option) 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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef FS_PLAYER_H_4083D3D3A05B4EDE891B31BB720CD06F
#define FS_PLAYER_H_4083D3D3A05B4EDE891B31BB720CD06F

#include "creature.h"
#include "container.h"
#include "cylinder.h"
#include "outfit.h"
#include "enums.h"
#include "vocation.h"
#include "protocolgame.h"
#include "ioguild.h"
#include "party.h"
#include "inbox.h"
#include "depotchest.h"
#include "depotlocker.h"
#include "guild.h"
#include "groups.h"
#include "town.h"
#include "mounts.h"

class House;
class NetworkMessage;
class Weapon;
class ProtocolGame;
class Npc;
class Party;
class SchedulerTask;
class Bed;
class Guild;

enum skillsid_t {
    SKILLVALUE_LEVEL = 0,
    SKILLVALUE_TRIES = 1,
    SKILLVALUE_PERCENT = 2,
};

enum fightMode_t : uint8_t {
    FIGHTMODE_ATTACK = 1,
    FIGHTMODE_BALANCED = 2,
    FIGHTMODE_DEFENSE = 3,
};

enum pvpMode_t : uint8_t {
    PVP_MODE_DOVE = 0,
    PVP_MODE_WHITE_HAND = 1,
    PVP_MODE_YELLOW_HAND = 2,
    PVP_MODE_RED_FIST = 3,
};

enum tradestate_t : uint8_t {
    TRADE_NONE,
    TRADE_INITIATED,
    TRADE_ACCEPT,
    TRADE_ACKNOWLEDGE,
    TRADE_TRANSFER,
};

enum attackHand_t : uint8_t {
    HAND_LEFT,
    HAND_RIGHT,
};

struct VIPEntry {
    VIPEntry(uint32_t guid, std::string name, std::string description, uint32_t icon, bool notify) :
        guid(guid), name(std::move(name)), description(std::move(description)), icon(icon), notify(notify) {}

    uint32_t guid;
    std::string name;
    std::string description;
    uint32_t icon;
    bool notify;
};

struct OpenContainer {
    Container* container;
    uint16_t index;
};

struct OutfitEntry {
    constexpr OutfitEntry(uint16_t lookType, uint8_t addons) : lookType(lookType), addons(addons) {}

    uint16_t lookType;
    uint8_t addons;
};

struct Skill {
    uint16_t level = 8;
};

using MuteCountMap = std::map<uint32_t, uint32_t>;

static constexpr int32_t PLAYER_MAX_SPEED = 1500;
static constexpr int32_t PLAYER_MIN_SPEED = 10;

class Player final : public Creature, public Cylinder
{
    public:
        explicit Player(ProtocolGame_ptr p);
        ~Player();

        // non-copyable
        Player(const Player&) = delete;
        Player& operator=(const Player&) = delete;

        Player* getPlayer() override {
            return this;
        }
        const Player* getPlayer() const override {
            return this;
        }

        void setID() override {
            if (id == 0) {
                id = playerAutoID++;
            }
        }

        static MuteCountMap muteCountMap;

        const std::string& getName() const override {
            return name;
        }
        void setName(std::string name) {
            this->name = std::move(name);
        }
        const std::string& getNameDescription() const override {
            return name;
        }
        std::string getDescription(int32_t lookDistance) const override;

        CreatureType_t getType() const override {
            return CREATURETYPE_PLAYER;
        }

        uint8_t getCurrentMount() const;
        void setCurrentMount(uint8_t mountId);
        bool isMounted() const {
            return defaultOutfit.lookMount != 0;
        }
        bool toggleMount(bool mount);
        bool tameMount(uint8_t mountId);
        bool untameMount(uint8_t mountId);
        bool hasMount(const Mount* mount) const;
        void dismount();

        void sendFYIBox(const std::string& message) {
            if (client) {
                client->sendFYIBox(message);
            }
        }

        void setGUID(uint32_t guid) {
            this->guid = guid;
        }
        uint32_t getGUID() const {
            return guid;
        }
        bool canSeeInvisibility() const override {
            return hasFlag(PlayerFlag_CanSenseInvisibility) || group->access;
        }

        void removeList() override;
        void addList() override;
        void kickPlayer(bool displayEffect);

        static uint64_t getExpForLevel(int32_t lv) {
            lv--;
            return ((50ULL * lv * lv * lv) - (150ULL * lv * lv) + (400ULL * lv)) / 3ULL;
        }

        uint16_t getStaminaMinutes() const {
            return staminaMinutes;
        }

        uint64_t getBankBalance() const {
            return bankBalance;
        }
        void setBankBalance(uint64_t balance) {
            bankBalance = balance;
        }

        Guild* getGuild() const {
            return guild;
        }
        void setGuild(Guild* guild);

        const GuildRank* getGuildRank() const {
            return guildRank;
        }
        void setGuildRank(const GuildRank* newGuildRank) {
            guildRank = newGuildRank;
        }

        bool isGuildMate(const Player* player) const;

        const std::string& getGuildNick() const {
            return guildNick;
        }
        void setGuildNick(std::string nick) {
            guildNick = nick;
        }

        bool isInWar(const Player* player) const;
        bool isInWarList(uint32_t guildId) const;

        void setLastWalkthroughAttempt(int64_t walkthroughAttempt) {
            lastWalkthroughAttempt = walkthroughAttempt;
        }
        void setLastWalkthroughPosition(Position walkthroughPosition) {
            lastWalkthroughPosition = walkthroughPosition;
        }

        Inbox* getInbox() const {
            return inbox;
        }

        uint16_t getClientIcons() const;

        const GuildWarVector& getGuildWarVector() const {
            return guildWarVector;
        }

        Vocation* getVocation() const {
            return vocation;
        }

        OperatingSystem_t getOperatingSystem() const {
            return operatingSystem;
        }
        void setOperatingSystem(OperatingSystem_t clientos) {
            operatingSystem = clientos;
        }

        uint16_t getProtocolVersion() const {
            if (!client) {
                return 0;
            }

            return client->getVersion();
        }

        bool hasSecureMode() const {
            return secureMode;
        }

        void setParty(Party* party) {
            this->party = party;
        }
        Party* getParty() const {
            return party;
        }
        PartyShields_t getPartyShield(const Player* player) const;
        bool isInviting(const Player* player) const;
        bool isPartner(const Player* player) const;
        void sendPlayerPartyIcons(Player* player);
        bool addPartyInvitation(Party* party);
        void removePartyInvitation(Party* party);
        void clearPartyInvitations();

        GuildEmblems_t getGuildEmblem(const Player* player) const;

        bool hasFlag(PlayerFlags value) const {
            return (group->flags & value) != 0;
        }

        BedItem* getBedItem() {
            return bedItem;
        }
        void setBedItem(BedItem* B) {
            bedItem = b;
        }

        void addBlessing(uint8_t blessing) {
            blessings |= blessing;
        }
        void removeBlessing(uint8_t blessing) {
            blessings &= ~blessing;
        }
        bool hasBlessing(uint8_t value) const {
            return (blessings & (static_cast<uint8_t>(1) << value)) != 0;
        }

        bool isOffline() const {
            return (getID() == 0);
        }
        void disconnect() {
            if (client) {
                client->disconnect();
            }
        }
        uint32_t getIP() const;

        void addContainer(uint8_t cid, Container* container);
        void closeContainer(uint8_t cid);
        void setContainerIndex(uint8_t cid, uint16_t index);

        Container* getContainerByID(uint8_t cid);
        int8_t getContainerID(const Container* container) const;
        uint16_t getContainerIndex(uint8_t cid) const;

        bool canOpenCorpse(uint32_t ownerId) const;

        void addStorageValue(const uint32_t key, const int32_t value, const bool isLogin = false);
        bool getStorageValue(const uint32_t key, int32_t& value) const;
        void genReservedStorageRange();

        void setGroup(Group* newGroup) {
            group = newGroup;
        }
        Group* getGroup() const {
            return group;
        }

        void setInMarket(bool value) {
            inMarket = value;
        }
        bool isInMarket() const {
            return inMarket;
        }

        void setLastDepotId(int16_t newId) {
            lastDepotId = newId;
        }
        int16_t getLastDepotId() const {
            return lastDepotId;
        }

        void resetIdleTime() {
            idleTime = 0;
        }

        bool isInGhostMode() const override {
            return ghostMode;
        }
        void switchGhostMode() {
            ghostMode = !ghostMode;
        }

        uint32_t getAccount() const {
            return accountNumber;
        }
        AccountType_t getAccountType() const {
            return accountType;
        }
        uint32_t getLevel() const {
            return level;
        }
        uint32_t getSkillPoints() const {
            return skillPoints;
        }
        void setSkillPoints(uint32_t value) {
            skillPoints = value;
        }
        uint8_t getLevelPercent() const {
            return levelPercent;
        }
        uint32_t getMagicLevel() const {
            return std::max<int32_t>(0, magLevel + varStats[STAT_MAGICPOINTS]);
        }
        uint32_t getBaseMagicLevel() const {
            return magLevel;
        }
        uint8_t getSoul() const {
            return soul;
        }
        bool isAccessPlayer() const {
            return group->access;
        }
        bool isPremium() const;
        void setPremiumDays(int32_t v);

        uint16_t getHelpers() const;

        bool setVocation(uint16_t vocId);
        uint16_t getVocationId() const {
            return vocation->getId();
        }

        PlayerSex_t getSex() const {
            return sex;
        }
        void setSex(PlayerSex_t);
        uint64_t getExperience() const {
            return experience;
        }

        time_t getLastLoginSaved() const {
            return lastLoginSaved;
        }

        time_t getLastLogout() const {
            return lastLogout;
        }

        const Position& getLoginPosition() const {
            return loginPosition;
        }
        const Position& getTemplePosition() const {
            return town->getTemplePosition();
        }
        Town* getTown() const {
            return town;
        }
        void setTown(Town* town) {
            this->town = town;
        }

        void clearModalWindows();
        bool hasModalWindowOpen(uint32_t modalWindowId) const;
        void onModalWindowHandled(uint32_t modalWindowId);

        bool isPushable() const override;
        uint32_t isMuted() const;
        void addMessageBuffer();
        void removeMessageBuffer();

        bool removeItemOfType(uint16_t itemId, uint32_t amount, int32_t subType, bool ignoreEquipped = false) const;

        uint32_t getCapacity() const{
        if (hasFlag(PlayerFlag_CannotPickupItem)) {
                return 0;
            } else if (hasFlag(PlayerFlag_HasInfiniteCapacity)) {
                return std::numeric_limits<uint32_t>::max();
            }
            return capacity;
        }

        uint32_t getFreeCapacity() const {
            if (hasFlag(PlayerFlag_CannotPickupItem)) {
                return 0;
            } else if (hasFlag(PlayerFlag_HasInfiniteCapacity)) {
                return std::numeric_limits<uint32_t>::max();
            } else {
                return std::max<int32_t>(0, capacity - inventoryWeight);
            }
        }

        int32_t getMaxHealth() const override {
            return std::max<int32_t>(1, healthMax + varStats[STAT_MAXHITPOINTS]);
        }
        uint32_t getMana() const {
            return mana;
        }
        uint32_t getMaxMana() const {
            return std::max<int32_t>(0, manaMax + varStats[STAT_MAXMANAPOINTS]);
        }

        Item* getInventoryItem(slots_t slot) const;

        bool isItemAbilityEnabled(slots_t slot) const {
            return inventoryAbilities[slot];
        }
        void setItemAbility(slots_t slot, bool enabled) {
            inventoryAbilities[slot] = enabled;
        }

        void setVarSkill(skills_t skill, int32_t modifier) {
            varSkills[skill] += modifier;
        }

        void setVarSpecialSkill(SpecialSkills_t skill, int32_t modifier) {
            varSpecialSkills[skill] += modifier;
        }

        void setVarStats(stats_t stat, int32_t modifier);
        int32_t getDefaultStats(stats_t stat) const;

        void addConditionSuppressions(uint32_t conditions);
        void removeConditionSuppressions(uint32_t conditions);

        DepotChest* getDepotChest(uint32_t depotId, bool autoCreate);
        DepotLocker* getDepotLocker(uint32_t depotId);
        void onReceiveMail() const;
        bool isNearDepotBox() const;

        bool canSee(const Position& pos) const override;
        bool canSeeCreature(const Creature* creature) const override;

        bool canWalkthrough(const Creature* creature) const;
        bool canWalkthroughEx(const Creature* creature) const;

        RaceType_t getRace() const override {
            return RACE_BLOOD;
        }

        uint64_t getMoney() const;

        //safe-trade functions
        void setTradeState(tradestate_t state) {
            tradeState = state;
        }
        tradestate_t getTradeState() const {
            return tradeState;
        }
        Item* getTradeItem() {
            return tradeItem;
        }

        //shop functions
        void setShopOwner(Npc* owner, int32_t onBuy, int32_t onSell) {
            shopOwner = owner;
            purchaseCallback = onBuy;
            saleCallback = onSell;
        }

        Npc* getShopOwner(int32_t& onBuy, int32_t& onSell) {
            onBuy = purchaseCallback;
            onSell = saleCallback;
            return shopOwner;
        }

        const Npc* getShopOwner(int32_t& onBuy, int32_t& onSell) const {
            onBuy = purchaseCallback;
            onSell = saleCallback;
            return shopOwner;
        }

        //V.I.P. functions
        void notifyStatusChange(Player* loginPlayer, VipStatus_t status);
        bool removeVIP(uint32_t vipGuid);
        bool addVIP(uint32_t vipGuid, const std::string& vipName, VipStatus_t status);
        bool addVIPInternal(uint32_t vipGuid);
        bool editVIP(uint32_t vipGuid, const std::string& description, uint32_t icon, bool notify);

        //follow functions
        bool setFollowCreature(Creature* creature) override;
        void goToFollowCreature() override;

        //follow events
        void onFollowCreature(const Creature* creature) override;

        //walk events
        void onWalk(Direction& dir) override;
        void onWalkAborted() override;
        void onWalkComplete() override;

        void stopWalk();
        void openShopWindow(Npc* npc, const std::list<ShopInfo>& shop);
        bool closeShopWindow(bool sendCloseShopWindow = true);
        bool updateSaleShopList(const Item* item);
        bool hasShopItemForSale(uint32_t itemId, uint8_t subType) const;

        void setChaseMode(bool mode);
        void setFightMode(fightMode_t mode) {
            fightMode = mode;
        }
        void setSecureMode(bool mode) {
            secureMode = mode;
        }

        //combat functions
        bool setAttackedCreature(Creature* creature) override;
        bool isImmune(CombatType_t type) const override;
        bool isImmune(ConditionType_t type) const override;
        bool hasShield() const;
        bool isAttackable() const override;
        static bool lastHitIsPlayer(Creature* lastHitCreature);

        void changeHealth(int32_t healthChange, bool sendHealthChange = true) override;
        void changeMana(int32_t manaChange);
        void changeSoul(int32_t soulChange);

        bool isPzLocked() const {
            return pzLocked;
        }
        BlockType_t blockHit(Creature* attacker, CombatType_t combatType, int32_t& damage,
                                     bool checkDefense = false, bool checkArmor = false, bool field = false) override;
        void doAttacking(uint32_t interval) override;
        bool hasExtraSwing() override {
            return lastAttack > 0 && ((OTSYS_TIME() - lastAttack) >= getAttackSpeed());
        }

        uint16_t getSpecialSkill(uint8_t skill) const {
            return std::max<int32_t>(0, varSpecialSkills[skill]);
        }
        uint16_t getSkillLevel(uint8_t skill) const {
            return std::max<int32_t>(0, skills[skill].level + varSkills[skill]);
        }
        uint16_t getBaseSkill(uint8_t skill) const {
            return skills[skill].level;
        }

        bool getAddAttackSkill() const {
            return addAttackSkillPoint;
        }
        BlockType_t getLastAttackBlockType() const {
            return lastAttackBlockType;
        }

        //NEW! DUAL WIELD SYSTEM
        void switchAttackHand() {
            lastAttackHand = lastAttackHand == HAND_LEFT ? HAND_RIGHT : HAND_LEFT;
            
        }

        //NEW! DUAL WIELD SYSTEM
        slots_t getAttackHand() const {
            return lastAttackHand == HAND_LEFT ? CONST_SLOT_LEFT : CONST_SLOT_RIGHT;
            
        }

        //NEW! DUAL WIELD SYSTEM
        void switchBlockSkillAdvance() {
            blockSkillAdvance = !blockSkillAdvance;
            
        }
        
        //NEW! DUAL WIELD SYSTEM
        bool getBlockSkillAdvance() {
            return blockSkillAdvance;
            
        }

        //NEW! DUAL WIELD SYSTEM
        bool isDualWielding() const;

        uint8_t getWandMaxDamageBonus() const {
            return wandMaxDamageBonus;
        }

        uint8_t getRodMaxDamageBonus() const {
            return rodMaxDamageBonus;
        }

        Item* getWeapon(slots_t slot, bool ignoreAmmo) const;
        Item* getWeapon(bool ignoreAmmo = false) const;
        WeaponType_t getWeaponType() const;
        int32_t getWeaponSkill(const Item* item) const;
        void getShieldAndWeapon(const Item*& shield, const Item*& weapon) const;

        void drainHealth(Creature* attacker, int32_t damage) override;
        void drainMana(Creature* attacker, int32_t manaLoss);

        int32_t getArmor() const override;
        int32_t getDefense() const override;
        float getAttackFactor() const override;
        float getDefenseFactor() const override;

        void addInFightTicks(bool pzlock = false);

        uint64_t getGainedExperience(Creature* attacker) const override;

        //combat event functions
        void onAddCondition(ConditionType_t type) override;
        void onAddCombatCondition(ConditionType_t type) override;
        void onEndCondition(ConditionType_t type) override;
        void onCombatRemoveCondition(Condition* condition) override;
        void onAttackedCreature(Creature* target) override;
        void onAttacked() override;
        void onAttackedCreatureDrainHealth(Creature* target, int32_t points) override;
        void onTargetCreatureGainHealth(Creature* target, int32_t points) override;
        bool onKilledCreature(Creature* target, bool lastHit = true) override;
        void onGainExperience(uint64_t gainExp, Creature* target) override;
        void onGainSharedExperience(uint64_t gainExp, Creature* source);
        void onAttackedCreatureBlockHit(BlockType_t blockType) override;
        void onBlockHit() override;
        void onChangeZone(ZoneType_t zone) override;
        void onAttackedCreatureChangeZone(ZoneType_t zone) override;
        void onIdleStatus() override;
        void onPlacedCreature() override;

        LightInfo getCreatureLight() const override;

        Skulls_t getSkull() const override;
        Skulls_t getSkullClient(const Creature* creature) const override;
        int64_t getSkullTicks() const { return skullTicks; }
        void setSkullTicks(int64_t ticks) { skullTicks = ticks; }

        bool hasAttacked(const Player* attacked) const;
        void addAttacked(const Player* attacked);
        void removeAttacked(const Player* attacked);
        void clearAttacked();
        void addUnjustifiedDead(const Player* attacked);
        void sendCreatureSkull(const Creature* creature) const {
            if (client) {
                client->sendCreatureSkull(creature);
            }
        }
        void checkSkullTicks(int32_t ticks);

        bool canWear(uint32_t lookType, uint8_t addons) const;
        void addOutfit(uint16_t lookType, uint8_t addons);
        bool removeOutfit(uint16_t lookType);
        bool removeOutfitAddon(uint16_t lookType, uint8_t addons);
        bool getOutfitAddons(const Outfit& outfit, uint8_t& addons) const;

        bool canLogout();

        size_t getMaxVIPEntries() const;
        size_t getMaxDepotItems() const;

        //tile
        //send methods
        void sendAddTileItem(const Tile* tile, const Position& pos, const Item* item) {
            if (client) {
                int32_t stackpos = tile->getStackposOfItem(this, item);
                if (stackpos != -1) {
                    client->sendAddTileItem(pos, stackpos, item);
                }
            }
        }
        void sendUpdateTileItem(const Tile* tile, const Position& pos, const Item* item) {
            if (client) {
                int32_t stackpos = tile->getStackposOfItem(this, item);
                if (stackpos != -1) {
                    client->sendUpdateTileItem(pos, stackpos, item);
                }
            }
        }
        void sendRemoveTileThing(const Position& pos, int32_t stackpos) {
            if (stackpos != -1 && client) {
                client->sendRemoveTileThing(pos, stackpos);
            }
        }
        void sendUpdateTile(const Tile* tile, const Position& pos) {
            if (client) {
                client->sendUpdateTile(tile, pos);
            }
        }

        void sendChannelMessage(const std::string& author, const std::string& text, SpeakClasses type, uint16_t channel) {
            if (client) {
                client->sendChannelMessage(author, text, type, channel);
            }
        }
        void sendChannelEvent(uint16_t channelId, const std::string& playerName, ChannelEvent_t channelEvent) {
            if (client) {
                client->sendChannelEvent(channelId, playerName, channelEvent);
            }
        }
        void sendCreatureAppear(const Creature* creature, const Position& pos, bool isLogin) {
            if (client) {
                client->sendAddCreature(creature, pos, creature->getTile()->getStackposOfCreature(this, creature), isLogin);
            }
        }
        void sendCreatureMove(const Creature* creature, const Position& newPos, int32_t newStackPos, const Position& oldPos, int32_t oldStackPos, bool teleport) {
            if (client) {
                client->sendMoveCreature(creature, newPos, newStackPos, oldPos, oldStackPos, teleport);
            }
        }
        void sendCreatureTurn(const Creature* creature) {
            if (client && canSeeCreature(creature)) {
                int32_t stackpos = creature->getTile()->getStackposOfCreature(this, creature);
                if (stackpos != -1) {
                    client->sendCreatureTurn(creature, stackpos);
                }
            }
        }
        void sendCreatureSay(const Creature* creature, SpeakClasses type, const std::string& text, const Position* pos = nullptr) {
            if (client) {
                client->sendCreatureSay(creature, type, text, pos);
            }
        }
        void sendPrivateMessage(const Player* speaker, SpeakClasses type, const std::string& text) {
            if (client) {
                client->sendPrivateMessage(speaker, type, text);
            }
        }
        void sendCreatureSquare(const Creature* creature, SquareColor_t color) {
            if (client) {
                client->sendCreatureSquare(creature, color);
            }
        }
        void sendCreatureChangeOutfit(const Creature* creature, const Outfit_t& outfit) {
            if (client) {
                client->sendCreatureOutfit(creature, outfit);
            }
        }
        void sendCreatureChangeVisible(const Creature* creature, bool visible) {
            if (!client) {
                return;
            }

            if (creature->getPlayer()) {
                if (visible) {
                    client->sendCreatureOutfit(creature, creature->getCurrentOutfit());
                } else {
                    static Outfit_t outfit;
                    client->sendCreatureOutfit(creature, outfit);
                }
            } else if (canSeeInvisibility()) {
                client->sendCreatureOutfit(creature, creature->getCurrentOutfit());
            } else {
                int32_t stackpos = creature->getTile()->getStackposOfCreature(this, creature);
                if (stackpos == -1) {
                    return;
                }

                if (visible) {
                    client->sendAddCreature(creature, creature->getPosition(), stackpos, false);
                } else {
                    client->sendRemoveTileThing(creature->getPosition(), stackpos);
                }
            }
        }
        void sendCreatureLight(const Creature* creature) {
            if (client) {
                client->sendCreatureLight(creature);
            }
        }
        void sendCreatureWalkthrough(const Creature* creature, bool walkthrough) {
            if (client) {
                client->sendCreatureWalkthrough(creature, walkthrough);
            }
        }
        void sendCreatureShield(const Creature* creature) {
            if (client) {
                client->sendCreatureShield(creature);
            }
        }
        void sendCreatureType(uint32_t creatureId, uint8_t creatureType) {
            if (client) {
                client->sendCreatureType(creatureId, creatureType);
            }
        }
        void sendCreatureHelpers(uint32_t creatureId, uint16_t helpers) {
            if (client) {
                client->sendCreatureHelpers(creatureId, helpers);
            }
        }
        void sendSpellCooldown(uint8_t spellId, uint32_t time) {
            if (client) {
                client->sendSpellCooldown(spellId, time);
            }
        }
        void sendSpellGroupCooldown(SpellGroup_t groupId, uint32_t time) {
            if (client) {
                client->sendSpellGroupCooldown(groupId, time);
            }
        }
        void sendModalWindow(const ModalWindow& modalWindow);

        //container
        void sendAddContainerItem(const Container* container, const Item* item);
        void sendUpdateContainerItem(const Container* container, uint16_t slot, const Item* newItem);
        void sendRemoveContainerItem(const Container* container, uint16_t slot);
        void sendContainer(uint8_t cid, const Container* container, bool hasParent, uint16_t firstIndex) {
            if (client) {
                client->sendContainer(cid, container, hasParent, firstIndex);
            }
        }

        //inventory
        void sendInventoryItem(slots_t slot, const Item* item) {
            if (client) {
                client->sendInventoryItem(slot, item);
            }
        }
        void sendItems() {
            if (client) {
                client->sendItems();
            }
        }

        //event methods
        void onUpdateTileItem(const Tile* tile, const Position& pos, const Item* oldItem,
                                      const ItemType& oldType, const Item* newItem, const ItemType& newType) override;
        void onRemoveTileItem(const Tile* tile, const Position& pos, const ItemType& iType,
                                      const Item* item) override;

        void onCreatureAppear(Creature* creature, bool isLogin) override;
        void onRemoveCreature(Creature* creature, bool isLogout) override;
        void onCreatureMove(Creature* creature, const Tile* newTile, const Position& newPos,
                                    const Tile* oldTile, const Position& oldPos, bool teleport) override;

        void onAttackedCreatureDisappear(bool isLogout) override;
        void onFollowCreatureDisappear(bool isLogout) override;

        //container
        void onAddContainerItem(const Item* item);
        void onUpdateContainerItem(const Container* container, const Item* oldItem, const Item* newItem);
        void onRemoveContainerItem(const Container* container, const Item* item);

        void onCloseContainer(const Container* container);
        void onSendContainer(const Container* container);
        void autoCloseContainers(const Container* container);

        //inventory
        void onUpdateInventoryItem(Item* oldItem, Item* newItem);
        void onRemoveInventoryItem(Item* item);

        void sendCancelMessage(const std::string& msg) const {
            if (client) {
                client->sendTextMessage(TextMessage(MESSAGE_STATUS_SMALL, msg));
            }
        }
        void sendCancelMessage(ReturnValue message) const;
        void sendCancelTarget() const {
            if (client) {
                client->sendCancelTarget();
            }
        }
        void sendCancelWalk() const {
            if (client) {
                client->sendCancelWalk();
            }
        }
        void sendChangeSpeed(const Creature* creature, double newSpeed) const {
            if (client) {
                client->sendChangeSpeed(creature, newSpeed);
            }
        }
        void sendCreatureHealth(const Creature* creature) const {
            if (client) {
                client->sendCreatureHealth(creature);
            }
        }
        void sendDistanceShoot(const Position& from, const Position& to, unsigned char type) const {
            if (client) {
                client->sendDistanceShoot(from, to, type);
            }
        }
        void sendHouseWindow(House* house, uint32_t listId) const;
        void sendCreatePrivateChannel(uint16_t channelId, const std::string& channelName) {
            if (client) {
                client->sendCreatePrivateChannel(channelId, channelName);
            }
        }
        void sendClosePrivate(uint16_t channelId);
        void sendIcons() const {
            if (client) {
                client->sendIcons(getClientIcons());
            }
        }
        void sendMagicEffect(const Position& pos, uint8_t type) const {
            if (client) {
                client->sendMagicEffect(pos, type);
            }
        }
        void sendPing();
        void sendPingBack() const {
            if (client) {
                client->sendPingBack();
            }
        }
        void sendStats();
        void sendBasicData() const {
            if (client) {
                client->sendBasicData();
            }
        }
        void sendSkills() const {
            if (client) {
                client->sendSkills();
            }
        }
        void sendTextMessage(MessageClasses mclass, const std::string& message) const {
            if (client) {
                client->sendTextMessage(TextMessage(mclass, message));
            }
        }
        void sendTextMessage(const TextMessage& message) const {
            if (client) {
                client->sendTextMessage(message);
            }
        }
        void sendReLoginWindow(uint8_t unfairFightReduction) const {
            if (client) {
                client->sendReLoginWindow(unfairFightReduction);
            }
        }
        void sendTextWindow(Item* item, uint16_t maxlen, bool canWrite) const {
            if (client) {
                client->sendTextWindow(windowTextId, item, maxlen, canWrite);
            }
        }
        void sendTextWindow(uint32_t itemId, const std::string& text) const {
            if (client) {
                client->sendTextWindow(windowTextId, itemId, text);
            }
        }
        void sendToChannel(const Creature* creature, SpeakClasses type, const std::string& text, uint16_t channelId) const {
            if (client) {
                client->sendToChannel(creature, type, text, channelId);
            }
        }
        void sendShop(Npc* npc) const {
            if (client) {
                client->sendShop(npc, shopItemList);
            }
        }
        void sendSaleItemList() const {
            if (client) {
                client->sendSaleItemList(shopItemList);
            }
        }
        void sendCloseShop() const {
            if (client) {
                client->sendCloseShop();
            }
        }
        void sendMarketEnter(uint32_t depotId) const {
            if (client) {
                client->sendMarketEnter(depotId);
            }
        }
        void sendMarketLeave() {
            inMarket = false;
            if (client) {
                client->sendMarketLeave();
            }
        }
        void sendMarketBrowseItem(uint16_t itemId, const MarketOfferList& buyOffers, const MarketOfferList& sellOffers) const {
            if (client) {
                client->sendMarketBrowseItem(itemId, buyOffers, sellOffers);
            }
        }
        void sendMarketBrowseOwnOffers(const MarketOfferList& buyOffers, const MarketOfferList& sellOffers) const {
            if (client) {
                client->sendMarketBrowseOwnOffers(buyOffers, sellOffers);
            }
        }
        void sendMarketBrowseOwnHistory(const HistoryMarketOfferList& buyOffers, const HistoryMarketOfferList& sellOffers) const {
            if (client) {
                client->sendMarketBrowseOwnHistory(buyOffers, sellOffers);
            }
        }
        void sendMarketDetail(uint16_t itemId) const {
            if (client) {
                client->sendMarketDetail(itemId);
            }
        }
        void sendMarketAcceptOffer(const MarketOfferEx& offer) const {
            if (client) {
                client->sendMarketAcceptOffer(offer);
            }
        }
        void sendMarketCancelOffer(const MarketOfferEx& offer) const {
            if (client) {
                client->sendMarketCancelOffer(offer);
            }
        }
        void sendTradeItemRequest(const std::string& traderName, const Item* item, bool ack) const {
            if (client) {
                client->sendTradeItemRequest(traderName, item, ack);
            }
        }
        void sendTradeClose() const {
            if (client) {
                client->sendCloseTrade();
            }
        }
        void sendWorldLight(LightInfo lightInfo) {
            if (client) {
                client->sendWorldLight(lightInfo);
            }
        }
        void sendChannelsDialog() {
            if (client) {
                client->sendChannelsDialog();
            }
        }
        void sendOpenPrivateChannel(const std::string& receiver) {
            if (client) {
                client->sendOpenPrivateChannel(receiver);
            }
        }
        void sendOutfitWindow() {
            if (client) {
                client->sendOutfitWindow();
            }
        }
        void sendCloseContainer(uint8_t cid) {
            if (client) {
                client->sendCloseContainer(cid);
            }
        }

        void sendChannel(uint16_t channelId, const std::string& channelName, const UsersMap* channelUsers, const InvitedMap* invitedUsers) {
            if (client) {
                client->sendChannel(channelId, channelName, channelUsers, invitedUsers);
            }
        }
        void sendTutorial(uint8_t tutorialId) {
            if (client) {
                client->sendTutorial(tutorialId);
            }
        }
        void sendAddMarker(const Position& pos, uint8_t markType, const std::string& desc) {
            if (client) {
                client->sendAddMarker(pos, markType, desc);
            }
        }
        void sendQuestLog() {
            if (client) {
                client->sendQuestLog();
            }
        }
        void sendQuestLine(const Quest* quest) {
            if (client) {
                client->sendQuestLine(quest);
            }
        }
        void sendEnterWorld() {
            if (client) {
                client->sendEnterWorld();
            }
        }
        void sendFightModes() {
            if (client) {
                client->sendFightModes();
            }
        }
        void sendNetworkMessage(const NetworkMessage& message) {
            if (client) {
                client->writeToOutputBuffer(message);
            }
        }

        void receivePing() {
            lastPong = OTSYS_TIME();
        }

        void onThink(uint32_t interval) override;

        void postAddNotification(Thing* thing, const Cylinder* oldParent, int32_t index, cylinderlink_t link = LINK_OWNER) override;
        void postRemoveNotification(Thing* thing, const Cylinder* newParent, int32_t index, cylinderlink_t link = LINK_OWNER) override;

        void setNextAction(int64_t time) {
            if (time > nextAction) {
                nextAction = time;
            }
        }
        bool canDoAction() const {
            return nextAction <= OTSYS_TIME();
        }
        uint32_t getNextActionTime() const;

        Item* getWriteItem(uint32_t& windowTextId, uint16_t& maxWriteLen);
        void setWriteItem(Item* item, uint16_t maxWriteLen = 0);

        House* getEditHouse(uint32_t& windowTextId, uint32_t& listId);
        void setEditHouse(House* house, uint32_t listId = 0);

        void learnInstantSpell(const std::string& spellName);
        void forgetInstantSpell(const std::string& spellName);
        bool hasLearnedInstantSpell(const std::string& spellName) const;
        bool autoLootGold = false; //NEW! AUTO LOOT GOLD
        bool autoLootAddon = false; //NEW! AUTO LOOT ADDON
        uint32_t title = 0; //NEW! TITLE

        //psychonaut autoloot
        void addAutoLootItem(uint16_t itemId);
        void removeAutoLootItem(uint16_t itemId);
        bool getAutoLootItem(uint16_t itemId);

        void setSkills(uint16_t magic, uint16_t vitality, uint16_t strenght, uint16_t defence,
                       uint16_t dexterity, uint16_t intelligence, uint16_t faith, uint16_t endurance);

        void refreshStats();

        static uint8_t getPercentLevel(uint64_t count, uint64_t nextLevelCount);

    private:
        bool setTitleDescription(PlayerTitle_t titleiD); //NEW! TITLE

        std::forward_list<Condition*> getMuteConditions() const;

        void checkTradeState(const Item* item);
        bool hasCapacity(const Item* item, uint32_t count) const;

        void gainExperience(uint64_t gainExp, Creature* source);
        void addExperience(Creature* source, uint64_t exp, bool sendText = false);
        void removeExperience(uint64_t exp, bool sendText = false);

        void updateInventoryWeight();

        void setNextWalkActionTask(SchedulerTask* task);
        void setNextWalkTask(SchedulerTask* task);
        void setNextActionTask(SchedulerTask* task);

        void death(Creature* lastHitCreature) override;
        bool dropCorpse(Creature* lastHitCreature, Creature* mostDamageCreature, bool lastHitUnjustified, bool mostDamageUnjustified) override;
        Item* getCorpse(Creature* lastHitCreature, Creature* mostDamageCreature) override;

        //cylinder implementations
        ReturnValue queryAdd(int32_t index, const Thing& thing, uint32_t count,
                uint32_t flags, Creature* actor = nullptr) const override;
        ReturnValue queryMaxCount(int32_t index, const Thing& thing, uint32_t count, uint32_t& maxQueryCount,
                uint32_t flags) const override;
        ReturnValue queryRemove(const Thing& thing, uint32_t count, uint32_t flags) const override;
        Cylinder* queryDestination(int32_t& index, const Thing& thing, Item** destItem,
                uint32_t& flags) override;

        void addThing(Thing*) override {}
        void addThing(int32_t index, Thing* thing) override;

        void updateThing(Thing* thing, uint16_t itemId, uint32_t count) override;
        void replaceThing(uint32_t index, Thing* thing) override;

        void removeThing(Thing* thing, uint32_t count) override;

        int32_t getThingIndex(const Thing* thing) const override;
        size_t getFirstIndex() const override;
        size_t getLastIndex() const override;
        uint32_t getItemTypeCount(uint16_t itemId, int32_t subType = -1) const override;
        std::map<uint32_t, uint32_t>& getAllItemTypeCount(std::map<uint32_t, uint32_t>& countMap) const override;
        Thing* getThing(size_t index) const override;

        void internalAddThing(Thing* thing) override;
        void internalAddThing(uint32_t index, Thing* thing) override;

        std::set<uint32_t> autoLootList;
        std::unordered_set<uint32_t> attackedSet;
        std::unordered_set<uint32_t> VIPList;

        std::map<uint8_t, OpenContainer> openContainers;
        std::map<uint32_t, DepotLocker*> depotLockerMap;
        std::map<uint32_t, DepotChest*> depotChests;
        std::map<uint32_t, int32_t> storageMap;

        std::vector<OutfitEntry> outfits;
        GuildWarVector guildWarVector;

        std::list<ShopInfo> shopItemList;

        std::forward_list<Party*> invitePartyList;
        std::forward_list<uint32_t> modalWindows;
        std::forward_list<std::string> learnedInstantSpellList;
        std::forward_list<Condition*> storedConditionList; // TODO: This variable is only temporarily used when logging in, get rid of it somehow

        std::string name;
        std::string guildNick;

        Skill skills[SKILL_LAST + 1];
        LightInfo itemsLight;
        Position loginPosition;
        Position lastWalkthroughPosition;

        time_t lastLoginSaved = 0;
        time_t lastLogout = 0;

        uint64_t experience = 0;
        uint64_t lastAttack = 0;
        uint64_t bankBalance = 0;
        uint64_t lastQuestlogUpdate = 0;
        int64_t lastFailedFollow = 0;
        int64_t skullTicks = 0;
        int64_t lastWalkthroughAttempt = 0;
        int64_t lastToggleMount = 0;
        int64_t lastPing;
        int64_t lastPong;
        int64_t nextAction = 0;

        BedItem* bedItem = nullptr;
        Guild* guild = nullptr;
        const GuildRank* guildRank = nullptr;
        Group* group = nullptr;
        Inbox* inbox;
        Item* tradeItem = nullptr;
         Item* inventory[CONST_SLOT_LAST + 1] = {};
        Item* writeItem = nullptr;
        House* editHouse = nullptr;
        Npc* shopOwner = nullptr;
        Party* party = nullptr;
        Player* tradePartner = nullptr;
        ProtocolGame_ptr client;
        SchedulerTask* walkTask = nullptr;
        Town* town = nullptr;
        Vocation* vocation = nullptr;

        uint32_t inventoryWeight = 0;
        uint32_t capacity = 40000;
        uint32_t damageImmunities = 0;
        uint32_t conditionImmunities = 0;
        uint32_t conditionSuppressions = 0;
        uint32_t level = 1;
        uint32_t actionTaskEvent = 0;
        uint32_t nextStepEvent = 0;
        uint32_t walkTaskEvent = 0;
        uint32_t MessageBufferTicks = 0;
        uint32_t lastIP = 0;
        uint32_t accountNumber = 0;
        uint32_t guid = 0;
        uint32_t windowTextId = 0;
        uint32_t editListId = 0;
        uint32_t mana = 0;
        uint32_t manaMax = 0;
        int32_t varSkills[SKILL_LAST + 1] = {};
        int32_t varSpecialSkills[SPECIALSKILL_LAST + 1] = {};
        int32_t varStats[STAT_LAST + 1] = {};
        int32_t purchaseCallback = -1;
        int32_t saleCallback = -1;
        int32_t MessageBufferCount = 0;
        int32_t premiumDays = 0;
        int32_t bloodHitCount = 0;
        int32_t shieldBlockCount = 0;
        int32_t idleTime = 0;

        uint16_t skillPoints = 0;
        uint16_t magLevel = 0;
        uint16_t lastStatsTrainingTime = 0;
        uint16_t staminaMinutes = 2520;
        uint16_t maxWriteLen = 0;
        int16_t lastDepotId = -1;

        uint8_t soul = 0;
        uint8_t blessings = 0;
        uint8_t levelPercent = 0;
        uint8_t wandMaxDamageBonus = 0;
        uint8_t rodMaxDamageBonus = 0;
        uint8_t walkSpeedBonus = 0;
        uint8_t    attackSpeedBonus = 0;

        PlayerSex_t sex = PLAYERSEX_FEMALE;
        OperatingSystem_t operatingSystem = CLIENTOS_NONE;
        BlockType_t lastAttackBlockType = BLOCK_NONE;
        tradestate_t tradeState = TRADE_NONE;
        fightMode_t fightMode = FIGHTMODE_ATTACK;
        AccountType_t accountType = ACCOUNT_TYPE_NORMAL;

        //NEW! DUAL WIELD SYSTEM
        attackHand_t lastAttackHand;

        //NEW! DUAL WIELD SYSTEM
        bool blockSkillAdvance;

        bool chaseMode = false;
        bool secureMode = false;
        bool inMarket = false;
        bool wasMounted = false;
        bool ghostMode = false;
        bool pzLocked = false;
        bool isConnecting = false;
        bool addAttackSkillPoint = false;
        bool inventoryAbilities[CONST_SLOT_LAST + 1] = {};

        static uint32_t playerAutoID;

        void updateItemsLight(bool internal = false);
        double getStepSpeed() const override {
            return std::max<double>(PLAYER_MIN_SPEED, std::min<double>(PLAYER_MAX_SPEED, getSpeed()));
        }

        //CHANGED! SKILL POINTS SYSTEM - DEXTERITY WALK SPEED
        void updateBaseSpeed() {
            if (!hasFlag(PlayerFlag_SetMaxSpeed)) {

                //increase walk speed in 1 = increase baseSpeed in 2
                baseSpeed = vocation->getBaseSpeed() + 2 * (level - 1) + (skills[SKILL_DEXTERITY].level - 8) / 2.0f;
            }
            else {
                baseSpeed = PLAYER_MAX_SPEED;
            }
        }

        bool isPromoted() const;

        //CHANGED! SKILL POINTS SYSTEM - DEXTERITY AND DUAL WIELD ATTACK SPEED
        uint32_t getAttackSpeed() const;

        double getLostPercent() const;
        uint64_t getLostExperience() const override {
            return skillLoss ? static_cast<uint64_t>(experience * getLostPercent()) : 0;
        }
        uint32_t getDamageImmunities() const override {
            return damageImmunities;
        }
        uint32_t getConditionImmunities() const override {
            return conditionImmunities;
        }
        uint32_t getConditionSuppressions() const override {
            return conditionSuppressions;
        }
        uint16_t getLookCorpse() const override;
        void getPathSearchParams(const Creature* creature, FindPathParams& fpp) const override;

        friend class Game;
        friend class Npc;
        friend class LuaScriptInterface;
        friend class Map;
        friend class Actions;
        friend class IOLoginData;
        friend class ProtocolGame;
};

#endif
 

 

Você tem alguma imagem que possa auxiliar no problema? Se sim, anexe-a dentro do spoiler abaixo:

Spoiler

 

 

Edited by Havokz

Share this post


Link to post
Share on other sites

4 answers to this question

Recommended Posts

  • 0
vankk    15
vankk
Posted (edited)

Você não vai conseguir chamar essas duas funções que estão no Player.h sem antes passar pelo o Luascript antes.
Basta você fazer algumas funções getters & Setters simples.
 

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

Lembre-se de registrar no Luascript.h e também registrar o método com registerMethod. Após isso, o objeto Player vai aceitar em qualquer da da parte de Lua você chamar essas duas funções.

Edited by vankk

Share this post


Link to post
Share on other sites
  • 0
Havokz    0
Havokz

Engraçado é que o cara consegue chamar essa função até dentro do module da janela de skills, com o player:getSkillPoints()

mas nos outros lugares não consigo lol

Share this post


Link to post
Share on other sites
  • 0
Havokz    0
Havokz
7 horas atrás, vankk disse:

Você não vai conseguir chamar essas duas funções que estão no Player.h sem antes passar pelo o Luascript antes.
Basta você fazer algumas funções getters & Setters simples.
 

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

Lembre-se de registrar no Luascript.h e também registrar o método com registerMethod. Após isso, o objeto Player vai aceitar em qualquer da da parte de Lua você chamar essas duas funções.

Registrei  no Luascript.cpp com registerMethod,

 mas onde exatamente eu tenho que adicionar essas linhas que você escreveu?  tentei adicionar no player.h e no proprio luascript.cpp, mas tive muitos erros na hora de compilar

Share this post


Link to post
Share on other sites
  • 0
Havokz    0
Havokz

Resolvido!

Usei o código do  @vankk com uma pequena correção, e me guiei por este tutorial  de attackspeed, para me localizar nos arquivos:

 

Hidden Content

    Sign In here or Sign Up here to see this hidden content.

 

Código :

Citar
int LuaScriptInterface::luaPlayerSetSkillPoints(lua_State* L)
{
    // player:setSkillPoints(value)
    Player* player = getUserdata<Player>(L, 1);
    if (!player) {
        lua_pushnil(L);
        return 1;
    }

    uint32_t value = getNumber<uint32_t>(L, 2);
    player->setSkillPoints(value)
    pushBoolean(L, true);
    return 1;
}


int LuaScriptInterface::luaPlayerGetSkillPoints(lua_State* L)
{
    // player:getSkillPoints()
    Player* player = getUserdata<Player>(L, 1);
    if (!player) {
        lua_pushnil(L);
        return 1;
    }

    lua_pushnumber(L, player->getSkillPoints());
    return 1;
}

 

Obrigado pela ajuda @vankk

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.

  • Recently Browsing   0 members

    No registered users viewing this page.

×