Question

我正在制作一个FireEmblem风格的游戏，我正在研究项目。我有一个Weapon类，其中派生了Sword，Axe等。我也有像Swordsman，Mage等字符类。我想有办法让课程只装备某些武器（Swordsman可以装备Sword但不能Axe）。我想到的一种方法是为WeaponType创建一个全局枚举，每个武器都有一个const weapon_type值。然后，每个角色类都有一个允许的WeaponTypes列表，您可以检查武器的weapon_type是否在允许列表中。

有没有更好的方法来实现这个？

Answer 1

假设你的角色基类中有一个看起来像

的函数

let path = 'foo';
require('./' + path);

您可以提供实际检查传递的class CharacterBase { public: bool equip(Weapon* weapon) { if(checkWeaponType(weapon)) { weapons.push_back(weapon); return true; } return false; } protected: virtual bool checkWeaponType(Weapon* weapon) const = 0; private: std::vector<Weapon*> weapons; };指针是否具有正确类型

的实现

Weapon

另外，我们假设您的class SwordsMan : public CharacterBase { protected: virtual bool checkWeaponType(Weapon* weapon) const { return dynamic_cast<Sword*>(weapon) != nullptr; } };字符也允许佩戴SwordsMan然后您延长支票

Dagger

Answer 2

刚刚产卵。

让我们说你允许的武器是你班上的一个字符串数组（字符串weaponAllow [10]）。

你的武器有名字。为你的法师/战士类制作一个物体阵列（生病叫它士兵）。也许当你拥有装备功能，或装备时你说：

for(int a=0; a<=10; a++) {
    if(soldier[whichTypeOfSoldier].weaponAllow[a]==item[whichitem].name) {
        (code to equip the item)
    }
}

我理所当然地认为您使用过对象数组，如果没有，我建议使用它们。

嗯，我刚刚产卵。希望你能得到我所说的。

Answer 3

请考虑以下事项：

struct WeaponAttributes {
    // Attributes to designate damage and weaknesses to
    // specific character classes and armor types.   
};

class Weapon {
public:
    enum WeaponClassType {
        WCT_SWORD,
        WCT_AXE,
        WCT_DAGGER,
        WCT_KNIFE,
        WCT_STAFF,
        /* WTC_ETC */
    };
private:
    std::string m_strWeaponClass;
    std::string m_strWeaponName;

    WeaponClassType m_WeaponClass;

public:
    // Constructor, Destructor and members this base class would have
    Weapon( const std::string& strWeaponClass, const std::string& strWeaponName, WeaponClassType weaponType );

    std::string getWeaponClassName() const;
    std::string getWeaponName() const;

    WeaponClassType getType() const;

    bool isWeaponType( const WeaponClassType& type ) const;
    bool isWeaponType( const std::string& strClassName ) const;

    void addAttributes( const WeaponAttributes& attributes ) = 0;          
};

class Sword : public Weapon {
private:
    WeaponAttributes m_attributes;

public:
    explicit Weapon( const std::string& strWeaponName );

    void addAttributes( const WeaponAttributes& attributes ) override;

};

struct CharacterAttributes {
    // Similar to WeaponAttributes
};

class Character {
public:
    enum CharacterClassType {
        CCT_FIGHTER,
        CCT_WARRIOR,
        CCT_MAGE,
        /* CCT_ETC */
    };

private:
    std::string m_strCharacterClassType;
    std::string m_strCharacterClassName;
    std::string m_strPlayerOrNPCName;

    CharacterClassType m_classType;

public:
    Character( const std::string& strName, const std::string& strClassName, const std::string strClassType, CharacterClassType classType );

    // Using Three Strings - Example: (Player's or NPC's game name, White, Mage )
    // (Player's or NPC's game name, Superior, Warrior )
    // (Player's or NPC's game name, Skilled, Fighter )
    std::string getName() const;
    std::string getClassName() const;
    std::string getCharacterName() const;

    CharacterClassType getCharacterType() const;

    bool isCharacterClassType( const CharacterClassType& type ) const;
    bool isCharacterClassType( const std::string& strClassType ) const;

    void addCharacterAttributes( const CharacterAtrributes& attributes ) = 0;
    bool equipWeapon( Weapon* pWeapon ) = 0;
    bool equipArmor( Armor* pArmor ) = 0;
};

class Character : public Fighter {
private:
    CharacterAttributes m_attributes;

    std::shared_ptr<Weapon> m_pWeapon;
    std::shared_ptr<Armor>  m_pArmor;

public:
     Fighter( const std::string& strPlayerOrNPCName, const std::string& strClassName );

     void addCharacterAttributes( const CharacterAttributes& attributes );
     bool equipWeapon( Weapon* pWeapon );
     bool equipArmor( Armor* pArmor );
};

使用这种类的层次结构，每个类都有一个枚举类型和字符串描述符以及检索类型，字符串和比较它们是否是特定类型的方法，您可以轻松遍历不同的列表或向量（容器）查看特定类型的护甲或武器是否可以装备到特定的类角色。这只是一种设计方法，因为有许多方法可以实现这样的系统。我不是吹嘘这是最好或最差的设计方法，但我觉得它是一个很好的指导或起点。一旦你在一个没有任何错误的工作稳定状态下获得所需的行为，那么只有这时才能修改现有的代码库以进行优化。

允许一个单位只装备某些类型的武器

3 个答案: