game2006/server/gameserver/creature.cc

#include "precompile.h"

#include <float.h>

#include "creature.h"
#include "metamgr.h"
#include "room.h"
#include "skill.h"
#include "human.h"
#include "hero.h"
#include "collider.h"
#include "roomobstacle.h"
#include "trigger.h"
#include "car.h"
#include "bullet.h"
#include "skillhelper.h"
#include "shot.h"
#include "movehelper.h"
#include "config.h"

#include "f8/utils.h"

static int GetTraceTargetId(Creature* c)
{
    return 0;
}

Creature::Creature():MoveableEntity()
{
    weak_ptr_chunk_.Set(this);
    trigger_ = new Trigger(this);
    trigger_->Init();
    ability_ = std::make_shared<Ability>();
    ability_->owner = GetWeakPtrRef();
    weapons.reserve(MAX_WEAPON_NUM);
    for (size_t i = 0; i < MAX_WEAPON_NUM; ++i) {
        auto& weapon = a8::FastAppend(weapons);
        weapon.weapon_idx = i;
        weapon.weapon_id = 0;
        weapon.ammo = 0;
    }

    for (size_t i = 0; i < inventory_.size(); ++i) {
        inventory_[i].slot = i;
        inventory_[i].itemid = 0;
        inventory_[i].num = 0;
    }

    inventory_[IS_1XSCOPE].num = 1;
    move_helper_ = std::make_shared<MoveHelper>(this);
}

Creature::~Creature()
{
    xtimer_attacher.ClearTimerList();
    ClearBuffList();
    for (auto& pair : skill_hash_) {
        delete pair.second;
    }
    skill_hash_.clear();
    ClearPassiveSkill();
    trigger_->UnInit();
    A8_SAFE_DELETE(trigger_);
    room->grid_service->RemoveCreature(this);
}

bool Creature::HasBuffEffect(int buff_effect_id)
{
    return GetBuffByEffectId(buff_effect_id) != nullptr;
}

Buff* Creature::GetBuffByEffectId(int effect_id)
{
    if (!IsValidBuffEffect(effect_id)) {
        return nullptr;
    }
    list_head* list = &buff_effect_[effect_id];
    if (list_empty(list)) {
        return nullptr;
    } else {
        Buff* buff = list_first_entry(list, Buff, effect_entry);
        return buff;
    }
}

Buff* Creature::GetBuffById(int buff_id)
{
    for (Buff& buff : buff_list_) {
        if (buff.meta->pb->buff_id() == buff_id) {
            return &buff;
        }
    }
    return nullptr;
}

Buff* Creature::GetBuffByUniId(int buff_uniid)
{
    for (Buff& buff : buff_list_) {
        if (buff.buff_uniid == buff_uniid) {
            return &buff;
        }
    }
    return nullptr;
}

int Creature::GetBuffNum(int buff_id)
{
    int num = 0;
    for (Buff& buff : buff_list_) {
        if (buff.meta->pb->buff_id() == buff_id) {
            ++num;
        }
    }
    return num;
}

int Creature::AddBuff(Creature* caster,
                      MetaData::Buff* buff_meta,
                      MetaData::Skill* buff_skill_meta,
                      bool no_check_immune)
{
#if 999
    if (buff_meta->pb->buff_id() == 8042) {
        if (GetBuffById(buff_meta->pb->buff_id())) {
            return 0;
        }
    }
#endif
    if (buff_meta->only_spec_race) {
        if (!a8::HasBitFlag(buff_meta->only_spec_race, GetEntityType())) {
            return 0;
        }
    }
    if (buff_meta->exclude_spec_race) {
        if (a8::HasBitFlag(buff_meta->exclude_spec_race, GetEntityType())) {
            return 0;
        }
    }
    if (!buff_meta->tags.empty() && GetAbility()->CanImmune(buff_meta->tags)) {
        return 0;
    }
    if (buff_meta->pb->buff_interval() > 0) {
        if (buff_interval_hash_.find(buff_meta->pb->buff_id()) != buff_interval_hash_.end()) {
            return 0;
        }
        buff_interval_hash_[buff_meta->pb->buff_id()] = room->GetFrameNo();
        room->xtimer.SetTimeoutEx
            (
             buff_meta->pb->buff_interval() / FRAME_RATE_MS,
             [this, buff_meta] (int event, const a8::Args* args)
             {
                 if (a8::TIMER_EXEC_EVENT == event) {
                     buff_interval_hash_.erase(buff_meta->pb->buff_id());
                 }
             },
             &xtimer_attacher);
    }
    if (buff_meta->pb->coexist_num() > 0){
        if (GetBuffNum(buff_meta->pb->buff_id()) >= buff_meta->pb->coexist_num()) {
            return 0;
        }
    }
    if (buff_meta->pb->no_immune()) {
        no_check_immune = 1;
    }
    if (!no_check_immune && IsImmuneBuffEffect(buff_meta->pb->buff_effect())) {
        return 0;
    }
    if (buff_meta->pb->depend_effect() != 0 && !HasBuffEffect(buff_meta->pb->depend_effect())) {
        return 0;
    }
    if (!buff_meta->EffectCanStack()) {
        Buff* buff = GetBuffByEffectId(buff_meta->pb->buff_effect());
        if (buff) {
            RemoveBuffById(buff->meta->pb->buff_id());
        }
    }
    ++buff_uniid_;
    int new_buff_uniid = buff_uniid_;
    Buff* buff = &a8::FastAppend(buff_list_);
    buff->buff_uniid = new_buff_uniid;
    buff->SetCaster(caster);
    buff->owner = this;
    buff->meta = buff_meta;
    buff->skill_meta = buff_skill_meta;
    buff->add_frameno = room->GetFrameNo();
    buff->xtimer_attacher.SetOwner(&room->xtimer);
    buff->Init();
    buff->PreProcess();
    if (on_add_buff) {
        on_add_buff(buff);
    }
    if (buff->meta->pb->lock_move()) {
        IncDisableMoveTimes();
    }
    if (buff->meta->pb->lock_dir()) {
        IncDisableAttackDirTimes();
    }
    if (buff->meta->pb->disable_shot()) {
        GetAbility()->IncDisableShotTimes();
    }
    if (buff->meta->pb->disable_useskill()) {
        GetAbility()->IncDisableUseSkillTimes();
    }
    list_add_tail(&buff->effect_entry, &buff_effect_[buff->meta->pb->buff_effect()]);
    if (buff->meta->pb->depend_effect() != 0 &&
        IsValidBuffEffect(buff->meta->pb->depend_effect())) {
        list_add_tail(&buff->depend_entry, &depend_effect_[buff->meta->pb->depend_effect()]);
    }
    {
        buff->remover_timer = room->xtimer.SetTimeoutWpEx
            (
             buff_meta->pb->duration_time() * SERVER_FRAME_RATE,
             [buff] (int event, const a8::Args* args)
             {
                 if (a8::TIMER_EXEC_EVENT == event) {
                     buff->owner->RemoveBuffByUniId(buff->buff_uniid);
                 }
             },
             &buff->xtimer_attacher);
    }
    GetTrigger()->ActiveBuff(buff->meta);
#ifdef DEBUG
    if (!f8::IsTestEnv()) {
        if (!GetBuffByUniId(new_buff_uniid)) {
            abort();
        }
    }
#endif
    ProcBuffEffect(caster, buff);
#ifdef DEBUG
    if (!f8::IsTestEnv()) {
        if (!GetBuffByUniId(new_buff_uniid)) {
            abort();
        }
    }
#endif
    AddBuffPostProc(caster, buff);
#ifdef DEBUG
    if (!f8::IsTestEnv()) {
        if (!GetBuffByUniId(new_buff_uniid)) {
            abort();
        }
    }
#endif
    if (!buff->meta->pb->only_server()) {
        room->frame_event.AddBuff(GetWeakPtrRef(), buff);
    }
#ifdef DEBUG
    {
        SendDebugMsg(a8::Format("添加buff_id:%d effect:%d %s params:%d,%d,%d,%d,%d uniid:%d dur:%d",
                                {
                                    buff_meta->pb->buff_id(),
                                buff_meta->pb->buff_effect(),
                                 buff_meta->pb->name(),
                                 buff_meta->int_param1,
                                 buff_meta->int_param2,
                                 buff_meta->int_param3,
                                 buff_meta->int_param4,
                                 buff_meta->int_param5,
                                 buff->buff_uniid,
                                 room->xtimer.GetRemainTime(buff->remover_timer)
                                }));
    }
#endif
    if (!buff->meta->child_buff_list.empty()) {
        for (int child_buff_id : buff->meta->child_buff_list) {
            MetaData::Buff* child_buff_meta = MetaMgr::Instance()->GetBuff(child_buff_id);
            if (child_buff_meta) {
                AddBuff(caster, child_buff_meta, buff_skill_meta, true);
            }
        }
    }
    return new_buff_uniid;
}

bool Creature::IsImmuneBuffEffect(int buff_effect)
{
    for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
        if (itr->meta->IsImmuneBuffEffect(buff_effect)) {
            return true;
        }
    }
    return false;
}

int Creature::MustBeAddBuff(Creature* caster, int buff_id)
{
    MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
    if (!buff_meta) {
        A8_ABORT();
    }
    return AddBuff(caster, buff_meta);
}

int Creature::TryAddBuff(Creature* caster, int buff_id, MetaData::Skill* skill_meta)
{
    MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
    if (buff_meta) {
        return AddBuff(caster, buff_meta, skill_meta);
    }
    return 0;
}

int Creature::TryAddBuffAndSetTime(Creature* caster, int buff_id, int time, MetaData::Skill* skill_meta)
{
    int buff_uniid = TryAddBuff(caster, buff_id, skill_meta);
    if (buff_uniid) {
        Buff* buff = GetBuffByUniId(buff_uniid);
        room->xtimer.ModifyTime
            (buff->remover_timer,
             time / FRAME_RATE_MS);
    }
    return buff_uniid;
}

a8::XTimerWp Creature::TryDelayAddBuff(Creature* caster, int buff_id, int time,
                                                       DelayAddBuffHandle* handle)
{
    auto caster_wp = caster->GetWeakPtrRef();
    return room->xtimer.SetTimeoutWpEx
        (
         time / FRAME_RATE_MS,
         [this, caster_wp, buff_id, handle]
         (int event, const a8::Args* args) mutable
         {
             if (a8::TIMER_EXEC_EVENT == event) {
                 if (caster_wp.Get() && !caster_wp.Get()->IsDead(caster_wp.Get()->room)) {
                     if (handle && handle->pre_add_cb) {
                         handle->pre_add_cb(this);
                     }
                     int buff_uniid = TryAddBuff(caster_wp.Get(), buff_id);
                     if (handle && handle->post_add_cb) {
                         handle->post_add_cb(this, buff_uniid);
                     }
                 }
             } else if (a8::TIMER_DELETE_EVENT == event) {
                 if (handle) {
                     delete handle;
                 }
             }
         },
         &xtimer_attacher);
}

int Creature::TryAddBuffWithTarget(Creature* caster, int buff_id)
{
    MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
    if (buff_meta) {
        bool be_add = false;
        switch (buff_meta->pb->buff_target()) {
        case kBuffTargetSelf:
            {
                be_add = caster == this;
            }
            break;
        case kBuffTargetFriendly:
            {
                team_id == caster->team_id;
            }
            break;
        case kBuffTargetEnemy:
            {
                team_id != caster->team_id;
            }
            break;
        default:
            {
            }
            break;
        }
        return TryAddBuff(caster, buff_id);
    }
    return -1;
}

void Creature::RemoveBuffById(int buff_id)
{
    int buff_uniid = 0;
    for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
        Buff& buff = *itr;
        if (buff.meta->pb->buff_id() == buff_id) {
            buff_uniid = buff.buff_uniid;
            break;
        }
    }
    if (buff_uniid != 0) {
        RemoveBuffByUniId(buff_uniid);
    }
}

void Creature::RemoveBuffByUniId(int buff_uniid)
{
    int buff_id = 0;
    std::vector<std::tuple<MetaData::Buff*, Creature*>> removed_buffs;
    for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
        Buff& buff = *itr;
        if (buff.buff_uniid == buff_uniid) {
            buff_id = buff.meta->pb->buff_id();
            removed_buffs.push_back(std::make_tuple(buff.meta, buff.GetCaster().Get()));
            OnBuffRemove(buff);
            buff.UnInit();
            buff_list_.erase(itr);
            break;
        }
    }
    for (auto& tuple1 : removed_buffs) {
        MetaData::Buff* buff_meta = std::get<0>(tuple1);
        Creature* caster = std::get<1>(tuple1);

        for (int child_buff_id : buff_meta->child_buff_list) {
            RemoveBuffById(child_buff_id);
        }

        if (!HasBuffEffect(buff_meta->pb->buff_effect()) &&
            !list_empty(&depend_effect_[buff_meta->pb->buff_effect()])) {
            struct list_head work_list;
            list_replace_init(&depend_effect_[buff_meta->pb->buff_effect()], &work_list);
            while (!list_empty(&work_list)) {
                Buff* buff = list_first_entry(&work_list, Buff, depend_entry);
                RemoveBuffById(buff->meta->pb->buff_id());
            }
        }
        GetTrigger()->DeactiveBuff(buff_meta);

#ifdef DEBUG
        {
            SendDebugMsg(a8::Format("移除buff_id:%d uniid:%d",
                                    {
                                     buff_id,
                                     buff_uniid
                                    }));
        }
#endif

        for (const auto& tuple : buff_meta->post_remove_action) {
            switch (std::get<0>(tuple)) {
            case kRemoveBuffByIdAction:
                {
                    for (int buff_id :std::get<1>(tuple)) {
                        RemoveBuffById(buff_id);
                    }
                }
                break;
            case kRemoveBuffByEffectAction:
                {
                    for (int buff_effect :std::get<1>(tuple)) {
                        RemoveBuffByEffectId(buff_effect);
                    }
                }
                break;
            case kAddBuffAction:
                {
                    for (int buff_id :std::get<1>(tuple)) {
                        TryAddBuff(caster, buff_id);
                    }
                }
                break;
            default:
                break;
            }
        }
    }
    RecalcBuffAttr();
}

void Creature::ClearBuffById(int buff_id)
{
    while (GetBuffById(buff_id)) {
        RemoveBuffById(buff_id);
    }
}

void Creature::SendDebugMsg(const std::string& debug_msg)
{

}

void Creature::AddBuffPostProc(Creature* caster, Buff* buff)
{

}

void Creature::RecalcBuffAttr()
{
    CheckAbilityUsed();
    ability_->Clear();
    bool need_refresh_hp = false;
    for (auto& buff : buff_list_) {
        if (buff.meta->pb->buff_effect() == kBET_ChgAttr ||
            buff.meta->pb->buff_effect() == kBET_Car ||
            buff.meta->pb->buff_effect() == kBET_CrazyMode) {
            int attr_type = (int)buff.meta->param1;
            int calc_type = (int)buff.meta->param2;
            if (IsValidHumanAttr(attr_type)) {
                if (calc_type == 1) {
                    float* p = ability_->GetBuffAttrAbsPtr(attr_type);
                    if (p) {
                        *p += buff.meta->param3;
                    }
                } else if (calc_type == 2) {
                    float* p = ability_->GetBuffAttrRatePtr(attr_type);
                    if (p) {
                        *p += buff.meta->param3;
                    }
                }
            }
            if (buff.add_frameno == room->GetFrameNo() &&
                attr_type == kHAT_MaxHp) {
                need_refresh_hp = true;
            }
        }
    }
    for (auto& tuple : talent_list) {
        auto talent_meta = MetaMgr::Instance()->GetTalent(std::get<0>(tuple), std::get<1>(tuple));
        if (talent_meta) {
            for (auto& tuple1 : talent_meta->addattr) {
                int attr_type = std::get<0>(tuple1);
                int attr_val = std::get<1>(tuple1);
                if (talent_meta->pb->addtype() == 0) {
                    float* p = ability_->GetBuffAttrAbsPtr(attr_type);
                    if (p) {
                        *p += attr_val;
                    }
                } else if (talent_meta->pb->addtype() == 1) {
                    float* p = ability_->GetBuffAttrRatePtr(attr_type);
                    if (p) {
                        *p += attr_val;
                    }
                }
            }
        }
    }
    if (need_refresh_hp) {
        SetHP(GetMaxHP());
        GetTrigger()->HpChg();
#if 1
        {
            //666
            MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
        }
#endif

    }
#if 0
    //666
    if (IsHuman()) {
        MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
    }
#endif
}

void Creature::OnBuffRemove(Buff& buff)
{
    if (buff.meta->pb->lock_move()) {
        DecDisableMoveTimes();
    }
    if (buff.meta->pb->lock_dir()) {
        DecDisableAttackDirTimes();
    }
    if (buff.meta->pb->disable_shot()) {
        GetAbility()->DecDisableShotTimes();
    }
    if (buff.meta->pb->disable_useskill()) {
        GetAbility()->DecDisableUseSkillTimes();
    }
#if 999
    if (buff.meta->pb->buff_id() == 8042) {
        if (GetAbility()->GetSpeedRuduceTimes() > 0) {
            GetAbility()->DelSpeedRuduce(-buff.meta->param3/100.0f);
        }
#ifdef DEBUG
        {
            a8::XPrintf("移除减速%f\nad", {buff.meta->param3});
        }
#endif
    }
#endif
    switch (buff.meta->pb->buff_effect()) {
    case kBET_OnceChgAttr:
        {
            buff.ProcRemoveOnceChgAttr();
        }
        break;
    case kBET_Sprint:
        {
            if (buff.meta->int_param5) {
                DecDisableMoveDirTimes();
            }
        }
        break;
    case kBET_HoldShield:
        {
            buff.ProcRemoveHoldShield();
        }
        break;
    case kBET_Hide:
        {
            buff.ProcRemoveHide();
        }
        break;
    case kBET_BePull:
        {
            int i = 0;
        }
        break;
    case kBET_Rescuer:
        {
            buff.ProcRemoveRescuer();
        }
        break;
    case kBET_Immune:
        {
            buff.ProcRemoveImmune();
        }
        break;
    case kBET_CallFunc:
        {
            buff.ProcRemoveCallFunc();
        }
        break;
    default:
        {
        }
        break;
    }
    if (!buff.meta->pb->only_server()) {
        room->frame_event.RemoveBuff(GetWeakPtrRef(), &buff);
    }
}

void Creature::RemoveBuffByEffectId(int buff_effect_id)
{
    Buff* buff = GetBuffByEffectId(buff_effect_id);
    while (buff) {
        RemoveBuffById(buff->meta->pb->buff_id());
        buff = GetBuffByEffectId(buff_effect_id);
    }
}

void Creature::ClearBuffList()
{
    for (auto itr = buff_list_.begin(); itr != buff_list_.end(); ++itr) {
        list_del_init(&itr->effect_entry);
        OnBuffRemove(*itr);
    }
    buff_list_.clear();
    buff_effect_ = {};
    RecalcBuffAttr();
}

void Creature::FillBuffList(Human* hum, ::google::protobuf::RepeatedPtrField<::cs::MFBuff>* pb_buff_list)
{
    for (auto& itr : buff_list_) {
        if (itr.NeedSync(hum)) {
            auto buff = pb_buff_list->Add();
            itr.FillMFBuff(buff);
        }
    }
}

void Creature::FillSkillList(::google::protobuf::RepeatedPtrField< cs::MFSkill >*
                             pb_skill_list)
{
    for (auto& pair : skill_hash_) {
        auto skill = pb_skill_list->Add();
        pair.second->FillMFSkill(skill);
    }
}

void Creature::AddPassiveSkill(int skill_id)
{
    MetaData::Skill* skill_meta = MetaMgr::Instance()->GetSkill(skill_id);
    if (skill_meta && !GetPassiveSkill(skill_meta->pb->skill_id())) {
        Skill* skill = new Skill;
        skill->owner = this;
        skill->meta = skill_meta;
        skill->xtimer_attacher.SetOwner(&room->xtimer);
        room->xtimer.SetIntervalEx
            (
             SERVER_FRAME_RATE * skill_meta->pb->skill_cd(),
             [this, skill_id] (int event, const a8::Args* args)
             {
                 if (a8::TIMER_EXEC_EVENT == event) {
                     Skill* skill = GetPassiveSkill(skill_id);
                     if (skill) {
                     }
                 }
             },
             &skill->xtimer_attacher);
        skill->Initialzie();
        passive_skill_hash_[skill_meta->pb->skill_id()] = skill;
    }
}

void Creature::RemovePassiveSkill(int skill_id)
{
    auto itr = passive_skill_hash_.find(skill_id);
    if (itr != passive_skill_hash_.end()) {
        delete itr->second;
        passive_skill_hash_.erase(itr);
    }
}

void Creature::ClearPassiveSkill()
{
    std::vector<int> del_skills;
    del_skills.reserve(passive_skill_hash_.size());
    for (auto& pair : passive_skill_hash_) {
        del_skills.push_back(pair.first);
    }
    for (int skill_id : del_skills) {
        RemovePassiveSkill(skill_id);
    }
}

Skill* Creature::GetPassiveSkill(int skill_id)
{
    auto itr = passive_skill_hash_.find(skill_id);
    return itr != passive_skill_hash_.end() ? itr->second : nullptr;
}

void Creature::TriggerBuff(Skill* skill, std::set<Creature*>& target_list, BuffTriggerType_e trigger_type)
{
    for (Creature* entity : target_list) {
        TriggerOneObjectBuff(skill, entity, trigger_type);
    }
    if (trigger_type == kBTT_UseSkill && !dead) {
        auto itr = skill->meta->trigger_type_buffs.find(trigger_type);
        if (itr != skill->meta->trigger_type_buffs.end()) {
            for (MetaData::Buff* buff_meta : itr->second) {
                switch (buff_meta->pb->buff_target()) {
                case kBuffTargetSelf: //自己
                    {
                        AddBuff(this, buff_meta, skill->meta);
                    }
                    break;
                }
            }
        }
    }
}

void Creature::TriggerOneObjectBuff(Skill* skill, Creature* target, BuffTriggerType_e trigger_type)
{
    if (target->dead) {
        return;
    }
    auto itr = skill->meta->trigger_type_buffs.find(trigger_type);
    if (itr != skill->meta->trigger_type_buffs.end()) {
        for (MetaData::Buff* buff_meta : itr->second) {
            switch (buff_meta->pb->buff_target()) {
            case kBuffTargetSelf: //自己
                {
                    if (target == this && trigger_type != kBTT_UseSkill) {
                        target->AddBuff(this, buff_meta, skill->meta);
                    }
                }
                break;
            case kBuffTargetFriendly: //友军
                {
                    if (target->team_id == team_id) {
                        target->AddBuff(this, buff_meta, skill->meta);
                    }
                }
                break;
            case kBuffTargetEnemy: //敌军
                {
                    if (target->team_id != team_id) {
                        target->AddBuff(this, buff_meta, skill->meta);
                    }
                }
                break;
            default:
                {
                }
                break;
            }
        }
    }
}

Skill* Creature::GetSkill(int skill_id)
{
    auto itr = skill_hash_.find(skill_id);
    return itr != skill_hash_.end() ? itr->second : nullptr;
}

bool Creature::CanUseSkill(int skill_id)
{
    Skill* skill = GetSkill(skill_id);
    if (!skill) {
        return false;
    }
    if (GetAbility()->GetDisableUseSkillTimes() > 0) {
        return false;
    }
    if (room->GetGasData().GetGasMode() == GasInactive &&
        !Config::Instance()->prebattle_can_use_skill) {
        return false;
    }
    if (HasBuffEffect(kBET_Vertigo) ||
        HasBuffEffect(kBET_Jump) ||
        HasBuffEffect(kBET_Fly) ||
        HasBuffEffect(kBET_MachineGun) ||
        HasBuffEffect(kBET_Sprint)) {
        return false;
    }
    if (skill->force_use_times > 0) {
        --skill->force_use_times;
        return true;
    }
    if (dead) {
        return false;
    }
    if (playing_skill) {
        return false;
    }
    if (IsHuman() && AsHuman()->downed) {
        return false;
    }
    return skill->GetCurrTimes() > 0 || skill->GetMinorType() != SMT_NONE;
}

void Creature::DoSkill(int skill_id,
                       int target_id,
                       const a8::Vec2& skill_dir,
                       float skill_distance,
                       const Position& target_pos)
{
    Skill* skill = GetSkill(skill_id);
    if (skill && CanUseSkill(skill_id)) {
        if (skill->GetMinorType()) {
            skill->DoMinorMode();
            return;
        }
        if (skill->meta->pb->attack_dir_lock_time()) {
            SetAttackDir(skill_dir);
            IncDisableAttackDirTimes();
            room->xtimer.SetTimeoutEx
                (
                 skill->meta->pb->attack_dir_lock_time() / FRAME_RATE_MS,
                 [this] (int event, const a8::Args* args)
                 {
                     if (a8::TIMER_EXEC_EVENT == event) {
                         DecDisableAttackDirTimes();
                     }
                 },
                 &xtimer_attacher);
        }
        DoSkillPreProc(skill_id, target_id, target_pos);
        ResetSkill();
        skill_target_id_ = target_id;
        // 999
        #if 1
        #else
        skill_target_pos_ = target_pos;
        #endif
        skill_dir_ = skill_dir;
        skill_distance_ = skill_distance;
        curr_skill_ = skill;
        playing_skill = true;
        context_dir = skill_dir_;
        // 999
        #if 1
        #else
        context_pos = GetPos() + skill_dir_ * skill_distance_;
        #endif
        CurrentSkill()->last_use_frameno = room->GetFrameNo();
        skill->LockCastPhase();
        if (CurrentSkill()->meta->pb->skill_target() == kST_Self
            ) {
            skill_target_id_ = GetUniId();
        }
        if (CurrentSkill()->meta->pb->skill_target() == kST_SpecDir) {
            std::set<Creature*> target_list;
            SelectSkillTargets(CurrentSkill(), GetPos(), target_list);
            TriggerBuff(CurrentSkill(), target_list, kBTT_UseSkill);
            if (!CurrentSkill()->meta->phases.empty() &&
                CurrentSkill()->meta->phases[0].time_offset <= 0) {
                UpdateSkill();
            }
        } else {
            if (skill_target_id_ == 0) {
                if (CurrentSkill()->meta->pb->skill_target() == kST_FriendlyIncludeSelf ||
                    CurrentSkill()->meta->pb->skill_target() == kST_FriendlyExcludeSelf) {
                    skill_target_id_ = GetUniId();
                }
            }
            Entity* entity = room->GetEntityByUniId(skill_target_id_);
            if (entity && entity->IsCreature(room)) {
                Creature* c = (Creature*)entity;
                std::set<Creature*> target_list;
                skill_target_pos_ = c->GetPos();
                SelectSkillTargets(CurrentSkill(), c->GetPos(), target_list);
                if (!CurrentSkill()->meta->phases.empty() &&
                    CurrentSkill()->meta->phases[0].time_offset <= 0) {
                    if (CurrentSkill()->meta->phases[0].func_id == kSkill_HoldShield) {
                        if (HasBuffEffect(kBET_HoldShield)) {
                            RemoveBuffByEffectId(kBET_HoldShield);
                            playing_skill = false;
                        } else {
                            UpdateSkill();
                        }
                    } else {
                        TriggerBuff(CurrentSkill(), target_list, kBTT_UseSkill);
                        UpdateSkill();
                    }
                } else {
                    TriggerBuff(CurrentSkill(), target_list, kBTT_UseSkill);
                }
            } else {
                std::set<Creature*> target_list;
                SelectSkillTargets(CurrentSkill(), GetPos(), target_list);
                TriggerBuff(CurrentSkill(), target_list, kBTT_UseSkill);
                if (!CurrentSkill()->meta->phases.empty() &&
                    CurrentSkill()->meta->phases[0].func_id == kSkill_Shot) {
                    playing_skill = true;
                } else {
                    playing_skill = false;
                }
            }
        }
        if (HasBuffEffect(kBET_Camouflage)) {
            RemoveBuffByEffectId(kBET_Camouflage);
        }
        GetTrigger()->UseSkill(skill);
        DoSkillPostProc(true, skill_id, target_id, target_pos);
        if (IsHuman()) {
            ++AsHuman()->stats.use_skill_times;
        }
#if 0
        if (skill_id != TURN_OVER_SKILL_ID) {
#else
            {
#endif
            CreatureWeakPtr ptr;
            ptr.Attach(this);
            room->frame_event.AddPlaySkill(ptr, skill_id);
        }
    }
}

void Creature::DoSkillPreProc(int skill_id, int target_id, const Position& target_pos)
{
}

void Creature::DoSkillPostProc(bool used, int skill_id, int target_id, const Position& target_pos)
{
}

void Creature::ResetSkill()
{
    curr_skill_ = nullptr;
    curr_skill_phase = 0;
    skill_dir_ = a8::Vec2();
    skill_target_pos_ = Position();
    skill_param1 = 0.0f;
    playing_skill = false;
}

void Creature::UpdateSkill()
{
    if (CurrentSkill() && !dead) {
        if (curr_skill_phase < CurrentSkill()->meta->phases.size()) {
            MetaData::SkillPhase* phase = &CurrentSkill()->meta->phases[curr_skill_phase];
            if (phase->time_offset <= CurrentSkill()->GetPassedTime()) {
                ProcSkillPhase(phase);
                ++curr_skill_phase;
            }
        } else {
            playing_skill = false;
        }
    } else {
        playing_skill = false;
    }
}

void Creature::ProcSkillPhase(MetaData::SkillPhase* phase)
{
    switch (phase->func_id) {
    case kSkill_TurnOver:
        {
        }
        break;
    case kSkill_JumpTo:
        {

        }
        break;
    case kSkill_Shot:
        {
            MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip(phase->param1.GetInt());
            if (weapon_meta) {
                MetaData::Equip* bullet_meta =
                    MetaMgr::Instance()->GetEquip(weapon_meta->pb->use_bullet());
                if (CurrentSkill()->meta->pb->skill_target() == kST_SpecDir) {
                    if (std::abs(skill_dir_.x) > FLT_EPSILON ||
                        std::abs(skill_dir_.y) > FLT_EPSILON) {
                        float target_distance = 5;
                        if (CurrentSkill()->meta->GetMagicId() == MAGIC_FG) {
                            target_distance = CurrentSkill()->meta->number_meta->float_range;
                        }
                        if (weapon_meta->pb->equip_type() == EQUIP_TYPE_THROW &&
                            weapon_meta->pb->equip_subtype() == THROW_EQUIP_TYPE_ADD_BUFF) {
                            target_distance = skill_distance_;
                            auto context_pos_p = context_pos;
                            room->xtimer.SetTimeoutEx
                                (
                                 (target_distance / weapon_meta->pb->bullet_speed() + 1.5) * 1000.0f / FRAME_RATE_MS,
                                 [this, context_pos_p, weapon_meta]
                                 (int event, const a8::Args* args)
                                 {
                                     if (a8::TIMER_EXEC_EVENT == event) {
                                         Position new_context_pos;
                                         new_context_pos.x = context_pos_p.x;
                                         new_context_pos.y = context_pos_p.y;
                                         Position old_context_pos = context_pos;
                                         context_pos = new_context_pos;
                                         TryAddBuff(this, weapon_meta->int_param1,
                                                    CurrentSkill() ? CurrentSkill()->meta : nullptr);
                                         context_pos = old_context_pos;
                                     }
                                 },
                                 &xtimer_attacher);
                        }
                        if (CurrentSkill()->meta->GetMagicId() == MAGIC_YLZ) {
                            target_distance = std::max(0.0001f, target_distance);
                        }
                        if (bullet_meta && target_distance > 0.00001f) {
                            int target_id = 0;
                            if (CurrentSkill()->meta->GetMagicId() == MAGIC_HJHX) {
                                target_distance = 0;
                                TryAddBuff(this, 202013);
                                TryAddBuff(this, 202014);
                                target_id = GetTraceTargetId(this);

                            }
                            a8::Vec2 old_attack_dir = GetAttackDir();
                            a8::Vec2 attack_dir = skill_dir_;
                            attack_dir.Normalize();
                            SetAttackDir(attack_dir);
                            InternalShot
                                (
                                 this,
                                 weapon_meta,
                                 bullet_meta,
                                 CurrentSkill() ? CurrentSkill()->meta : nullptr,
                                 target_distance,
                                 0,
                                 0);
#if 0
                            SetAttackDir(old_attack_dir);
#endif
                        }
                    }
                } else {
                    Entity* entity = room->GetEntityByUniId(skill_target_id_);
                    if (entity) {
                        float target_distance = entity->GetPos().Distance2D2(GetPos());
                        if (bullet_meta && target_distance > 0.00001f) {
                            if (CurrentSkill()->meta->GetMagicId() == MAGIC_HJHX) {
                                TryAddBuff(this, 202013);
                                TryAddBuff(this, 202014);
                            }
                            a8::Vec2 old_attack_dir = GetAttackDir();
                            a8::Vec2 attack_dir = GetPos().CalcDir2D(entity->GetPos());
                            attack_dir.Normalize();
                            SetAttackDir(attack_dir);
                            InternalShot
                                (
                                 this,
                                 weapon_meta,
                                 bullet_meta,
                                 CurrentSkill() ? CurrentSkill()->meta : nullptr,
                                 target_distance,
                                 0,
                                 0);
#if 0
                            SetAttackDir(old_attack_dir);
#endif
                        }
                    }
                }
            }
        }
        break;
    case kSkill_Pull:
        {

        }
        break;
    case kSkill_HoldShield:
        {
        }
        break;
    case kSkill_ForthBackJump:
        {
            a8::Vec2 old_dir = GetMoveDir();
            Position old_pos = GetPos();
            if (CurrentSkill()->GetMinorType() == SMT_NONE) {
                int buff_id1 = phase->param3_ints.size() > 0 ? phase->param3_ints[0] : 0;
                int buff_id2 = phase->param3_ints.size() > 1 ? phase->param3_ints[1] : 0;
                int buff_id3 = phase->param3_ints.size() > 2 ? phase->param3_ints[2] : 0;
                MetaData::Skill* skill_meta = CurrentSkill()->meta;
                TryAddBuff(this, buff_id1);
                int land_effect_buff_uniid = TryAddBuffAndSetTime
                    (this,
                     buff_id3,
                     skill_meta->number_meta->float_time * 1000);
#ifdef DEBUG
                a8::XPrintf("old_pos:%f,%f\n", {GetPos().x, GetPos().y});
#endif
                #if 1
                _UpdateMove(SkillHelper::GetSjydhxForthDistance(CurrentSkill()->meta));
                #else
                _UpdateMove(phase->param1.GetInt());
                #endif
                float recover_hp = SkillHelper::GetSjydhxRecoverHp(this, CurrentSkill()->meta);
                AddHp(recover_hp);
                a8::Vec2 pre_dir = old_dir;
                Position pre_pos = old_pos;
#ifdef DEBUG
                a8::XPrintf("new_pos:%f,%f", {GetPos().x, GetPos().y});
#endif
                CurrentSkill()->AddMinorMode
                    (
                     SMT_BLINK,
#if 1
                     skill_meta->number_meta->float_time * 1000,
#else
                     phase->param2.GetInt() * 1000,
#endif
                     [this, pre_pos, pre_dir, buff_id1, buff_id2, buff_id3, land_effect_buff_uniid,
                      skill_meta] () {
                         a8::Vec2 old_dir = GetMoveDir();
                         Position old_pos = GetPos();
                         float distance = GetPos().Distance2D2(pre_pos);
                         RemoveBuffByUniId(land_effect_buff_uniid);
                         if (distance > 0.0001f) {
                             a8::Vec2 new_dir = GetPos().CalcDir2D(pre_pos);
                             new_dir.Normalize();
                             SetMoveDir(new_dir);
                             TryAddBuff(this, buff_id2);
                             _UpdateMove(distance);
                         }
                         SetMoveDir(old_dir);
                         TryAddBuffAndSetTime(this,
                                              skill_meta->number_meta->pb->buff_id(),
                                              skill_meta->number_meta->pb->buff_time() * 1000,
                                              skill_meta);
                     }
                     );
            }
            SetMoveDir(old_dir);
        }
        break;
    default:
        {
        }
        break;
    }
}

MetaData::SkillPhase* Creature::GetCurrSkillPhase()
{
    return curr_skill_phase < CurrentSkill()->meta->phases.size() ?
        &CurrentSkill()->meta->phases[curr_skill_phase] : nullptr;
}

Skill* Creature::CurrentSkill()
{
    return curr_skill_;
}

void Creature::ActiveAllSkill()
{
    for (auto& pair : skill_hash_) {
        pair.second->Accelerate(-10000000);
    }
}

void Creature::ProcBuffEffect(Creature* caster, Buff* buff)
{
#ifdef DEBUG
    if (IsPlayer()) {
        if (buff->meta->pb->buff_effect() == kBET_Vertigo) {
            int i = 0;
        }
    }
#endif
#if 999
    if (buff->meta->pb->buff_id() == 8042) {
#ifdef DEBUG
        {
            a8::XPrintf("添加减速%f", {buff->meta->param3});
        }
#endif
        if (GetAbility()->GetSpeedRuduceTimes() <= 0) {
            GetAbility()->AddSpeedRuduce(-buff->meta->param3/100.0f);
        }
    }
#endif
    MetaData::Buff* buff_meta = buff->meta;
    switch (buff->meta->pb->buff_effect()) {
    case kBET_ChgAttr:
    case kBET_Car:
    case kBET_CrazyMode:
        {
            RecalcBuffAttr();
            if (buff->meta->pb->buff_effect() == kBET_Car) {
                RecalcSelfCollider();
                MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(buff->meta->param4);
                if (equip_meta &&
                    equip_meta->pb->equip_type() == EQUIP_TYPE_CAR &&
                    equip_meta->pb->equip_subtype() == 1
                    ) {
                    MetaData::Equip* spec_weapon_meta = MetaMgr::Instance()->GetEquip(equip_meta->int_param1);
                    if (spec_weapon_meta) {
                        second_weapon.weapon_idx = 100;
                        second_weapon.weapon_id = spec_weapon_meta->pb->id();
                        second_weapon.meta = spec_weapon_meta;
                        second_weapon.Recalc();
                        second_weapon.ammo = second_weapon.GetClipVolume(this);
                    }
                }
            }
        }
        break;
    case kBET_TurnOver:
        {
            buff->ProcTurnOver();
        }
        break;
    case kBET_Camouflage:
        {
            if (aiming) {
                aiming = false;
            }
            if (action_type != AT_None) {
                CancelAction();
            }
            if (IsHuman()) {
                ++AsHuman()->stats.use_camouflage_times;
            }
        }
        break;
    case kBET_BePull:
        {
            if (caster == this) {
                A8_ABORT();
            }
            if (caster->GetEntitySubType() == EST_Android) {
                float target_distance = caster->GetPos().Distance2D2(GetPos());
                if (target_distance <= 0.000001f) {
                    SetPos(caster->GetPos());
                    target_pos = caster->GetPos();
                } else {
                    if (target_distance <= buff->meta->param3) {
                        SetPos(caster->GetPos());
                        target_pos = caster->GetPos();
                    } else {
                        a8::Vec2 move_dir = GetPos().CalcDir2D(caster->GetPos());
                        move_dir.Normalize();
                        SetMoveDir(move_dir);
                        // 999
                        #if 1
                        #else
                        target_pos  = GetPos() + GetMoveDir() * (target_distance - buff->meta->param3);
                        #endif
                    }
                }
            } else {
                caster->skill_dir_.Normalize();
                // 999
                #if 1
                #else
                target_pos = caster->GetPos() + caster->skill_dir_ * caster->skill_distance_;
                #endif
                a8::Vec2 move_dir = GetPos().CalcDir2D(target_pos);
                move_dir.Normalize();
                SetMoveDir(move_dir);
            }
        }
        break;
    case kBET_JumpTo:
        {
            Entity* entity = room->GetEntityByUniId(skill_target_id_);
            if (entity) {
                float target_distance = entity->GetPos().Distance2D2(GetPos());
                if (target_distance <= 0.000001f) {
                    SetPos(entity->GetPos());
                    skill_target_pos_ = entity->GetPos();
                } else {
                    if (target_distance <= buff->meta->param3) {
                        SetPos(entity->GetPos());
                        skill_target_pos_ = entity->GetPos();
                    } else {
                        a8::Vec2 move_dir = GetPos().CalcDir2D(entity->GetPos());
                        move_dir.Normalize();
                        SetMoveDir(move_dir);
                        skill_dir_ = GetMoveDir();
                        // 999
                        #if 1
                        #else
                        skill_target_pos_  = GetPos() + GetMoveDir() * (target_distance - buff->meta->param3);
                        #endif
                    }
                }
            }
            target_pos = skill_target_pos_;
        }
        break;
    case kBET_Pull:
        {
            int i = 0;
        }
        break;
    case kBET_PlayShotAni:
        {

        }
        break;
    case kBET_Vertigo:
        {
            int i = 0;
        }
        break;
    case kBET_DecHp:
        {
#if 0
            float def = hum->ability.def * (1 + hum->GetBuffAttrRate(kHAT_Def)) +
                hum->GetBuffAttrAbs(kHAT_Def);
#endif
#if 0
            if (caster->GetEntityType() == ET_Player) {
                DecHP(buff->meta->param1,
                      caster->GetUniId(),
                      ((Human*)caster)->name,
                      0);
            }
#endif
        }
        break;
    case kBET_DelayAddBuff:
        {
            buff->ProcDelayAddBuff();
        }
        break;
    case kBET_IntervalAddBuff:
        {
            buff->ProcIntervalAddBuff();
        }
        break;
    case kBET_OnceChgAttr:
        {
            buff->ProcOnceChgAttr();
        }
        break;
    case kBET_OnceAddHp:
        {
            AddHp(buff->meta->param1);
        }
        break;
    case kBET_SummonHero:
        {
            if (!dead || buff->meta->pb->dead_valid() != 0) {
                SummonHero(buff, GetPos(), GetMoveDir());
            }
        }
        break;
    case kBET_Shield:
        {

        }
        break;
    case kBET_Hide:
        {
            buff->ProcHide();
        }
        break;
    case kBET_Rescuer:
        {
            buff->ProcRescuer();
        }
        break;
    case kBET_Immune:
        {
            buff->ProcImmune();
        }
        break;
    case kBET_SummonObstacle:
        {
            if (!dead || buff->meta->pb->dead_valid() != 0) {
                SummonObstacle(buff, buff->meta->param1, context_pos);
            }
        }
        break;
    case kBET_Sprint:
        {
            buff->ProcSprint();
        }
        break;
    case kBET_FlashMove:
        {
            if (buff->meta->int_param1 == 0) {
                Position old_pos = GetPos();
                // 999
                #if 1
                Position new_pos = GetPos();
                #else
                a8::Vec2 new_pos = GetPos() + skill_dir_ * std::max(skill_distance_, 300.0f);
                #endif
                SetPos(new_pos);
                if (CollisonDetection()) {
                    SetPos(old_pos);
                } else {
                    room->grid_service->MoveCreature(this);
                }
            }
        }
        break;
    case kBET_BatchAddBuff:
        {
            buff->ProcBatchAddBuff();
        }
        break;
    case kBET_BeRecycle:
        {
            buff->ProcBeRecycle();
        }
        break;
    case kBET_Become:
        {
            buff->ProcBecome();
        }
        break;
    case kBET_SelectTargetWithSelfPos:
        {
            buff->ProcSeletTargetWithSelfPos();
        }
        break;
    case kBET_Driver:
        {
            buff->ProcDriver();
        }
        break;
    case kBET_Passenger:
        {
            buff->ProcPassenger();
        }
        break;
    case kBET_PullToWalkable:
        {
            buff->ProcPullToWalkable();
        }
        break;
    case kBET_CondAddBuff:
        {
            if (!IsValidCondBuff(buff->meta->int_param1)) {
                A8_ABORT();
            }
            list_add_tail(&buff->cond_entry, &cond_buffs_[buff->meta->int_param1]);
        }
        break;
    case kBET_AddInventory:
        {
            for (int slot : buff->meta->param2_int_list) {
                if (IsValidSlotId(slot)) {
                    buff_inventory_[slot].num += buff->meta->int_param1;
                }
            }
            if (IsHuman()) {
                AsHuman()->RecalcVolume();
            }
            MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
        }
        break;
    case kBET_AddCarBuff:
        {
            if (IsHuman() && AsHuman()->GetCar()) {
                AsHuman()->GetCar()->TryAddBuff(this, buff->meta->int_param1);
            }
        }
        break;
    case kBET_RemoveCarBuff:
        {
            if (IsHuman() && AsHuman()->GetCar()) {
                AsHuman()->GetCar()->RemoveBuffById(buff->meta->int_param1);
            }
        }
        break;
    case kBET_UseSkill:
        {
            Skill* skill = GetSkill(buff->meta->int_param1);
            if (skill) {
                ++skill->force_use_times;
                Position target_pos = GetPos();
                DoSkill(
                        skill->meta->pb->skill_id(),
                        GetUniId(),
                        GetAttackDir(),
                        0,
                        target_pos
                        );
            }
        }
        break;
    case kBET_CamouflageAddition:
        {
            Buff* camouflage_buff = GetBuffByEffectId(kBET_Camouflage);
            if (camouflage_buff && !camouflage_buff->remover_timer.expired() && buff->meta->int_param1 > 0) {
                int remain_time = room->xtimer.GetRemainTime(camouflage_buff->remover_timer) * FRAME_RATE_MS;
                remain_time += buff->meta->int_param1;
                room->xtimer.ModifyTime(camouflage_buff->remover_timer, remain_time / FRAME_RATE_MS);
            }
            if (buff->meta->int_param2 != 0) {
                ++camouflage_move_addition_;
            }
            if (buff->meta->int_param3 != 0) {
                ++camouflage_aiming_addition_;
            }
        }
        break;
    case kBET_AutoShot:
        {
            buff->ProcAutoShot();
        }
        break;
    case kBET_BeatBack:
        {
            buff->ProcBeatBack();
        }
        break;
    case kBET_Disperse:
        {
            buff->ProcDisperse();
        }
        break;
    case kBET_PeaceMode:
        {
        }
        break;
    case kBET_Dive:
        {
            buff->ProcDive();
        }
        break;
    case kBET_InWater:
        {
            buff->ProcInWater();
        }
        break;
    case kBET_Reverse:
        {
            buff->ProcReserve();
        }
        break;
    case kBET_ReverseMove:
        {
            buff->ProcReserveMove();
        }
        break;
    case kBET_MachineGun:
        {
            buff->ProcMachineGun();
        }
        break;
    case kBET_HoldShield:
        {
            buff->ProcHoldShield();
        }
        break;
    case kBET_CallFunc:
        {
            buff->ProcCallFunc();
        }
        break;
    default:
        {
        }
        break;
    }
}

void Creature::Initialize()
{
    MoveableEntity::Initialize();
    for (auto& node : buff_effect_) {
        INIT_LIST_HEAD(&node);
    }
    for (auto& node : depend_effect_) {
        INIT_LIST_HEAD(&node);
    }
    for (auto& node : cond_buffs_) {
        INIT_LIST_HEAD(&node);
    }
}

void Creature::SetMoveDir(const a8::Vec2& move_dir)
{
    if (GetDisableMoveDirTimes() <= 0) {
        MoveableEntity::SetMoveDir(move_dir);
    }
}

void Creature::AddSkill(int skill_id)
{
    MetaData::Skill* skill_meta = MetaMgr::Instance()->GetSkill(skill_id);
    if (skill_meta && !GetSkill(skill_id)) {
        if (skill_meta->pb->skill_type() == 1) {
            Skill* skill = new Skill;
            skill->owner = this;
            skill->meta = skill_meta;
            skill->xtimer_attacher.SetOwner(&room->xtimer);
            skill->Initialzie();
            skill_hash_[skill_id] = skill;
        } else if (skill_meta->pb->skill_type() == 2) {
            AddPassiveSkill(skill_id);
        } else {
            return;
        }
    }
}

void Creature::ClearSkill()
{
    Skill* reserve_skill = nullptr;
    for (auto& pair : skill_hash_) {
        if (pair.second->meta->IsTurnOverSkill()) {
            reserve_skill = pair.second;
        } else {
            delete pair.second;
        }
    }
    skill_hash_.clear();
    if (reserve_skill) {
        skill_hash_[reserve_skill->meta->pb->skill_id()] = reserve_skill;
    }
}

bool Creature::CanSee(const Creature* c) const
{
    return room->grid_service->InView(GetGridId(), c->GetGridId());
}

bool Creature::IsPlayer() const
{
    return IsHuman() && IsEntitySubType(EST_Player);
}

bool Creature::IsAndroid() const
{
    return IsHuman() && IsEntitySubType(EST_Android);
}

bool Creature::IsHuman() const
{
    return IsEntityType(ET_Player);
}

bool Creature::IsCar() const
{
    return IsEntityType(ET_Car);
}

void Creature::StartAction(ActionType_e action_type,
                           int action_duration,
                           int item_id,
                           int target_id)
{
    if (this->action_type == action_type &&
        this->action_item_id == item_id &&
        this->action_target_id == target_id) {
        return;
    }
    action_duration = std::max(0, action_duration);
    this->action_type = action_type;
    this->action_frameno = room->GetFrameNo();
    this->action_duration = action_duration;
    this->action_item_id = item_id;
    this->action_target_id = target_id;
    MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
    if (HasBuffEffect(kBET_Camouflage)) {
        RemoveBuffByEffectId(kBET_Camouflage);
    }
}

void Creature::CancelAction()
{
    if (action_type == AT_Relive) {
        Entity* entity = room->GetEntityByUniId(action_target_id);
        if (!entity->IsEntityType(ET_Player)) {
            Human* hum = (Human*)entity;
            if (hum->action_type == AT_Rescue) {
                hum->CancelAction();
            }
        }
        RemoveBuffByEffectId(kBET_Rescuer);
    }
    if (action_type == AT_Rescue) {
        RemoveBuffByEffectId(kBET_InRescue);
    }
    ResetAction();
}

void Creature::ResetAction()
{
    action_type = AT_None;
    action_duration = 0;
    action_frameno = 0;
    action_item_id = 0;
    action_target_id = 0;
    MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
    if (!reload_delay_timer_.expired()) {
        room->xtimer.Delete(reload_delay_timer_);
    }
}

bool Creature::IsProperTarget(Creature* target, bool no_teammate)
{
    if (target->dead) {
        return false;
    }
    if (a8::HasBitFlag(target->status, CS_Disable)) {
        return false;
    }
    if (!no_teammate && team_id == target->team_id) {
        return false;
    }
    if (target->IsInvincible()) {
        return false;
    }
    if (target->HasBuffEffect(kBET_Hide)) {
        return false;
    }
    if (target->HasBuffEffect(kBET_Driver)) {
        return false;
    }
    if (target->HasBuffEffect(kBET_Passenger)) {
        return false;
    }
    return true;
}

bool Creature::IsEnemy(Creature* target)
{
    return team_id != target->team_id;
}

void Creature::TraverseProperTargets(std::function<void (Creature*, bool&)> func)
{
    auto callback =
        [this, func] (Creature* c, bool& stop)
        {
            if (IsProperTarget(c)) {
                func(c, stop);
            }
        };
    room->grid_service->TraverseCreatures(room->GetRoomIdx(),
                                       GetGridList(),
                                       callback);
}

void Creature::TraverseProperTargetsNoTeammate(std::function<void (Creature*, bool&)> func)
{
    auto callback =
        [this, func] (Creature* c, bool& stop)
        {
            if (IsProperTarget(c, true)) {
                func(c, stop);
            }
        };
    room->grid_service->TraverseCreatures(room->GetRoomIdx(),
                                       GetGridList(),
                                       callback);
}

void Creature::UpdatePoisoning()
{
    if (dead) {
        poisoning_time = 0;
        return;
    }
    bool need_notify = poisoning_time > 1000;
    while (poisoning_time > 1000) {
        float dmg = 0;
        if (room->GetGasData().is_last_gas) {
            dmg = room->GetGasData().new_area_meta->pb->hurt();
        } else {
            dmg = room->GetGasData().old_area_meta->pb->hurt();
        }
        if (room->IsPveRoom()) {
            dmg = room->GetGasData().new_area_meta->pb->hurt();
        }
        dmg = dmg * GetMaxHP();
        dmg *= 1 + GetAbility()->GetAttrRate(kHAT_PoisoningReduction);
        if (room->IsPveRoom()) {
            dmg = std::max(1.0f, dmg);
        } else {
            dmg = std::max(1.0f, dmg);
        }
        DecHP(dmg, VP_Gas, TEXT("battle_server_killer_gas", "毒圈"), VW_Gas,
              VP_Gas,
              TEXT("battle_server_killer_gas", "毒圈"));
        if (dead) {
            poisoning_time = 0;
            break;
        }
        poisoning_time -= 1000;
    }
    if (need_notify && IsEntitySubType(EST_Player)) {
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    }
}

void Creature::Shot(a8::Vec2& target_dir, bool& shot_ok, float fly_distance, int trace_target_uniid)
{
    shot_ok = false;
    if (!GetCurrWeapon()->meta) {
        return;
    }
    if (downed) {
        return;
    }
    if (!GetCurrWeapon()->meta) {
        return;
    }

    if (HasBuffEffect(kBET_Jump) ||
        HasBuffEffect(kBET_Fly)) {
        return;
    }

    if (GetAbility()->GetDisableShotTimes() > 0) {
        return;
    }

    if (GetCurrWeapon()->weapon_idx != 0 &&
        GetCurrWeapon()->ammo <= 0) {
        CheckLoadingBullet();
        //AutoLoadingBullet();
        return;
    }

    if (action_type == AT_Reload) {
        CancelAction();
    }
    if (action_type == AT_Reload ||
        action_type == AT_Rescue ||
        action_type == AT_UseItem ||
        action_type == AT_Relive) {
        CancelAction();
    }

    if (IsCar()) {
        if (room->GetFrameNo() - last_shot_frameno_ > 0) {
            if ((room->GetFrameNo() - last_shot_frameno_) * (1000 / SERVER_FRAME_RATE) <
                GetCurrWeapon()->GetFireRate(this)
                ) {
                return;
            }
        }
    } else {
        if ((room->GetFrameNo() - last_shot_frameno_) * (1000 / SERVER_FRAME_RATE) <
            GetCurrWeapon()->GetFireRate(this)
            ) {
            return;
        }
    }

    if (GetCurrWeapon()->meta->power_charge.empty() || power_idx < 0) {
        InternalShot(this,
                     GetCurrWeapon()->meta,
                     GetCurrWeapon()->bullet_meta,
                     GetCurrWeapon()->skill_meta,
                     fly_distance,
                     GetCurrWeapon()->weapon_uniid,
                     trace_target_uniid);
    } else if (power_idx < GetCurrWeapon()->meta->power_charge.size()) {
        MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip
            (std::get<1>(GetCurrWeapon()->meta->power_charge[power_idx]));
        if (weapon_meta) {
            MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(weapon_meta->pb->use_bullet());;

            if (bullet_meta) {
                #ifdef DEBUG
                SendDebugMsg(a8::Format("蓄力射击 %d 枪:%d 子弹:%d",
                                        {
                                         power_idx,
                                         weapon_meta->pb->id(),
                                         bullet_meta->pb->id()
                                        }));
                #endif
                InternalShot(this,
                             weapon_meta,
                             bullet_meta,
                             nullptr,
                             fly_distance,
                             0,
                             trace_target_uniid);
            } else {
                A8_ABORT();
            }
        } else {
            A8_ABORT();
        }
    } else {
        A8_ABORT();
    }

    if (GetCurrWeapon()->weapon_idx != 0 &&
        GetCurrWeapon()->meta->pb->bullet_consume_type() == kBulletConsumeOne) {
        --GetCurrWeapon()->ammo;
    }
    int slot_id = GetCurrWeapon()->meta->pb->_inventory_slot();
    #ifdef DEBUG
    if (IsPlayer()) {
        SendDebugMsg(a8::Format("使用武器 %s slot:%d", {GetCurrWeapon()->meta->pb->name(), slot_id}));
    }
    #endif
    bool auto_switch_weapon = false;
    switch (slot_id) {
    case IS_FRAG: //手雷
    case IS_SMOKE: //烟雾弹
        {
#if 1
            DecInventory(slot_id, 1);
#endif
            if (GetCurrWeapon()->ammo <= 0) {
                if (GetInventory(slot_id) > 0) {
                    DecInventory(slot_id, 1);
                    ++GetCurrWeapon()->ammo;
                } else {
                    auto_switch_weapon = true;
                }
            }
            MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
            SyncAroundPlayers(__FILE__, __LINE__, __func__);
        }
        break;
    case IS_POSION_GAS_BOMB: //毒气弹
    case IS_MOLOTOR_COCKTAIL: //燃烧瓶
    case IS_TRAP: //陷井
    case IS_MINE: //地雷
        {
#if 1
            DecInventory(slot_id, 1);
#endif
            if (GetCurrWeapon()->ammo <= 0) {
                if (GetInventory(slot_id) > 0) {
                    DecInventory(slot_id, 1);
                    ++GetCurrWeapon()->ammo;
                } else {
                    auto_switch_weapon = true;
                }
            }
            MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
            SyncAroundPlayers(__FILE__, __LINE__, __func__);
        }
        break;
    case IS_C4:
    case IS_SHIELD_WALL:
    case IS_SINGAL_GUN:
    case IS_OIL_BUCKET:
        {
#if 1
            DecInventory(slot_id, 1);
#endif
            if (GetCurrWeapon()->ammo <= 0) {
                if (GetInventory(slot_id) > 0) {
                    DecInventory(slot_id, 1);
                    ++GetCurrWeapon()->ammo;
                } else {
                    auto_switch_weapon = true;
                }
            }
            MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
            SyncAroundPlayers(__FILE__, __LINE__, __func__);
        }
        break;
    default:
        {
        }
        break;
    }
    if (auto_switch_weapon) {
        AutoSwitchWeapon();
    } else {
        CheckLoadingBullet();
    }
    last_shot_frameno_ = room->GetFrameNo();
    if ((IsPlayer() || IsCar())) {
        room->frame_event.AddBulletNumChg(GetWeakPtrRef());
        room->frame_event.AddWeaponAmmoChg(GetWeakPtrRef());
    }
    if (HasBuffEffect(kBET_Camouflage)) {
        RemoveBuffByEffectId(kBET_Camouflage);
    }
    shot_ok = true;
}

void Creature::AutoLoadingBullet(bool manual)
{
    Weapon* p_weapon = GetCurrWeapon();
    if (second_weapon.meta) {
        p_weapon = &second_weapon;
    }
    if (p_weapon->weapon_idx != 0 &&
        (p_weapon->ammo <= 0 ||
         (manual && p_weapon->ammo < p_weapon->GetClipVolume(this)))
         ) {
        MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(p_weapon->meta->pb->use_bullet());
        if (bullet_meta &&
            bullet_meta->pb->_inventory_slot() >= 0 &&
            bullet_meta->pb->_inventory_slot() < (int)inventory_.size()
            ) {
            if (GetInventory(bullet_meta->pb->_inventory_slot()) > 0) {
                if (on_loading_bullet) {
                    on_loading_bullet();
                }
                int duration_time = p_weapon->GetReloadTime(this) *
                    (1 + GetAbility()->GetAttrRate(kHAT_WeaponReloadTime));
                StartAction(AT_Reload,
                            duration_time,
                            p_weapon->weapon_id,
                            p_weapon->weapon_idx);
            }
        }
        return;
    }
}

int Creature::GetInventory(int slot_id)
{
    if (!IsValidSlotId(slot_id)) {
        A8_ABORT();
    }
    return inventory_[slot_id].num;
}

void Creature::AddInventory(int slot_id, int num)
{
    assert(num > 0);
    if (!IsValidSlotId(slot_id)) {
        A8_ABORT();
    }
    inventory_[slot_id].num += num;
}

void Creature::DecInventory(int slot_id, int num)
{
    assert(num > 0);
    if (!IsValidSlotId(slot_id)) {
        A8_ABORT();
    }
    inventory_[slot_id].num -= num;
}

void Creature::CheckSpecObject()
{
    std::set<ColliderComponent*> colliders;
    room->map_service->GetSpecColliders(SPEC_MAP_OBJECT_FLAGS, room, GetPos().x, GetPos().y, colliders);

    #ifdef DEBUG
    int water_w = 0;
    int water_h = 0;
    #endif
    long long old_cell_flags = cell_flags_;
    cell_flags_ = 0;
    for (const ColliderComponent* collider : colliders) {
        switch (collider->owner->GetEntityType()) {
        case ET_Obstacle:
        case ET_Building:
        case ET_Dummy:
        case ET_MapBlock:
            {
                if (TestCollision(room, (ColliderComponent*)collider)) {
                    cell_flags_ |= collider->tag;
                    #ifdef DEBUG
                    if (a8::HasBitFlag(collider->tag, kColliderTag_Water)) {
                        water_w = collider->param1;
                        water_h = collider->param2;
                    }
                    #endif
                }
            }
            break;
        default:
            break;
        }
    }
    if (old_cell_flags != cell_flags_) {
        if (!a8::SameBitFlag(old_cell_flags, cell_flags_, kColliderTag_Grass)) {
            if (a8::HasBitFlag(cell_flags_, kColliderTag_Grass)) {
                TryAddBuff(this, kInGrassBuffId);
            } else {
                RemoveBuffById(kInGrassBuffId);
            }
        }

        if (!a8::SameBitFlag(old_cell_flags, cell_flags_, kColliderTag_Water)) {
            if (a8::HasBitFlag(cell_flags_, kColliderTag_Water)) {
                TryAddBuff(this, kInWaterBuffId);
            } else {
                RemoveBuffById(kInWaterBuffId);
            }
        }

        if (!a8::SameBitFlag(old_cell_flags, cell_flags_, kColliderTag_Ice)) {
            if (a8::HasBitFlag(cell_flags_, kColliderTag_Ice)) {
                TryAddBuff(this, kInIceBuffId);
            } else {
                RemoveBuffById(kInIceBuffId);
            }
        }

        if (!a8::SameBitFlag(old_cell_flags, cell_flags_, kColliderTag_MountainTop)) {
            if (a8::HasBitFlag(cell_flags_, kColliderTag_MountainTop)) {
                TryAddBuff(this, kInMountainTopBuffId);
            } else {
                RemoveBuffById(kInMountainTopBuffId);
            }
        }

    }
    #ifdef DEBUG
    if (IsPlayer()) {
        if (old_cell_flags != cell_flags_) {
            std::string msg = "terrain changed old:";
            {
                if (a8::HasBitFlag(old_cell_flags, kColliderTag_Grass)) {
                    msg += " grass:1";
                } else {
                    msg += " grass:0";
                }
                if (a8::HasBitFlag(old_cell_flags, kColliderTag_Water)) {
                    msg += " water:1";
                } else {
                    msg += " water:0";
                }
                if (a8::HasBitFlag(old_cell_flags, kColliderTag_Ice)) {
                    msg += " ice:1";
                } else {
                    msg += " ice:0";
                }
                if (a8::HasBitFlag(old_cell_flags, kColliderTag_MountainTop)) {
                    msg += " mountaintop:1";
                } else {
                    msg += " mountaintop:0";
                }
            }
            {
                msg += " new:";
                if (a8::HasBitFlag(cell_flags_, kColliderTag_Grass)) {
                    msg += " grass:1";
                } else {
                    msg += " grass:0";
                }
                if (a8::HasBitFlag(cell_flags_, kColliderTag_Water)) {
                    msg += " water:1";
                } else {
                    msg += " water:0";
                }
                if (a8::HasBitFlag(cell_flags_, kColliderTag_Ice)) {
                    msg += " ice:1";
                } else {
                    msg += " ice:0";
                }
                if (a8::HasBitFlag(cell_flags_, kColliderTag_MountainTop)) {
                    msg += " mountaintop:1";
                } else {
                    msg += " mountaintop:0";
                }
            }
            msg += a8::Format("  o:%d n:%d w:%d h:%d", {old_cell_flags, cell_flags_, water_w, water_h});
            SendDebugMsg(msg);
        }
    }
    #endif
}

void Creature::SummonObstacle(Buff* buff, int id, const Position& target_pos)
{
    if (buff->meta->int_param2 > 0) {
        RemoveSurplusObstacle(buff->meta->pb->buff_id(), id, buff->meta->int_param2);
    }
    float *p_rotate = nullptr;
    float rotate = 0.0f;
    Position pos = target_pos;
    if (buff->skill_meta) {
        switch (buff->skill_meta->GetMagicId()) {
        case MAGIC_WLFB:
            {
                if (!GetAttackDir().IsZero()) {
                    // 999
                    #if 1
                    #else
                    pos = target_pos + GetAttackDir() * 100;
                    #endif
                    rotate = GetAttackDir().CalcAngleEx(a8::Vec2::UP);
                    if (GetAttackDir().x < 0.00001f) {
                        rotate = -rotate;
                    }
                    p_rotate = &rotate;
                }
            }
            break;
        default:
            {
            }
            break;
        }
    }
    RoomObstacle* obstacle = room->CreateObstacle(id, pos.x, pos.y);
    if (obstacle) {
        obstacle->buff_meta = buff->meta;
        obstacle->skill_meta = buff->skill_meta;
        obstacle->master.Attach(this);
        obstacle->SetTeamId(room, team_id);
        obstacle->SetMasterId(room, GetUniId());
        obstacle->Active();
        if (p_rotate) {
            obstacle->SetRotate(*p_rotate);
        }
        obstacle->context_ability = context_ability;
        slave_things_.push_back(std::make_tuple(buff->meta->pb->buff_id(), obstacle));
        if (buff->skill_meta) {
            SkillHelper::ProcSummonObstacle(buff->skill_meta, obstacle);
        }
#ifdef DEBUG
        SendDebugMsg(a8::Format("召唤物件 buff_id:%d thing_id:%d pos:%f,%f target_pos:%f,%f",
                                {buff->meta->pb->buff_id(),
                                 id,
                                 GetPos().x,
                                 GetPos().y,
                                 pos.x,
                                 pos.y
                                }));
#endif
    } else {
#ifdef DEBUG
        A8_ABORT();
#endif
    }
}

bool Creature::CollisonDetection()
{
    ColliderComponent* pickup_collider = nullptr;
    return CollisonDetectionAndGetCollider(&pickup_collider);
}

bool Creature::CollisonDetectionAndGetCollider(ColliderComponent** pickup_collider)
{
    bool through_wall = HasBuffEffect(kBET_ThroughWall) ||
        HasBuffEffect(kBET_Fly);
    AabbCollider aabb_box;
    GetAabbBox(aabb_box);
    return room->map_service->CollisionDetectionAndGetCollider
        (
         room,
         through_wall,
         GetPos(),
         &aabb_box,
         pickup_collider
         );
}

void Creature::FillSkillCasterState(SkillCasterState* caster_state)
{
    caster_state->caster.Attach(this);
    caster_state->caster_pos = GetPos();
    caster_state->caster_skill_id = CurrentSkill() ? CurrentSkill()->meta->pb->skill_id() : 0;
    caster_state->caster_skill_target_id = skill_target_id_;
    caster_state->caster_skill_dir = skill_dir_;
    caster_state->caster_skill_distance = skill_distance_;
    caster_state->caster_skill_param1 = skill_param1;
}

void Creature::RecoverSkillCasterState(SkillCasterState* caster_state)
{
    Global::Instance()->verify_set_pos = 1;
    SetPos(caster_state->caster_pos);
    Global::Instance()->verify_set_pos = 0;
    skill_target_id_ = caster_state->caster_skill_target_id;
    skill_dir_ = caster_state->caster_skill_dir;
    skill_distance_ = caster_state->caster_skill_distance;
    skill_param1 = caster_state->caster_skill_param1;
}

CreatureWeakPtr Creature::AllocWeakPtr()
{
    CreatureWeakPtr ptr;
    ptr.Attach(this);
    return ptr;
}

CreatureWeakPtr& Creature::GetWeakPtrRef()
{
    if (!weak_ptr_.Get()) {
        weak_ptr_.Attach(this);
    }
    return weak_ptr_;
}

Weapon* Creature::AutoChgWeapon()
{
    if (weapons[GUN_SLOT1].weapon_id != 0) {
        SetCurrWeapon(&weapons[GUN_SLOT1]);
    } else if (weapons[GUN_SLOT2].weapon_id != 0) {
        SetCurrWeapon(&weapons[GUN_SLOT2]);
    } else {
        SetCurrWeapon(&weapons[0]);
    }
    return GetCurrWeapon();
}

Weapon* Creature::ChooseNextWeapon(int curr_weapon_slot_id, int begin_slot_id, int end_slot_id)
{
    if (curr_weapon_slot_id < begin_slot_id) {
        A8_ABORT();
    }
    if (curr_weapon_slot_id > end_slot_id) {
        A8_ABORT();
    }
    if (begin_slot_id > end_slot_id) {
        A8_ABORT();
    }
    if (begin_slot_id < 0 ||
        end_slot_id < 0) {
        A8_ABORT();
    }
    Weapon* next_weapon = nullptr;
    for (int i = 1; i <= (end_slot_id - begin_slot_id + 1); ++i) {
        int slot_id = begin_slot_id +
            (i + curr_weapon_slot_id - begin_slot_id) % (end_slot_id - begin_slot_id + 1);
        int idx = -1;
        if (slot_id >= SPEC1_IS_BEGIN && slot_id <= SPEC1_IS_END) {
            idx = SPEC1_SLOT_BEGIN + (slot_id - SPEC1_IS_BEGIN);
        }
        if (slot_id >= SPEC2_IS_BEGIN && slot_id <= SPEC2_IS_END) {
            idx = SPEC2_SLOT_BEGIN + (slot_id - SPEC2_IS_BEGIN);
        }
        if (slot_id >= SPEC3_IS_BEGIN && slot_id <= SPEC3_IS_END) {
            idx = SPEC3_SLOT_BEGIN + (slot_id - SPEC3_IS_BEGIN);
        }
        if (idx != -1 && weapons.at(idx).weapon_id != 0) {
            next_weapon = &weapons[idx];
            break;
        }
    }
    return next_weapon;
}

void Creature::SetCurrWeapon(Weapon* weapon)
{
    #ifdef DEBUG
    bool found = false;
    for (auto& p : weapons) {
        if (&p == weapon) {
            found = true;
        }
    }
    if (!found) {
        A8_ABORT();
    }
    #endif
    bool need_recalc = curr_weapon_ != weapon;
    if (!auto_switch_weapon_timer_.expired()) {
        room->xtimer.Delete(auto_switch_weapon_timer_);
    }
    if (curr_weapon_ != weapon) {
        GetTrigger()->TakeonWeapon(curr_weapon_, weapon);
    }
    curr_weapon_ = weapon;
    if (need_recalc) {
        RecalcDtoAttr();
    }
}

void Creature::ResetAllSkillCd()
{
    for (auto& pair : skill_hash_) {
        pair.second->ResetSkillCd();
    }
}

void Creature::SummonHero(Buff* buff,
                          const Position& pos,
                          const a8::Vec2& dir
                          )
{
    for (auto& info : buff->meta->hero_infos) {
        int through_wall = std::get<0>(info);
        float x = std::get<1>(info);
        float y = std::get<2>(info) ;
        int hero_id = std::get<3>(info);
        int num = std::get<4>(info);
        int life_time = std::get<5>(info);
        MetaData::Player* hero_meta = MetaMgr::Instance()->GetPlayer(hero_id);
        if (hero_meta) {
            for (int j = 0; j < num; ++j) {
                bool can_create = false;
                Position born_pos;
                Hero* hero = nullptr;
                for (int i = 0; i < 4; ++i) {
                    a8::Vec2 born_dir = dir;
                    a8::Vec2 born_offset(x, y);
                    born_offset.Rotate(born_dir.CalcAngle(a8::Vec2::UP));
                    born_offset.Rotate(i * 0.5);
                    // 999
                    #if 1
                    #else
                    born_pos = pos + born_offset;
                    #endif
                    can_create = TrySummonHero(hero_meta,
                                               dir,
                                               born_pos,
                                               through_wall);
                    if (can_create) {
                        break;
                    }
                }//end for i
                if (!can_create) {
                    born_pos = GetPos();
                    can_create = TrySummonHero(hero_meta,
                                               GetAttackDir(),
                                               born_pos,
                                               through_wall);
                }
                if (can_create) {
                    InternalSummonHero(buff,
                                       hero_meta,
                                       GetAttackDir(),
                                       born_pos,
                                       through_wall,
                                       num,
                                       life_time);
                }
            }//end for j
        }
    }
}

bool Creature::FreezeOperate()
{
    Buff* buff = GetBuffByEffectId(kBET_Become);
    bool freeze =  buff && buff->FreezeOperate();
    if (!freeze) {
        freeze = GetBuffByEffectId(kBET_Vertigo) ||
            GetBuffByEffectId(kBET_Driver) ||
            GetBuffByEffectId(kBET_MachineGun) ||
            GetBuffByEffectId(kBET_Passenger);
    }
    return freeze;
}

void Creature::SlaveOnRemove(Entity* slave)
{
    switch (slave->GetEntityType()) {
    case ET_Hero:
        {
            for (auto itr = slave_heros_.begin(); itr != slave_heros_.end(); ++itr) {
                if ((Entity*)std::get<1>(*itr) == slave) {
                    slave_heros_.erase(itr);
                    break;
                }
            }
        }
        break;
    case ET_Obstacle:
        {
            for (auto itr = slave_things_.begin(); itr != slave_things_.end(); ++itr) {
                if ((Entity*)std::get<1>(*itr) == slave) {
                    slave_things_.erase(itr);
                    break;
                }
            }
        }
        break;
    default:
        {
            A8_ABORT();
        }
        break;
    }
}

void Creature::RemoveSurplusHero(int buff_id, int id, int num)
{
    if (slave_heros_.size() >= num && num > 0) {
        std::vector<Hero*> matched_heros;
        for (auto& itr : slave_heros_) {
            if (std::get<0>(itr) == buff_id &&
                std::get<1>(itr)->meta->pb->id() == id) {
                matched_heros.push_back(std::get<1>(itr));
            }
        }
        while (matched_heros.size() > num) {
            matched_heros[0]->Destory();
            matched_heros.erase(matched_heros.begin());
        }
    }
}

void Creature::RemoveSurplusObstacle(int buff_id, int id, int num)
{
    if (slave_things_.size() >= num && num > 0) {
        std::vector<RoomObstacle*> matched_things;
        for (auto& itr : slave_things_) {
            if (std::get<0>(itr) == buff_id &&
                std::get<1>(itr)->meta->pb->thing_id() == id) {
                matched_things.push_back(std::get<1>(itr));
            }
        }
        while (matched_things.size() > num) {
            matched_things[0]->Destory();
            matched_things.erase(matched_things.begin());
        }
    }
}

bool Creature::IsInvincible()
{
    return
        HasBuffEffect(kBET_Invincible) ||
        HasBuffEffect(kBET_Driver) ||
        HasBuffEffect(kBET_Passenger)
        ;
}

void Creature::ClearAimingBuffs()
{
    for (int buff_id : aiming_buffs) {
        RemoveBuffById(buff_id);
    }
    aiming_buffs.clear();
}

float Creature::GetHP()
{
    return ability.hp;
}

float Creature::GetMaxHP()
{
#if 1
    return ability.max_hp;
#else
    return ability.max_hp * (1 + GetAbility()->GetAttrRate(kHAT_MaxHp)) +
        GetAbility()->GetAttrAbs(kHAT_MaxHp);
#endif
}

float Creature::GetHPRate()
{
    return GetMaxHP() > 0.00001 ? GetHP() / GetMaxHP() : 0;
}

void Creature::GetHitEnemys(std::set<Creature*>& enemys, float radius)
{
    float min_distance = 9999999999;
    room->grid_service->TraverseCreatures
        (room->GetRoomIdx(),
         GetGridList(),
         [this, &enemys, radius, &min_distance] (Creature* c, bool& stop)
         {
             if (IsProperTarget(c)) {
                 float distance = GetPos().Distance2D2(c->GetPos());
                 min_distance = std::min(min_distance, distance);
                 if (distance < radius) {
                     enemys.insert(c);
                 }
             }
         });
    int i = 0;
}

void Creature::AddHp(float hp)
{
    if (dead) {
        return;
    }
    float old_health = GetHP();
    ability.hp += hp;
    ability.hp = std::min(GetHP(), GetMaxHP());
    if (IsHuman()) {
        Human* hum = (Human*)this;
        hum->stats.heal_amount += GetHP() - old_health;
#if 1
        room->frame_event.AddHpChg(GetWeakPtrRef());
#else
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
#endif
    }
}

void Creature::SetHP(float hp)
{
    ability.hp = hp;
#ifdef DEBUG1
    if (IsPlayer()) {
        a8::XPrintf("hp:%f maxhp:%f\n",
                    {
                     GetHP(),
                     GetMaxHP()
                    });
    }
#endif
}

void Creature::SetMaxHP(float max_hp)
{
    ability.max_hp = max_hp;
#ifdef DEBUG1
    if (IsPlayer()) {
        a8::XPrintf("hp:%f maxhp:%f\n",
                    {
                     GetHP(),
                     GetMaxHP()
                    });
    }
#endif
}

bool Creature::TryMove(const Position& target_pos, Position& out_pos)
{
    bool move_ok = false;
    Position old_pos = GetPos();
    out_pos = GetPos();

    SetPos(target_pos);
    if (CollisonDetection()) {
        out_pos = target_pos;
        move_ok = true;
    } else {
    }
    return move_ok;
}

void Creature::SetInfiniteBulletMode()
{
    inventory_[IS_9MM].num = FIGHTING_MODE_BULLET_NUM;
    inventory_[IS_556MM].num = FIGHTING_MODE_BULLET_NUM;
    inventory_[IS_762MM].num = FIGHTING_MODE_BULLET_NUM;
    inventory_[IS_12GAUGE].num = FIGHTING_MODE_BULLET_NUM;
    inventory_[IS_RPG].num = FIGHTING_MODE_BULLET_NUM;
    inventory_[IS_ICE].num = FIGHTING_MODE_BULLET_NUM;
}

void Creature::FindLocation()
{
    ColliderComponent* target_collider = nullptr;
    if (CollisonDetectionAndGetCollider(&target_collider)) {
        if (!target_collider) {
            A8_ABORT();
        }
    }
}

bool Creature::Attackable(Room* room)
{
    if (dead) {
        return false;
    }
    if (a8::HasBitFlag(status, CS_Disable)) {
        return false;
    }
    if (IsInvincible()) {
        return false;
    }
    if (HasBuffEffect(kBET_Hide)) {
        return false;
    }
    if (HasBuffEffect(kBET_Driver)) {
        return false;
    }
    if (HasBuffEffect(kBET_Passenger)) {
        return false;
    }
    return true;
}

bool Creature::ReceiveExplosionDmg(Explosion* explosion)
{
    return true;
}

bool Creature::CheckCollision()
{
    Global::last_collider = nullptr;
    if (room->OverBorder(GetPos(), GetRadius())){
        ++collision_times_;
        return true;
    }
    if (HasBuffEffect(kBET_ThroughWall) ||
        HasBuffEffect(kBET_Fly)) {
        return false;
    }

    std::set<ColliderComponent*> colliders;
    room->map_service->GetColliders(room, GetPos().GetX(), GetPos().GetY(), colliders);

    AabbCollider aabb_box;
    GetAabbBox(aabb_box);
    for (ColliderComponent* collider : colliders) {
        {
            switch (collider->owner->GetEntityType()) {
            case ET_Obstacle:
                {
                    Obstacle* obstacle = (Obstacle*)collider->owner;
                    if (!obstacle->CanThroughable(this)) {
                        if (
                            (collider->type == CT_Aabb && aabb_box.Intersect(collider)) ||
                            (collider->type == CT_Circle && self_collider_->Intersect(collider))
                            ) {
                            if (obstacle->OnCollisionTrigger(this, collider) == 1) {
                                ++collision_times_;
                                return true;
                            }
                        }
                    }
                }
                break;
            case ET_Building:
                {
                    if (
                        (collider->type == CT_Aabb && aabb_box.Intersect(collider)) ||
                        (collider->type == CT_Circle && self_collider_->Intersect(collider))
                        ) {
                        Global::last_collider = collider;
                        ++collision_times_;
                        return true;
                    }
                }
                break;
            case ET_Dummy:
                {
                    if (
                        (collider->type == CT_Aabb && aabb_box.Intersect(collider)) ||
                        (collider->type == CT_Circle && self_collider_->Intersect(collider))
                        ) {
                        Global::last_collider = collider;
                        ++collision_times_;
                        return true;
                    }
                }
                break;
            default:
                {
                }
                break;
            }
        }
    }
    return false;
}

void Creature::CheckAbilityUsed()
{
    if (ability_.use_count() > 1) {
        std::shared_ptr<Ability> old_val = ability_;
        ability_ = std::make_shared<Ability>();
        *ability_.get() = *(old_val.get());
    }
}

void Creature::RefreshHP()
{

}

void Creature::TraverseBuff(std::function<void (Buff*, bool&)> func)
{
    bool stop = false;
    for (auto& buff : buff_list_) {
        func(&buff, stop);
        if (stop) {
            return;
        }
    }
}

bool Creature::TrySummonHero(MetaData::Player* hero_meta, a8::Vec2 dir, Position born_pos, bool through_wall)
{
    AabbCollider collider;
    collider._min.x = -hero_meta->pb->radius();
    collider._min.y = -hero_meta->pb->radius();
    collider._max.x = hero_meta->pb->radius();
    collider._max.y = hero_meta->pb->radius();
    collider.MoveCenter(hero_meta->pb->move_offset_x(), hero_meta->pb->move_offset_y());
    return !room->map_service->CollisionDetection
        (
         room,
         through_wall,
         born_pos,
         &collider
         );
}

Hero* Creature::InternalSummonHero(Buff* buff, MetaData::Player* hero_meta, a8::Vec2 dir, Position born_pos,
                                   bool through_wall, int num, int life_time)
{
    struct SummonHeroInfo
    {
        MetaData::Player* hero_meta = nullptr;
        a8::Vec2 dir;
        Position born_pos;
        bool through_wall = false;
        int num = 0;
        int life_time = 0;
    };
    if (TrySummonHero(hero_meta, dir, born_pos, through_wall)) {
        int delay_time = 0;
        for (auto& tuple : hero_meta->pre_appear_effect) {
            RoomObstacle* obstacle = room->CreateObstacle
                (
                 std::get<0>(tuple),
                 born_pos.x,
                 born_pos.y
                 );
            if (obstacle) {
                obstacle->DestoryAt(std::get<1>(tuple));
            }
            delay_time = std::max(std::get<1>(tuple), delay_time);
        }
        std::shared_ptr<SummonHeroInfo> summon_info = std::make_shared<SummonHeroInfo>();
        summon_info->hero_meta = hero_meta;
        summon_info->dir = dir;
        summon_info->born_pos = born_pos;
        summon_info->through_wall = through_wall;
        summon_info->num = num;
        summon_info->life_time = life_time;
        int buff_id = buff->meta->pb->buff_id();
        room->xtimer.SetTimeoutEx
            (
             delay_time / FRAME_RATE_MS + NEXT_FRAME_TIMER,
             [this, summon_info, buff_id]
             (int event, const a8::Args* args)
             {
                 if (a8::TIMER_EXEC_EVENT == event) {
                     Hero* hero = room->CreateHero
                         (this,
                          summon_info->hero_meta,
                          summon_info->born_pos,
                          summon_info->dir,
                          team_id
                          );
                     if (!hero) {
                         return;
                     }
                     RemoveSurplusHero(buff_id,
                                       summon_info->hero_meta->pb->id(),
                                       summon_info->num);
                     slave_heros_.push_back(std::make_tuple(buff_id, hero));
                     hero->room->xtimer.SetTimeoutEx
                         (
                          summon_info->life_time / FRAME_RATE_MS,
                          [] (int event, const a8::Args* args)
                          {
                          },
                          &hero->xtimer_attacher);
#ifdef DEBUG
                     SendDebugMsg(a8::Format("summon hero id:%d pos:%f,%f",
                                              {
                                                  summon_info->hero_meta->pb->id(),
                                                  summon_info->born_pos.x,
                                                  summon_info->born_pos.y
                                              }));
#endif
                 }
             },
             &xtimer_attacher);
    }
    return nullptr;
}

std::string Creature::DebugOutBuffList()
{
    std::string data;
    for (auto& itr : buff_list_) {
        data += a8::Format("buffid:%d effect:%d\n",
                           {
                            itr.meta->pb->buff_id(),
                            itr.meta->pb->buff_effect()
                           });
    }
    return data;
}

void Creature::AutoSwitchWeapon()
{
    auto weapon_idx = GetCurrWeapon()->weapon_idx;
    auto weapon_meta = GetCurrWeapon()->meta;
    auto switch_func =
        [this, weapon_idx, weapon_meta] (int event, const a8::Args* args)
        {
            if (a8::TIMER_EXEC_EVENT == event) {
                if (!(GetCurrWeapon()->weapon_idx == weapon_idx &&
                      GetCurrWeapon()->meta == weapon_meta)) {
                    return;
                }

                bool switch_ok = false;
                int slot_id = weapon_meta->pb->_inventory_slot();
                if (GetCurrWeapon()->ammo <= 0 && slot_id > 0) {
                    if (GetInventory(slot_id) > 0) {
                    } else {
                        int weapon_idx = GetCurrWeapon()->weapon_idx;
                        *GetCurrWeapon() = Weapon();
                        GetCurrWeapon()->weapon_idx = weapon_idx;
                        Weapon* next_weapon = ChooseNextSpecWeapon(slot_id);
                        if (!next_weapon) {
                            next_weapon = AutoChgWeapon();
                        }
                        if (next_weapon) {
                            SetCurrWeapon(next_weapon);
                            switch_ok = true;
                        } else {
                            A8_ABORT();
                        }
                    }
                }
                if (switch_ok) {
                    MarkSyncActivePlayer(__FILE__, __LINE__, __func__);
                    SyncAroundPlayers(__FILE__, __LINE__, __func__);
                }
                CheckLoadingBullet();
            }
        };
    if (GetCurrWeapon()->meta->pb->auto_switch_weapon_time() > 0) {
        if (!auto_switch_weapon_timer_.expired()) {
            room->xtimer.Delete(auto_switch_weapon_timer_);
        }
        auto_switch_weapon_timer_ = room->xtimer.SetTimeoutWpEx
            (
             GetCurrWeapon()->meta->pb->auto_switch_weapon_time() / FRAME_RATE_MS,
             switch_func,
             &xtimer_attacher);
    } else {
        switch_func(a8::TIMER_EXEC_EVENT, nullptr);
    }
}

void Creature::CheckLoadingBullet()
{
    if (GetCurrWeapon()->weapon_idx != 0 &&
        GetCurrWeapon()->ammo <= 0 &&
        reload_delay_timer_.expired()) {
        #ifdef DEBUG
        if (IsPlayer()) {
            a8::XPrintf("CheckLoadingBullet1\n", {});
        }
        #endif
        if (GetCurrWeapon()->meta->pb->reload_delay_time() > 0) {
            int weapon_id = GetCurrWeapon()->weapon_id;
            reload_delay_timer_ = room->xtimer.SetTimeoutWpEx
                (
                 GetCurrWeapon()->meta->pb->reload_delay_time() / FRAME_RATE_MS,
                 [this, weapon_id] (int event, const a8::Args* args)
                 {
                     if (a8::TIMER_EXEC_EVENT == event) {
                         if (GetCurrWeapon()->weapon_id == weapon_id) {
#ifdef DEBUG
                             if (IsPlayer()) {
                                 a8::XPrintf("CheckLoadingBullet3\n", {});
                             }
#endif
                             AutoLoadingBullet();
                         }
                     }
                 },
                 &xtimer_attacher);
        } else {
#ifdef DEBUG
            if (IsPlayer()) {
                a8::XPrintf("CheckLoadingBullet2\n", {});
            }
#endif
            AutoLoadingBullet();
        }
    }
}

Weapon* Creature::ChooseNextSpecWeapon(int curr_weapon_slot_id)
{
    Weapon* next_weapon = nullptr;
    int data[][3]= {
        {SPEC1_IS_BEGIN, SPEC1_IS_END, 0},
        {SPEC2_IS_BEGIN, SPEC2_IS_END, 0},
        {SPEC3_IS_BEGIN, SPEC3_IS_END, 0}
    };
    int idx = -1;
    for (int i = 0; i < sizeof(data) /sizeof(data[0]); ++i) {
        int start_id = data[i][0];
        int end_id = data[i][1];
        if (curr_weapon_slot_id >= start_id &&
            curr_weapon_slot_id <= end_id) {
            idx = i;
            data[i][2] = 1;
            break;
        }
    }
    if (idx > -1) {
        for (int i = 0; i < sizeof(data) /sizeof(data[0]); ++i) {
            int real_i = (i + idx) % (sizeof(data) /sizeof(data[0]));
            int start_id = data[real_i][0];
            int end_id = data[real_i][1];
            int flag = data[real_i][2];
            next_weapon = ChooseNextWeapon(flag ? curr_weapon_slot_id : start_id, start_id, end_id);
            if (next_weapon) {
                break;
            }
        }
    }
    return next_weapon;
}

void Creature::OnBattleStart(Room* room)
{
#ifdef DEBUG1
    if (IsPlayer()) {
        SendDebugMsg(a8::Format("OnBattleStart clear buff", {}));
    }
#endif
    int try_count = 0;
    while (try_count++ < 10) {
        std::vector<int> del_buffs;
        del_buffs.reserve(buff_list_.size());
        for (auto& buff : buff_list_) {
            if (!buff.meta->pb->post_battle_valid()) {
                if (!buff.skill_meta || buff.skill_meta->pb->skill_type() != kPassiveSkill) {
                    del_buffs.push_back(buff.buff_uniid);
                }
            }
        }
        for (auto itr = del_buffs.rbegin(); itr != del_buffs.rend(); ++itr) {
            RemoveBuffByUniId(*itr);
        }
        if (del_buffs.empty()) {
            break;
        }
    }
#ifdef DEBUG
    if (try_count > 5) {
        A8_ABORT();
    }
#endif
}

bool Creature::CanFollow(Creature* follower)
{
    #ifdef DEBUG1
    return false;
    #endif
    if (follower->GetUniId() == GetUniId()) {
        return false;
    }
    #if 0
    if (!follower->IsPlayer()) {
        return false;
    }
    #endif
    if (follower->team_id != team_id) {
        return false;
    }
    #if 0
    if (follower->follow_target.Get()) {
        return false;
    }
    #endif
    if (follower->HasBuffEffect(kBET_Jump)) {
        return false;
    }
    if (!follower->HasBuffEffect(kBET_Fly) && room->GetGasData().GetGasMode() != GasInactive) {
        return false;
    }

    #if 0
    if (!IsPlayer()) {
        return false;
    }
    #endif
    if (HasBuffEffect(kBET_Jump)) {
        return false;
    }
    if (!HasBuffEffect(kBET_Fly) && room->GetGasData().GetGasMode() != GasInactive) {
        return false;
    }
    return true;
}

void Creature::FollowToTarget()
{
    if (HasBuffEffect(kBET_Jump) &&
        follow_target.Get() &&
        follow_target.Get()->GetChgAttackDirTimes() > follow_target_last_chg_move_dir_times_) {
#if 1
        {
#else
        if (GetPos().ManhattanDistance(follow_target.Get()->GetPos()) > 70) {
#endif
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            dir.Normalize();
            // 999
            #if 1
            Position target_pos = follow_target.Get()->GetPos();
            #else
            a8::Vec2 target_pos = follow_target.Get()->GetPos() + dir * (30 + (rand() % 10));
            #endif
            if (GetPos().ManhattanDistance2D(target_pos) > 5) {
                a8::Vec2 move_dir = GetPos().CalcDir2D(target_pos);
                move_dir.Normalize();
                SetMoveDir(move_dir);
            }
            follow_target_last_chg_move_dir_times_ = follow_target.Get()->GetChgAttackDirTimes();
        }
    }
}

void Creature::DoRecoilForce(int distance)
{
    if (distance > 0) {
        a8::Vec2 old_move_dir = GetMoveDir();
        MustBeAddBuff(this, kRecoilBuffId);
        SetMoveDir(GetAttackDir() * -1);
        _UpdateMove(distance);
        SetMoveDir(old_move_dir);
    }
}

void Creature::WinSkillExp(int win_exp)
{
    if (!IsHuman()) {
        return;
    }
}

float Creature::GetAttrAbs(int attr_id)
{
    float val = 0;
    if (GetAbility()){
        val += GetAbility()->GetAttrAbs(attr_id);
    }
    return val;
}

float Creature::GetAttrRate(int attr_id)
{
    float val = 0;
    if (GetAbility()){
        val += GetAbility()->GetAttrRate(attr_id);
    }
    return val;
}

void Creature::RecalcDtoAttr()
{
    if (!IsHuman()) {
        return;
    }
    if (GetCurrWeapon()) {
        if (GetBattleContext()) {
        }
    } else {
        if (GetBattleContext()) {
        }
    }
}

void Creature::SetBattleContext(std::shared_ptr<BattleDataContext> c)
{
    battle_context_ = c;
}


bool Creature::HasSpecMove()
{
    return GetBuffByEffectId(kBET_JumpTo) ||
        GetBuffByEffectId(kBET_BePull);
}

void Creature::_UpdateSpecMove()
{
    if (!HasSpecMove()) {
        return;
    }
    bool move_end = false;
    float target_distance = target_pos.Distance2D2(GetPos());
    if (target_distance <= 0.000001f) {
        move_end = true;
    } else {
        a8::Vec2 old_move_dir = GetMoveDir();
        a8::Vec2 move_dir = GetPos().CalcDir2D(target_pos);
        move_dir.Normalize();
        SetMoveDir(move_dir);
        bool is_collision = false;
        _UpdateMove(std::min((int)target_distance, (int)GetSpeed()));
        move_dir = old_move_dir;
        target_distance = target_pos.Distance2D2(GetPos());
        if (is_collision || target_distance <= 1.0001f) {
            move_end = true;
        }
    }
    if (move_end) {
        Buff* buff = GetBuffByEffectId(kBET_JumpTo);
        if (buff) {
            if (CurrentSkill() &&
                                buff->skill_meta == CurrentSkill()->meta &&
                                !CurrentSkill()->meta->phases.empty()) {
                std::set<Creature*> target_list;
                metatable::Skill* mutable_skill_meta = (metatable::Skill*)CurrentSkill()->meta->pb;
                float old_skill_distance = CurrentSkill()->meta->pb->skill_distance();
                mutable_skill_meta->set_skill_distance(CurrentSkill()->meta->phases[0].param1.GetDouble());
                SelectSkillTargets(CurrentSkill(), GetPos(), target_list);
                mutable_skill_meta->set_skill_distance(old_skill_distance);

                TriggerBuff(CurrentSkill(), target_list, kBTT_SkillHit);
            }
            RemoveBuffByEffectId(kBET_JumpTo);
        }
        buff = GetBuffByEffectId(kBET_BePull);
        if (buff) {
            MetaData::Buff* new_buff = MetaMgr::Instance()->GetBuff(1039);
            if (new_buff) {
                AddBuff(this, new_buff);
            }
            RemoveBuffByEffectId(kBET_BePull);
        }
    }
}

void Creature::AutoNavigation(Position target_pos, float speed,
                              std::function<void (Creature*)> cb)
{
    float distance = GetPos().Distance2D2(target_pos);
    if (distance < 0.001f) {
        cb(this);
        return;
    }
    if (speed < 0.001f) {
        cb(this);
        return;
    }

    struct NavContext
    {
        CreatureWeakPtr c;
        Position src_pos;
        Position target_pos;
        a8::Vec2 dir;
        int exec_frameno = 0;
        float speed = 0.0f;
        float distance = 0.0f;
        std::function<void (Creature*)> cb;
    };
    std::shared_ptr<NavContext> context = std::make_shared<NavContext>();
    context->c = GetWeakPtrRef();
    context->src_pos = GetPos();
    context->target_pos = target_pos;
    context->dir = GetPos().CalcDir2D(target_pos);
    context->dir.Normalize();
    context->speed = speed;
    context->distance = distance;
    context->cb = cb;

    IncDisableMoveTimes();
    room->xtimer.SetIntervalEx
        (1,
         [context] (int event, const a8::Args* args)
         {
             if (a8::TIMER_EXEC_EVENT == event) {
                 ++context->exec_frameno;

                 Room* room = context->c.Get()->room;
                 Creature* c = context->c.Get();

                 a8::Vec2 dir = c->GetPos().CalcDir2D(context->target_pos);
                 dir.Normalize();
                 Position old_pos = c->GetPos();
                 float move_length = context->speed / (float)SERVER_FRAME_RATE;
                 float move_distance = std::min(move_length * context->exec_frameno, context->distance);
                 // 999
#if 1
                 Position new_pos = context->src_pos;
#else
                 a8::Vec2 new_pos = context->src_pos + dir * move_distance;
#endif
                 c->SetPos(new_pos);

#ifdef DEBUG
                 a8::XPrintf("speed:%d src_pos:%f,%f new_pos:%f,%f move_distance:%f\n",
                             {
                                 context->speed,
                                 context->src_pos.x,
                                 context->src_pos.y,
                                 new_pos.x,
                                 new_pos.y,
                                 move_distance
                             });
#endif
                 bool ok = false;
                 if (c->CheckCollision()) {
                     c->SetPos(old_pos);
                     ok = true;
                 } else {
                     ok = std::abs(move_distance - context->distance) < 0.0001f;
                     room->grid_service->MoveCreature(c);
                 }

                 if (ok || c->dead) {
                     context->cb(c);
                     c->DecDisableMoveTimes();
                     room->xtimer.DeleteCurrentTimer();
                 }
             }
         },
         &xtimer_attacher);
}

void Creature::AddTraceBullet(int bullet_uniid, int target_uniid, int gun_id)
{
    trace_bullet_hash_[bullet_uniid] = std::make_tuple(target_uniid, gun_id);
    room->xtimer.SetTimeoutEx
        (
         SERVER_FRAME_RATE * 10,
         [this, bullet_uniid] (int event, const a8::Args* args)
         {
             if (a8::TIMER_EXEC_EVENT == event) {
                 trace_bullet_hash_.erase(bullet_uniid);
                 Entity* entity = room->GetEntityByUniId(bullet_uniid);
                 if (entity && entity->GetEntityType() == ET_Bullet) {
                     Bullet* bullet = (Bullet*)entity;
                     bullet->ForceRemove();
                 }
             }
         },
         &xtimer_attacher);
}

void Creature::LockAttackDir(int time)
{
    IncDisableAttackDirTimes();
    room->xtimer.SetTimeoutEx
        (
         time / FRAME_RATE_MS,
         [this] (int event, const a8::Args* args)
         {
             if (a8::TIMER_EXEC_EVENT == event) {
             } else if (a8::TIMER_DELETE_EVENT == event){
                 DecDisableAttackDirTimes();
             }
         },
         &xtimer_attacher);
}

void Creature::PullTarget(const a8::Vec2& target_pos)
{

}

bool Creature::IsHpFull()
{
    return std::abs(GetMaxHP() - GetHP()) < 0.0001f;
}

void Creature::MarkSyncActivePlayer(const char* file, int line, const char* func)
{
#ifdef DEBUG
    if (!f8::IsTestEnv()) {
        if (IsPlayer()) {
            a8::XPrintf("MarkSyncActivePlayer file:%s line:%d func:%s\n",
                        {
                            file,
                                line,
                                func
                                });
        }
    }
#endif
    need_sync_active_player_ = true;
}

void Creature::SetPos(Position pos)
{
    if (!Global::Instance()->verify_set_pos) {
        abort();
    }
    Entity::SetPos(pos);
}