game2004/server/gameserver/bullet.cc

#include "precompile.h"

#include "bullet.h"
#include "metamgr.h"
#include "room.h"
#include "collider.h"
#include "obstacle.h"
#include "player.h"
#include "app.h"

Bullet::Bullet():MoveableEntity()
{
    entity_type = ET_Bullet;
    ++App::Instance()->perf.entity_num[ET_Bullet];
}

Bullet::~Bullet()
{
    --App::Instance()->perf.entity_num[ET_Bullet];
}

void Bullet::Initialize()
{
    MoveableEntity::Initialize();
    RecalcSelfCollider();
}

void Bullet::Update(int delta_time)
{
    #ifdef DEBUG
    player->room->CheckPartObjects();
    #endif
    MapServiceUpdate();
    #ifdef DEBUG
    player->room->CheckPartObjects();
    #endif
    ++updated_times_;
}

void Bullet::RecalcSelfCollider()
{
    if (!self_collider_) {
        self_collider_ = new CircleCollider();
        self_collider_->owner = this;
        AddEntityCollider(self_collider_);
    }
    self_collider_->pos = a8::Vec2();
    self_collider_->rad = gun_meta->i->bullet_rad();
}

void Bullet::OnHit(std::set<Entity*>& objects)
{
    for (auto& target : objects) {
        switch (target->entity_type) {
        case ET_Player:
            {
                Human* hum = (Human*)target;
                if (hum->HasBuffEffect(kBET_Invincible) ||
                    hum->HasBuffEffect(kBET_AdPlaying)) {
                    continue;
                }
                if (!hum->dead && (IsBomb() || player->team_id != hum->team_id)) {
                    float dmg = GetAtk() * (1 + player->GetBuffAttrRate(kHAT_Atk)) +
                        player->GetBuffAttrAbs(kHAT_Atk);
                    float def = hum->ability.def * (1 + hum->GetBuffAttrRate(kHAT_Def)) +
                        hum->GetBuffAttrAbs(kHAT_Def);
                    float finaly_dmg = dmg * (1 - def/MetaMgr::Instance()->K);
                    player->stats.damage_amount_out += finaly_dmg;
                    hum->DecHP(finaly_dmg, player->entity_uniid, player->name, gun_meta->i->id());
                    #ifdef DEBUG
                    player->SendDebugMsg(a8::Format("bullet atk:%f", {GetAtk()}));
                    #endif
                }
            }
            break;
        case ET_Obstacle:
            {
                Obstacle* obstacle = (Obstacle*)target;
                if (!obstacle->IsDead(room) && obstacle->meta->i->attack_type() == 1) {
                    float dmg = GetAtk() * (1 + player->GetBuffAttrRate(kHAT_Atk)) +
                        player->GetBuffAttrAbs(kHAT_Atk);
                    float def = 0;
                    float finaly_dmg = dmg * (1 - def/MetaMgr::Instance()->K);
                    obstacle->SetHealth(room, std::max(0.0f, obstacle->GetHealth(room) - finaly_dmg));
                    if (obstacle->GetHealth(room) <= 0.01f) {
                        obstacle->Die(room);
                    }
                    if (obstacle->IsDead(room)) {
                        if (obstacle->meta->i->damage_dia() > 0.01f &&
                            obstacle->meta->i->damage() > 0.01f) {
                            obstacle->Explosion(this);
                        }
                        player->DropItems(obstacle);
                    }
                    obstacle->BroadcastFullState(room);
                    #ifdef DEBUG
                    player->SendDebugMsg(a8::Format("bullet atk:%f", {GetAtk()}));
                    #endif
                }
            }
            break;
        default:
            break;
        }
    }
}

void Bullet::ProcBomb()
{
    self_collider_->rad = gun_meta->i->explosion_range();
    std::set<Entity*> objects;
    for (auto& grid : grid_list) {
        for (Human* hum: grid->human_list[room->GetRoomIdx()]) {
                if (!is_tank_skin || player->team_id != hum->team_id) {
                    //友军火箭筒伤害取消
                    if ((meta->i->_inventory_slot() == 4 ||
                         meta->i->_inventory_slot() == 5) &&
                        player->team_id == hum->team_id) {
                        continue;
                    }
                    if (TestCollision(room, hum)) {
                        objects.insert(hum);
                    }
                }
        }
        for (Entity* entity : grid->entity_list[0]) {
            switch (entity->entity_type) {
            case ET_Obstacle:
            case ET_Building:
                {
                    if (TestCollision(room, entity)) {
                        objects.insert(entity);
                    }
                }
                break;
            default:
                {
                }
                break;
            }
        }
        for (Entity* entity : grid->entity_list[room->GetRoomIdx()]) {
            switch (entity->entity_type) {
            case ET_Obstacle:
            case ET_Building:
                {
                    if (TestCollision(room, entity)) {
                        objects.insert(entity);
                    }
                }
                break;
            default:
                {
                }
                break;
            }
        }
    }//end for

    switch (meta->i->_inventory_slot()) {
    case 4:
        {
            //榴弹炮
            a8::Vec2 bomb_pos = GetPos();
            room->frame_event.AddExplosionEx(player, 0, bomb_pos, 0);
            OnHit(objects);
        }
        break;
    case 5:
        {
            //手雷
            a8::Vec2 bomb_pos = GetPos();
            room->frame_event.AddExplosion(this, meta->i->id(), bomb_pos);
            OnHit(objects);
        }
        break;
    case 6:
        {
            //烟雾弹
            a8::Vec2 bomb_pos = GetPos();
            room->frame_event.AddSmoke(this, meta->i->id(), bomb_pos);
        }
        break;
    }
    room->RemoveObjectLater(this);
}

bool Bullet::IsBomb()
{
    return
        meta->i->_inventory_slot() == 4 ||
        meta->i->_inventory_slot() == 5 ||
        meta->i->_inventory_slot() == 6;
}

void Bullet::MapServiceUpdate()
{
    SetPos(GetPos() + dir * gun_meta->i->bullet_speed() / (float)SERVER_FRAME_RATE);
    float distance = (GetPos() - born_pos).Norm();
    if (room->OverBorder(GetPos(), gun_meta->i->bullet_rad())) {
        if (IsBomb()) {
            ProcBomb();
        } else {
            room->RemoveObjectLater(this);
        }
    } else {
        room->grid_service->MoveBullet(this);
        std::set<Entity*> objects;
        for (auto& grid : grid_list) {
            for (Human* hum: grid->human_list[room->GetRoomIdx()]) {
                if (hum != player && !hum->dead && TestCollision(room, hum)) {
                    objects.insert(hum);
                }
            }
        }//end for
        {
            std::set<ColliderComponent*> colliders;
            room->map_service->GetColliders(room, GetX(), GetY(), colliders);
            for (ColliderComponent* collider : colliders) {
                if (TestCollision(room, collider)) {
                    objects.insert(collider->owner);
                }
            }
        }
        float bullet_range = gun_meta->i->range();
        if (gun_upgrade_meta && gun_upgrade_meta->GetAttrValue(gun_lv, kHAT_ShotRange) > 0) {
            bullet_range += gun_upgrade_meta->GetAttrValue(gun_lv, kHAT_ShotRange);
        }
        if (!objects.empty() || distance > bullet_range ||
            (IsBomb() && meta->i->_inventory_slot() != 4 && distance >= fly_distance)
            ) {
            if (IsBomb()) {
                ProcBomb();
            } else {
                if (!objects.empty()) {
                    OnHit(objects);
                }
                room->RemoveObjectLater(this);
            }
        }
    }
}


float Bullet::GetAtk()
{
    return gun_meta->i->atk() +
        (gun_upgrade_meta ? gun_upgrade_meta->GetAttrValue(gun_lv, kHAT_Atk) : 0);
}