game2006/server/gameserver/skillhelper.cc

#include "precompile.h"

#include "skillhelper.h"
#include "creature.h"
#include "buff.h"
#include "bullet.h"
#include "skill.h"
#include "room.h"
#include "roomobstacle.h"
#include "ability.h"
#include "battledatacontext.h"

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

std::map<int, int> SkillHelper::magic_skill_hash_;
std::map<int, int> SkillHelper::skill_magic_hash_;

static int GetMagicSkillId(int magic_id)
{
}

void SkillHelper::Init()
{
    for (int i = MAGIC_NONE; i < MAGIC_END; ++i) {
        if (i != 0) {
            int skill_id = GetMagicSkillId(i);
            if (skill_id) {
                magic_skill_hash_[i] = skill_id;
                skill_magic_hash_[skill_id] = i;
            } else {
                abort();
            }
        }
    }
}

void SkillHelper::GetMagicIdAndBaseSkillId(int skill_id, int& magic_id, int& base_skill_id)
{
    magic_id = 0;
    base_skill_id = 0;
    for (auto& pair : skill_magic_hash_) {
#if 1
        if (skill_id - pair.first >= 0 &&
            skill_id - pair.first < MAX_SKILL_LV) {
            magic_id = pair.second;
            base_skill_id = pair.first;
            break;
        }
#else
        if (std::abs(skill_id - pair.first) < MAX_SKILL_LV) {
            magic_id = pair.second;
            base_skill_id = pair.first;
            break;
        }
        if (std::abs(skill_id - pair.first - 10000) < MAX_SKILL_LV) {
            magic_id = pair.second;
            base_skill_id = pair.first + 10000;
            break;
        }
#endif
    }
}

int SkillHelper::GetCmxdDmg(Creature* c, const mt::Skill* skill_meta)
{
    float dmg =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 * c->GetBattleContext()->GetHeroTotalAtk());
    return dmg;
}

int SkillHelper::GetCmxdRange(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_int_range;
}

int SkillHelper::GetCmxdDistance(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_int_range2;
}

int SkillHelper::GetCmxdExplosion(const mt::Skill* skill_meta)
{
    return 7;
}

int SkillHelper::GetCmxdVertigoTime(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_time;
}

int SkillHelper::GetJshxHp(Creature* c, const mt::Skill* skill_meta)
{
    float hp =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 * c->GetBattleContext()->GetHeroTotalAtk()) *
        (1 + c->GetBattleContext()->GetExtRecoverHp());
    return hp;
}

int SkillHelper::GetSwzbRadius(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_range;
}

int SkillHelper::GetSwzbDmg(Creature* c, const mt::Skill* skill_meta)
{
    float finaly_dmg =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 * c->GetBattleContext()->GetHeroTotalAtk());
    return finaly_dmg;
}

int SkillHelper::GetSwzbEffect(const mt::Skill* skill_meta)
{
    return 9;
}

int SkillHelper::GetSwzbPullDistance(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_range2;
}

int SkillHelper::GetSwzbBuffId(const mt::Skill* skill_meta)
{
    return kVertigoEffectBuffId;
}

float SkillHelper::GetSwzbBuffTime(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_time;
}

void SkillHelper::ProcBulletHitBuff(IBullet* bullet, Creature* c, int buff_uniid)
{
    Buff* buff = c->GetBuffByUniId(buff_uniid);
    if (!buff) {
        return;
    }
    auto skill_meta = bullet->GetSkillMeta();
    if (!skill_meta) {
        return;
    }
    switch (skill_meta->GetMagicId()) {
    case MAGIC_20101_HL:
        {
            if (buff->meta->buff_effect() == kBET_Vertigo) {
                c->room->xtimer.ModifyTime
                    (buff->remover_timer,
                     skill_meta->_number_meta->_float_time * 1000 / FRAME_RATE_MS);
#ifdef DEBUG
                {
                    std::string dbg_msg = a8::Format
                        (
                         "skill_id:%d 眩晕时间%f",
                         {
                          skill_meta->skill_id(),
                          skill_meta->_number_meta->_float_time
                         });
                    bullet->GetSender().Get()->SendDebugMsg(dbg_msg);
                    a8::XPrintf("%s\n", {dbg_msg});
                }
#endif
            }
        }
        break;
    default:
        {
        }
        break;
    }
}

float SkillHelper::GetSjydhxRecoverHp(Creature* c, const mt::Skill* skill_meta)
{
    float hp =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 * c->GetBattleContext()->GetHeroTotalAtk()) *
        (1 + c->GetBattleContext()->GetExtRecoverHp());
#ifdef DEBUG
    {
        std::string dbg_msg = a8::Format
            (
             "skill_id:%d 瞬间移动回血 ratio:%f ratio2:%f human.atk:%f extRecoverHp:%f hp:%f",
             {
              skill_meta->skill_id(),
              skill_meta->_number_meta->_float_ratio,
              skill_meta->_number_meta->_float_ratio2,
              c->GetBattleContext()->GetHeroTotalAtk(),
              c->GetBattleContext()->GetExtRecoverHp(),
              hp
             });
        c->SendDebugMsg(dbg_msg);
        a8::XPrintf("%s\n", {dbg_msg});
    }
#endif
    return hp;
}

float SkillHelper::GetSjydhxForthDistance(const mt::Skill* skill_meta)
{
    return skill_meta && skill_meta->_number_meta ? skill_meta->_number_meta->_int_range : 0;
}

float SkillHelper::GetSjydhxBackTime(const mt::Skill* skill_meta)
{
    return skill_meta && skill_meta->_number_meta ? skill_meta->_number_meta->_float_time : 0;
}

int SkillHelper::GetYmczBuffTime(const mt::Skill* skill_meta)
{
    return skill_meta && skill_meta->_number_meta ? 3000 : 0;
}

int SkillHelper::GetYmczReserveDistance(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_range2;
}

float SkillHelper::GetYmczDmg(Creature* sender, Creature* target, const mt::Skill* skill_meta)
{
    float finaly_dmg =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 *
         sender->GetBattleContext()->GetHeroTotalAtk()) *
        (1 - target->GetBattleContext()->GetDef() / (target->GetBattleContext()->GetDef() + 400));
    return finaly_dmg;
}

bool SkillHelper::ProcBulletDmg(IBullet* bullet, Creature* target, float& finaly_dmg)
{
    finaly_dmg = 0.0f;
    const mt::Skill* skill_meta = bullet->GetSkillMeta();
    if (!skill_meta || !skill_meta->_number_meta) {
        return false;
    }
   switch (skill_meta->GetMagicId()) {
   case MAGIC_20101_HL:
   case MAGIC_20401_MAO:
        {
            finaly_dmg =
                (skill_meta->_number_meta->_float_ratio +
                 skill_meta->_number_meta->_float_ratio2 *
                 bullet->GetSender().Get()->GetBattleContext()->GetHeroTotalAtk()) *
                (1 - target->GetBattleContext()->GetDef() / (target->GetBattleContext()->GetDef() + 400));
#ifdef DEBUG
            {
                std::string dbg_msg = a8::Format
                    (
                     "skill_id:%d 子弹伤害 ratio:%f ratio2:%f huamn.atk:%f target.def:%f finaly_dmg:%f",
                     {
                      skill_meta->skill_id(),
                      skill_meta->_number_meta->_float_ratio,
                      skill_meta->_number_meta->_float_ratio2,
                          bullet->GetSender().Get()->GetBattleContext()->GetHeroTotalAtk(),
                      target->GetBattleContext()->GetDef(),
                      finaly_dmg
                     });
                bullet->GetSender().Get()->SendDebugMsg(dbg_msg);
                a8::XPrintf("%s\n", {dbg_msg});
            }
#endif
            return true;
        }
        break;
    default:
        {
        }
        break;
    }
    return false;
}

void SkillHelper::ProcSummonObstacle(const mt::Skill* skill_meta, RoomObstacle* ob)
{
    if (!skill_meta || skill_meta->_number_meta) {
        return;
    }
   switch (skill_meta->GetMagicId()) {
   case MAGIC_20601_DJS:
   case MAGIC_20301_XL:
        {
            if (!ob->life_time_timer.expired()) {
                ob->room->xtimer.ModifyTime(ob->life_time_timer,
                                            skill_meta->_number_meta->_float_time * 1000 / FRAME_RATE_MS);
#ifdef DEBUG
            {
                std::string dbg_msg = a8::Format
                    (
                     "skill_id:%d 持续时间:%f",
                     {
                      skill_meta->skill_id(),
                      skill_meta->_number_meta->_float_time
                     });
                ob->master.Get()->SendDebugMsg(dbg_msg);
                a8::XPrintf("%s\n", {dbg_msg});
            }
#endif
            }
        }
        break;
    default:
        {
        }
        break;
    }

}

int SkillHelper::GetYlzRange(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_range2;
}

int SkillHelper::GetYlzRecoverHp(Creature* sender, Creature* target, const mt::Skill* skill_meta)
{
    float hp =
        (skill_meta->_number_meta->_float_ratio +
         skill_meta->_number_meta->_float_ratio2 * sender->GetBattleContext()->GetHeroTotalAtk()) *
        (1 + target->GetBattleContext()->GetExtRecoverHp());
    return hp;
}

int SkillHelper::GetJyfhBuffId(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->buff_id();
}

float SkillHelper::GetJyfhBuffTime(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_time;
}

float SkillHelper::GetSsjsHpRate(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_ratio2;
}

float SkillHelper::GetSsjsTime(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_time;
}

float SkillHelper::GetSsjsProb(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_probability;
}

float SkillHelper::GetSsjsSpeedRate(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_speed;
}

float SkillHelper::GetMyxySpeedRate(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_speed;
}

float SkillHelper::GetMyxyAtkRate(const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_ratio;
}

float SkillHelper::GetLdfyHp(Creature* c, const mt::Skill* skill_meta)
{
    float hp = skill_meta->_number_meta->_float_ratio + skill_meta->_number_meta->_float_ratio2 * c->GetMaxHP();
    return hp;
}

float SkillHelper::GetLdfyBuffTime(Creature* c, const mt::Skill* skill_meta)
{
    return skill_meta->_number_meta->_float_time;
}