game2006/server/gameserver/skillhelper.cc

#include "precompile.h"

#include <a8/magicenum.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 "netdata.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_;

void SkillHelper::Init()
{
    auto fields = a8::GetEnumFields<MagicType_e>();
    for (auto& tuple : *fields){
        std::string name = std::get<0>(tuple);
        int val = std::get<1>(tuple);
        if (val > MAGIC_NONE && val < MAGIC_END) {
            std::vector<std::string> strings;
            a8::Split(name, strings, '_');
            int skill_id = a8::XValue(strings[1]);
            if (skill_id) {
                magic_skill_hash_[val] = skill_id;
                skill_magic_hash_[skill_id] = val;
            } else {
                abort();
            }
        }
    }
    magic_skill_hash_[MAGIC_60100_1_BOSS] = 60101;
    magic_skill_hash_[MAGIC_60100_2_BOSS] = 60111;
    magic_skill_hash_[MAGIC_60100_3_BOSS] = 60121;

    skill_magic_hash_[60101] = MAGIC_60100_1_BOSS;
    skill_magic_hash_[60111] = MAGIC_60100_2_BOSS;
    skill_magic_hash_[60121] = MAGIC_60100_3_BOSS;
}

void SkillHelper::GetMagicIdAndBaseSkillId(int skill_id, int& magic_id, int& base_skill_id)
{
    magic_id = 0;
    base_skill_id = skill_id;
    if (skill_magic_hash_.find(skill_id) != skill_magic_hash_.end()) {
        magic_id = skill_magic_hash_[skill_id];
        base_skill_id = skill_id;
        return;
    }
    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
    }
}

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 MYDEBUG
                {
                    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;
    }
}

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 MYDEBUG
            {
                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 MYDEBUG
            {
                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->resume() +
        skill_meta->_number_meta->resume_addition() * sender->GetBattleContext()->GetHeroTotalAtk();
    hp *= 1.0f + sender->GetBattleContext()->GetRecoverHpAdd();
    return hp;
}

int SkillHelper::GetYlzDamage(Creature* sender, Creature* target, const mt::Skill* skill_meta)
{
    float dmg =
        skill_meta->_number_meta->damage() +
        skill_meta->_number_meta->damage_addition() * sender->GetBattleContext()->GetHeroTotalAtk();
    return dmg;
}