#include "precompile.h"

#include <float.h>

#include <a8/mutable_xobject.h>
#include <a8/collision.h>

#include "human.h"
#include "cs_proto.pb.h"
#include "metamgr.h"
#include "room.h"
#include "bullet.h"
#include "collider.h"
#include "loot.h"
#include "building.h"
#include "app.h"
#include "roommgr.h"
#include "android.h"
#include "gamelog.h"
#include "typeconvert.h"
#include "obstacle.h"
#include "roomobstacle.h"
#include "player.h"
#include "buff.h"
#include "car.h"
#include "roomobstacle.h"
#include "aicomponent.h"
#include "jsondatamgr.h"
#include "skill.h"
#include "incubator.h"

#include "framework/cpp/utils.h"
#include "framework/cpp/httpclientpool.h"

const int kReviveTimeAdd = 12;
const int kSkinNum = 4;
const int kREVIVE_BUFF_ID = 0;

Human::Human():Creature()
{
    default_weapon.weapon_idx = 0;
    default_weapon.weapon_id = 30101;
    default_weapon.weapon_lv = 1;
    default_weapon.ammo = 1;
    default_weapon.meta = MetaMgr::Instance()->GetEquip(default_weapon.weapon_id);
    default_weapon.Recalc();
    for (int i = 0; i < kSkinNum; ++i) {
        Skin& skin = a8::FastAppend(skins);
        skin.skin_id = 0;
        skin.skin_lv = 1;
    }
    weapons[0] = default_weapon;
    SetCurrWeapon(&weapons[0]);
}

Human::~Human()
{
}

void Human::Initialize()
{
    Creature::Initialize();
    RecalcSelfCollider();
    volume_ = meta->volume;
    observers_.insert(this);
    ability.hp = meta->i->health();
    for (auto& weapon : spec_weapons) {
        if (weapon.meta) {
            ability.hp += weapon.meta ? weapon.GetAttrValue(kHAT_MaxHp) : 0;
        }
    }
}

float Human::GetSpeed()
{
    {
        Buff* buff = GetBuffByEffectId(kBET_JumpTo);
        if (buff) {
            return buff->meta->param2;
        }
    }
    {
        Buff* buff = GetBuffByEffectId(kBET_BePull);
        if (buff) {
            return buff->meta->param2;
        }
    }
    if (downed) {
        return meta->i->move_speed3();
    } else {
        if (shot_hold) {
            if (GetCurrWeapon()->weapon_idx == GUN_SLOT1 ||
                GetCurrWeapon()->weapon_idx == GUN_SLOT2) {
                if (action_type != AT_Reload) {
                    return meta->i->shot_speed();
                }
            }
        } else if (aiming) {
            return std::max(1, meta->i->aiming_speed());
        } else if (action_type != AT_None) {
            return std::max(1, meta->i->reload_speed());
        }
        float speed = meta->i->move_speed();
        speed = (speed + GetBuffAttrAbs(kHAT_Speed)) * (1 + GetBuffAttrRate(kHAT_Speed));
        if (a8::HasBitFlag(cell_flags_, kColliderTag_Water)) {
            speed *= MetaMgr::Instance()->water_move_coefficient;
        }
        return std::max(speed, 1.0f);
    }
}

float Human::GetSpeed4()
{
    return meta->i->move_speed4();
}

void Human::FillMFObjectPart(Room* room, Human* hum, cs::MFObjectPart* part_data)
{
    part_data->set_object_type(ET_Player);
    cs::MFPlayerPart* p = part_data->mutable_union_obj_1();
    p->set_obj_uniid(GetEntityUniId());
    p->set_speed(GetSpeed() * SERVER_FRAME_RATE);
    TypeConvert::ToPb(GetPos(), p->mutable_pos());
    TypeConvert::ToPb(GetAttackDir(), p->mutable_dir());
}

void Human::FillMFObjectLess(Room* room, Human* hum, cs::MFPlayerFull* full_data)
{
    cs::MFPlayerFull* p = full_data;
    p->set_obj_uniid(GetEntityUniId());
    TypeConvert::ToPb(GetPos(), p->mutable_pos());
    TypeConvert::ToPb(GetAttackDir(), p->mutable_dir());

    p->set_health(GetHP());
    p->set_max_health(GetMaxHP());
    p->set_dead(dead);
    p->set_downed(downed);
    p->set_disconnected(disconnected);
    p->set_anim_type(anim_type);
    p->set_anim_seq(anim_seq);
    for (auto itr : skins) {
        auto skin = p->add_skin();
        itr.ToPB(skin);
    }
    p->set_backpack(backpack);
    p->set_helmet(helmet);
    p->set_chest(chest);
    p->set_shoot_offset_x(shoot_offset.x);
    p->set_shoot_offset_y(shoot_offset.y);
    GetCurrWeapon()->ToPB(p->mutable_weapon());
}

void Human::FillMFObjectFull(Room* room, Human* hum, cs::MFObjectFull* full_data)
{
    full_data->set_object_type(ET_Player);
    cs::MFPlayerFull* p = full_data->mutable_union_obj_1();
    p->set_obj_uniid(GetEntityUniId());
    TypeConvert::ToPb(GetPos(), p->mutable_pos());
    TypeConvert::ToPb(GetAttackDir(), p->mutable_dir());

    p->set_health(GetHP());
    p->set_max_health(GetMaxHP());
    p->set_dead(dead);
    p->set_downed(downed);
    p->set_disconnected(disconnected);
    p->set_anim_type(anim_type);
    p->set_anim_seq(anim_seq);
    p->set_speed(GetSpeed() * SERVER_FRAME_RATE);
    for (auto itr : skins) {
        auto skin = p->add_skin();
        itr.ToPB(skin);
    }
    p->set_backpack(backpack);
    p->set_helmet(helmet);
    p->set_chest(chest);
    GetCurrWeapon()->ToPB(p->mutable_weapon());
    p->set_energy_shield(energy_shield);
    p->set_shoot_offset_x(shoot_offset.x);
    p->set_shoot_offset_y(shoot_offset.y);
    #if 1
    {
        p->set_max_energy_shield(max_energy_shield);
    }
    #endif
    if (guild_id != 0) {
        p->set_guild_id(guild_id);
    }
    if (vip_lv != 0) {
        p->set_vip_lv(vip_lv);
    }
    if (head != 0) {
        p->set_head(head);
    }
    if (sex != 0) {
        p->set_sex(sex);
    }
    if (!user_data.empty()) {
        p->set_user_data(user_data);
    }
    p->set_vip(vip);
    p->set_sdmg(sdmg);
    p->set_kill_count(stats.kills);
    if (emoji1 != 0) {
        p->set_emoji1(emoji1);
    }
    if (emoji2 != 0) {
        p->set_emoji2(emoji2);
    }
    if (parachute != 0) {
        p->set_parachute(parachute);
    }
    FillBodyState(p->mutable_states());
    FillBuffList(hum, p->mutable_buff_list());
    FillSkillList(p->mutable_skill_list());
    if (dead) {
        p->set_killer_name(stats.killer_name);
        p->set_killer_id(stats.killer_id);
        if (real_dead){
            p->set_can_revive(false);
        } else {
            p->set_can_revive(true);
            int countdown = 0;
            if (revive_timer) {
                countdown = std::ceil(room->xtimer.GetRemainTime(revive_timer) / SERVER_FRAME_RATE);
            } else {
                a8::UdpLog::Instance()->Warning("Human::FillMFObjectfull revive_timer == nullptr "
                                                "dead_frameno:%d dead_times:%d alive_count:%d "
                                                "room.frameno:%d",
                                                {
                                                 dead_frameno,
                                                 dead_times,
                                                 room->AliveCount(),
                                                 room->GetFrameNo()
                                                });
            }
            countdown = std::max(0, countdown - kReviveTimeAdd);
            p->set_revive_countdown(countdown);
        }
    }
    if (room->GetRoomMode() == kZombieMode) {
        p->set_charid(meta->i->id());
    }
    if (GetCar()) {
        p->set_car_uniid(GetCar()->car_uniid);
        p->set_car_seat(GetSeat());
    } else {
        p->set_car_uniid(0);
        p->set_car_seat(0);
    }
}

void Human::FillMFPlayerStats(cs::MFPlayerStats* stats_pb)
{
    stats_pb->set_player_id(GetEntityUniId());
    stats_pb->set_player_avatar_url(avatar_url);
    stats_pb->set_charid(meta->i->id());
    stats_pb->set_team_id(team_id);
    stats_pb->set_nickname(name);

    if (!dead) {
        stats_pb->set_time_alive(room->GetFrameNo() * 1000.0f / SERVER_FRAME_RATE);
    } else {
        stats_pb->set_time_alive(dead_frameno * 1000.0f / SERVER_FRAME_RATE);
    }
    stats_pb->set_kills(stats.kills);
    stats_pb->set_damage_amount(stats.damage_amount_out);
    stats_pb->set_heal_amount(stats.heal_amount);

    stats_pb->set_history_time_alive(stats.history_time_alive);
    stats_pb->set_history_kills(stats.history_kills);
    stats_pb->set_history_damage_amount(stats.history_damage_amount);
    stats_pb->set_history_heal_amount(stats.history_heal_amount);

    stats_pb->set_gold(stats.gold);
    stats_pb->set_score(stats.score);
    stats_pb->set_pass_score(stats.pass_score);
    stats_pb->set_rank_score(stats.rank_score);
    stats_pb->set_has_pass(has_pass);

    stats_pb->set_dead(dead);
    stats_pb->set_killer_id(stats.killer_id);
    stats_pb->set_killer_name(stats.killer_name);
    {
        Player* killer = room->GetPlayerByUniId(stats.killer_id);
        if (killer) {
            stats_pb->set_killer_avatar_url(killer->avatar_url);
            stats_pb->set_killer_account_id(killer->account_id);
        } else {
            stats_pb->set_killer_avatar_url("");
            stats_pb->set_killer_account_id("");
        }
    }

    stats_pb->set_account_id(account_id);
    if (guild_id != 0) {
        stats_pb->set_guild_id(guild_id);
    }
    stats_pb->set_rescue_guild_member(stats.rescue_guild_member);

    for (auto& pair : stats.items) {
        auto p = stats_pb->add_items();
        p->set_key(pair.first);
        p->set_value(pair.second);
    }
    for (auto& pair : stats.extra_drop) {
        auto p = stats_pb->add_extra_drop();
        p->set_key(pair.first);
        p->set_value(pair.second);
    }
    if (vip_lv != 0) {
        stats_pb->set_vip_lv(vip_lv);
    }
    if (head != 0) {
        stats_pb->set_head(head);
    }
    if (sex != 0) {
        stats_pb->set_sex(sex);
    }
    {
        for (auto& skin : skins) {
            auto pb_skin = stats_pb->add_skin();
            skin.ToPB(pb_skin);
        }
    }
}

void Human::GetAabbBox(AabbCollider& aabb_box)
{
    if (!meta) {
        abort();
    }
    aabb_box.active = true;
    aabb_box.owner = this;
    if (GetCar() && GetCar()->IsDriver(this)) {
        aabb_box._min.x = -GetCar()->meta->i->rad();
        aabb_box._min.y = -GetCar()->meta->i->rad();
        aabb_box._max.x = GetCar()->meta->i->rad();
        aabb_box._max.y = GetCar()->meta->i->rad();
    } else {
        aabb_box._min.x = -meta->i->radius();
        aabb_box._min.y = -meta->i->radius();
        aabb_box._max.x = meta->i->radius();
        aabb_box._max.y = meta->i->radius();
    }
}

bool Human::IsDead(Room * room)
{
    return dead;
}

long long Human::GetDeadFrameNo(Room* room)
{
    return dead_frameno;
}

void Human::FillItemList(::google::protobuf::RepeatedPtrField<::cs::MFPair>* pb_item_list)
{
    for (auto& pair : items_) {
        auto p = pb_item_list->Add();
        p->set_key(pair.first);
        p->set_value(pair.second);
    }
}

long long Human::GetRealDeadFrameNo(Room* room)
{
    return real_dead_frameno;
}

void Human::FillMFTeamData(cs::MFTeamData* team_data, bool is_game_over)
{
    {
        last_sync_teamdata_frameno_ = room->GetFrameNo();

        team_data->set_player_id(GetEntityUniId());
        if (is_game_over || !real_dead || room->GetFrameNo() - GetRealDeadFrameNo(room) < 4) {
            TypeConvert::ToPb(GetPos(), team_data->mutable_pos());
            TypeConvert::ToPb(GetAttackDir(), team_data->mutable_dir());
            team_data->set_health(GetHP());
            team_data->set_max_health(GetMaxHP());
            team_data->set_dead(dead);
            team_data->set_downed(downed);
        }

        if (is_game_over || room->GetGasData().gas_mode == GasInactive) {
            team_data->set_name(name);
        }

        if (room->GetGasData().gas_mode != GasInactive &&
            room->GetFrameNo() - room->GetBattleStartFrameNo() < 4) {
            team_data->set_name(name);
            team_data->set_disconnected(socket_handle == 0);
        }

        if (is_game_over) {
            team_data->set_account_id(account_id);
            team_data->set_avatar_url(avatar_url);
            team_data->set_user_value1(user_value1);
            team_data->set_user_value2(user_value2);
            team_data->set_user_value3(user_value3);
            if (guild_id != 0) {
                team_data->set_guild_id(guild_id);
            }
        }
        if (vip_lv != 0) {
            team_data->set_vip_lv(vip_lv);
        }
        if (head != 0) {
            team_data->set_head(head);
        }
        if (sex != 0) {
            team_data->set_sex(sex);
        }
        if (room->GetGasData().gas_mode == GasInactive ||
            room->GetFrameNo() - room->GetBattleStartFrameNo() < 4) {
            team_data->set_user_data(user_data);
        }
    }
}

void Human::CarShot(const a8::Vec2& target_dir)
{
    if (!second_weapon.meta) {
        return;
    }

    if (second_weapon.weapon_idx != 0 &&
        second_weapon.ammo <= 0) {
        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();
    }

    InternalShot(this,
                 second_weapon.meta,
                 second_weapon.GetUpgradeMeta(),
                 second_weapon.bullet_meta,
                 second_weapon.weapon_lv,
                 0,
                 5,
                 false);

    --second_weapon.ammo;
    last_shot_frameno_ = room->GetFrameNo();
}

void Human::RecalcSelfCollider()
{
    if (!self_collider_) {
        self_collider_ = new CircleCollider();
        self_collider_->owner = this;
        AddEntityCollider(self_collider_);
    }
    self_collider_->pos = a8::Vec2();
    self_collider_->rad = meta->i->radius();
    Buff* buff = GetBuffByEffectId(kBET_Car);
    if (buff) {
        MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(buff->meta->param4);
        if (equip_meta &&
            equip_meta->i->rad() > 1 &&
            equip_meta->i->equip_type() == EQUIP_TYPE_CAR
            ) {
            self_collider_->rad = equip_meta->i->rad();
        }
    }
}

bool Human::IsCollisionInMapService()
{
    Global::last_collider = nullptr;
    if (room->OverBorder(GetPos(), meta->i->radius())){
        return true;
    }
    if (HasBuffEffect(kBET_ThroughWall) ||
        HasBuffEffect(kBET_Fly)) {
        return false;
    }

    std::set<ColliderComponent*> colliders;
    room->map_service->GetColliders(room, GetX(), 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->IsDead(room) &&
                    (
                     (collider->type == CT_Aabb && aabb_box.Intersect((ColliderComponent*)collider)) ||
                     (collider->type == CT_Circle && self_collider_->Intersect((ColliderComponent*)collider))
                     ) &&
                    !obstacle->CanThroughable(this)) {
                    if (last_collision_door_ != collider->owner) {
                        if (!obstacle->IsDead(room) &&
                            obstacle->Attackable() &&
                            obstacle->meta->i->drop() != 0 &&
                            room->GetGasData().gas_mode != GasInactive &&
                            (!obstacle->IsTerminatorAirDropBox(room) || GetRace() == kHumanRace)
                            ) {
                            obstacle->Die(room);
                            if (obstacle->IsDead(room)) {
                                #if 0
                                if (obstacle->meta->i->damage_dia() > 0.01f &&
                                    obstacle->meta->i->damage() > 0.01f) {
                                    obstacle->Explosion(this);
                                }
                                #endif
                                DropItems(obstacle);
                            }
                            obstacle->BroadcastFullState(room);
                            if (obstacle->IsTerminatorAirDropBox(room) &&
                                GetRace() == kHumanRace &&
                                !HasBuffEffect(kBET_Terminator)) {
                                MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(TERMINATOR_BUFF_ID);
                                if (buff_meta) {
                                    AddBuff(this, buff_meta, 1);
                                }
                            }
                        } else {
                            Global::last_collider = collider;
                            return true;
                        }
                    }
                }
            }
            break;
        case ET_Building:
            {
#if 1
                if (
                    (
                     (collider->type == CT_Aabb && aabb_box.Intersect((ColliderComponent*)collider)) ||
                     (collider->type == CT_Circle && self_collider_->Intersect((ColliderComponent*)collider))
                     )
                    ) {
#else
                if (!collider->owner->dead && TestCollision((ColliderComponent*)collider)) {
#endif
                    if (last_collision_door_ != collider->owner) {
                        Global::last_collider = collider;
                        return true;
                    }
                }
            }
            break;
        default:
            break;
        }
    }
    return false;
}

void Human::FindPathInMapService()
{
    a8::Vec2 old_pos = GetPos();
    ColliderComponent* last_collider = Global::last_collider;
    if (last_collider) {
        switch (last_collider->type) {
        case CT_Aabb:
            {
            }
            break;
        case CT_Circle:
            {
                a8::Vec2 extend_dir = GetPos() - last_collider->owner->GetPos();
                if (std::abs(extend_dir.x) > FLT_EPSILON ||
                    std::abs(extend_dir.y) > FLT_EPSILON) {
                    extend_dir.Normalize();
                    {
                        #if 0
                        a8::Vec2 extend_dir_inverse(extend_dir.y, extend_dir.x);
                        float angle = extend_dir_inverse.CalcAngle(move_dir);
                        if (angle > 0.001f) {
                            extend_dir.Rotate(-1/180.0f);
                        } else {
                            extend_dir.Rotate(1/180.0f);
                        }
                        #endif
                        extend_dir.Rotate(1/180.0f);
                    }
                    float distance = ((CircleCollider*)last_collider)->rad + meta->i->radius();
                    SetPos(last_collider->owner->GetPos() + extend_dir * (distance + 1));
                    if (IsCollisionInMapService()) {
                        SetPos(old_pos);
                    }
                }
                return;
            }
            break;
        default:
            break;
        }
    }
    {
        float up_dot = a8::Vec2::UP.Dot(GetMoveDir());
        bool at_left_side = a8::Vec2::LEFT.Dot(GetMoveDir()) > 0.0001f;
        if (std::abs(up_dot) <= 0.001f) { //相互垂直
            //向上
            SetPos(old_pos + a8::Vec2::UP);
            if (!IsCollisionInMapService()) {
                return;
            } else {
                //向下
                SetPos(old_pos + a8::Vec2::DOWN);
                if (!IsCollisionInMapService()) {
                    return;
                }
            }
        } else if (up_dot > 0.001f) { //基本相同
            SetPos(old_pos + (at_left_side ? a8::Vec2::LEFT : a8::Vec2::RIGHT));
            if (!IsCollisionInMapService()) {
                return;
            } else {
                //向上
                SetPos(old_pos + a8::Vec2::UP);
                if (!IsCollisionInMapService()) {
                    return;
                }
            }
        } else if (up_dot < 0.001f) { //基本相反
            SetPos(old_pos + (at_left_side ? a8::Vec2::LEFT : a8::Vec2::RIGHT));
            if (!IsCollisionInMapService()) {
                return;
            } else {
                //向下
                SetPos(old_pos + a8::Vec2::DOWN);
                if (!IsCollisionInMapService()) {
                    return;
                }
            }
        }
    }
    SetPos(old_pos);
}

void Human::FillSMGameOver(cs::SMGameOver& msg)
{
    if (stats.rank <= 0) {
        std::vector<Human*> human_list;
        room->TraverseHumanList(a8::XParams(),
                             [&human_list] (Human* hum, a8::XParams& param) -> bool
                             {
                                 if (hum->leave_frameno_ == 0 ||
                                     hum->leave_frameno_ > hum->room->GetBattleStartFrameNo()) {
                                     human_list.push_back(hum);
                                 }
                                 return true;
                             });
        std::sort(human_list.begin(), human_list.end(),
                  [] (Human* a, Human* b )
                  {
                      if (a->real_dead && b->real_dead) {
                          if (a->dead_frameno == b->dead_frameno) {
                              return a->GetEntityUniId() < b->GetEntityUniId();
                          } else {
                              return a->dead_frameno == 0 ||
                                  (b->dead_frameno != 0 && a->dead_frameno > b->dead_frameno);
                          }
                      } else {
                          if (a->real_dead) {
                              return false;
                          }
                          if (b->real_dead) {
                              return true;
                          }
                          return a->GetEntityUniId() < b->GetEntityUniId();
                      }
                  });
        int rank = human_list.size();
        for (size_t i = 0; i < human_list.size(); ++i) {
            if (human_list[i] == this) {
                rank = i + 1;
                break;
            }
        }
        if (room->GetAliveTeamNum() == 1) {
            std::set<Human*>* alive_team = room->GetAliveTeam();
            if (alive_team == team_members) {
                rank = 1;
            }
        }
        stats.rank = rank;
    }

    msg.set_team_id(team_id);
    msg.set_team_rank(stats.rank);
    msg.set_team_allcnt(1);
    msg.set_game_over(room->IsGameOver());
    msg.set_victory(!dead);
    msg.set_room_uuid(a8::XValue(room->GetRoomUuid()));
    msg.set_total_human_num(room->GetHumanNum());
    msg.set_alive_human_num(room->AliveCount());

    {
        for (auto& itr : *team_members) {
            if (itr != this) {
                itr->FillMFTeamData(msg.add_team_data(), true);
            }
        }
    }
    {
        cs::MFPlayerStats* p = msg.add_player_stats();
        FillMFPlayerStats(p);
    }
    {
        for (auto& pair : spoils_items) {
            auto p = msg.add_spoils_items();
            p->add_values(pair.first);
            p->add_values(pair.second);
        }
    }
}

void Human::BeKill(int killer_id, const std::string& killer_name, int weapon_id)
{
    #ifdef DEBUG
    room->CheckPartObjects();
    #endif
    if (!dead && !room->IsGameOver() && !real_dead) {
        lethal_weapon = weapon_id;
        Entity* hum = room->GetEntityByUniId(killer_id);
        if (hum && hum->IsEntityType(ET_Player)) {
            Creature* killer = (Creature*)hum;
            if (killer_id == GetEntityUniId()) {
                std::string msg = a8::Format(TEXT("battle_server_dead_specate", "%s 自杀").c_str(),
                                             {
                                              killer_name,
                                             });
                SendRollMsg(msg, killer->GetEntityUniId(), killer->team_id);
            } else {
                ((Human*)hum)->stats.kills++;
                ((Human*)hum)->stats.last_kill_frameno = room->GetFrameNo();
                ((Human*)hum)->kill_humans.insert(this);
                ((Human*)hum)->SyncAroundPlayers(__FILE__, __LINE__, __func__);
                if (weapon_id == VW_Tank) {
                    std::string msg = a8::Format(TEXT("battle_server_dead_car", "%s 使用 载具 干掉了 %s").c_str(),
                                                 {
                                                  killer_name,
                                                  name
                                                 });
                    SendRollMsg(msg, killer->GetEntityUniId(), killer->team_id);
                } else {
                    MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(weapon_id);
                    if (equip_meta) {
                        std::string msg = a8::Format(TEXT("battle_server_dead_weapon", "%s 使用 %s 干掉了 %s").c_str(),
                                                     {
                                                      killer_name,
                                                      equip_meta->i->name(),
                                                      name
                                                     });
                        SendRollMsg(msg, killer->GetEntityUniId(), killer->team_id);
                    }
                }
            }
        } else {
            switch (weapon_id) {
            case VW_SafeArea:
                {
                    std::string msg = a8::Format(TEXT("battle_server_dead_gas", "%s 被毒圈干掉").c_str(),
                                                 {
                                                  name
                                                 });
                    SendRollMsg(msg, 0, 0);
                }
                break;
            case VW_Spectate:
                {
                    std::string msg = a8::Format(TEXT("battle_server_dead_specate", "%s 自杀").c_str(),
                                                 {
                                                  name
                                                 });
                    SendRollMsg(msg, 0, 0);
                }
                break;
            case VW_SelfDetonate:
                {
                    std::string msg = a8::Format(TEXT("battle_server_dead_self_detonate", "%s 被炸死").c_str(),
                                                 {
                                                  name
                                                 });
                    SendRollMsg(msg, 0, 0);
                }
                break;
            case VW_Mine:
                {
                    std::string msg = a8::Format(TEXT("battle_server_dead_mine", "%s 被地雷炸死").c_str(),
                                                 {
                                                  name
                                                 });
                    SendRollMsg(msg, 0, 0);
                }
                break;
            }
        }
        ++stats.dead_times;
        stats.killer_id = killer_id;
        stats.killer_name = killer_name;
        stats.weapon_id = weapon_id;
        if (room->GetRoomMode() == kZombieMode) {
            dead = true;
            downed = false;
            real_dead = true;
            dead_frameno = room->GetFrameNo();
            DoGetDown();
            if (HasBuffEffect(kBET_Camouflage)) {
                RemoveBuffByEffectId(kBET_Camouflage);
            }
            ClearLordMode();
            ClearBuffList();
            room->frame_event.AddDead(GetWeakPtrRef(),
                                      meta->i->revive_time() * 1000);
            SyncAroundPlayers(__FILE__, __LINE__, __func__);
            room->xtimer.AddDeadLineTimerAndAttach
                (meta->i->revive_time() * SERVER_FRAME_RATE,
                 a8::XParams()
                 .SetSender(this),
                 [] (const a8::XParams& param)
                 {
                     Human* hum = (Human*)param.sender.GetUserData();
                     hum->Revive();
                 },
                 &xtimer_attacher.timer_list_
                 );
            room->OnHumanDie(this);
        } else {
            dead = true;
            downed = false;
            ability.hp = 0.0f;
            dead_frameno = room->GetFrameNo();
            ++dead_times;
            if (HasBuffEffect(kBET_Camouflage)) {
                RemoveBuffByEffectId(kBET_Camouflage);
            }
            ClearLordMode();
            room->frame_event.AddDead(GetWeakPtrRef(),
                                      0);
#ifdef DEBUG
            room->CheckPartObjects();
#endif
            #if 1
            real_dead = true;
            OnDie();
            #else
            int max_revive_times = MetaMgr::Instance()->GetSysParamAsInt("max_revive_times", 1);
            if (weapon_id != VW_Spectate &&
                dead_times <= max_revive_times &&
                room->AliveCount() >= 5 &&
                IsEntitySubType(EST_Player)) {
                Revive();
            } else {
                real_dead = true;
                OnDie();
            }
            #endif
            DoGetDown();
        }
    }
}

void Human::DecHP(float dec_hp, int killer_id, const std::string& killer_name, int weapon_id)
{
    #ifdef DEBUG
    #if 0
    if (IsPlayer()) {
        return;
    }
    #endif
    #endif
    {
        Buff* buff = GetBuffByEffectId(kBET_Shield);
        if (buff) {
            dec_hp = std::max((float)1.0, dec_hp - buff->meta->param2);
        }
    }
    auto downed_func =
        [] (const a8::XParams& param)
        {
            Human* hum = (Human*)param.sender.GetUserData();
            if (!hum->downed) {
                hum->FreeDownedTimer();
                return;
            }
            if (hum->dead) {
                hum->FreeDownedTimer();
                return;
            }
            if (!hum->HasLiveTeammate()) {
                hum->FreeDownedTimer();
                hum->BeKill(param.param1, param.param2, param.param3);
                return;
            }
            int dec_hp = MetaMgr::Instance()->GetSysParamAsInt("downed_dec_hp");
            hum->DecHP(dec_hp, param.param1, param.param2, param.param3);
        };
    if (energy_shield > 0.001f) {
        energy_shield = std::max(0.0f, energy_shield - dec_hp);
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    } else {
        float old_health = GetHP();
        float new_health = std::max(0.0f, GetHP() - dec_hp);
        AdjustDecHp(old_health, new_health);
        ability.hp = std::max(0.0f, new_health);
        if (GetHP() - old_health > 0.001f) {
            stats.damage_amount_in += GetHP() - old_health;
        }
        if (GetHP() <= 0.0001f && !dead) {
            if (downed) {
                if (downed_timer) {
                    room->xtimer.DeleteTimer(downed_timer);
                }
                downed = false;
                downed_timer = nullptr;
                BeKill(killer_id, killer_name, weapon_id);
                SyncAroundPlayers(__FILE__, __LINE__, __func__);
            } else {
                if (HasNoDownedTeammate()) {
                    ability.hp = MetaMgr::Instance()->GetSysParamAsInt("downed_recover_hp");
                    downed = true;
                    if (HasBuffEffect(kBET_Camouflage)) {
                        RemoveBuffByEffectId(kBET_Camouflage);
                    }
                    CancelAction();
                    DoGetDown();
                    downed_timer = room->xtimer.AddRepeatTimerAndAttach
                        (
                         SERVER_FRAME_RATE,
                         a8::XParams()
                         .SetSender(this)
                         .SetParam1(killer_id)
                         .SetParam2(killer_name)
                         .SetParam3(weapon_id),
                         downed_func,
                         &xtimer_attacher.timer_list_
                         );
                    SyncAroundPlayers(__FILE__, __LINE__, __func__);
                    if (GetNearbyTeammateNum(MetaMgr::Instance()->refresh_ai_downed_nearby_range) <
                        MetaMgr::Instance()->refresh_ai_downed_nearby_teammate_num) {
                        #if 0
                        room->GetIncubator()->AllocAndroid(this, 1 + rand() % 2);
                        #endif
                    }
                } else {
                    BeKill(killer_id, killer_name, weapon_id);
                }
            }
        }
        room->frame_event.AddHpChg(GetWeakPtrRef());
    }
}

void Human::AddToNewObjects(Entity* entity)
{
    new_objects.insert(entity);
}

void Human::AddToPartObjects(Entity* entity)
{
    PartObject part_obj;
    part_obj.entity_uniid = entity->GetEntityUniId();
    part_obj.entity_type = entity->GetEntityType();
    part_obj.entity_subtype = entity->GetEntitySubType();
    part_obj.add_frameno = room->GetFrameNo();
    part_objects[entity] = part_obj;
    entity->OnAddToTargetPartObject(this);
}

void Human::RemovePartObjects(Entity* entity)
{
    part_objects.erase(entity);
    entity->OnRemoveFromTargetPartObject(this);
}

void Human::ClearPartObjects()
{
    part_objects.clear();
}

int Human::GetPartObjectsCount()
{
    return part_objects.size();
}

bool Human::InNewObjects(Entity* target)
{
    return new_objects.find(target) != new_objects.end();
}

bool Human::InPartObjects(Entity* target)
{
    return part_objects.find(target) != part_objects.end();
}

void Human::RemoveObjects(Entity* entity)
{
    del_objects.insert(entity->GetEntityUniId());
}

void Human::AddOutObjects(Entity* entity)
{
    out_objects.insert(entity->GetEntityUniId());
}

void Human::RemoveOutObjects(Entity* entity)
{
    out_objects.erase(entity->GetEntityUniId());
}

bool Human::HasLiveTeammate()
{
    if (room->GetRoomMode() == kZombieMode) {
        return true;
    }
    if (team_members) {
        for (auto& hum : *team_members) {
            if (hum != this && !hum->dead) {
                return true;
            }
        }
    }
    return false;
}

bool Human::HasNoDownedTeammate()
{
    if (room->GetRoomMode() == kZombieMode) {
        if (GetRace() == kHumanRace) {
            bool has_now_downed_teammate = false;
            Human* myself = this;
            room->TraverseHumanList
                (
                 a8::XParams(),
                 [myself, &has_now_downed_teammate] (Human* hum, const a8::XParams& param)
                 {
                     if (myself != hum &&
                         !hum->dead &&
                         !hum->downed &&
                         hum->GetRace() == kHumanRace) {
                         has_now_downed_teammate = true;
                         return false;
                     }
                     return true;
                 }
                 );
            return has_now_downed_teammate;
        } else {
            return false;
        }
    }
    if (team_members) {
        for (auto& hum : *team_members) {
            if (hum != this && !hum->dead && !hum->downed) {
                return true;
            }
        }
    }
    return false;
}

int Human::GetNearbyTeammateNum(float range)
{
    int num = 0;
    if (team_members) {
        for (auto& hum : *team_members) {
            if (hum != this && !hum->dead && !hum->downed) {
                if (hum->GetPos().Distance(GetPos()) <= range) {
                    ++num;
                }
            }
        }
    }
    return num;
}

bool Human::CanUseSkill(int skill_id)
{
    return !downed && Creature::CanUseSkill(skill_id);
}

void Human::DoJump()
{
    if (HasBuffEffect(kBET_Fly)) {
        a8::UnSetBitFlag(status, HS_DisableAttack);
        RemoveBuffByEffectId(kBET_Fly);
        MustBeAddBuff(this, kThroughWall_BUFFID);
        MustBeAddBuff(this, JUMP_BUFFID);
        jump_frameno_ = room->GetFrameNo();
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    }
}

Skill* Human::SelectSkill()
{
    return nullptr;
}

void Human::DoGetOn(int obj_uniid)
{
    if (room->GetGasData().gas_mode == GasInactive) {
        return;
    }
    Entity* entity = room->GetEntityByUniId(obj_uniid);
    if (!entity) {
        return;
    }
    if (GetPos().Distance(entity->GetPos()) > MetaMgr::Instance()->max_mount_horse_distance) {
        return;
    }
    if (downed) {
        return;
    }
    switch (entity->GetEntityType()) {
    case ET_Loot:
        {
            DoGetOnWithLoot((Loot*)entity);
        }
        break;
    case ET_Car:
        {
            DoGetOnWithCar((Car*)entity);
        }
        break;
    default:
        break;
    }
}

void Human::FindLocation()
{
    Entity* target = nullptr;
    TraverseAllLayerEntityList
        (
         [this, &target] (Entity* entity, bool& stop)
         {
             switch (entity->GetEntityType()) {
             case ET_Obstacle:
                 {
                    if (!target) {
                        if (TestCollision(room, entity)) {
                            target = entity;
                        }
                    }
                 }
                 break;
             case ET_Building:
                 {
                     if (!target || !target->IsEntityType(ET_Building)) {
                         AabbCollider aabb_box;
                         entity->GetAabbBox(aabb_box);
                         if (TestCollision(room, &aabb_box)) {
                             target = entity;
                         }
                     }
                 }
                 break;
             default:
                 {
                 }
                 break;
             }
         });
    if (target) {
        FindLocationWithTarget(target);
    }
}

void Human::RefreshView()
{
    TraverseAllLayerHumanList
        (
         [this] (Human* hum, bool& stop)
         {
             hum->AddToNewObjects(this);
             hum->AddToPartObjects(this);
             AddToNewObjects(hum);
             AddToPartObjects(hum);
         });
    TraverseAllLayerEntityList
        (
         [this] (Entity* entity, bool& stop)
         {
             switch (entity->GetEntityType()) {
             case ET_Building:
             case ET_Obstacle:
             case ET_Loot:
                 {
                     AddToNewObjects(entity);
                 }
                 break;
             default:
                 {
                 }
                 break;
             }
         });
}

void Human::OnGridListChange(std::set<GridCell*>& old_grids,
                             std::set<GridCell*>& inc_grids,
                             std::set<GridCell*>& dec_grids
                             )
{
    ProcIncGridList(old_grids, inc_grids, dec_grids);
    ProcDecGridList(old_grids, inc_grids, dec_grids);

    if (IsPlayer() && on_grid_chg) {
        on_grid_chg(this);
    }
}

void Human::SyncAroundPlayers(const char* file, int line, const char* func)
{
    #if 0
    if (a8::HasBitFlag(status, HS_Disable)) {
        return;
    }
    #endif
    #ifdef DEBUG
    #if 0
    room->CheckPartObjects();
    a8::UdpLog::Instance()->Debug("room_idx:%d syncaround begin %s %d %s",
                                  {
                                   room->GetRoomIdx(),
                                   file,
                                   line,
                                   func
                                  });
    #endif
    #endif
    TraverseAllLayerHumanList
        (
         [this, file, line, func] (Human* hum, bool& stop)
         {
             hum->AddToNewObjects(this);
#ifdef DEBUG
             #if 0
            {
                std::string objs_str;
                for (auto& obj : hum->part_objects) {
                    objs_str += a8::Format("%d ", {(long long)obj});
                }
                a8::UdpLog::Instance()->Debug("hum1 %d    %s", {(long long)hum, objs_str});
            }
            {
                std::string objs_str;
                for (auto& obj : part_objects) {
                    objs_str += a8::Format("%d ", {(long long)obj});
                }
                a8::UdpLog::Instance()->Debug("hum2 %d    %s", {(long long)this, objs_str});
            }
            room->CheckPartObjects(hum, this);
            hum->InPartObjects(this);
            #endif
#endif
            assert(hum->InPartObjects(this));
            if (!hum->InPartObjects(this)) {
                static long long last_debugout_tick = 0;
                if (a8::XGetTickCount() - last_debugout_tick > 1000 * 10) {
                    last_debugout_tick = a8::XGetTickCount();
                    a8::UdpLog::Instance()->Warning
                        ("SyncAroundPlayers error room_idx:%d, file:%s line:%d func:%s",
                         {
                          room->GetRoomIdx(),
                          file,
                          line,
                          func
                         });
                }
            }
         });
#ifdef DEBUG
    #if 0
    room->CheckPartObjects();
    a8::UdpLog::Instance()->Debug("syncaround end %s %d %s",
                                  {
                                   file,
                                   line,
                                   func
                                  });
    #endif
#endif
}

void Human::FillMFActivePlayerData(cs::MFActivePlayerData* player_data)
{
    {
        player_data->set_action_type(action_type);
        if (action_type != AT_None) {
            int duration = std::max(0,
                                    action_duration -
                                    (int)((room->GetFrameNo() - action_frameno) * 1.0f / SERVER_FRAME_RATE) * 1000
                                    );
            player_data->set_action_item_id(action_item_id);
            player_data->set_action_duration(duration);
            player_data->set_action_target_id(action_target_id);
        }
    }
    #if 1
    for (auto itr : skins) {
        auto skin = player_data->add_skin();
        itr.ToPB(skin);
    }
    #else
    skin.ToPB(player_data->mutable_skin());
    #endif
    player_data->set_backpack(backpack);
    player_data->set_helmet(helmet);
    player_data->set_chest(chest);
    player_data->set_health(GetHP());
    player_data->set_max_health(GetMaxHP());
    player_data->set_cur_weapon_idx(GetCurrWeapon()->weapon_idx);
    player_data->set_cur_scope(curr_scope_idx);
    for (auto& weapon : weapons) {
        auto p = player_data->add_weapons();
        weapon.ToPB(p);
    }
    for (auto& num : GetInventoryData()) {
        player_data->add_inventory(num);
    }
    player_data->set_energy_shield(energy_shield);
    #if 1
    {
        player_data->set_max_energy_shield(max_energy_shield);
    }
    #endif
    FillBodyState(player_data->mutable_states());
    FillItemList(player_data->mutable_items());
    FillSkillList(player_data->mutable_skill_list());
    player_data->set_shoot_offset_x(shoot_offset.x);
    player_data->set_shoot_offset_y(shoot_offset.y);
}

void Human::FillMFGasData(cs::MFGasData* gas_data)
{
    gas_data->set_mode(room->GetGasData().gas_mode);
    if (room->GetGasData().gas_mode == GasInactive) {
        long long duration = room->GetGasInactiveTime() * SERVER_FRAME_RATE -
            (room->GetFrameNo() - room->GetGasData().gas_start_frameno);
        gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
    } else if (room->GetGasData().gas_mode == GasJump) {
        gas_data->set_duration(0);
   } else if (room->GetGasData().gas_mode == GasMoving) {
        if (room->GetGasData().new_area_meta->i->shrink_speed() > 0.01f) {
            long long duration = (room->GetGasData().old_area_meta->i->rad() - room->GetGasData().new_area_meta->i->rad()) /
                room->GetGasData().new_area_meta->i->shrink_speed();
            ++duration;
            gas_data->set_duration(++duration);
        } else {
            gas_data->set_duration(0);
        }
     } else {
        if (room->GetGasData().old_area_meta->i->wait_time() <= 0) {
            gas_data->set_duration(0);
        } else {
            long long duration = room->GetGasData().old_area_meta->i->wait_time() * 20 -
                (room->GetFrameNo() - room->GetGasData().gas_start_frameno);
            gas_data->set_duration(std::max(duration * 50, (long long)1000) / 1000);
        }
    }
    TypeConvert::ToPb(room->GetGasData().pos_old, gas_data->mutable_pos_old());
    TypeConvert::ToPb(room->GetGasData().pos_new, gas_data->mutable_pos_new());
    gas_data->set_rad_old(room->GetGasData().rad_old);
    gas_data->set_rad_new(room->GetGasData().rad_new);
}

void Human::RecalcVolume()
{
    MetaData::Equip* backpack_meta = MetaMgr::Instance()->GetEquip(backpack);
    if (backpack_meta) {
        for (size_t i = 0; i < backpack_meta->volume.size(); ++i) {
            volume_[i] = meta->volume[i] + backpack_meta->volume[i];
        }
    }
}

void Human::RecalcBaseAttr()
{
    ability.def = meta->i->def();
    MetaData::Equip* chest_meta = MetaMgr::Instance()->GetEquip(chest);
    if (chest_meta) {
        ability.def += chest_meta->i->def();
    }
    MetaData::Equip* helmet_meta = MetaMgr::Instance()->GetEquip(helmet);
    if (helmet_meta) {
        ability.def += helmet_meta->i->def();
    }
    ability.max_hp = std::max(ability.hp, ability.max_hp);
}

int Human::GetVolume(int slot_id)
{
    if (!IsValidSlotId(slot_id)) {
        abort();
    }
    return volume_[slot_id];
}

void Human::RecoverHp(int inc_hp)
{
    if (!dead) {
        ability.hp += inc_hp;
        ability.hp = std::max(GetHP(), GetMaxHP());
    }
}

void Human::FillBodyState(::google::protobuf::RepeatedPtrField<::cs::MFBodyState>* states)
{
    if (pain_killer_timer) {
        int passed_time = (room->GetFrameNo() - pain_killer_frameno) * FRAME_RATE_MS;
        int left_time = std::max(0, pain_killer_lastingtime * 1000 - passed_time);
        int anodyne_max_time = MetaMgr::Instance()->GetSysParamAsInt("anodyne_max_time");
        left_time = std::min(left_time, anodyne_max_time * 1000);

        cs::MFBodyState* state = states->Add();
        state->set_state_type(1);
        state->set_left_time(left_time);
        state->set_lasting_time(anodyne_max_time * 1000);
    }
}

void Human::AddObserver(Human* observer)
{
    observers_.insert(observer);
}

void Human::RemoveObserver(Human* observer)
{
    observers_.erase(observer);
}

void Human::SendUpdateMsg()
{
    if (!follow_target_ && !a8::HasBitFlag(status, HS_Disable) && IsPlayer()) {
        #ifdef DEBUG
        long long begin_tick = a8::XGetTickCount();
        long long end_tick = a8::XGetTickCount();
        #endif
        cs::MFActivePlayerData* active_player_data_pb = nullptr;
        if (send_msg_times == 0 || need_sync_active_player) {
            active_player_data_pb = new cs::MFActivePlayerData();
            FillMFActivePlayerData(active_player_data_pb);
            need_sync_active_player = false;
        }
        #ifdef DEBUG
        end_tick = a8::XGetTickCount();
        if (a8::XGetTickCount() - begin_tick > 1000) {
            abort();
        }
        begin_tick = a8::XGetTickCount();
        #endif

        cs::SMUpdate* msg = room->frame_maker.MakeUpdateMsg(this);
        if (send_msg_times == 0 || last_sync_gas_frameno < room->GetGasData().gas_start_frameno) {
            last_sync_gas_frameno = room->GetGasData().gas_start_frameno;
            FillMFGasData(msg->mutable_gas_data());
        }
        #ifdef DEBUG
        end_tick = a8::XGetTickCount();
        if (a8::XGetTickCount() - begin_tick > 1000) {
            abort();
        }
        begin_tick = a8::XGetTickCount();
        #endif
        NotifyObservers(msg, active_player_data_pb);
        delete msg;

        if (active_player_data_pb) {
            delete active_player_data_pb;
        }
        ++send_msg_times;
    } else {
        need_sync_active_player = false;
    }
    ClearFrameData();
}

void Human::SendGameOver()
{
    if (IsEntitySubType(EST_Player)) {
        //!!!必须要在SendNotifyMsg之前注意哦
        if (!sent_battlereport_) {
            SendBattleReport();
            sent_battlereport_ = true;
            GameLog::Instance()->GameEnd((Player*)this);
        }
        {
            cs::SMGameOver msg;
            FillSMGameOver(msg);
            SendNotifyMsg(msg);
        }
    }
}

void Human::FollowTarget(Human* target)
{
    if (target == this) {
        return;
    }
    if (follow_target_) {
        follow_target_->RemoveObserver(this);
    }
    target->AddObserver(this);
    follow_target_ = target;
    follow_synced_active_player = false;
}

void Human::SendDebugMsg(const std::string& debug_msg)
{
    cs::SMDebugMsg notify_msg;
    notify_msg.set_debug_msg(debug_msg);
    SendNotifyMsg(notify_msg);
}

void Human::SendRollMsg(const std::string& msg, int killer_id, bool killer_team_id)
{
    room->xtimer.AddDeadLineTimerAndAttach
        (
         0,
         a8::XParams()
         .SetSender(this)
         .SetParam1(killer_id)
         .SetParam2(killer_team_id)
         .SetParam3(msg),
         [] (const a8::XParams& param)
         {
             Human* target = (Human*)param.sender.GetUserData();
             int killer_id = param.param1;
             int killer_team_id = param.param2;
             std::string text = param.param3.GetString();
             target->room->TraversePlayerList
                 (a8::XParams(),
                  [target, killer_id, killer_team_id, text] (Human* hum, a8::XParams& param) -> bool
                  {
                      cs::SMRollMsg msg;
                      auto element = msg.add_elements();
                      element->set_element_type(1);
                      element->mutable_union_obj_1()->set_text(text);
                      if (killer_id == hum->GetEntityUniId()){
                          element->mutable_union_obj_1()->set_color(MetaMgr::Instance()->self_kill_color);
                      } else if (killer_team_id == hum->team_id) {
                          element->mutable_union_obj_1()->set_color(MetaMgr::Instance()->teammate_kill_color);
                      } else if (target == hum) {
                          element->mutable_union_obj_1()->set_color(MetaMgr::Instance()->self_bekill_color);
                      } else if (target->team_id == hum->team_id) {
                          element->mutable_union_obj_1()->set_color(MetaMgr::Instance()->teammate_bekill_color);
                      }
                      hum->SendNotifyMsg(msg);
                      return true;
                  });
         },
         &xtimer_attacher.timer_list_,
         [] (const a8::XParams& param)
         {
         }
         );
}

void Human::UpdateAction()
{
    int passed_time = (room->GetFrameNo() - action_frameno) * FRAME_RATE_MS;
    int left_time = std::max(0, action_duration - passed_time);
    if (left_time <= 0) {
        switch (action_type) {
        case AT_Reload:
            {
                ProcReloadAction();
            }
            break;
        case AT_UseItem:
            {
                ProcUseItemAction();
            }
            break;
        case AT_Relive:
            {
                ProcReliveAction();
            }
            break;
        default:
            {
            }
            break;
        }
        ResetAction();
    }
}

void Human::SendUIUpdate()
{
    cs::SMUiUpdate notifymsg;
    notifymsg.set_alive_count(room->AliveCount());
    notifymsg.set_kill_count(stats.kills);
    room->FillSMUiUpdate(notifymsg);
    SendNotifyMsg(notifymsg);
}

void Human::SendWxVoip()
{
    cs::SMWxVoip notifymsg;
    if (!team_uuid.empty()) {
        notifymsg.set_group_id(a8::XValue(room->GetRoomUuid()).GetString() + "_" + a8::XValue(team_id).GetString());
    }
    SendNotifyMsg(notifymsg);
}

void Human::SendSysPiaoMsg(const std::string& msg, int color, int duration)
{
    cs::SMSysPiaoMsg notifymsg;
    notifymsg.set_msg(msg);
    notifymsg.set_color(color);
    notifymsg.set_duration(duration);
    SendNotifyMsg(notifymsg);
}

void Human::SendShowCountdown(const std::string& msg, int countdown)
{
    cs::SMShowCountdown notifymsg;
    notifymsg.set_msg(msg);
    notifymsg.set_countdown(countdown);
    SendNotifyMsg(notifymsg);
}

int Human::GetWeaponConfigLv(int weapon_id)
{
    auto itr = weapon_configs.find(weapon_id);
    return itr != weapon_configs.end() ? itr->second : 0;
}

int Human::GetSkinConfigLv(int skin_id)
{
    auto itr = skin_configs.find(skin_id);
    return itr != skin_configs.end() ? itr->second : 0;
}

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

void Human::_UpdateSpecMove()
{
    if (!HasSpecMove()) {
        return;
    }
    bool move_end = false;
    float target_distance = target_pos.Distance(GetPos());
    if (target_distance <= 0.000001f) {
        move_end = true;
    } else {
        a8::Vec2 old_move_dir = GetMoveDir();
        a8::Vec2 move_dir = target_pos - GetPos();
        move_dir.Normalize();
        SetMoveDir(move_dir);
        bool is_collision = false;
        std::function<bool ()> old_on_move_collision = on_move_collision;
        on_move_collision =
            [&is_collision] () {
                is_collision = true;
                return false;
            };

        _UpdateMove(std::min((int)target_distance, (int)GetSpeed()));

        on_move_collision = old_on_move_collision;
        move_dir = old_move_dir;
        target_distance = target_pos.Distance(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->i;
                float old_skill_distance = CurrentSkill()->meta->i->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, 1);
            }
            RemoveBuffByEffectId(kBET_BePull);
        }
    }
}

void Human::_UpdateMove(int speed)
{
    if (!HasBuffEffect(kBET_Vertigo)) {
        do {
            int distance = std::min(5, speed);
            _InternalUpdateMove(distance);
            speed -= distance;
        } while (speed > 0);
        CheckSpecObject();
    }
}

void Human::ChangeToRace(RaceType_e race, int level)
{
    if (race != kHumanRace &&
        race != kZombieRace) {
        abort();
    }
    if (race_ != race && IsAndroid()) {
        Android* android = (Android*)this;
        android->ai->Reset();
        if (race == kHumanRace) {
            android->ai->SetAiMode(kHumanAiMode);
        } else if (race == kZombieRace) {
            android->ai->SetAiMode(kZombieAiMode);
        }
    }
    race_ = race;
    level_ = level;
    if (race_ == kHumanRace) {
        meta = MetaMgr::Instance()->GetPlayer(HUMAN_RACE_META_START_ID + level_ - 1);
        if (!meta) {
            abort();
        }
        exp_ = meta->i->exp();
        OnMetaChange();
    } else if (race_ == kZombieRace) {
        DoGetDown();
        meta = MetaMgr::Instance()->GetPlayer(ZOMBIE_RACE_META_START_ID + level_ - 1);
        if (!meta) {
            abort();
        }
        exp_ = meta->i->exp();
        OnMetaChange();
    } else {
        abort();
    }
}

void Human::ChangeToRaceAndNotify(RaceType_e race, int level)
{
    ChangeToRace(race, level);
    room->frame_event.AddZombieIdChg(this);
}

void Human::WinExp(Human* sender, int exp)
{
    if (race_ != kHumanRace &&
        race_ != kZombieRace) {
        abort();
    }
    if (room->debug_trace) {
        a8::UdpLog::Instance()->Debug
            (
             "WinExp before sender_id:%d uniid:%d race:%d level:%d exp:%d add_exp:%d ",
             {
              sender->GetEntityUniId(),
              GetEntityUniId(),
              GetRace(),
              GetLevel(),
              GetExp(),
              exp
             }
             );
    }
    exp_ += exp;
    MetaData::Player* old_meta = meta;
    int start_meta_id = race_ == kHumanRace ? HUMAN_RACE_META_START_ID : ZOMBIE_RACE_META_START_ID;
    ClearSkill();
    do {
        MetaData::Player* tmp_meta = MetaMgr::Instance()->GetPlayer(start_meta_id + level_);
        if (!tmp_meta) {
            break;
        }
        if (exp_ >= tmp_meta->i->exp()) {
            meta = tmp_meta;
            AddSkill(meta->i->active_skill());
            ResetSkill();
            ++level_;
        } else {
            break;
        }
    } while (true);
    if (old_meta != meta) {
        room->frame_event.AddZombieIdChg(this);
        OnMetaChange();
        if (GetRace() == kZombieRace && meta->i->level() == 3) {
            room->OnZombieAppear(this);
        }
    }
    if (room->debug_trace) {
        a8::UdpLog::Instance()->Debug
            (
             "WinExp after sender_id:%d uniid:%d race:%d level:%d exp:%d add_exp:%d ",
             {
              sender->GetEntityUniId(),
              GetEntityUniId(),
              GetRace(),
              GetLevel(),
              GetExp(),
              exp
             }
             );
    }
}

void Human::_InternalUpdateMove(float speed)
{
    float nx = GetMoveDir().x * speed;
    float ny = GetMoveDir().y * speed;
    a8::Vec2 old_pos = GetPos();

    #if 1
    SetPos(old_pos + a8::Vec2(nx, ny));
    if (!IsCollisionInMapService()) {
        room->grid_service->MoveCreature(this);
        return;
    } else {
        if (Global::last_collider && Global::last_collider->type == CT_Circle) {
            SetPos(old_pos + a8::Vec2(nx, ny));
            if (self_collider_->Intersect(Global::last_collider)) {
                CircleCollider* circle_collider = (CircleCollider*)Global::last_collider;
                a8::Vec2 tmp_dir = GetPos() - (circle_collider->owner->GetPos() + circle_collider->pos);
                float len = circle_collider->rad + self_collider_->rad + 1;
                float rate = len - tmp_dir.Norm();
                tmp_dir.Normalize();
                a8::Vec2 new_dir = tmp_dir * rate;
                SetPos(GetPos() + new_dir);
            }
            if (!IsCollisionInMapService()) {
                room->grid_service->MoveCreature(this);
                return;
            }
        }
    }
    #endif

    SetPos(old_pos + a8::Vec2(nx, 0));
    if (IsCollisionInMapService()) {
        if (on_move_collision && !on_move_collision()) {
            SetPos(old_pos);
            return;
        }
        nx = 0;
    }

    SetPos(old_pos + a8::Vec2(nx, ny));
    if (IsCollisionInMapService()) {
        if (on_move_collision && !on_move_collision()) {
            SetPos(old_pos);
            return;
        }
        ny = 0;
    }

    SetPos(old_pos + a8::Vec2(nx, ny));
    room->grid_service->MoveCreature(this);
}

void Human::ClearFrameData()
{
    if (!new_objects.empty()) {
        new_objects.clear();
    }
    if (!del_objects.empty()) {
        if (!a8::HasBitFlag(status, HS_Disable)) {
            for (auto& itr : del_objects) {
                Entity* entity = room->GetEntityByUniId(itr);
                if (entity) {
                    RemovePartObjects(entity);
                    if (entity->IsEntityType(ET_Player)) {
                        Human* hum = (Human*)entity;
                        hum->RemovePartObjects(this);
                    }
#ifdef DEBUG1
                    room->CheckPartObjects();
#endif
                }
            }
        }
        del_objects.clear();
    }
    if (!out_objects.empty()) {
        if (!a8::HasBitFlag(status, HS_Disable)) {
            for (auto& itr : out_objects) {
                Entity* entity = room->GetEntityByUniId(itr);
                if (entity) {
                    RemovePartObjects(entity);
                    if (entity->IsEntityType(ET_Player)) {
                        Human* hum = (Human*)entity;
                        hum->RemovePartObjects(this);
                    }
                }
#ifdef DEBUG1
                room->CheckPartObjects();
#endif
            }
        }
        out_objects.clear();
    }
    if (!shots_.empty()) {
        shots_.clear();
    }
    if (!bullets_.empty()) {
        bullets_.clear();
    }
    if (!explosions_.empty()) {
        explosions_.clear();
    }
    if (!smokes_.empty()) {
        smokes_.clear();
    }
    if (!play_skills_.empty()) {
        play_skills_.clear();
    }
    if (!emotes_.empty()) {
        emotes_.clear();
    }
    if (!chged_bullet_nums_.empty()) {
        chged_bullet_nums_.clear();
    }
    if (!chged_hps_.empty()) {
        chged_hps_.clear();
    }
    if (!chged_buffs_.empty()) {
        chged_buffs_.clear();
    }
    if (!chged_skillcds_.empty()) {
        chged_skillcds_.clear();
    }
    if (!chged_skill_curr_times_.empty()) {
        chged_skill_curr_times_.clear();
    }
    if (!chged_items_.empty()) {
        chged_items_.clear();
    }
    if (!chged_weapon_ammo_.empty()) {
        chged_weapon_ammo_.clear();
    }
    if (!chged_level_.empty()) {
        chged_level_.clear();
    }
    if (!chged_exp_.empty()) {
        chged_exp_.clear();
    }
    if (!chged_race_.empty()) {
        chged_race_.clear();
    }
    if (!chged_zombieid_.empty()) {
        chged_zombieid_.clear();
    }
    if (!dead_alive_objs_.empty()) {
        dead_alive_objs_.clear();
    }
    if (!chged_cars_.empty()) {
        chged_cars_.clear();
    }
}

void Human::GenBattleReportData(a8::MutableXObject* params)
{
    params->SetVal("room_mode", room->GetRoomMode());
    int rank = 0;
    {
        std::vector<Human*> human_list;
        room->TraverseHumanList(a8::XParams(),
                             [&human_list] (Human* hum, a8::XParams& param) -> bool
                             {
                                 human_list.push_back(hum);
                                 return true;
                             });
        std::sort(human_list.begin(), human_list.end(),
                  [] (Human* a, Human* b )
                  {
                      if (a->real_dead && b->real_dead) {
                          if (a->dead_frameno == b->dead_frameno) {
                              return a->GetEntityUniId() < b->GetEntityUniId();
                          } else {
                              return a->dead_frameno == 0 ||
                                  (b->dead_frameno != 0 && a->dead_frameno > b->dead_frameno);
                          }
                      } else {
                          if (a->real_dead) {
                              return false;
                          }
                          if (b->real_dead) {
                              return true;
                          }
                          return a->GetEntityUniId() < b->GetEntityUniId();
                      }
                  });
        rank = human_list.size();
        for (size_t i = 0; i < human_list.size(); ++i) {
            if (human_list[i] == this) {
                rank = i + 1;
                break;
            }
        }
        if (room->GetAliveTeamNum() == 1) {
            std::set<Human*>* alive_team = room->GetAliveTeam();
            if (alive_team == team_members) {
                rank = 1;
            }
        }
    }
    stats.rank = rank;
    params->SetVal("account_id", account_id);
    params->SetVal("session_id", session_id);
    params->SetVal("map_id", room->GetMapMeta()->i->map_id());
    params->SetVal("map_name", room->GetMapMeta()->i->map_name());
    params->SetVal("map_tpl_name", room->GetMapTplName());
    params->SetVal("game_time", time(nullptr));
    params->SetVal("hurt", stats.damage_amount_in);
    params->SetVal("rank", rank);
    params->SetVal("kills", stats.kills);
    params->SetVal("harm", stats.damage_amount_out);
    params->SetVal("add_HP", stats.heal_amount);
    if (!dead) {
        params->SetVal("alive_time", room->GetFrameNo() * 1000.0f / SERVER_FRAME_RATE);
    } else {
        params->SetVal("alive_time", dead_frameno * 1000.0f / SERVER_FRAME_RATE);
    }
    params->SetVal("team_status", team_members && team_members->size() > 1 ? 1 : 0);
    params->SetVal("room_uuid", room->GetRoomUuid());

    int snipe_kill = 0;
    int rifle_kill = 0;
    int pistol_kill = 0;
    int submachine_kill = 0;
    for (Human* hum : kill_humans) {
        MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquip(hum->lethal_weapon);
        if (equip_meta) {
            switch (equip_meta->i->equip_subtype()) {
            case 7:
                {
                    //狙击枪
                    ++snipe_kill;
                }
                break;
            case 5:
                {
                    //步枪
                    ++rifle_kill;
                }
                break;
            case 2:
                {
                    //手枪
                    ++pistol_kill;
                }
                break;
            case 3:
                {
                    //冲锋枪
                    ++submachine_kill;
                }
                break;
            }
        }
    }
    params->SetVal("snipe_kill", snipe_kill);
    params->SetVal("rifle_kill", rifle_kill);
    params->SetVal("pistol_kill", pistol_kill);
    params->SetVal("submachine_kill", submachine_kill);

    params->SetVal("rescue_member", stats.rescue_member);
    params->SetVal("rescue_guild_member", stats.rescue_guild_member);
    {
        float rank_param = MetaMgr::Instance()->GetRankRewardParam(rank);
        float kill_param = MetaMgr::Instance()->GetKillRewardParam(stats.kills);
        int coin_num = (rank_param * MetaMgr::Instance()->rank_param) +
            (kill_param * MetaMgr::Instance()->kill_param);
        stats.gold = coin_num;
        params->SetVal("coin_num", coin_num);
    }
    {
        std::string items_str;
        MetaData::RankReward* rank_reward_meta = MetaMgr::Instance()->GetRankReward(rank);
#ifdef DEBUG1
        {
#else
        if (rank_reward_meta && rank_reward_meta->i->drop() > 0) {
#endif
#ifdef DEBUG1
            {
#else
            if (rand() % 100 < rank_reward_meta->i->drop()) {
#endif
                MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(grow_weapon.weapon_id);
                if (item_meta) {
                    MetaData::Drop* drop_meta = MetaMgr::Instance()->GetDrop(item_meta->i->drop_id());
                    if (drop_meta) {
                        std::vector<std::tuple<int, int, int>> drop_items;
                        drop_meta->RandItems(drop_items);
                        for (auto& item : drop_items) {
                            int item_id = std::get<0>(item);
                            int item_num = std::get<1>(item);
                            stats.items.push_back(std::make_pair(
                                                                 item_id,
                                                                 item_num
                                                                 ));
                            items_str += a8::Format("%d:%d|", {item_id, item_num});
                            #ifdef DEBUG
                            SendDebugMsg
                                (a8::Format("drop weapon_id:%d drop_id:%d item_id:%d item_num:%d",
                                            {
                                             grow_weapon.weapon_id,
                                             item_meta->i->drop_id(),
                                             item_id,
                                             item_num
                                            }));
                            #endif
                        }
                    }
                }
            }
        }//end if rank_reward_meta
        if (!items_str.empty() && items_str[items_str.size() - 1] == '|') {
            items_str.erase(items_str.begin() + items_str.size() - 1);
        }
        params->SetVal("items", items_str);
    }
    {
        stats.pass_score = MetaMgr::Instance()->GetKillPointParam1(stats.kills);
        stats.pass_score += MetaMgr::Instance()->GetRankPointParam1(rank);
        stats.rank_score = MetaMgr::Instance()->GetKillPointParam2(stats.kills);
        if (room->IsMiniRoom()) {
            stats.rank_score += MetaMgr::Instance()->GetRankPointParam3(rank);
        } else {
            stats.rank_score += MetaMgr::Instance()->GetRankPointParam2(rank);
        }
    }
    params->SetVal("score", 0);
    params->SetVal("pass_score", has_pass ? stats.pass_score * 2 : stats.pass_score);
    params->SetVal("rank_score", stats.rank_score);
}

void Human::GenZbModeBattleReportData(a8::MutableXObject* params)
{
    params->SetVal("room_mode", room->GetRoomMode());
    int rank = 0;
    {
        std::vector<Human*> human_list;
        room->TraverseHumanList(a8::XParams(),
                             [&human_list] (Human* hum, a8::XParams& param) -> bool
                             {
                                 human_list.push_back(hum);
                                 return true;
                             });
       std::sort(human_list.begin(), human_list.end(),
                  [] (Human* a, Human* b )
                  {
                      if (a->stats.kills > b->stats.kills) {
                          return true;
                      }
                      if (a->stats.kills < b->stats.kills) {
                          return false;
                      }
                      if (a->stats.last_kill_frameno < b->stats.last_kill_frameno) {
                          return true;
                      }
                      return a->GetEntityUniId() < b->GetEntityUniId();
                  });
       rank = human_list.size();
       for (size_t i = 0; i < human_list.size(); ++i) {
           if (human_list[i] == this) {
               rank = i + 1;
               break;
           }
       }
    }
    stats.rank = rank;
    params->SetVal("account_id", account_id);
    params->SetVal("session_id", session_id);
    params->SetVal("map_id", room->GetMapMeta()->i->map_id());
    params->SetVal("game_time", time(nullptr));
    params->SetVal("rank", rank);
    params->SetVal("kills", stats.kills);
    params->SetVal("room_uuid", room->GetRoomUuid());
}

void Human::DeadDrop()
{
    auto SkinCanDrop =
        [this] (Skin* skin) -> bool
        {
            #ifdef DEBUG
            return false;
            #else
            if (JsonDataMgr::Instance()->channel == kTouTiaoChannelId) {
                return false;
            } else {
                return skin->skin_id != 0;
            }
            #endif
        };

    if (GetRace() == kHumanRace &&
        !HasBuffEffect(kBET_Terminator) &&
        !(HasBuffEffect(kBET_Become) && GetBuffByEffectId(kBET_Become)->FreezeOperate())) {
        for (auto& weapon : weapons) {
            if (weapon.weapon_id != 0 &&
                weapon.weapon_id != default_weapon.weapon_id
                ) {
                a8::Vec2 drop_pos = GetPos();
                room->DropItem(drop_pos, weapon.weapon_id, 1, weapon.weapon_lv);
                weapon.Clear();
            }
        }
        {
            weapons[0] = default_weapon;
            SetCurrWeapon(&weapons[0]);
        }
    }
    {
        Skin* old_skin = GetSkinByIdx(kSkinSlot_HAT);
        if (old_skin && old_skin->skin_id != 0 && SkinCanDrop(old_skin)) {
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            room->CreateLoot(old_skin->skin_id, GetPos() + dir * (40 + rand() % 50), 1, 1);
            *old_skin = Skin();
        }
    }
    {
        Skin* old_skin = GetSkinByIdx(kSkinSlot_CLOTH);
        if (old_skin && old_skin->skin_id != 0 && SkinCanDrop(old_skin)) {
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            room->CreateLoot(old_skin->skin_id, GetPos() + dir * (40 + rand() % 50), 1, 1);
            *old_skin = Skin();
        }
    }
    {
        //头盔
        if (helmet != 0) {
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            room->CreateLoot(helmet, GetPos() + dir * (40 + rand() % 50), 1, 1);
            helmet = 0;
        }
        //衣服
        if (chest != 0) {
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            room->CreateLoot(chest, GetPos() + dir * (40 + rand() % 50), 1, 1);
            chest = 0;
        }
        //背包
        if (backpack != 0) {
            a8::Vec2 dir = a8::Vec2::UP;
            dir.Rotate(a8::RandAngle());
            room->CreateLoot(backpack, GetPos() + dir * (40 + rand() % 50), 1, 1);
            backpack = 0;
        }
    }
    for (size_t slot = 0; slot < GetInventoryData().size(); ++slot) {
        if (GetInventoryData()[slot] > 0) {
            MetaData::Equip* equip_meta = MetaMgr::Instance()->GetEquipBySlotId(slot);
            if (equip_meta) {
                if (equip_meta->i->equip_type() == EQUIP_TYPE_BULLET) {
                    switch (equip_meta->i->_inventory_slot()) {
                    case IS_FRAG:
                    case IS_SMOKE:
                    case IS_POSION_GAS_BOMB:
                    case IS_MOLOTOR_COCKTAIL:
                    case IS_TRAP:
                    case IS_MINE:
                        {
                            a8::Vec2 drop_pos = GetPos();
                            room->DropItem(drop_pos, equip_meta->i->id(), GetInventoryData()[slot], 1);
                            DecInventory(slot, GetInventoryData()[slot]);
                        }
                        break;
                    default:
                        break;
                    }
                } else {
                    a8::Vec2 drop_pos = GetPos();
                    room->DropItem(drop_pos, equip_meta->i->id(), GetInventoryData()[slot], 1);
                }
            }
        }
    }
    need_sync_active_player = true;
}

void Human::SendBattleReport()
{
    a8::MutableXObject* params = a8::MutableXObject::NewObject();
    if (room->GetRoomMode() == kZombieMode) {
        GenZbModeBattleReportData(params);
    } else {
        GenBattleReportData(params);
    }
    auto on_ok = [] (a8::XParams& param, a8::XObject& data)
                 {
                 };
    auto on_error = [] (a8::XParams& param, const std::string& response)
                    {
                        a8::UdpLog::Instance()->Error("battleReport http error params: %s response: %s",
                                                      {
                                                       param.param2,
                                                       response
                                                      });
                    };
    std::string url;
    if (!f8::IsOnlineEnv()) {
        if (JsonDataMgr::Instance()->channel != 0) {
            url = a8::Format("http://game2005api-test.kingsome.cn/%d/webapp/index.php?c=Role&a=battleReport",
                             {
                              JsonDataMgr::Instance()->channel
                             });
        } else {
            url = "https://game2005api-test.kingsome.cn/webapp/index.php?c=Role&a=battleReport";
        }
    } else {
        if (JsonDataMgr::Instance()->channel != 0) {
            if (kTouTiaoChannelId == JsonDataMgr::Instance()->channel) {
                url = a8::Format("http://game2005api-al.kingsome.cn/%d/webapp/index.php?c=Role&a=battleReport",
                                 {
                                  JsonDataMgr::Instance()->channel
                                 });
            } else {
                url = a8::Format("http://game2005api.kingsome.cn/%d/webapp/index.php?c=Role&a=battleReport",
                                 {
                                  JsonDataMgr::Instance()->channel
                                 });
            }
        } else {
            url = "http://game2005api.kingsome.cn/webapp/index.php?c=Role&a=battleReport";
        }
    }
    JsonDataMgr::Instance()->GetBattleReportUrl(url);
    std::string data;
    params->ToUrlEncodeStr(data);
    f8::HttpClientPool::Instance()->HttpGet(
                                            a8::XParams()
                                            .SetSender(room->GetRoomUuid())
                                            .SetParam1(GetEntityUniId())
                                            .SetParam2(data),
                                            on_ok,
                                            on_error,
                                            url.c_str(),
                                            *params,
                                            MAX_SYS_HTTP_NUM + (GetEntityUniId() % MAX_USER_HTTP_NUM)
                                            );
    delete params;
}

void Human::ProcLootSkin(Loot* entity, MetaData::Equip* item_meta)
{
    switch (item_meta->i->equip_subtype()) {
    case 11:
        {
            //装饰
            Skin* old_skin = GetSkinByIdx(kSkinSlot_HAT);
            if (old_skin) {
                if (old_skin->skin_id != 0) {
                    a8::Vec2 dir = a8::Vec2::UP;
                    dir.Rotate(a8::RandAngle());
                    room->CreateLoot(old_skin->skin_id, GetPos() + dir * (40 + rand() % 50), 1, 1);
                }

                *old_skin = Skin();
                old_skin->skin_id = item_meta->i->id();
                old_skin->skin_lv = 1;
                SyncAroundPlayers(__FILE__, __LINE__, __func__);
            }
        }
        break;
    case 12:
        {
            //衣服
            Skin* old_skin = GetSkinByIdx(kSkinSlot_CLOTH);
            if (old_skin) {
                if (old_skin->skin_id != 0) {
                    a8::Vec2 dir = a8::Vec2::UP;
                    dir.Rotate(a8::RandAngle());
                    room->CreateLoot(old_skin->skin_id, GetPos() + dir * (40 + rand() % 50), 1, 1);
                }

                *old_skin = Skin();
                old_skin->skin_id = item_meta->i->id();
                old_skin->skin_lv = 1;
                SyncAroundPlayers(__FILE__, __LINE__, __func__);
            }
        }
        break;
    }
}

void Human::ProcLootCar(Loot* entity, MetaData::Equip* item_meta)
{
    DoGetOn(entity->GetEntityUniId());
}

void Human::ProcCamoutflage(Loot* entity, MetaData::Equip* item_meta)
{
    AddItem(item_meta->i->id(), 1);
}

void Human::ProcSpoils(Loot* entity, MetaData::Equip* item_meta)
{
    if (spoils_items.find(item_meta->i->id()) !=
        spoils_items.end()) {
        spoils_items[item_meta->i->id()] += entity->count;
    } else {
        spoils_items[item_meta->i->id()] = entity->count;
    }
}

void Human::FindLocationWithTarget(Entity* target)
{
    a8::Vec2 old_pos = GetPos();
    a8::Vec2 new_pos = GetPos();
    AabbCollider a_collider;
    GetAabbBox(a_collider);
    AabbCollider target_collider;
    target->GetAabbBox(target_collider);
    {
        bool ret = a_collider.CalcSafePoint(&target_collider, new_pos);
        if (!ret) {
            abort();
        }
    }
    a8::Vec2 new_pos_dir = new_pos - old_pos;
    new_pos_dir.Normalize();
    float distance = (new_pos - old_pos).Norm();
    for (int i = distance; i < 10000000; i += 5) {
        SetPos(old_pos + new_pos_dir * i);
        room->grid_service->MoveCreature(this);

        Entity* building = nullptr;
        std::set<GridCell*> tmp_grids;
        room->grid_service->GetAllCellsByXy(room, GetX(), GetY(), tmp_grids);
        room->grid_service->TraverseAllLayerEntityList
            (
             room->GetRoomIdx(),
             tmp_grids,
             [this, &building] (Entity* entity, bool& stop)
             {
                 switch (entity->GetEntityType()) {
                 case ET_Building:
                     {
                         if (TestCollision(room, entity)) {
                             building = entity;
                             stop = true;
                         }
                     }
                     break;
                 default:
                     break;
                 }
             });

        if (!building) {
            bool is_collision = false;
            std::set<ColliderComponent*> colliders;
            room->map_service->GetColliders(room, GetX(), GetY(), colliders);
            for (ColliderComponent* collider : colliders) {
                if (TestCollision(room, collider)) {
                    is_collision = true;
                    break;
                }
            }
            if (!is_collision) {
                break;
            }
        }
    }
}

void Human::OnDie()
{
    real_dead_frameno = room->GetFrameNo();
    room->OnHumanDie(this);
    SyncAroundPlayers(__FILE__, __LINE__, __func__);
    if (team_members) {
        for (auto& hum : *team_members) {
            if (hum != this && hum->action_type == AT_Relive &&
                hum->action_target_id == GetEntityUniId()) {
                hum->CancelAction();
            }
        }
    }
    {
        std::set<Human*> over_humans;
        if (!leave_) {
            if (!HasNoDownedTeammate()) {
                if (team_members) {
                    for (auto& member : *team_members) {
                        if (member->real_dead) {
                            over_humans.insert(member);
                        }
                    }
                } else {
                    over_humans.insert(this);
                }
            } else {
                over_humans.insert(this);
            }
        }
        if (room->GetAliveTeamNum() == 1) {
            std::set<Human*>* alive_team = room->GetAliveTeam();
            if (alive_team) {
                for (Human* member : *alive_team) {
                    over_humans.insert(member);
                }
            }
        }
        for (Human* hum : over_humans) {
            hum->SendGameOver();
        }
    }
    DeadDrop();
}

void Human::FreeDownedTimer()
{
    if (downed_timer) {
        room->xtimer.DeleteTimer(downed_timer);
        downed_timer = nullptr;
    }
}

void Human::FreeReviveTimer()
{
    if (revive_timer) {
        room->xtimer.DeleteTimer(revive_timer);
        revive_timer = nullptr;
    }
}

void Human::SetSkin(int idx, int skin_id)
{
    if (idx < kSkinNum) {
        Skin& skin = skins[idx];
        skin.skin_id = skin_id;
        skin.skin_lv = 1;
    }
}

Skin* Human::GetSkinByIdx(int idx)
{
    int i = 0;
    for (auto& skin : skins) {
        if (i == idx) {
            return &skin;
        }
        ++i;
    }
    return nullptr;
}

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

int Human::GetItemNum(int item_id)
{
    auto itr = items_.find(item_id);
    return itr != items_.end() ? itr->second : 0;
}

void Human::AddItem(int item_id, int item_num)
{
    auto itr = items_.find(item_id);
    if (itr != items_.end()) {
        itr->second += item_num;
    } else {
        items_[item_id] = item_num;
    }

    if (room && room->GetFrameNo() > join_frameno) {
        room->frame_event.AddItemChg(this, item_id, items_[item_id]);
    } else {
        if (item_num <= 0) {
            battling_items_.insert(item_id);
        }
    }
}

void Human::DecItem(int item_id, int item_num)
{
    auto itr = items_.find(item_id);
    if (itr != items_.end()) {
        itr->second -= item_num;
        room->frame_event.AddItemChg(this, item_id, std::max(0, itr->second));
        if (itr->second <= 0) {
            if (battling_items_.find(item_id) == battling_items_.end()) {
                items_.erase(itr);
            }
        }
    }
}

void Human::DropItems(Obstacle* obstacle)
{
    bool is_treasure_box = false;
    if (obstacle->IsEntitySubType(EST_RoomObstacle)) {
        is_treasure_box = ((RoomObstacle*)obstacle)->is_treasure_box;
    }
    int drop_id = obstacle->meta->i->drop();
    if (drop_id == 0) {
        return;
    }
    if (room->GetRoomType() == RT_NewBrid && IsPlayer()) {
        if (is_treasure_box) {
            if (box_drop_times_ < MetaMgr::Instance()->newbie_airdrop.size()) {
                drop_id = MetaMgr::Instance()->newbie_airdrop[box_drop_times_];
            }
        } else {
            if (normal_drop_times_ < MetaMgr::Instance()->newbie_drop.size()) {
                if (normal_drop_times_ == 0) {
                }
                drop_id = MetaMgr::Instance()->newbie_drop[normal_drop_times_];
            }
        }
    }

    if (drop_id == 0) {
        drop_id = obstacle->meta->i->drop();
    }
    room->ScatterDrop(obstacle->GetPos(), drop_id);
    if (is_treasure_box) {
        ++box_drop_times_;
    } else {
        ++normal_drop_times_;
    }
    {
        if (behavior.curr_start_destory_box_frameno <= 0 ||
            behavior.curr_destory_box_times >= MetaMgr::Instance()->refresh_ai_destory_box_times ||
            (room->GetFrameNo() - behavior.curr_start_destory_box_frameno >
             MetaMgr::Instance()->refresh_ai_destory_box_time * SERVER_FRAME_RATE)){
            behavior.curr_start_destory_box_frameno = room->GetFrameNo();
            behavior.curr_destory_box_times = 0;
        }
        behavior.curr_destory_box_times++;
        behavior.total_destory_box_times++;
        if (behavior.curr_destory_box_times >= MetaMgr::Instance()->refresh_ai_destory_box_times) {
            #if 0
            room->GetIncubator()->AllocAndroid(this, 1 + rand() % 2);
            #endif
        }
    }
    #ifdef DEBUG
    #if 0
    a8::UdpLog::Instance()->Debug("DropItems normal:%d box:%d drop_id:%d is_treasure_box:%d",
                                  {
                                   normal_drop_times_,
                                   box_drop_times_,
                                   drop_id,
                                   is_treasure_box ? 1 : 0
                                  });
    #endif
    #endif
}

void Human::Revive()
{
    if (room->GetRoomMode() == kZombieMode) {
        if (GetRace() == kHumanRace) {
            ChangeToRaceAndNotify(kZombieRace, 1);
        }
        dead = false;
        downed = false;
        real_dead = false;
        ability.hp = GetMaxHP();
        ClearBuffList();
        {
            MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(kREVIVE_BUFF_ID);
            if (buff_meta) {
                AddBuff(this, buff_meta, 1);
            }
        }
        room->frame_event.AddRevive(GetWeakPtrRef());
        room->OnHumanRevive(this);

        ResetSkill();
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    } else {
        auto callback =
            [] (const a8::XParams& param)
            {
                Human* hum = (Human*)param.sender.GetUserData();
                hum->dead = true;
                hum->real_dead = true;
                hum->downed = false;
                hum->OnDie();
            };
        int wait_revive_time = MetaMgr::Instance()->GetSysParamAsInt("revive_time", 25) + kReviveTimeAdd;
        revive_timer = room->xtimer.AddDeadLineTimerAndAttach(SERVER_FRAME_RATE * wait_revive_time,
                                                              a8::XParams()
                                                              .SetSender(this),
                                                              callback,
                                                              &xtimer_attacher.timer_list_,
                                                              [] (const a8::XParams& param)
                                                              {
                                                                  Human* hum = (Human*)param.sender.GetUserData();
                                                                  hum->revive_timer = nullptr;
                                                              });
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    }
}

void Human::CancelRevive()
{
    if (dead && revive_timer && !real_dead) {
        dead = true;
        real_dead = true;
        downed = false;
        FreeDownedTimer();
        OnDie();
        FreeReviveTimer();
    }
}

void Human::ProcNewBieLogic()
{
    if (a8::HasBitFlag(status, HS_AlreadyProcNewBieLogic)) {
        return;
    }
    a8::SetBitFlag(status, HS_AlreadyProcNewBieLogic);
    //刷一个机器人
    room->xtimer.AddDeadLineTimerAndAttach
        (SERVER_FRAME_RATE * MetaMgr::Instance()->newbie_first_robot_appeartime,
         a8::XParams()
         .SetSender(this),
         [] (const a8::XParams& param)
         {
             Human* hum = (Human*)param.sender.GetUserData();
             hum->room->ShuaGuideAndroid(hum);
         },
         &xtimer_attacher.timer_list_
         );
    //6秒后出现空投
    room->xtimer.AddDeadLineTimerAndAttach
        (SERVER_FRAME_RATE * MetaMgr::Instance()->newbie_airdrop_appeartime,
         a8::XParams()
         .SetSender(this),
         [] (const a8::XParams& param)
         {
             Human* hum = (Human*)param.sender.GetUserData();
             hum->room->InitAirDrop();
         },
         &xtimer_attacher.timer_list_
         );
}

void Human::ClearLordMode()
{
    Buff* buff = GetBuffByEffectId(kBET_LordMode);
    if (buff) {
        std::vector<std::string> strings;
        a8::Split(buff->meta->i->buff_param1(), strings, ':');
        for (auto& str : strings) {
            int buff_id = a8::XValue(str);
            RemoveBuffById(buff_id);
        }
        RemoveBuffByEffectId(kBET_LordMode);
    }
}

void Human::AdjustDecHp(float old_health, float& new_health)
{
    Buff* buff = GetBuffByEffectId(kBET_NewProtect);
    if (buff) {
        if (new_health < GetMaxHP() * buff->meta->param1) {
            new_health = std::max(GetMaxHP() * buff->meta->param1, (float)0);
        }
    }
}

void Human::OnEnable()
{
    a8::UnSetBitFlag(status, HS_Disable);
    enable_frameno = room->GetFrameNo();
    room->grid_service->MoveCreature(this);
    FindLocation();
    RefreshView();
}

void Human::OnDisable()
{
    a8::SetBitFlag(status, HS_Disable);
    RemoveFromScene();
    ClearFrameData();
    ClearPartObjects();
}

void Human::GetViewObjects(std::set<Entity*>& view_objects)
{
    TraverseAllLayerHumanList
        (
         [&view_objects] (Human* hum, bool& stop)
         {
             view_objects.insert(hum);
         });
    TraverseAllLayerEntityList
        (
         [&view_objects] (Entity* entity, bool& stop)
         {
             switch (entity->GetEntityType()) {
             case ET_Building:
             case ET_Obstacle:
             case ET_Loot:
                 {
                     view_objects.insert(entity);
                 }
                 break;
             default:
                 {
                 }
                 break;
             }
         });
}

void Human::NotifyObservers(cs::SMUpdate* msg, cs::MFActivePlayerData* active_player_data_pb)
{
    bool refreshed_view = false;
    for (Human* observer : observers_) {
        msg->clear_team_data();
        if (observer->team_members) {
            for (auto& itr : *observer->team_members) {
                if (itr != observer) {
                    itr->FillMFTeamData(msg->add_team_data(), false);
                }
            }
        }
        if (observer != this && !observer->follow_synced_active_player) {
            msg->set_active_player_id(GetEntityUniId());
            FillMFActivePlayerData(msg->mutable_active_player_data());
            if (!refreshed_view) {
                std::set<Entity*> view_objects;
                GetViewObjects(view_objects);
                for (Entity* entity : view_objects) {
                    if (new_objects.find(entity) == new_objects.end()) {
                        entity->FillMFObjectFull(room, this, msg->add_full_objects());
                    }
                }
                refreshed_view = true;
            }
            observer->follow_synced_active_player = true;
        } else {
            if (active_player_data_pb) {
                msg->set_active_player_id(GetEntityUniId());
                *msg->mutable_active_player_data() = *active_player_data_pb;
            } else {
                msg->clear_active_player_id();
                msg->clear_active_player_data();
            }
        }
        observer->SendNotifyMsg(*msg);
    }
}

void Human::ProcIncGridList(std::set<GridCell*>& old_grids,
                            std::set<GridCell*>& inc_grids,
                            std::set<GridCell*>& dec_grids)
{
    room->grid_service->TraverseCreatures
        (
         room->GetRoomIdx(),
         inc_grids,
         [this, &old_grids] (Creature* c, bool& stop)
         {
            if (!room->grid_service->CreatureInGridList(c, old_grids)) {
                c->AddToNewObjects(this);
                c->AddToPartObjects(this);
                c->RemoveOutObjects(this);
                AddToNewObjects(c);
                AddToPartObjects(c);
                RemoveOutObjects(c);
            }
         });
    room->grid_service->TraverseAllLayerEntityList
        (
         room->GetRoomIdx(),
         inc_grids,
         [this] (Entity* entity, bool& stop)
         {
             switch (entity->GetEntityType()) {
             case ET_Building:
             case ET_Obstacle:
             case ET_Loot:
                 {
                     AddToNewObjects(entity);
                     RemoveOutObjects(entity);
                 }
                 break;
             default:
                 {
                 }
                 break;
             }
         });
}

void Human::ProcDecGridList(std::set<GridCell*>& old_grids,
                            std::set<GridCell*>& inc_grids,
                            std::set<GridCell*>& dec_grids)
{
    room->grid_service->TraverseCreatures
        (
         room->GetRoomIdx(),
         dec_grids,
         [this] (Creature* c, bool& stop)
         {
             if (!room->grid_service->CreatureInGridList(c, GetGridList())) {
                AddOutObjects(c);
                c->AddOutObjects(this);
                #ifdef DEBUG
                #if 0
                a8::UdpLog::Instance()->Debug("addoutobjects %d %d",
                                              {
                                               (long long)c,
                                               c->GetEntityUniId()
                                              });
                #endif
                #endif
            }
         });
    room->grid_service->TraverseAllLayerEntityList
        (
         room->GetRoomIdx(),
         dec_grids,
         [this] (Entity* entity, bool& stop)
         {
             if (!room->grid_service->EntityInGridList(room, entity, GetGridList())) {
                 switch (entity->GetEntityType()) {
                 case ET_Building:
                 case ET_Obstacle:
                 case ET_Loot:
                     {
                         AddOutObjects(entity);
                     }
                     break;
                 default:
                     {
                     }
                     break;
                 }
             }
         });
}

void Human::RemoveFromScene()
{
    room->grid_service->DeatchHuman(this);
    room->TraverseHumanList
        (
         a8::XParams()
         .SetSender(this),
         [] (Human* hum, a8::XParams& param)
         {
             Human* target = (Human*)param.sender.GetUserData();
             hum->RemovePartObjects(target);
             return true;
         });
    last_collision_door_ = nullptr;
}

ObjectSyncFlags* Human::GetObjectSyncFlags(int obj_uniid)
{
    if ((size_t)obj_uniid < fixed_object_sync_flags_.size()) {
        return &fixed_object_sync_flags_[obj_uniid];
    } else {
        return nullptr;
    }
}

void Human::OnMetaChange()
{
    if (GetRace() == kZombieRace) {
        MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip(meta->i->normal_skill());
        if (weapon_meta) {
            default_weapon.weapon_idx = 0;
            default_weapon.weapon_id = weapon_meta->i->id();
            default_weapon.weapon_lv = 1;
            default_weapon.ammo = 1;
            default_weapon.meta = weapon_meta;
            default_weapon.Recalc();
            weapons[0] = default_weapon;
            SetCurrWeapon(&weapons[0]);
        }
    }
    ability.hp = meta->i->health();
    for (auto& weapon : spec_weapons) {
        if (weapon.meta) {
            ability.hp += weapon.meta ? weapon.GetAttrValue(kHAT_MaxHp) : 0;
        }
    }
    room->frame_event.AddHpChg(GetWeakPtrRef());
    RecalcBaseAttr();
    ClearSkill();
    AddSkill(meta->i->active_skill());
    ResetSkill();
    ClearPassiveSkill();
    AddPassiveSkill(meta->i->passive_skill());
}

void Human::OnChgToTerminator()
{
    Buff* buff = GetBuffByEffectId(kBET_Terminator);
    if (buff) {
        std::vector<std::string> strings;
        a8::Split(buff->meta->i->buff_param4(), strings, ':');
        if (strings.size() >= 3) {
            for (size_t i = 0; i < strings.size(); ++i) {
                int weapon_id = a8::XValue(strings[i]);
                MetaData::Equip* weapon_meta = MetaMgr::Instance()->GetEquip(weapon_id);
                if (weapon_meta) {
                    Weapon* weapon = nullptr;
                    switch (i) {
                    case 0:
                        {
                            weapon = &weapons[0];
                        }
                        break;
                    case 1:
                        {
                            weapon = &weapons[GUN_SLOT1];
                        }
                        break;
                    case 2:
                        {
                            weapon = &weapons[GUN_SLOT2];
                        }
                        break;
                    default:
                        {
                        }
                        break;
                    }
                    weapon->weapon_idx = i;
                    weapon->weapon_id = weapon_meta->i->id();
                    weapon->weapon_lv = 1;
                    weapon->meta = weapon_meta;
                    weapon->Recalc();
                    weapon->ammo = weapon->GetClipVolume();
                    if (i == 0) {
                        default_weapon = *weapon;
                    }
                }
            }
        }//end if
        need_sync_active_player = true;
        SyncAroundPlayers(__FILE__, __LINE__, __func__);
    }
}

void Human::ProcReloadAction()
{
    Weapon* p_weapon = GetCurrWeapon();
    if (second_weapon.meta) {
        p_weapon = &second_weapon;
    }

    if (p_weapon->weapon_idx == action_target_id &&
        p_weapon->weapon_id == action_item_id &&
        p_weapon->weapon_idx != 0) {
        MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(p_weapon->meta->i->use_bullet());
        if (bullet_meta) {
            int ammo = p_weapon->ammo;
            if (ammo < p_weapon->GetClipVolume()) {
                if (bullet_meta->i->_inventory_slot() >= 0 &&
                    bullet_meta->i->_inventory_slot() < IS_END) {
                    if (GetInventory(bullet_meta->i->_inventory_slot()) > 0) {
                        int add_num = 0;
                        if (GetInventory(bullet_meta->i->_inventory_slot()) <=
                            p_weapon->GetClipVolume() - ammo) {
                            add_num = GetInventory(bullet_meta->i->_inventory_slot());
                            if (p_weapon->meta->i->reloadtype() == 1) {
                                add_num = 1;
                            }
                            DecInventory(bullet_meta->i->_inventory_slot(), add_num);
                        } else {
                            add_num = p_weapon->GetClipVolume() - ammo;
                            if (p_weapon->meta->i->reloadtype() == 1) {
                                add_num = 1;
                            }
                            DecInventory(bullet_meta->i->_inventory_slot(), add_num);
                        }
                        p_weapon->ammo += add_num;
                        need_sync_active_player = true;
                        if (p_weapon->meta->i->reloadtype() == 1) {
                            room->xtimer.AddDeadLineTimerAndAttach
                                (1,
                                 a8::XParams()
                                 .SetSender(this)
                                 .SetParam1(p_weapon->weapon_idx)
                                 .SetParam2(p_weapon->weapon_id),
                                 [] (const a8::XParams& param)
                                 {
                                     Human* hum = (Human*)param.sender.GetUserData();
                                     hum->NextReload(param.param2, param.param1);
                                 },
                                 &xtimer_attacher.timer_list_
                                 );
                        }
                    }
                }
            }
        }

    }
}

void Human::ProcUseItemAction()
{
    MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(action_item_id);
    if (!item_meta) {
        return;
    }
    if (GetInventory(item_meta->i->_inventory_slot()) <= 0) {
        return;
    }
    switch (action_item_id) {
    case IS_HEALTHKIT:
        {
            AddHp(item_meta->i->heal());
            DecInventory(item_meta->i->_inventory_slot(), 1);
        }
        break;
    case IS_PAIN_KILLER:
        {
            if (pain_killer_timer) {
                int passed_time = (room->GetFrameNo() - pain_killer_frameno) * FRAME_RATE_MS;
                int left_time = std::max(0, pain_killer_lastingtime * 1000 - passed_time);
                int anodyne_max_time = MetaMgr::Instance()->GetSysParamAsInt("anodyne_max_time");
                left_time = std::min(left_time, anodyne_max_time * 1000);
                pain_killer_lastingtime += std::min(item_meta->i->time() * 1000,
                                                    anodyne_max_time * 1000 - left_time) / 1000;
            } else {
                pain_killer_frameno = room->GetFrameNo();
                pain_killer_lastingtime = item_meta->i->time();
                if (pain_killer_lastingtime > 0) {
                    pain_killer_timer = room->xtimer.AddRepeatTimerAndAttach
                        (
                         SERVER_FRAME_RATE,
                         a8::XParams()
                         .SetSender(this)
                         .SetParam1(item_meta->i->heal()),
                         [] (const a8::XParams& param)
                         {
                             Human* hum = (Human*)param.sender.GetUserData();
                             hum->AddHp(param.param1.GetDouble());
                             if (hum->room->GetFrameNo() - hum->pain_killer_frameno >
                                 hum->pain_killer_lastingtime * SERVER_FRAME_RATE) {
                                 hum->room->xtimer.DeleteTimer(hum->pain_killer_timer);
                             }
                         },
                         &xtimer_attacher.timer_list_,
                         [] (const a8::XParams& param)
                         {
                             Human* hum = (Human*)param.sender.GetUserData();
                             hum->pain_killer_timer = nullptr;
                         });
                }
                AddHp(item_meta->i->heal());
            }
            DecInventory(item_meta->i->_inventory_slot(), 1);
            need_sync_active_player = true;
        }
        break;
    default:
        {
        }
        break;
    }
}

void Human::ProcReliveAction()
{
    Entity* entity = room->GetEntityByUniId(action_target_id);
    if (!entity->IsEntityType(ET_Player)) {
        return;
    }
    Human* hum = (Human*)entity;
    if (hum->action_type == AT_Rescue) {
        hum->CancelAction();
        return;
    }
    if (!hum->dead && hum->downed) {
        hum->ability.hp = MetaMgr::Instance()->GetSysParamAsInt("downed_relive_recover_hp");
        hum->downed = false;
        if (hum->downed_timer) {
            room->xtimer.DeleteTimer(hum->downed_timer);
            hum->downed_timer = nullptr;
        }
        ++hum->stats.rescue_member;
        if (hum->guild_id != 0 && hum->guild_id == guild_id) {
            ++hum->stats.rescue_guild_member;
        }
    }
    hum->SyncAroundPlayers(__FILE__, __LINE__, __func__);
}

void Human::OnBuffRemove(Buff& buff)
{
    switch (buff.meta->i->buff_effect()) {
    case kBET_Jump:
        {
            //跳伞结束
            room->xtimer.AddDeadLineTimerAndAttach
                (1,
                 a8::XParams()
                 .SetSender(this),
                 [] (const a8::XParams& param)
                 {
                     Human* hum = (Human*)param.sender.GetUserData();
                     hum->OnLand();
                 },
                 &xtimer_attacher.timer_list_
                 );
        }
        break;
    case kBET_Become:
        {
            buff.ProcRemoveBecome(this);
        }
        break;
    case kBET_Driver:
        {
            buff.ProcRemoveDriver(this);
        }
        break;
    case kBET_Passenger:
        {
            buff.ProcRemovePassenger(this);
        }
        break;
    default:
        break;
    }
    if (!buff.meta->i->only_server()) {
        room->frame_event.RemoveBuff(GetWeakPtrRef(), buff.meta->i->buff_id());
    }
}

void Human::OnLand()
{
    //着陆
    RemoveBuffByEffectId(kBET_Jump);
    RemoveBuffByEffectId(kBET_ThroughWall);
    if (IsAndroid() && team_uuid.empty()) {
        MustBeAddBuff(this, kBeRecycleBuffId);
    }
    if (IsPlayer()) {
        refresh_view_timer_ = room->xtimer.AddRepeatTimerAndAttach
            (
             SERVER_FRAME_RATE * MetaMgr::Instance()->refresh_view_time,
             a8::XParams()
             .SetSender(this),
             [] (const a8::XParams& param)
             {
                 Human* hum = (Human*)param.sender.GetUserData();
                 hum->UpdateViewObjects();
             },
             &xtimer_attacher.timer_list_,
             [] (const a8::XParams& param)
             {
                 Human* hum = (Human*)param.sender.GetUserData();
                 hum->refresh_view_timer_ = nullptr;
             });
    }
    if (IsCollisionInMapService()) {
        a8::Vec2 old_pos = GetPos();
        std::vector<a8::Vec2> dirs;
        {
            dirs.push_back(a8::Vec2::UP);
            dirs.push_back(a8::Vec2::DOWN);
            dirs.push_back(a8::Vec2::LEFT);
            dirs.push_back(a8::Vec2::RIGHT);
        }
        for (int i = 0; i < 10000000; i += 10) {
            for (const a8::Vec2& dir : dirs) {
                SetPos(old_pos + dir * i);
                if (!IsCollisionInMapService()) {
                    room->grid_service->MoveCreature(this);
                    return;
                }
            }
        }
        SetPos(old_pos);
    }
}

void Human::NextReload(int prev_weapon_id, int prev_weapon_idx)
{
    if (action_type != AT_None) {
        return;
    }
    Weapon* p_weapon = GetCurrWeapon();
    if (second_weapon.meta) {
        p_weapon = &second_weapon;
    }
    if (p_weapon &&
        p_weapon->weapon_id == prev_weapon_id &&
        p_weapon->weapon_idx == prev_weapon_idx) {
        AutoLoadingBullet(true);
    }
}

void Human::DoGetDown()
{
    if (GetCar()) {
        GetCar()->GetDown(this);
    }
}

void Human::DoGetOnWithLoot(Loot* entity)
{
    MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(entity->item_id);
    if (!item_meta) {
        return;
    }
    if (GetCar()) {
        GetCar()->GetDown(this);
    }
    Car* car = room->CreateCar(
                    this,
                    entity->GetEntityUniId(),
                    item_meta,
                    entity->GetPos(),
                    team_id
                    );
    car->GetOn(this);
    room->TakeOnCarObject(entity->GetEntityUniId());
    room->NotifyUiUpdate();
    #ifdef DEBUG
    a8::XPrintf("DoGetOnWithLoot uniid:%d car_uniid:%d\n", {car->GetEntityUniId(), car->car_uniid});
    #endif
}

void Human::DoGetOnWithCar(Car* car)
{
    car->GetOn(this);
}

void Human::OnEnterSpecMapArea(int tag, SpecMapObject& map_obj)
{
    #ifdef DEBUG
    SendDebugMsg("进入特殊区域");
    #endif
    ClearSpecMapAreaTimer(map_obj);
    map_obj.enter_timer = room->xtimer.AddDeadLineTimerAndAttach
        (MetaMgr::Instance()->GetSpecMapAreaEnterTime(tag) * SERVER_FRAME_RATE,
         a8::XParams()
         .SetSender(this)
         .SetParam1(&map_obj)
         .SetParam2(tag),
         [] (const a8::XParams& param)
         {
             Human* hum = (Human*)param.sender.GetUserData();
             int buff_id = MetaMgr::Instance()->GetSpecMapAreaBuffId(param.param2);
             hum->MustBeAddBuff(hum, buff_id);
         },
         &xtimer_attacher.timer_list_,
         [] (const a8::XParams& param)
         {
             SpecMapObject* map_obj = (SpecMapObject*)param.param1.GetUserData();
             map_obj->enter_timer = nullptr;
         });

}

void Human::OnLeaveSpecMapArea(int tag, SpecMapObject& map_obj)
{
    #ifdef DEBUG
    SendDebugMsg("离开特殊区域");
    #endif
    ClearSpecMapAreaTimer(map_obj);
    map_obj.leave_timer = room->xtimer.AddDeadLineTimerAndAttach
        (MetaMgr::Instance()->GetSpecMapAreaLeaveTime(tag) * SERVER_FRAME_RATE,
         a8::XParams()
         .SetSender(this)
         .SetParam1(&map_obj)
         .SetParam2(tag),
         [] (const a8::XParams& param)
         {
             Human* hum = (Human*)param.sender.GetUserData();
             hum->RemoveBuffById((MetaMgr::Instance()->GetSpecMapAreaBuffId(param.param2)));
         },
         &xtimer_attacher.timer_list_,
         [] (const a8::XParams& param)
         {
             SpecMapObject* map_obj = (SpecMapObject*)param.param1.GetUserData();
             map_obj->leave_timer = nullptr;
         });

}

void Human::ClearSpecMapAreaTimer(SpecMapObject& map_obj)
{
    if (map_obj.leave_timer) {
        room->xtimer.DeleteTimer(map_obj.leave_timer);
        map_obj.leave_timer = nullptr;
    }
    if (map_obj.enter_timer) {
        room->xtimer.DeleteTimer(map_obj.enter_timer);
        map_obj.enter_timer = nullptr;
    }
}

void Human::DoSkillPreProc(int skill_id, int target_id, const a8::Vec2& target_pos)
{
    if (action_type == AT_Reload ||
        action_type == AT_UseItem
        ) {
        CancelAction();
    }
}

void Human::DoSkillPostProc(bool used, int skill_id, int target_id, const a8::Vec2& target_pos)
{
    if (used) {
        ++stats.skill_times;
        Skill* skill = GetSkill(skill_id);
        if (skill) {
            skill->DecTimes();
            room->frame_event.AddSkillCdChg(AllocWeakPtr(), skill_id, skill->GetLeftTime());
            room->frame_event.AddSkillCurrTimesChg(AllocWeakPtr(), skill_id, skill->GetCurrTimes());
        }
        OnAttack();
    }
}

float Human::GetRadius()
{
    return meta->i->radius();
}

float Human::GetHitRadius()
{
    return meta->i->hit_radius();
}

void Human::GetHitAabbBox(AabbCollider& aabb_box)
{
    if (!meta) {
        abort();
    }
    aabb_box.active = true;
    aabb_box.owner = this;
    if (GetCar() && GetCar()->IsDriver(this)) {
        aabb_box._min.x = -GetCar()->meta->i->rad();
        aabb_box._min.y = -GetCar()->meta->i->rad();
        aabb_box._max.x = GetCar()->meta->i->rad();
        aabb_box._max.y = GetCar()->meta->i->rad();
    } else {
        aabb_box._min.x = -GetHitRadius();
        aabb_box._min.y = -GetHitRadius();
        aabb_box._max.x = GetHitRadius();
        aabb_box._max.y = GetHitRadius();
    }
}

void Human::UpdateViewObjects()
{
    if (view_objects_.size() >= 2) {
        std::vector<Human*> deleted_humans;
        for (Human* hum : view_objects_) {
            if (hum->dead ||
                hum->GetPos().ManhattanDistance(GetPos()) > MetaMgr::Instance()->view_objects_out_distance) {
                deleted_humans.push_back(hum);
            }
        }
        for (Human* hum : deleted_humans) {
            view_objects_.erase(hum);
        }
    }
    if (view_objects_.size() < 2) {
        TraverseAllLayerHumanList
            (
             [this] (Human* hum, bool& stop)
             {
                 if (hum->IsAndroid() && !hum->dead && view_objects_.find(hum) == view_objects_.end()) {
                     if (hum->GetPos().ManhattanDistance(GetPos()) <
                         MetaMgr::Instance()->view_objects_in_distance) {
                         view_objects_.insert(hum);
                     }
                     if (view_objects_.size() >= 2) {
                         stop = true;
                         return;
                     }
                 }
             });
    }
    if (view_objects_.size() < 2) {
        room->GetIncubator()->AllocAndroid(this, 1 + rand() % 2);
        if (refresh_view_timer_) {
            room->xtimer.ModifyTimer(refresh_view_timer_,
                                     SERVER_FRAME_RATE * (MetaMgr::Instance()->refresh_view_time + (rand() % 3))
                                     );
        }
    }
}

void Human::GMAddItem(int item_id, int item_num)
{
    MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(item_id);
    if (!item_meta) {
        return;
    }
    if (item_meta->i->equip_type() == EQUIP_TYPE_WEAPON) {
        if (item_meta->i->equip_subtype() == 1) {
            if (default_weapon.weapon_id != weapons[0].weapon_id) {
            } else {
                weapons[0].weapon_idx = 0;
                weapons[0].weapon_id = item_id;
                weapons[0].weapon_lv = std::max(1, 1);
                weapons[0].ammo = 0;
                weapons[0].meta = item_meta;
                weapons[0].Recalc();
            }
        } else {
            Weapon* weapon = nullptr;
            if (weapons[GUN_SLOT1].weapon_id == 0) {
                weapon = &weapons[GUN_SLOT1];
                weapon->weapon_idx = GUN_SLOT1;
                if (GetCurrWeapon() != &weapons[GUN_SLOT2] && !FreezeOperate()) {
                    SetCurrWeapon(&weapons[GUN_SLOT1]);
                }
            } else if (weapons[GUN_SLOT2].weapon_id == 0) {
                weapon = &weapons[GUN_SLOT2];
                weapon->weapon_idx = GUN_SLOT2;
                if (GetCurrWeapon() != &weapons[GUN_SLOT1] && !FreezeOperate()) {
                    SetCurrWeapon(&weapons[GUN_SLOT2]);
                }
            }
            if (weapon) {
                weapon->weapon_id = item_id;
                weapon->weapon_lv = std::max(1, 1);
                weapon->ammo = 0;
                weapon->meta = item_meta;
                weapon->Recalc();
            }
        }
    } else {
        if (item_meta->i->_inventory_slot() >= 0 &&
            item_meta->i->_inventory_slot() < IS_END) {
            if (GetInventory(item_meta->i->_inventory_slot()) >=
                GetVolume(item_meta->i->_inventory_slot())
                ) {
                /*
                  cs::SMPickup notifymsg;
                  notifymsg.set_error_code(1);
                  SendNotifyMsg(notifymsg);
                */
                return;
            }
            int add_num = GetVolume(item_meta->i->_inventory_slot()) -
                GetInventory(item_meta->i->_inventory_slot());
            add_num = std::min(item_num, add_num);

            AddInventory(item_meta->i->_inventory_slot(), add_num);
            switch (item_meta->i->_inventory_slot()) {
            case IS_FRAG:
            case IS_SMOKE:
                {
                    Weapon* weapon = &weapons[SPEC1_SLOT_BEGIN +
                                              (item_meta->i->_inventory_slot() - SPEC1_IS_BEGIN)
                                              ];
                    weapon->weapon_id = item_id;
                    weapon->weapon_lv = 1;
                    weapon->ammo += item_num;
                    weapon->meta = item_meta;
                    weapon->Recalc();
                    DecInventory(item_meta->i->_inventory_slot(), add_num);
                }
                break;
            case IS_1XSCOPE:
            case IS_2XSCOPE:
            case IS_4XSCOPE:
            case IS_8XSCOPE:
            case IS_15XSCOPE:
                {
                    if (item_meta->i->_inventory_slot() - IS_1XSCOPE > curr_scope_idx) {
                        curr_scope_idx = item_meta->i->_inventory_slot() - IS_1XSCOPE;
                    }
                }
                break;
            case IS_POSION_GAS_BOMB:
            case IS_MOLOTOR_COCKTAIL:
            case IS_TRAP:
            case IS_MINE:
                {
                    Weapon* weapon = &weapons[SPEC2_SLOT_BEGIN +
                                              (item_meta->i->_inventory_slot() - SPEC2_IS_BEGIN)
                                              ];
                    weapon->weapon_id = item_id;
                    weapon->weapon_lv = 1;
                    weapon->ammo += item_num;
                    weapon->meta = item_meta;
                    weapon->Recalc();
                    DecInventory(item_meta->i->_inventory_slot(), add_num);
                }
                break;
            default:
                {
#if 0
                    abort();
#endif
                }
                break;
            }
        }
    }
    need_sync_active_player = true;
    SyncAroundPlayers(__FILE__, __LINE__, __func__);
}

void Human::OnBulletHit(Bullet* bullet)
{
    if (IsInvincible()) {
        return;
    }
    if (bullet->sender.Get()->room->GetRoomMode() == kZombieMode &&
        bullet->sender.Get()->GetRace() == GetRace()) {
        return;
    }
    if (!dead && (bullet->IsBomb() || bullet->sender.Get()->team_id != team_id)) {
        float dmg = bullet->GetAtk() * (1 + bullet->sender.Get()->GetAttrRate(kHAT_Atk)) +
            bullet->sender.Get()->GetAttrAbs(kHAT_Atk);
        float def = ability.def * (1 + GetAttrRate(kHAT_Def)) +
            GetAttrAbs(kHAT_Def);
        float finaly_dmg = dmg * (1 - def/MetaMgr::Instance()->K);
        finaly_dmg = std::max(finaly_dmg, 0.0f);
#if 0
        sender->stats.damage_amount_out += finaly_dmg;
#endif
#ifdef DEBUG
        if (App::Instance()->HasFlag(1) && IsPlayer())  {
            return;
        }
#endif
        if (bullet->meta->buff_meta) {
            MustBeAddBuff(this, bullet->meta->i->buffid());
        }
        DecHP(finaly_dmg,
              bullet->sender.Get()->GetEntityUniId(),
              bullet->sender.Get()->GetName(),
              bullet->gun_meta->i->id());
#ifdef DEBUG
        bullet->sender.Get()->SendDebugMsg
            (a8::Format("bullet weapon_id:%d atk:%f",
                        {
                         bullet->gun_meta->i->id(),
                         bullet->GetAtk()
                        })
             );
#endif
    }
}