Stats.hpp

Go to the documentation of this file.

#ifndef CORE_PEOPLEMON_STATS_HPP
#define CORE_PEOPLEMON_STATS_HPP
 
#include <BLIB/Serialization.hpp>
#include <Core/Peoplemon/Stat.hpp>
#include <array>
 
namespace core
{
namespace pplmn
{
struct Stats {
    int hp;
    int atk;
    int def;
    int spatk;
    int spdef;
    int spd;
 
    Stats();
 
    Stats(Stat stat, int points);
 
    int sum() const;
 
    void randomize();
 
    void addEVs(const Stats& evs);
 
    int& get(Stat stat);
 
    int get(Stat stat) const;
 
    static float stageMultiplier(int stage);
 
    static Stats computeStats(const Stats& base, const Stats& evs, const Stats& ivs,
                              unsigned int level, const Stats& stages = {});
 
    static const char* statToString(Stat stat);
 
    static const std::array<Stat, 6> IterableStats;
 
    static constexpr int MaxEVSum = 510;
 
    static constexpr int MaxEVStat = 255;
 
    static constexpr int MaxIVStat = 31;
};
 
} // namespace pplmn
} // namespace core
 
namespace bl
{
namespace serial
{
namespace binary
{
using core::pplmn::Stats;
 
template<>
struct Serializer<Stats> {
    static bool serialize(OutputStream& output, const Stats& v) {
        if (!output.write<std::int16_t>(v.hp)) return false;
        if (!output.write<std::int16_t>(v.atk)) return false;
        if (!output.write<std::int16_t>(v.def)) return false;
        if (!output.write<std::int16_t>(v.spatk)) return false;
        if (!output.write<std::int16_t>(v.spdef)) return false;
        if (!output.write<std::int16_t>(v.spd)) return false;
        return true;
    }
 
    static bool deserialize(InputStream& input, Stats& v) {
        std::int16_t val = 0;
        if (!input.read<std::int16_t>(val)) return false;
        v.hp = val;
        if (!input.read<std::int16_t>(val)) return false;
        v.atk = val;
        if (!input.read<std::int16_t>(val)) return false;
        v.def = val;
        if (!input.read<std::int16_t>(val)) return false;
        v.spatk = val;
        if (!input.read<std::int16_t>(val)) return false;
        v.spdef = val;
        if (!input.read<std::int16_t>(val)) return false;
        v.spd = val;
        return true;
    }
 
    static std::size_t size(const Stats&) { return sizeof(std::int16_t) * 6; }
};
 
} // namespace binary
 
template<>
struct SerializableObject<core::pplmn::Stats> : public SerializableObjectBase {
    using Stats = core::pplmn::Stats;
 
    SerializableField<1, Stats, int> hp;
    SerializableField<2, Stats, int> atk;
    SerializableField<3, Stats, int> def;
    SerializableField<4, Stats, int> spd;
    SerializableField<5, Stats, int> spatk;
    SerializableField<6, Stats, int> spdef;
 
    SerializableObject()
    : SerializableObjectBase("Stats")
    , hp("hp", *this, &Stats::hp, SerializableFieldBase::Required{})
    , atk("atk", *this, &Stats::atk, SerializableFieldBase::Required{})
    , def("def", *this, &Stats::def, SerializableFieldBase::Required{})
    , spd("spd", *this, &Stats::spd, SerializableFieldBase::Required{})
    , spatk("spatk", *this, &Stats::spatk, SerializableFieldBase::Required{})
    , spdef("spdef", *this, &Stats::spdef, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif