game2006/server/gameserver/skillhelper.cc

#include "precompile.h"

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

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

static int GetMagicSkillId(int magic_id)
{
    switch (magic_id) {
    case MAGIC_AXXF:
        {
            return 20101;
        }
        break;
    case MAGIC_SJYDHX:
        {
            return 20701;
        }
        break;
    case MAGIC_HLYZ:
        {
            return 20801;
        }
        break;
    case MAGIC_YMCZ:
        {
            return 20901;
        }
        break;
    case MAGIC_LDFY:
        {
            return 21001;
        }
        break;
    case MAGIC_HJHX:
        {
            return 20201;
        }
        break;
    case MAGIC_FG:
        {
            return 20401;
        }
        break;
    case MAGIC_WLFB:
        {
            return 20601;
        }
        break;
    case MAGIC_YLZ:
        {
            return 20301;
        }
        break;
    case MAGIC_YS:
        {
            return 20501;
        }
        break;

    case MAGIC_SJXY:
        {
            return 30101;
        }
        break;
    case MAGIC_SSJS:
        {
            return 30201;
        }
        break;
    case MAGIC_JSHX:
        {
            return 30301;
        }
        break;
    case MAGIC_SWZB:
        {
            return 30401;
        }
        break;
    case MAGIC_CMXD:
        {
            return 30501;
        }
        break;
    case MAGIC_MYXY:
        {
            return 30601;
        }
        break;
    case MAGIC_GZJS:
        {
            return 30701;
        }
        break;
    case MAGIC_JYFH:
        {
            return 30801;
        }
        break;
    case MAGIC_FH:
        {
            return 30901;
        }
        break;
    case MAGIC_YSHF:
        {
            return 31001;
        }
        break;

    default:
        {
            return 0;
        }
        break;
    }
}

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 (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;
        }
    }
}

int SkillHelper::GetCmxdDmg(Creature* c, const MetaData::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 MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->int_range;
}

int SkillHelper::GetCmxdDistance(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->int_range2;
}

int SkillHelper::GetCmxdExplosion(const MetaData::Skill* skill_meta)
{
    return 0;
}

int SkillHelper::GetJshxHp(Creature* c, const MetaData::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 MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_range;
}

int SkillHelper::GetSwzbDmg(Creature* c, const MetaData::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 MetaData::Skill* skill_meta)
{
    return 0;
}

int SkillHelper::GetSwzbPullDistance(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_range2;
}

int SkillHelper::GetSwzbBuffId(const MetaData::Skill* skill_meta)
{
    return kVertigoBuffId;
}

float SkillHelper::GetSwzbBuffTime(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_time;
}

void SkillHelper::ProcBulletHitBuff(Bullet* bullet, Creature* c, int buff_uniid)
{
    Buff* buff = c->GetBuffByUniId(buff_uniid);
    if (!buff) {
        return;
    }
    auto skill_meta = bullet->skill_meta;
    if (!skill_meta) {
        return;
    }
    switch (skill_meta->GetMagicId()) {
    case MAGIC_AXXF:
        {
            if (buff->meta->i->buff_effect() == kBET_Vertigo) {
                c->room->xtimer.ModifyTimer
                    (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->i->skill_id(),
                          skill_meta->number_meta->float_time
                         });
                    bullet->sender.Get()->SendDebugMsg(dbg_msg);
                    a8::XPrintf("%s\n", {dbg_msg});
                }
#endif
            }
        }
        break;
    default:
        {
        }
        break;
    }
}

float SkillHelper::GetSjydhxRecoverHp(Creature* c, const MetaData::Skill* skill_meta)
{
    float hp =
        (skill_meta->number_meta->float_ratio +
         skill_meta->number_meta->float_ratio * c->GetBattleContext()->GetHeroTotalAtk()) *
        (1 + c->GetBattleContext()->GetExtRecoverHp());
    return hp;
}

float SkillHelper::GetSjydhxForthDistance(const MetaData::Skill* skill_meta)
{
    return skill_meta && skill_meta->number_meta ? skill_meta->number_meta->int_range : 0;
}

float SkillHelper::GetSjydhxBackTime(const MetaData::Skill* skill_meta)
{
    return skill_meta && skill_meta->number_meta ? skill_meta->number_meta->float_time : 0;
}

int SkillHelper::GetYmczBuffTime(const MetaData::Skill* skill_meta)
{
    return 0;
}

int SkillHelper::GetYmczReserveDistance(const MetaData::Skill* skill_meta)
{
    return 0;
}

float SkillHelper::GetYmczDmg(Creature* sender, Creature* target, const MetaData::Skill* skill_meta)
{
    return 0;
}

bool SkillHelper::ProcBulletDmg(Bullet* bullet, Creature* target, float& finaly_dmg)
{
    finaly_dmg = 0.0f;
    MetaData::Skill* skill_meta = bullet->skill_meta;
    if (!skill_meta || skill_meta->number_meta) {
        return false;
    }
   switch (skill_meta->GetMagicId()) {
   case MAGIC_AXXF:
   case MAGIC_HLYZ:
   case MAGIC_FG:
        {
            finaly_dmg =
                (skill_meta->number_meta->float_ratio +
                 skill_meta->number_meta->float_ratio2 *
                 bullet->sender.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->i->skill_id(),
                      skill_meta->number_meta->float_ratio,
                      skill_meta->number_meta->float_ratio2,
                      bullet->sender.Get()->GetBattleContext()->GetHeroTotalAtk(),
                      target->GetBattleContext()->GetDef(),
                      finaly_dmg
                     });
                bullet->sender.Get()->SendDebugMsg(dbg_msg);
                a8::XPrintf("%s\n", {dbg_msg});
            }
#endif
            return true;
        }
        break;
    default:
        {
        }
        break;
    }
    return false;
}

void SkillHelper::ProcSummonObstacle(const MetaData::Skill* skill_meta, RoomObstacle* ob)
{
    if (!skill_meta || skill_meta->number_meta) {
        return;
    }
   switch (skill_meta->GetMagicId()) {
   case MAGIC_WLFB:
   case MAGIC_YLZ:
        {
            if (!ob->life_time_timer.expired()) {
                ob->room->xtimer.ModifyTimer(ob->life_time_timer,
                                            skill_meta->number_meta->float_time * 1000 / FRAME_RATE_MS);
            }
        }
        break;
    default:
        {
        }
        break;
    }

}

int SkillHelper::GetYlzRange(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_range2;
}

int SkillHelper::GetYlzRecoverHp(Creature* sender, Creature* target, const MetaData::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 MetaData::Skill* skill_meta)
{
    return 0;
}

float SkillHelper::GetJyfhBuffTime(const MetaData::Skill* skill_meta)
{
    return 0;
}

float SkillHelper::GetJyfhDmgRuduce(const MetaData::Skill* skill_meta)
{
    return 0;
}

float SkillHelper::GetSsjsHpRate(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_range2;
}

float SkillHelper::GetSsjsTime(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_time;
}

float SkillHelper::GetSsjsProb(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_probability;
}

float SkillHelper::GetSsjsSpeedRate(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_speed;
}

float SkillHelper::GetMyxySpeedRate(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_speed;
}

float SkillHelper::GetMyxyDefRate(const MetaData::Skill* skill_meta)
{
    return skill_meta->number_meta->float_ratio;
}