Advancement types

[punt]

Code: Select all

//======================================================================
// AdvancementEntry
//======================================================================
struct AdvancementEntry {
    int minimumValue ;
    int successChance ;
    int failureChance ;
    util::range_t<int> increaseAmount ;
    AdvancementEntry() ;
    AdvancementEntry(int value,int success,int failure, const util::range_t<int> &range) ;
    AdvancementEntry(const std::string &line) ;
    auto describe() const -> std::string ;
    auto modifierBasedOnValue(int value) -> int ;
    auto success(int modifier=0) const ->bool ;
    auto amount() const -> int ;
    auto succesAmount(int modifier = 0 ) -> int ;
    auto operator<(const AdvancementEntry &entry) const ->bool ;
    
};
//======================================================================
// Advancement
//======================================================================
struct Advancement {
    std::vector<AdvancementEntry> advanceLevels ;
    static const AdvancementEntry badEntry ;
    Advancement() =default;
    Advancement(const std::vector<AdvancementEntry> &levels);
    auto operator[](int currentValue) const -> const AdvancementEntry& ;
    
};
//======================================================================
// SkillAdvancment
//======================================================================
struct SkillAdvancement : public Advancement {
    Attribute attribute ;
    SkillAdvancement():Advancement(){}
    SkillAdvancement(const Attribute &attribute, const std::vector<AdvancementEntry> &levels);

};

[punt]

Code: Select all

//======================================================================
// AdvancementEntry
//======================================================================
//======================================================================
AdvancementEntry::AdvancementEntry() {
    this->minimumValue = 10000 ;
    this->successChance = 0 ;
    this->failureChance = 0 ;
    this->increaseAmount = util::range_t(1,1);
}

//======================================================================
AdvancementEntry::AdvancementEntry(int value,int success,int failure, const util::range_t<int> &range){
    this->minimumValue = value ;
    this->successChance = success ;
    this->failureChance = failure;
    this->increaseAmount = range ;
}
//======================================================================
AdvancementEntry::AdvancementEntry(const std::string &line):AdvancementEntry(){
    auto [first,second] = util::split(line, ":");
    if (!second.empty()){
        increaseAmount = util::range_t<int>(second) ;
    }
    auto values = util::parse(first,",") ;
    minimumValue = std::stoi(values[0],nullptr,0);
    successChance = std::stoi(values[1],nullptr,0) * 10 ;
    failureChance = std::stoi(values[2],nullptr,0) * 10 ;
}
//======================================================================
auto AdvancementEntry::describe() const -> std::string{
    return std::to_string(minimumValue) + ","s+std::to_string(successChance/10) + ","s + std::to_string(failureChance/10)+":"+increaseAmount.describe();
}
//======================================================================
auto AdvancementEntry::modifierBasedOnValue(int value) -> int {
    return (value - minimumValue) ;
}
//======================================================================
auto AdvancementEntry::success(int modifier) const ->bool {
    
    if (Random::get(1,1000)> (successChance + modifier)){
        if (Random::get(1,1000)> failureChance){
            return false ;
        }
    }
    return true ;
    
}
//======================================================================
auto AdvancementEntry::amount() const -> int{
    return increaseAmount.random() ;
}
//======================================================================
auto AdvancementEntry::operator<(const AdvancementEntry &entry) const ->bool{
    return minimumValue<entry.minimumValue ;
}
//======================================================================
// Advancement
//======================================================================
//======================================================================
const AdvancementEntry Advancement::badEntry = AdvancementEntry(0,0,0, util::range_t<int>(0,0));
//======================================================================
Advancement::Advancement(const std::vector<AdvancementEntry> &levels){
    this->advanceLevels = levels ;
    std::sort(advanceLevels.begin(),advanceLevels.end(),[](const AdvancementEntry &lhs,const AdvancementEntry &rhs){
        return lhs.minimumValue>rhs.minimumValue;
    });
}
//======================================================================
auto Advancement::operator[](int currentValue) const -> const AdvancementEntry& {
    auto iter = std::find_if(advanceLevels.begin(),advanceLevels.end(),[currentValue](const AdvancementEntry &entry){
        return currentValue >= entry.minimumValue;
    });
    if (iter != advanceLevels.end()){
        return *iter;
    }
    return badEntry ;
}
//======================================================================
// SkillAdvancment
//======================================================================
SkillAdvancement::SkillAdvancement(const Attribute &attribute, const std::vector<AdvancementEntry> &levels):Advancement(levels){
    this->attribute = attribute ;
}