1286 lines
43 KiB
C++
1286 lines
43 KiB
C++
#include "precompile.h"
|
||
|
||
#include <float.h>
|
||
|
||
#include "playermgr.h"
|
||
#include "player.h"
|
||
#include "cs_proto.pb.h"
|
||
#include "room.h"
|
||
#include "metamgr.h"
|
||
#include "bullet.h"
|
||
#include "obstacle.h"
|
||
#include "building.h"
|
||
#include "loot.h"
|
||
#include "app.h"
|
||
#include "collider.h"
|
||
#include "typeconvert.h"
|
||
|
||
const int kREVIVE_BUFF_ID = 1005;
|
||
|
||
Player::Player():Human()
|
||
{
|
||
entity_type = ET_Player;
|
||
entity_subtype = EST_Player;
|
||
++App::Instance()->perf.entity_num[ET_Player];
|
||
}
|
||
|
||
Player::~Player()
|
||
{
|
||
--App::Instance()->perf.entity_num[ET_Player];
|
||
}
|
||
|
||
void Player::Initialize()
|
||
{
|
||
Human::Initialize();
|
||
max_energy_shield = energy_shield;
|
||
skill_meta_ = MetaMgr::Instance()->GetSkill(41001);
|
||
RecalcBaseAttr();
|
||
}
|
||
|
||
void Player::Update(int delta_time)
|
||
{
|
||
if (poisoning) {
|
||
poisoning_time += delta_time;
|
||
}
|
||
#if 0
|
||
if (a8::HasBitFlag(status, HS_Fly)) {
|
||
SetPos(room->plane.curr_pos);
|
||
room->grid_service.MoveHuman(this);
|
||
}
|
||
#endif
|
||
if (moving) {
|
||
UpdateMove();
|
||
}
|
||
if (room->frame_no % 2 == 0) {
|
||
if (drop_weapon) {
|
||
UpdateDropWeapon();
|
||
}
|
||
if (interaction_objids.size() > 0) {
|
||
ProcInteraction();
|
||
}
|
||
if (poisoning) {
|
||
UpdatePoisoning();
|
||
}
|
||
if (select_weapon) {
|
||
UpdateSelectWeapon();
|
||
}
|
||
if (use_scope) {
|
||
UpdateUseScope();
|
||
}
|
||
if (reload) {
|
||
UpdateReload();
|
||
}
|
||
if (cancel_action) {
|
||
UpdateCancelAction();
|
||
}
|
||
if (use_item) {
|
||
UpdateUseItemIdx();
|
||
}
|
||
if (action_type != AT_None) {
|
||
UpdateAction();
|
||
}
|
||
if (spectate) {
|
||
UpdateSpectate();
|
||
}
|
||
if (emote) {
|
||
UpdateEmote();
|
||
}
|
||
if (get_down) {
|
||
UpdateGetDown();
|
||
}
|
||
if (shot_start || shot_hold) {
|
||
UpdateShot();
|
||
}
|
||
if (use_skill) {
|
||
UpdateUseSkill();
|
||
}
|
||
if (aiming) {
|
||
if (HasBuffEffect(kBET_Camouflage)) {
|
||
RemoveBuffByEffectId(kBET_Camouflage);
|
||
}
|
||
}
|
||
if (has_use_item_id) {
|
||
UpdateUseItemId();
|
||
}
|
||
}
|
||
}
|
||
|
||
void Player::UpdateMove()
|
||
{
|
||
if (action_type == AT_Relive) {
|
||
CancelAction();
|
||
}
|
||
if (dead ||
|
||
room->waiting_start) {
|
||
moving = false;
|
||
moved_frames = 0;
|
||
last_collision_door = nullptr;
|
||
return;
|
||
}
|
||
if (HasBuffEffect(kBET_Camouflage)) {
|
||
RemoveBuffByEffectId(kBET_Camouflage);
|
||
}
|
||
++moved_frames;
|
||
if (moved_frames > 4) {
|
||
moving = false;
|
||
moved_frames = 0;
|
||
return;
|
||
}
|
||
if (tank_weapon.meta && tank_oil_value < 0.00001f) {
|
||
return;
|
||
}
|
||
a8::Vec2 old_pos = GetPos();
|
||
_UpdateMove(std::max(1, (int)GetSpeed()));
|
||
if (last_collision_door && !TestCollision(last_collision_door)) {
|
||
last_collision_door = nullptr;
|
||
}
|
||
if (tank_weapon.meta) {
|
||
CheckSkinTank();
|
||
tank_oil_value -= old_pos.Distance(GetPos()) * (MetaMgr::Instance()->average_oil / 100.0f);
|
||
tank_oil_value = std::max(0.0f, tank_oil_value);
|
||
}
|
||
}
|
||
|
||
void Player::UpdateShot()
|
||
{
|
||
if (dead ||
|
||
downed ||
|
||
room->waiting_start) {
|
||
shot_start = false;
|
||
shot_hold = false;
|
||
series_shot_frames = 0;
|
||
return;
|
||
}
|
||
if (shot_start) {
|
||
shot_start = false;
|
||
Shot();
|
||
return;
|
||
}
|
||
Weapon* p_weapon = curr_weapon;
|
||
if (tank_weapon.meta) {
|
||
p_weapon = &tank_weapon;
|
||
}
|
||
if (shot_hold) {
|
||
++series_shot_frames;
|
||
if (last_shot_frameno_ == 0 ||
|
||
(
|
||
(room->frame_no - last_shot_frameno_) * (1000 / SERVER_FRAME_RATE)) >=
|
||
p_weapon->GetAttrValue(kHAT_FireRate)
|
||
) {
|
||
Shot();
|
||
}
|
||
if (series_shot_frames > 8) {
|
||
shot_hold = false;
|
||
series_shot_frames = 0;
|
||
}
|
||
}
|
||
if (HasBuffEffect(kBET_Camouflage)) {
|
||
RemoveBuffByEffectId(kBET_Camouflage);
|
||
}
|
||
}
|
||
|
||
void Player::UpdateSelectWeapon()
|
||
{
|
||
if (selected_weapon_idx >= 0 && selected_weapon_idx < weapons.size()) {
|
||
Weapon* old_weapon = curr_weapon;
|
||
Weapon* weapon = &weapons[selected_weapon_idx];
|
||
if (weapon->weapon_id != 0) {
|
||
curr_weapon = weapon;
|
||
ResetAction();
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
if (old_weapon != weapon) {
|
||
AutoLoadingBullet();
|
||
}
|
||
}
|
||
}
|
||
select_weapon = false;
|
||
selected_weapon_idx = 0;
|
||
if (HasBuffEffect(kBET_Camouflage)) {
|
||
RemoveBuffByEffectId(kBET_Camouflage);
|
||
}
|
||
}
|
||
|
||
void Player::UpdateReload()
|
||
{
|
||
AutoLoadingBullet(true);
|
||
reload = false;
|
||
}
|
||
|
||
void Player::UpdateCancelAction()
|
||
{
|
||
CancelAction();
|
||
cancel_action = false;
|
||
}
|
||
|
||
void Player::UpdateUseItemIdx()
|
||
{
|
||
if (downed) {
|
||
return;
|
||
}
|
||
if (use_item_idx >= 0 && use_item_idx < IS_END) {
|
||
switch (use_item_idx) {
|
||
case IS_HEALTHKIT:
|
||
{
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(use_item_idx);
|
||
if (item_meta) {
|
||
StartAction(
|
||
AT_UseItem,
|
||
item_meta->i->use_time(),
|
||
use_item_idx,
|
||
0
|
||
);
|
||
}
|
||
}
|
||
break;
|
||
case IS_PAIN_KILLER:
|
||
{
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquipBySlotId(use_item_idx);
|
||
if (item_meta) {
|
||
StartAction(
|
||
AT_UseItem,
|
||
item_meta->i->use_time(),
|
||
use_item_idx,
|
||
0
|
||
);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
{
|
||
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
use_item_idx = 0;
|
||
use_item = false;
|
||
}
|
||
|
||
void Player::UpdateUseItemId()
|
||
{
|
||
if (downed) {
|
||
return;
|
||
}
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(use_item_id);
|
||
if (item_meta && item_meta->i->equip_type() == EQUIP_TYPE_CAMOUFLAGE) {
|
||
int item_num = GetItemNum(use_item_id);
|
||
if (item_num > 0) {
|
||
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(item_meta->i->buffid());
|
||
if (buff_meta && !GetBuffById(item_meta->i->buffid())) {
|
||
if (HasBuffEffect(kBET_Camouflage)) {
|
||
RemoveBuffByEffectId(kBET_Camouflage);
|
||
}
|
||
AddBuff(buff_meta, 1);
|
||
DecItem(use_item_id, 1);
|
||
}
|
||
}
|
||
}
|
||
use_item_id = 0;
|
||
has_use_item_id = false;
|
||
}
|
||
|
||
void Player::UpdateSpectate()
|
||
{
|
||
if (room->gas_data.gas_mode == GasInactive ||
|
||
room->gas_data.gas_mode == GasJump) {
|
||
spectate = false;
|
||
return;
|
||
}
|
||
BeKill(entity_uniid, name, VW_Spectate);
|
||
spectate = false;
|
||
}
|
||
|
||
void Player::UpdateEmote()
|
||
{
|
||
room->frame_event.AddEmote(this, emote_id);
|
||
emote = false;
|
||
emote_id = 0;
|
||
}
|
||
|
||
void Player::UpdateGetDown()
|
||
{
|
||
DoGetDown();
|
||
get_down = false;
|
||
}
|
||
|
||
void Player::UpdateUseSkill()
|
||
{
|
||
DoSkill();
|
||
}
|
||
|
||
void Player::Shot()
|
||
{
|
||
if (tank_weapon.meta) {
|
||
TankShot(attack_dir);
|
||
return;
|
||
}
|
||
if (!curr_weapon->meta) {
|
||
return;
|
||
}
|
||
|
||
if (curr_weapon->weapon_idx != 0 &&
|
||
curr_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();
|
||
}
|
||
#if 1
|
||
if (true) {
|
||
#else
|
||
if (room->gas_data.gas_mode != GasInactive &&
|
||
!a8::HasBitFlag(status, HS_Fly) &&
|
||
!a8::HasBitFlag(status, HS_Jump)
|
||
) {
|
||
#endif
|
||
for (auto& tuple : curr_weapon->meta->bullet_born_offset) {
|
||
a8::Vec2 bullet_born_offset = a8::Vec2(std::get<0>(tuple), std::get<1>(tuple));
|
||
bullet_born_offset.Rotate(attack_dir.CalcAngle(a8::Vec2::UP));
|
||
a8::Vec2 bullet_born_pos = GetPos() + bullet_born_offset;
|
||
if (room->OverBorder(bullet_born_pos, 0)) {
|
||
return;
|
||
}
|
||
}
|
||
room->frame_event.AddShot(this);
|
||
for (auto& tuple : curr_weapon->meta->bullet_born_offset) {
|
||
a8::Vec2 bullet_born_offset = a8::Vec2(std::get<0>(tuple), std::get<1>(tuple));
|
||
bullet_born_offset.Rotate(attack_dir.CalcAngle(a8::Vec2::UP));
|
||
a8::Vec2 bullet_born_pos = GetPos() + bullet_born_offset;
|
||
a8::Vec2 bullet_dir = attack_dir;
|
||
float bullet_angle = std::get<2>(tuple);
|
||
if (curr_weapon->meta->i->bullet_angle() >= 0.01f) {
|
||
int angle = (int)curr_weapon->meta->i->bullet_angle() * 1000;
|
||
if (curr_weapon->GetUpgradeMeta()) {
|
||
angle -= curr_weapon->GetAttrValue(kHAT_BulletAngle) * 1000;
|
||
}
|
||
if (angle > 0) {
|
||
bullet_angle += (rand() % angle) / 1000.0f * (rand() % 2 == 0 ? 1 : -1);
|
||
}
|
||
}
|
||
bullet_dir.Rotate(bullet_angle / 180.0f);
|
||
if (car_.car_id != 0) {
|
||
bullet_born_pos.x += MetaMgr::Instance()->horse_shoot_x;
|
||
bullet_born_pos.y += MetaMgr::Instance()->horse_shoot_y;
|
||
}
|
||
room->frame_event.AddBullet(this, bullet_born_pos, bullet_dir, fly_distance);
|
||
if (room->BattleStarted()) {
|
||
room->CreateBullet(this, curr_weapon, bullet_born_pos, bullet_dir, fly_distance);
|
||
}
|
||
}
|
||
} else {
|
||
return;
|
||
}
|
||
if (curr_weapon->weapon_idx != 0) {
|
||
--curr_weapon->ammo;
|
||
}
|
||
int slot_id = curr_weapon->meta->i->_inventory_slot();
|
||
//扔完手雷,如无手雷，则优先换武器1>武器2
|
||
switch (slot_id) {
|
||
case 5:
|
||
{
|
||
//手雷
|
||
if (curr_weapon->ammo <= 0) {
|
||
if (GetInventory(slot_id) > 0) {
|
||
DecInventory(slot_id, 1);
|
||
++curr_weapon->ammo;
|
||
} else {
|
||
int weapon_idx = curr_weapon->weapon_idx;
|
||
*curr_weapon = Weapon();
|
||
curr_weapon->weapon_idx = weapon_idx;
|
||
if (weapons[SMOKE_SLOT].weapon_id != 0) {
|
||
curr_weapon = &weapons[SMOKE_SLOT];
|
||
} else {
|
||
AutoChgWeapon();
|
||
}
|
||
AutoLoadingBullet();
|
||
}
|
||
}
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
break;
|
||
case 6:
|
||
{
|
||
//烟雾弹
|
||
if (curr_weapon->ammo <= 0) {
|
||
if (GetInventory(slot_id) > 0) {
|
||
DecInventory(slot_id, 1);
|
||
++curr_weapon->ammo;
|
||
} else {
|
||
int weapon_idx = curr_weapon->weapon_idx;
|
||
*curr_weapon = Weapon();
|
||
curr_weapon->weapon_idx = weapon_idx;
|
||
if (weapons[FRAG_SLOT].weapon_id != 0) {
|
||
curr_weapon = &weapons[FRAG_SLOT];
|
||
} else {
|
||
AutoChgWeapon();
|
||
}
|
||
AutoLoadingBullet();
|
||
}
|
||
}
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
break;
|
||
}
|
||
if (curr_weapon->weapon_idx != 0 &&
|
||
curr_weapon->ammo <= 0) {
|
||
AutoLoadingBullet();
|
||
}
|
||
last_shot_frameno_ = room->frame_no;
|
||
need_sync_active_player = true;
|
||
}
|
||
|
||
void Player::ProcInteraction()
|
||
{
|
||
for (auto obj_id : interaction_objids) {
|
||
Entity* entity = room->GetEntityByUniId(obj_id);
|
||
if (entity) {
|
||
switch (entity->entity_type) {
|
||
case ET_Obstacle:
|
||
{
|
||
ObstacleInteraction((Obstacle*)entity);
|
||
}
|
||
break;
|
||
case ET_Loot:
|
||
{
|
||
LootInteraction((Loot*)entity);
|
||
}
|
||
break;
|
||
case ET_Player:
|
||
{
|
||
HumanInteraction((Human*)entity);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
interaction_objids.Clear();
|
||
}
|
||
|
||
void Player::ObstacleInteraction(Obstacle* entity)
|
||
{
|
||
if (entity->is_door) {
|
||
if (entity->door_state == DoorStateClose) {
|
||
entity->door_state = DoorStateOpen;
|
||
entity->SetPos(a8::Vec2(entity->building->GetX() + entity->door_state1->x() - entity->building->meta->i->tilewidth() / 2.0,
|
||
entity->building->GetY() + entity->door_state1->y() - entity->building->meta->i->tileheight() / 2.0));
|
||
} else {
|
||
entity->door_state = DoorStateClose;
|
||
entity->SetPos(a8::Vec2(entity->building->GetX() + entity->door_state0->x() - entity->building->meta->i->tilewidth() / 2.0,
|
||
entity->building->GetY() + entity->door_state0->y() - entity->building->meta->i->tileheight() / 2.0));
|
||
}
|
||
++entity->door_open_times;
|
||
entity->RecalcSelfCollider();
|
||
room->TouchHumanList(a8::XParams(),
|
||
[entity] (Human* hum, a8::XParams& param) -> bool
|
||
{
|
||
hum->AddToNewObjects(entity);
|
||
if (entity->TestCollision(hum)) {
|
||
hum->last_collision_door = entity;
|
||
} else if (hum->last_collision_door == entity) {
|
||
hum->last_collision_door = nullptr;
|
||
}
|
||
return true;
|
||
});
|
||
}
|
||
}
|
||
|
||
void Player::LootInteraction(Loot* entity)
|
||
{
|
||
if (entity->pickuped ||
|
||
entity->count <= 0) {
|
||
return;
|
||
}
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(entity->item_id);
|
||
if (!item_meta) {
|
||
return;
|
||
}
|
||
switch (item_meta->i->equip_type()) {
|
||
case EQUIP_TYPE_WEAPON:
|
||
{
|
||
//装备
|
||
if (item_meta->i->equip_subtype() == 1) {
|
||
//近战
|
||
if (default_weapon.weapon_id != weapons[0].weapon_id) {
|
||
/*
|
||
cs::SMPickup notifymsg;
|
||
notifymsg.set_error_code(2);
|
||
SendNotifyMsg(notifymsg);
|
||
*/
|
||
return;
|
||
} else {
|
||
weapons[0].weapon_idx = 0;
|
||
weapons[0].weapon_id = entity->item_id;
|
||
#if 1
|
||
weapons[0].weapon_lv = std::max(1, entity->item_level);
|
||
#else
|
||
weapons[0].weapon_lv = std::max(1, GetWeaponConfigLv(weapons[0].weapon_id));
|
||
#endif
|
||
weapons[0].ammo = 0;
|
||
weapons[0].meta = item_meta;
|
||
weapons[0].Recalc();
|
||
}
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
} else {
|
||
Weapon* weapon = nullptr;
|
||
if (weapons[GUN_SLOT1].weapon_id == 0) {
|
||
weapon = &weapons[GUN_SLOT1];
|
||
weapon->weapon_idx = GUN_SLOT1;
|
||
if (curr_weapon != &weapons[GUN_SLOT2]) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
}
|
||
} else if (weapons[GUN_SLOT2].weapon_id == 0) {
|
||
weapon = &weapons[GUN_SLOT2];
|
||
weapon->weapon_idx = GUN_SLOT2;
|
||
if (curr_weapon != &weapons[GUN_SLOT1]) {
|
||
curr_weapon = &weapons[GUN_SLOT2];
|
||
}
|
||
}
|
||
if (!weapon) {
|
||
/*
|
||
cs::SMPickup notifymsg;
|
||
notifymsg.set_error_code(2);
|
||
SendNotifyMsg(notifymsg);
|
||
*/
|
||
return;
|
||
}
|
||
weapon->weapon_id = entity->item_id;
|
||
#if 1
|
||
weapon->weapon_lv = std::max(1, entity->item_level);
|
||
#else
|
||
weapon->weapon_lv = std::max(1, GetWeaponConfigLv(weapon->weapon_id));
|
||
#endif
|
||
weapon->ammo = 0;
|
||
weapon->meta = item_meta;
|
||
weapon->Recalc();
|
||
AutoLoadingBullet();
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
}
|
||
break;
|
||
case EQUIP_TYPE_OLDSKIN:
|
||
{
|
||
ProcLootOldSkin(entity, item_meta);
|
||
}
|
||
break;
|
||
case EQUIP_TYPE_SKIN:
|
||
{
|
||
ProcLootSkin(entity, item_meta);
|
||
}
|
||
break;
|
||
case EQUIP_TYPE_CAR:
|
||
{
|
||
ProcLootCar(entity, item_meta);
|
||
}
|
||
break;
|
||
case EQUIP_TYPE_CAMOUFLAGE:
|
||
{
|
||
ProcCamoutflage(entity, item_meta);
|
||
}
|
||
break;
|
||
default:
|
||
{
|
||
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(entity->count, add_num);
|
||
|
||
AddInventory(item_meta->i->_inventory_slot(), add_num);
|
||
if (item_meta->i->_inventory_slot() == 5 ||
|
||
item_meta->i->_inventory_slot() == 6) {
|
||
Weapon* weapon = &weapons[3 + (item_meta->i->_inventory_slot() - 5)];
|
||
weapon->weapon_id = entity->item_id;
|
||
weapon->weapon_lv = 1;
|
||
weapon->ammo += entity->count;
|
||
weapon->meta = item_meta;
|
||
weapon->Recalc();
|
||
DecInventory(item_meta->i->_inventory_slot(), add_num);
|
||
}
|
||
if (item_meta->i->_inventory_slot() > 12) {
|
||
if (item_meta->i->_inventory_slot() - 12 > curr_scope_idx) {
|
||
curr_scope_idx = item_meta->i->_inventory_slot() - 12;
|
||
}
|
||
}
|
||
if (add_num < entity->count) {
|
||
//刷新数量
|
||
entity->count -= add_num;
|
||
entity->BroadcastFullState();
|
||
return;
|
||
}
|
||
} else {
|
||
switch (item_meta->i->equip_type()) {
|
||
case 7:
|
||
{
|
||
//背包
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(backpack);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
return;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
backpack = item_meta->i->id();
|
||
RecalcVolume();
|
||
}
|
||
break;
|
||
case 4:
|
||
{
|
||
//防具
|
||
if (item_meta->i->equip_subtype() == 1) {
|
||
//盔甲
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(chest);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
return;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
chest = item_meta->i->id();
|
||
RecalcBaseAttr();
|
||
} else if (item_meta->i->equip_subtype() == 2) {
|
||
//头盔
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(helmet);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
return;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
helmet = item_meta->i->id();
|
||
RecalcBaseAttr();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (action_type == AT_None) {
|
||
AutoLoadingBullet();
|
||
}
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
break;
|
||
}
|
||
entity->pickuped = true;
|
||
room->RemoveObjectLater(entity);
|
||
}
|
||
|
||
void Player::HumanInteraction(Human* hum)
|
||
{
|
||
if (downed) {
|
||
return;
|
||
}
|
||
if (hum == this) {
|
||
return;
|
||
}
|
||
if (!hum->downed) {
|
||
return;
|
||
}
|
||
if (hum->action_type == AT_Rescue) {
|
||
return;
|
||
}
|
||
hum->StartAction(
|
||
AT_Rescue,
|
||
MetaMgr::Instance()->GetSysParamAsInt("downed_relive_time") * 1000,
|
||
room->frame_no,
|
||
entity_uniid
|
||
);
|
||
StartAction(
|
||
AT_Relive,
|
||
MetaMgr::Instance()->GetSysParamAsInt("downed_relive_time") * 1000,
|
||
room->frame_no,
|
||
hum->entity_uniid
|
||
);
|
||
}
|
||
|
||
void Player::ProcPrepareItems(const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& prepare_items)
|
||
{
|
||
std::set<int> handled_items;
|
||
for (int equip_id : prepare_items) {
|
||
if (handled_items.find(equip_id) != handled_items.end()) {
|
||
continue;
|
||
}
|
||
handled_items.insert(equip_id);
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(equip_id);
|
||
if (item_meta) {
|
||
switch (item_meta->i->equip_type()) {
|
||
case EQUIP_TYPE_WEAPON:
|
||
{
|
||
//装备
|
||
if (item_meta->i->equip_subtype() == 1) {
|
||
//近战
|
||
if (default_weapon.weapon_id == weapons[0].weapon_id) {
|
||
weapons[0].weapon_idx = 0;
|
||
weapons[0].weapon_id = equip_id;
|
||
weapons[0].weapon_lv = std::max(1, GetWeaponConfigLv(weapons[0].weapon_id));
|
||
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 (curr_weapon != &weapons[GUN_SLOT2]) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
}
|
||
} else if (weapons[GUN_SLOT2].weapon_id == 0) {
|
||
weapon = &weapons[GUN_SLOT2];
|
||
weapon->weapon_idx = GUN_SLOT2;
|
||
if (curr_weapon != &weapons[GUN_SLOT1]) {
|
||
curr_weapon = &weapons[GUN_SLOT2];
|
||
}
|
||
}
|
||
if (weapon) {
|
||
weapon->weapon_id = equip_id;
|
||
weapon->weapon_lv = std::max(1, GetWeaponConfigLv(weapon->weapon_id));
|
||
weapon->ammo = 0;
|
||
weapon->meta = item_meta;
|
||
weapon->Recalc();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case EQUIP_TYPE_CAR:
|
||
{
|
||
int car_uniid = room->CreateAndTakeonCar(item_meta->i->id(), GetPos());
|
||
if (car_uniid != -1) {
|
||
car_.car_uniid = car_uniid;
|
||
car_.car_id = item_meta->i->id();
|
||
car_.meta = item_meta;
|
||
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(car_.meta->i->buffid());
|
||
if (buff_meta) {
|
||
AddBuff(buff_meta, 1);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
{
|
||
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())
|
||
) {
|
||
break;
|
||
}
|
||
int add_num = GetVolume(item_meta->i->_inventory_slot()) -
|
||
GetInventory(item_meta->i->_inventory_slot());
|
||
add_num = std::min(1, add_num);
|
||
|
||
AddInventory(item_meta->i->_inventory_slot(), add_num);
|
||
if (item_meta->i->_inventory_slot() == 5 ||
|
||
item_meta->i->_inventory_slot() == 6) {
|
||
Weapon* weapon = &weapons[3 + (item_meta->i->_inventory_slot() - 5)];
|
||
weapon->weapon_id = equip_id;
|
||
weapon->weapon_lv = 1;
|
||
weapon->ammo += 1;
|
||
weapon->meta = item_meta;
|
||
weapon->Recalc();
|
||
DecInventory(item_meta->i->_inventory_slot(), add_num);
|
||
}
|
||
if (item_meta->i->_inventory_slot() > 12) {
|
||
if (item_meta->i->_inventory_slot() - 12 > curr_scope_idx) {
|
||
curr_scope_idx = item_meta->i->_inventory_slot() - 12;
|
||
}
|
||
}
|
||
} else {
|
||
switch (item_meta->i->equip_type()) {
|
||
case 7:
|
||
{
|
||
//背包
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(backpack);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
break;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
backpack = item_meta->i->id();
|
||
RecalcVolume();
|
||
}
|
||
break;
|
||
case 4:
|
||
{
|
||
//防具
|
||
if (item_meta->i->equip_subtype() == 1) {
|
||
//盔甲
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(chest);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
break;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
chest = item_meta->i->id();
|
||
RecalcBaseAttr();
|
||
} else if (item_meta->i->equip_subtype() == 2) {
|
||
//头盔
|
||
MetaData::Equip* old_item_meta = MetaMgr::Instance()->GetEquip(helmet);
|
||
if (old_item_meta) {
|
||
if (old_item_meta->i->equip_lv() >= item_meta->i->equip_lv()) {
|
||
break;
|
||
}
|
||
room->DropItem(GetPos(), old_item_meta->i->id(), 1, 1);
|
||
}
|
||
helmet = item_meta->i->id();
|
||
RecalcBaseAttr();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}//end for
|
||
if (curr_weapon) {
|
||
MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(curr_weapon->meta->i->use_bullet());
|
||
if (bullet_meta) {
|
||
int add_num = GetInventory(bullet_meta->i->_inventory_slot());
|
||
add_num = curr_weapon->GetClipVolume();
|
||
curr_weapon->ammo = add_num;
|
||
}
|
||
}
|
||
if (spec_weapon.weapon_id != 0) {
|
||
MetaData::Equip* item_meta = MetaMgr::Instance()->GetEquip(spec_weapon.weapon_id);
|
||
if (item_meta &&
|
||
item_meta->i->equip_type() == EQUIP_TYPE_WEAPON) {
|
||
if (item_meta->i->equip_subtype() != 1) {
|
||
Weapon* weapon = &weapons[GUN_SLOT1];
|
||
weapon->weapon_idx = GUN_SLOT1;
|
||
if (curr_weapon != &weapons[GUN_SLOT2]) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
}
|
||
if (weapon) {
|
||
weapon->weapon_id = spec_weapon.weapon_id;
|
||
weapon->weapon_lv = spec_weapon.weapon_lv;
|
||
weapon->ammo = spec_weapon.ammo;
|
||
weapon->meta = item_meta;
|
||
weapon->Recalc();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
need_sync_active_player = true;
|
||
if (prepare_items.size() > 0) {
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
}
|
||
|
||
void Player::_CMMove(f8::MsgHdr& hdr, const cs::CMMove& msg)
|
||
{
|
||
moving = false;
|
||
if (msg.has_move_dir()) {
|
||
if (std::abs(msg.move_dir().x()) > FLT_EPSILON ||
|
||
std::abs(msg.move_dir().y()) > FLT_EPSILON
|
||
) {
|
||
a8::Vec2 old_move_dir;
|
||
TypeConvert::FromPb(move_dir, &msg.move_dir());
|
||
move_dir.Normalize();
|
||
moving = true;
|
||
}
|
||
}
|
||
assert(!isnan(move_dir.x) && !isnan(move_dir.y));
|
||
if (msg.has_attack_dir()) {
|
||
if (std::isfinite(msg.attack_dir().x()) &&
|
||
std::isfinite(msg.attack_dir().y()) &&
|
||
(
|
||
std::abs(msg.attack_dir().x()) > 0.00001f ||
|
||
std::abs(msg.attack_dir().y()) > 0.00001f
|
||
)
|
||
){
|
||
TypeConvert::FromPb(attack_dir, &msg.attack_dir());
|
||
attack_dir.Normalize();
|
||
}
|
||
} else {
|
||
if (moving) {
|
||
attack_dir = move_dir;
|
||
}
|
||
}
|
||
if (moving) {
|
||
moved_frames = 0;
|
||
}
|
||
shot_start = msg.shot_start();
|
||
shot_hold = msg.shot_hold();
|
||
fly_distance = std::min(200.0f, msg.fly_distance());
|
||
if (!shot_hold) {
|
||
series_shot_frames = 0;
|
||
}
|
||
if (msg.has_interaction()) {
|
||
interaction_objids = msg.interaction_objids();
|
||
}
|
||
last_seq_id = msg.seq();
|
||
if (msg.has_select_weapon()) {
|
||
select_weapon = true;
|
||
selected_weapon_idx = msg.select_weapon();
|
||
}
|
||
if (msg.has_drop_weapon()) {
|
||
drop_weapon = true;
|
||
drop_weapon_idx = msg.drop_weapon();
|
||
}
|
||
if (msg.has_use_scope()) {
|
||
use_scope = true;
|
||
use_scope_idx = msg.use_scope();
|
||
}
|
||
if (msg.has_reload()) {
|
||
reload = msg.reload();
|
||
}
|
||
if (msg.has_cancel_action()) {
|
||
cancel_action = msg.cancel_action();
|
||
}
|
||
if (msg.has_use_item_idx()) {
|
||
use_item = true;
|
||
use_item_idx = msg.use_item_idx();
|
||
}
|
||
if (msg.has_use_item_id()) {
|
||
has_use_item_id = true;
|
||
use_item_id = msg.use_item_id();
|
||
}
|
||
if (msg.has_spectate()) {
|
||
spectate = true;
|
||
}
|
||
if (msg.has_emote()) {
|
||
emote = true;
|
||
emote_id = msg.emote();
|
||
}
|
||
if (msg.has_aiming()) {
|
||
aiming = msg.aiming();
|
||
} else {
|
||
aiming = false;
|
||
}
|
||
if (msg.has_get_down()) {
|
||
get_down = msg.get_down();
|
||
}
|
||
if (msg.has_use_skill()) {
|
||
use_skill = msg.use_skill();
|
||
skill_target_id = msg.skill_target_id();
|
||
} else {
|
||
use_skill = false;
|
||
}
|
||
}
|
||
|
||
void Player::UpdateDropWeapon()
|
||
{
|
||
if (drop_weapon_idx >= 0 && drop_weapon_idx < weapons.size()) {
|
||
bool drop_ok = false;
|
||
Weapon* weapon = &weapons[drop_weapon_idx];
|
||
int weapon_id = weapon->weapon_id;
|
||
int weapon_lv = weapon->weapon_lv;
|
||
int weapon_ammo = weapon->ammo;
|
||
MetaData::Equip* weapon_meta = weapon->meta;
|
||
if (weapon->weapon_id != 0) {
|
||
if (weapon->weapon_idx == 0) {
|
||
if (weapon->weapon_id != default_weapon.weapon_id) {
|
||
drop_ok = true;
|
||
*weapon = default_weapon;
|
||
}
|
||
} else if (weapon->weapon_idx == GUN_SLOT1) {
|
||
drop_ok = true;
|
||
*weapon = Weapon();
|
||
weapon->weapon_idx = drop_weapon_idx;
|
||
if (curr_weapon == weapon) {
|
||
if (weapons[GUN_SLOT2].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT2];
|
||
} else {
|
||
curr_weapon = &weapons[0];
|
||
}
|
||
}
|
||
} else if (weapon->weapon_idx == GUN_SLOT2) {
|
||
drop_ok = true;
|
||
*weapon = Weapon();
|
||
weapon->weapon_idx = drop_weapon_idx;
|
||
if (curr_weapon == weapon) {
|
||
if (weapons[GUN_SLOT1].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
} else {
|
||
curr_weapon = &weapons[0];
|
||
}
|
||
}
|
||
} else if (weapon->weapon_idx == FRAG_SLOT) {
|
||
drop_ok = true;
|
||
*weapon = Weapon();
|
||
weapon->weapon_idx = drop_weapon_idx;
|
||
if (curr_weapon == weapon) {
|
||
if (weapons[GUN_SLOT1].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
} else if (weapons[GUN_SLOT2].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT2];
|
||
} else {
|
||
curr_weapon = &weapons[0];
|
||
}
|
||
}
|
||
} else if (weapon->weapon_idx == SMOKE_SLOT) {
|
||
drop_ok = true;
|
||
*weapon = Weapon();
|
||
weapon->weapon_idx = drop_weapon_idx;
|
||
if (curr_weapon == weapon) {
|
||
if (weapons[GUN_SLOT1].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT1];
|
||
} else if (weapons[GUN_SLOT2].weapon_id != 0) {
|
||
curr_weapon = &weapons[GUN_SLOT2];
|
||
} else {
|
||
curr_weapon = &weapons[0];
|
||
}
|
||
}
|
||
}
|
||
if (drop_ok) {
|
||
if (drop_weapon_idx == 0 ||
|
||
drop_weapon_idx == GUN_SLOT1 ||
|
||
drop_weapon_idx == GUN_SLOT2 ||
|
||
drop_weapon_idx == FRAG_SLOT ||
|
||
drop_weapon_idx == SMOKE_SLOT
|
||
) {
|
||
a8::Vec2 dir = a8::Vec2::UP;
|
||
dir.Rotate(a8::RandAngle());
|
||
room->CreateLoot(weapon_id, GetPos() + dir * (40 + rand() % 50), 1, weapon_lv);
|
||
}
|
||
if (weapon_ammo > 0) {
|
||
MetaData::Equip* bullet_meta = MetaMgr::Instance()->GetEquip(weapon_meta->i->use_bullet());
|
||
if (bullet_meta && bullet_meta->i->_inventory_slot() > 0) {
|
||
int volume = GetVolume(bullet_meta->i->_inventory_slot());
|
||
int inventory = GetInventory(bullet_meta->i->_inventory_slot());
|
||
int add_inventory = std::min(weapon_ammo, volume - std::min(volume, inventory));
|
||
if (add_inventory > 0 &&
|
||
!(drop_weapon_idx == FRAG_SLOT || drop_weapon_idx == SMOKE_SLOT)) {
|
||
AddInventory(bullet_meta->i->_inventory_slot(), add_inventory);
|
||
}
|
||
int drop_num = weapon_ammo - add_inventory;
|
||
if (drop_num > 0) {
|
||
a8::Vec2 drop_dir = a8::Vec2::UP;
|
||
drop_dir.Rotate(a8::RandAngle());
|
||
a8::Vec2 drop_pos = GetPos() + drop_dir * (25 + rand() % 50);
|
||
room->DropItem(drop_pos, bullet_meta->i->id(), drop_num, 1);
|
||
}
|
||
}
|
||
}
|
||
need_sync_active_player = true;
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
}
|
||
}
|
||
}
|
||
ResetAction();
|
||
AutoLoadingBullet();
|
||
drop_weapon = false;
|
||
drop_weapon_idx = 0;
|
||
}
|
||
|
||
void Player::UpdateUseScope()
|
||
{
|
||
if (IS_1XSCOPE + use_scope_idx >= IS_1XSCOPE && IS_1XSCOPE + use_scope_idx <= IS_15XSCOPE) {
|
||
if (GetInventory(IS_1XSCOPE + use_scope_idx) > 0) {
|
||
curr_scope_idx = use_scope_idx;
|
||
need_sync_active_player = true;
|
||
}
|
||
}
|
||
use_scope = false;
|
||
use_scope_idx = 0;
|
||
}
|
||
|
||
void Player::_CMEmote(f8::MsgHdr& hdr, const cs::CMEmote& msg)
|
||
{
|
||
|
||
}
|
||
|
||
void Player::_CMVoice(f8::MsgHdr& hdr, const cs::CMVoice& msg)
|
||
{
|
||
cs::SMVoiceNotify notifymsg;
|
||
notifymsg.set_account_id(account_id);
|
||
notifymsg.set_download_url(msg.download_url());
|
||
auto send_func = [] (Player* hum, a8::XParams& param)
|
||
{
|
||
cs::SMVoiceNotify* msg = (cs::SMVoiceNotify*)param.sender.GetUserData();
|
||
hum->SendNotifyMsg(*msg);
|
||
};
|
||
room->TouchPlayerList(a8::XParams()
|
||
.SetSender(¬ifymsg),
|
||
send_func);
|
||
}
|
||
|
||
void Player::_CMGameOver(f8::MsgHdr& hdr, const cs::CMGameOver& msg)
|
||
{
|
||
CancelRevive();
|
||
SendGameOver();
|
||
}
|
||
|
||
void Player::_CMWatchWar(f8::MsgHdr& hdr, const cs::CMWatchWar& msg)
|
||
{
|
||
cs::SMWatchWar respmsg;
|
||
Human* target = room->GetWatchWarTarget(this);
|
||
if (target) {
|
||
SendNotifyMsg(respmsg);
|
||
hdr.hum->FollowTarget(target);
|
||
} else {
|
||
respmsg.set_error_code(1);
|
||
SendNotifyMsg(respmsg);
|
||
}
|
||
}
|
||
|
||
void Player::_CMLeave(f8::MsgHdr& hdr, const cs::CMLeave& msg)
|
||
{
|
||
if (!leave_) {
|
||
if (room->BattleStarted()) {
|
||
//如果战斗已经开始算自杀
|
||
BeKill(entity_uniid, name, VW_Spectate);
|
||
}
|
||
leave_ = true;
|
||
leave_frameno_ = room->frame_no;
|
||
}
|
||
cs::SMLeave respmsg;
|
||
SendNotifyMsg(respmsg);
|
||
}
|
||
|
||
void Player::_CMRevive(f8::MsgHdr& hdr, const cs::CMRevive& msg)
|
||
{
|
||
if (real_dead) {
|
||
SendGameOver();
|
||
return;
|
||
}
|
||
if (dead && !real_dead && revive_timer) {
|
||
dead = false;
|
||
real_dead = false;
|
||
downed = false;
|
||
FreeDownedTimer();
|
||
ability.hp = GetMaxHP();
|
||
ResetTankSkin();
|
||
SyncAroundPlayers(__FILE__, __LINE__, __func__);
|
||
FreeReviveTimer();
|
||
#if 1
|
||
{
|
||
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(kREVIVE_BUFF_ID);
|
||
if (buff_meta) {
|
||
AddBuff(buff_meta, 1);
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
void Player::_CMCancelRevive(f8::MsgHdr& hdr, const cs::CMCancelRevive& msg)
|
||
{
|
||
CancelRevive();
|
||
}
|
||
|
||
void Player::_CMAdStart(f8::MsgHdr& hdr, const cs::CMAdStart& msg)
|
||
{
|
||
if (downed || dead) {
|
||
return;
|
||
}
|
||
if (GetBuffByEffectId(kBET_LordMode)) {
|
||
return;
|
||
}
|
||
if (GetBuffByEffectId(kBET_AdPlaying)) {
|
||
return;
|
||
}
|
||
if (a8::HasBitFlag(status, HS_AlreadyLordMode)) {
|
||
return;
|
||
}
|
||
if (ad_timer_) {
|
||
room->xtimer.DeleteTimer(ad_timer_);
|
||
ad_timer_ = nullptr;
|
||
}
|
||
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(ADPLAY_BUFFID);
|
||
if (buff_meta) {
|
||
AddBuff(buff_meta, 1);
|
||
room->xtimer.
|
||
AddDeadLineTimerAndAttach(
|
||
buff_meta->i->duration_time() * SERVER_FRAME_RATE + 2,
|
||
a8::XParams()
|
||
.SetSender(this),
|
||
[] (const a8::XParams& param)
|
||
{
|
||
Player* hum = (Player*)param.sender.GetUserData();
|
||
hum->InternalAdCancel();
|
||
},
|
||
&xtimer_attacher.timer_list_,
|
||
[] (const a8::XParams& param)
|
||
{
|
||
Human* hum = (Human*)param.sender.GetUserData();
|
||
hum->ad_timer_ = nullptr;
|
||
}
|
||
);
|
||
}
|
||
}
|
||
|
||
void Player::_CMAdCancel(f8::MsgHdr& hdr, const cs::CMAdCancel& msg)
|
||
{
|
||
InternalAdCancel();
|
||
}
|
||
|
||
void Player::_CMAdEnd(f8::MsgHdr& hdr, const cs::CMAdEnd& msg)
|
||
{
|
||
if (GetBuffByEffectId(kBET_LordMode)) {
|
||
return;
|
||
}
|
||
if (GetBuffByEffectId(kBET_AdPlaying)) {
|
||
MetaData::Buff* buff_meta = MetaMgr::Instance()->GetBuff(ADPLAY_BUFFID);
|
||
if (buff_meta) {
|
||
MetaData::Buff* lord_buff_meta = nullptr;
|
||
if (msg.param() == 1) {
|
||
lord_buff_meta = MetaMgr::Instance()->GetBuff(buff_meta->param1);
|
||
} else if (msg.param() == 2) {
|
||
lord_buff_meta = MetaMgr::Instance()->GetBuff(buff_meta->param2);
|
||
}
|
||
if (lord_buff_meta) {
|
||
a8::SetBitFlag(status, HS_AlreadyLordMode);
|
||
AddBuff(lord_buff_meta, 1);
|
||
std::vector<std::string> strings;
|
||
a8::Split(lord_buff_meta->i->buff_param1(), strings, ':');
|
||
for (auto& str : strings) {
|
||
int buff_id = a8::XValue(str);
|
||
MetaData::Buff* ext_buff_meta = MetaMgr::Instance()->GetBuff(buff_id);
|
||
if (ext_buff_meta) {
|
||
AddBuff(ext_buff_meta, 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
RemoveBuffByEffectId(kBET_AdPlaying);
|
||
if (ad_timer_) {
|
||
room->xtimer.DeleteTimer(ad_timer_);
|
||
ad_timer_ = nullptr;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Player::InternalAdCancel()
|
||
{
|
||
if (GetBuffByEffectId(kBET_AdPlaying)) {
|
||
RemoveBuffByEffectId(kBET_AdPlaying);
|
||
if (ad_timer_) {
|
||
room->xtimer.DeleteTimer(ad_timer_);
|
||
ad_timer_ = nullptr;
|
||
}
|
||
}
|
||
if (GetBuffByEffectId(kBET_LordMode)) {
|
||
return;
|
||
}
|
||
}
|