OwnedPeoplemon.hpp

Go to the documentation of this file.

#ifndef CORE_PEOPLEMON_OWNEDPEOPLEMON_HPP
#define CORE_PEOPLEMON_OWNEDPEOPLEMON_HPP
 
#include <BLIB/Serialization.hpp>
#include <Core/Items/Id.hpp>
#include <Core/Peoplemon/Ailment.hpp>
#include <Core/Peoplemon/Id.hpp>
#include <Core/Peoplemon/OwnedMove.hpp>
#include <Core/Peoplemon/SpecialAbility.hpp>
#include <Core/Peoplemon/Stats.hpp>
#include <Core/Peoplemon/Type.hpp>
#include <string>
 
namespace editor
{
namespace component
{
class OwnedPeoplemonWindow;
}
} // namespace editor
 
namespace core
{
namespace pplmn
{
class OwnedPeoplemon;
} // namespace pplmn
} // namespace core
 
namespace core
{
namespace pplmn
{
struct WildPeoplemon;
class BattlePeoplemon;
 
class OwnedPeoplemon {
public:
    OwnedPeoplemon();
 
    OwnedPeoplemon(Id id, unsigned int level);
 
    bool loadLegacyFile(const std::string& file);
 
    Id id() const;
 
    void evolve();
 
    const std::string& name() const;
 
    void setCustomName(const std::string& name);
 
    Type type() const;
 
    unsigned int currentLevel() const;
 
    unsigned int evolveLevel() const;
 
    Id evolvesInto() const;
 
    bool& pendingEvolution();
 
    bool pendingEvolution() const;
 
    unsigned int currentXP() const;
 
    unsigned int nextLevelXP() const;
 
    unsigned int awardXP(unsigned int xp);
 
    MoveId levelUp();
 
    Stats currentStats() const;
 
    const Stats& currentEVs() const;
 
    const Stats& currentIVs() const;
 
    std::uint16_t& currentHp();
 
    std::uint16_t currentHp() const;
 
    void applyDamage(int dmg);
 
    void giveHealth(int hp);
 
    void awardEVs(const Stats& evs);
 
    Ailment& currentAilment();
 
    Ailment currentAilment() const;
 
    item::Id& holdItem();
 
    item::Id holdItem() const;
 
    SpecialAbility ability() const;
 
    const OwnedMove* knownMoves() const;
 
    OwnedMove* knownMoves();
 
    bool knowsMove(MoveId move) const;
 
    void learnMove(MoveId move, unsigned int i);
 
    bool gainMove(MoveId move);
 
    void heal();
 
    bool hasExpShare() const;
 
    unsigned int xpYield(bool isTrainer) const;
 
    OwnedMove* findMove(MoveId id);
 
    bool shakePasses(item::Id ball, int turnNumber, unsigned int opLevel);
 
    bool canClone() const;
 
private:
    Id _id;
    std::string customName;
    std::uint16_t level;
    std::uint32_t xp;
    std::uint16_t hp;
    Stats ivs;
    Stats evs;
    OwnedMove moves[4];
    Ailment ailment;
    item::Id item;
    bool pendingEvolve;
 
    friend struct WildPeoplemon;
    friend class BattlePeoplemon;
    friend struct bl::serial::SerializableObject<OwnedPeoplemon>;
    friend class editor::component::OwnedPeoplemonWindow;
};
 
} // namespace pplmn
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::pplmn::OwnedPeoplemon> : public SerializableObjectBase {
    using OP    = core::pplmn::OwnedPeoplemon;
    using Id    = core::pplmn::Id;
    using Stats = core::pplmn::Stats;
    using Move  = core::pplmn::OwnedMove;
    using Ail   = core::pplmn::Ailment;
    using Item  = core::item::Id;
 
    SerializableField<1, OP, Id> id;
    SerializableField<2, OP, std::string> customName;
    SerializableField<3, OP, std::uint16_t> level;
    SerializableField<4, OP, std::uint32_t> xp;
    SerializableField<5, OP, std::uint16_t> hp;
    SerializableField<6, OP, Stats> ivs;
    SerializableField<7, OP, Stats> evs;
    SerializableField<8, OP, Move[4]> moves;
    SerializableField<9, OP, Ail> ailment;
    SerializableField<10, OP, Item> item;
 
    SerializableObject()
    : SerializableObjectBase("OwnedPeoplemon")
    , id("id", *this, &OP::_id, SerializableFieldBase::Required{})
    , customName("name", *this, &OP::customName, SerializableFieldBase::Required{})
    , level("level", *this, &OP::level, SerializableFieldBase::Required{})
    , xp("xp", *this, &OP::xp, SerializableFieldBase::Required{})
    , hp("hp", *this, &OP::hp, SerializableFieldBase::Required{})
    , ivs("ivs", *this, &OP::ivs, SerializableFieldBase::Required{})
    , evs("evs", *this, &OP::evs, SerializableFieldBase::Required{})
    , moves("moves", *this, &OP::moves, SerializableFieldBase::Required{})
    , ailment("ailment", *this, &OP::ailment, SerializableFieldBase::Required{})
    , item("item", *this, &OP::item, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif