game2006/server/gameserver/ability.cc

#include "precompile.h"

#include "ability.h"
#include "buff.h"
#include "creature.h"

#include "mt/Equip.h"
#include "mt/Buff.h"

float Ability::GetAttrAbs(int attr_id)
{
    float attr_abs_val = GetBuffAttrAbs(attr_id);
    if (attr_id == kHAT_Atk || attr_id == kHAT_Def) {
        if (owner.Get()) {
        }
    }
    return attr_abs_val;
}

float Ability::GetAttrRate(int attr_id)
{
    float attr_rate_val = GetBuffAttrRate(attr_id) / 100.0f;
    return attr_rate_val;
}

float Ability::GetBuffAttrAbs(int attr_id)
{
    if (IsValidHumanAttr(attr_id)) {
        return buff_attr_abs_[attr_id];
    }
    return 0;
}

float Ability::GetBuffAttrRate(int attr_id)
{
    if (IsValidHumanAttr(attr_id)) {
        return buff_attr_rate_[attr_id];
    }
    return 0;
}

void Ability::Clear()
{
    buff_attr_abs_ = {};
    buff_attr_rate_ = {};
    buff_attr_flag_ = {};
}

float* Ability::GetBuffAttrAbsPtr(int attr_id)
{
    if (!IsValidHumanAttr(attr_id)) {
        return nullptr;
    }
    buff_attr_flag_[attr_id] = 1;
    return &buff_attr_abs_[attr_id];
}

float* Ability::GetBuffAttrRatePtr(int attr_id)
{
    if (!IsValidHumanAttr(attr_id)) {
        return nullptr;
    }
    buff_attr_flag_[attr_id] = 1;
    return &buff_attr_rate_[attr_id];
}

void Ability::AddSpeedAddition(float rate)
{
    speed_addition_rate_ += rate;
    ++speed_addition_times_;
}

void Ability::DelSpeedAddition(float rate)
{
    speed_addition_rate_ -= rate;
    speed_addition_rate_ = std::max(0.0f, speed_addition_rate_);
    --speed_addition_times_;
#ifdef DEBUG
    if (speed_addition_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetSpeedAddition()
{
    return speed_addition_rate_;
}

int Ability::GetSpeedAdditionTimes()
{
    return speed_addition_times_;
}

void Ability::AddDmgRuduce(float rate)
{
    dmg_ruduce_rate_ += rate;
    ++dmg_ruduce_times_;
}

void Ability::DelDmgRuduce(float rate)
{
    dmg_ruduce_rate_ -= rate;
    dmg_ruduce_rate_ = std::max(0.0f, dmg_ruduce_rate_);
    --dmg_ruduce_times_;
#ifdef DEBUG
    if (dmg_ruduce_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetDmgRuduce()
{
    return dmg_ruduce_rate_;
}

int Ability::GetDmgRuduceTimes()
{
    return dmg_ruduce_times_;
}

void Ability::AddDmgAddition(float rate)
{
    dmg_addition_rate_ += rate;
    ++dmg_addition_times_;
}

void Ability::DelDmgAddition(float rate)
{
    dmg_addition_rate_ -= rate;
    dmg_addition_rate_ = std::max(0.0f, dmg_addition_rate_);
    --dmg_addition_times_;
#ifdef DEBUG
    if (dmg_addition_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetDmgAddition()
{
    return dmg_addition_rate_;
}

int Ability::GetDmgAdditionTimes()
{
    return dmg_addition_times_;
}

void Ability::AddDefAddition(float rate)
{
    def_addition_rate_ += rate;
    ++def_addition_times_;
}

void Ability::DelDefAddition(float rate)
{
    def_addition_rate_ -= rate;
    def_addition_rate_ = std::max(0.0f, def_addition_rate_);
    --def_addition_times_;
#ifdef DEBUG
    if (def_addition_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetDefAddition()
{
    return def_addition_rate_;
}

int Ability::GetDefAdditionTimes()
{
    return def_addition_times_;
}

void Ability::AddAtkAddition(float rate)
{
    atk_addition_rate_ += rate;
    ++atk_addition_times_;
}

void Ability::DelAtkAddition(float rate)
{
    atk_addition_rate_ -= rate;
    atk_addition_rate_ = std::max(0.0f, atk_addition_rate_);
    --atk_addition_times_;
#ifdef DEBUG
    if (atk_addition_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetAtkAddition()
{
    return atk_addition_rate_;
}

int Ability::GetAtkAdditionTimes()
{
    return atk_addition_times_;
}

void Ability::IncImmuneTimes(int tag)
{
    auto itr = immune_tags_.find(tag);
    if (itr != immune_tags_.end()) {
        ++itr->second;
    } else {
        immune_tags_[tag] = 1;
    }
}

void Ability::DecImmuneTimes(int tag)
{
    auto itr = immune_tags_.find(tag);
    if (itr != immune_tags_.end()) {
        --itr->second;
        if (itr->second <= 0) {
            immune_tags_.erase(itr);
        }
    }
}

bool Ability::CanImmune(int tag)
{
    return immune_tags_.find(tag) != immune_tags_.end();
}

bool Ability::CanImmune(const std::set<int>& tags)
{
    if (!immune_tags_.empty()) {
        for (int tag : tags) {
            if (CanImmune(tag)) {
                return true;
            }
        }
    }
    return false;
}

void Ability::AddSpeedRuduce(float rate)
{
    speed_ruduce_rate_ += rate;
    ++speed_ruduce_times_;
}

void Ability::DelSpeedRuduce(float rate)
{
    speed_ruduce_rate_ -= rate;
    speed_ruduce_rate_ = std::max(0.0f, speed_ruduce_rate_);
    --speed_ruduce_times_;
    if (speed_ruduce_times_ <= 0) {
        speed_ruduce_rate_ = 0;
    }
#ifdef DEBUG
    if (speed_ruduce_times_ < 0) {
        abort();
    }
#endif
}

float Ability::GetSpeedRuduce()
{
#ifdef DEBUG1
    if (std::abs(speed_ruduce_rate_) > 0.001f && owner.Get() && owner.Get()->IsPlayer()) {
        a8::XPrintf("speed_ruduce_rate:%f speed_ruduce_times_:%d\n",
                    {
                        speed_ruduce_rate_,
                            speed_ruduce_times_
                    });
    }
#endif
    return speed_ruduce_rate_;
}

int Ability::GetSpeedRuduceTimes()
{
    return speed_ruduce_times_;
}

void Ability::IncDisableShotTimes()
{
    ++disable_shot_times_;
}

void Ability::DecDisableShotTimes()
{
    --disable_shot_times_;
    disable_shot_times_ = std::max(0, disable_shot_times_);
}

int Ability::GetDisableShotTimes()
{
    return disable_shot_times_;
}

void Ability::IncDisableUseSkillTimes()
{
    ++disable_useskill_times_;
}

void Ability::DecDisableUseSkillTimes()
{
    --disable_useskill_times_;
    disable_useskill_times_ = std::max(0, disable_useskill_times_);
}

int Ability::GetDisableUseSkillTimes()
{
    return disable_useskill_times_;
}

void Ability::SetFixedSpeed(float speed)
{
    fixed_speed_ = speed;
    ++fixed_speed_times_;
}

void Ability::UnSetFixedSpeed()
{
    fixed_speed_ = 0.0f;
    fixed_speed_times_ = 0;
}

int Ability::GetFixedSpeedTimes()
{
    return fixed_speed_times_;
}

float Ability::GetFixedSped()
{
    return fixed_speed_;
}

AttrAdditionHandle Ability::AddAttr(int attr_id, float rate)
{

}

void Ability::RemoveAttrAddition(AttrAdditionHandle handler)
{

}

AttrRuduceHandle Ability::DecAttr(int attr_id, float rate)
{

}

void Ability::RemoveAttrRuduce(AttrRuduceHandle handler)
{

}