543 lines
21 KiB
C++
543 lines
21 KiB
C++
#include "precompile.h"
|
|
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
#include <glm/vec2.hpp>
|
|
|
|
#include "shot.h"
|
|
#include "creature.h"
|
|
#include "room.h"
|
|
#include "car.h"
|
|
#include "trigger.h"
|
|
#include "buff.h"
|
|
#include "debugcmd.h"
|
|
|
|
#include "mt/Param.h"
|
|
#include "mt/Hero.h"
|
|
#include "mt/Equip.h"
|
|
#include "mt/Buff.h"
|
|
#include "mt/Skill.h"
|
|
#include "mt/SkillNumber.h"
|
|
|
|
static const auto hero_transform =
|
|
glm::rotate(
|
|
glm::mat4(1.0),
|
|
//glm::radians(65.0f),
|
|
glm::radians(0.0f),
|
|
glm::vec3(0.0, 0.0, 1.0)
|
|
);
|
|
|
|
struct BulletInfo
|
|
{
|
|
CreatureWeakPtr c;
|
|
long long weapon_uniid = 0;
|
|
const mt::Equip* weapon_meta = nullptr;
|
|
const mt::Equip* bullet_meta = nullptr;
|
|
const mt::Skill* skill_meta = nullptr;
|
|
Position bullet_born_pos;
|
|
glm::vec3 bullet_dir = GlmHelper::ZERO;
|
|
float fly_distance = 0;
|
|
int weapon_lv = 0;
|
|
int delay_time = 0;
|
|
float recoil_force = 0;
|
|
int invincible_buff_uniid = 0;
|
|
int trace_target_uniid = 0;
|
|
float track_change_time = 0;
|
|
int is_through = 0;
|
|
int hand = 0;
|
|
float shot_animi_time = 0;
|
|
const mt::HeroShotAnimation* shot_animi = nullptr;
|
|
int bullet_idx = 0;
|
|
int bullet_num = 0;
|
|
a8::XTimerWp keep_shot_animi_timer_ptr;
|
|
};
|
|
|
|
static void CalcGunMuzzlePosition(Creature* c,
|
|
const mt::Equip* weapon_meta,
|
|
const mt::HeroShotAnimation* shot_animi,
|
|
glm::vec4& gun_muzzle_position,
|
|
int bulletIdx,
|
|
int bulletNum)
|
|
{
|
|
if (shot_animi) {
|
|
if (weapon_meta->double_gun()&&
|
|
bulletIdx > (int)(bulletNum / 2)) {
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
shot_animi->l_x,
|
|
shot_animi->l_y,
|
|
shot_animi->l_z,
|
|
0
|
|
);
|
|
} else {
|
|
if (c->IsCar() && !weapon_meta->double_gun()) {
|
|
switch (c->shot_hole) {
|
|
case 1:
|
|
{
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
shot_animi->p3_x,
|
|
shot_animi->p3_y,
|
|
shot_animi->p3_z,
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
shot_animi->p4_x,
|
|
shot_animi->p4_y,
|
|
shot_animi->p4_z,
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
shot_animi->p5_x,
|
|
shot_animi->p5_y,
|
|
shot_animi->p5_z,
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
shot_animi->r_x,
|
|
shot_animi->r_y,
|
|
shot_animi->r_z,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}//end if
|
|
if (weapon_meta->_gun_muzzle_position) {
|
|
gun_muzzle_position +=
|
|
glm::vec4(
|
|
-std::get<0>(*weapon_meta->_gun_muzzle_position.get()),
|
|
std::get<1>(*weapon_meta->_gun_muzzle_position.get()),
|
|
std::get<2>(*weapon_meta->_gun_muzzle_position.get()),
|
|
0
|
|
);
|
|
}
|
|
}
|
|
|
|
static void InternalCreateBullet(BulletInfo& bullet_info)
|
|
{
|
|
if (!bullet_info.c.Get()) {
|
|
return;
|
|
}
|
|
Creature* c = bullet_info.c.Get();
|
|
if (c->dead) {
|
|
return;
|
|
}
|
|
if (c->downed) {
|
|
return;
|
|
}
|
|
if (bullet_info.delay_time <= 0) {
|
|
if (c->GetCurrWeapon()->meta->bullet_consume_type() == kBulletConsumeMulti) {
|
|
if (c->GetCurrWeapon()->ammo <= 0) {
|
|
return;
|
|
}
|
|
--c->GetCurrWeapon()->ammo;
|
|
if (c->GetCurrWeapon()->ammo <= 0) {
|
|
c->AutoLoadingBullet();
|
|
}
|
|
if ((c->IsPlayer() || c->IsCar())) {
|
|
c->room->frame_event.AddBulletNumChg(c->GetWeakPtrRef());
|
|
c->room->frame_event.AddWeaponAmmoChg(c->GetWeakPtrRef());
|
|
}
|
|
}
|
|
if (bullet_info.recoil_force > 0) {
|
|
if (c->GetCurrWeapon()->ammo <= 0) {
|
|
c->DoRecoilForce(bullet_info.recoil_force);
|
|
bullet_info.bullet_born_pos.FromGlmVec3(bullet_info.bullet_born_pos.ToGlmVec3() -
|
|
(bullet_info.bullet_dir * bullet_info.recoil_force));
|
|
}
|
|
}
|
|
if (c->IsCar() && c->AsCar()->IsSingle()) {
|
|
glm::vec3 bullet_born_offset;
|
|
bool is_player = c->IsPlayer();
|
|
bool is_car = c->IsCar();
|
|
float bullet_born_angle = GlmHelper::CalcAngle(c->GetAttackDir(), GlmHelper::RIGHT);
|
|
if (c->GetAttackDir().y > 0.00001f) {
|
|
bullet_born_angle = -bullet_born_angle;
|
|
}
|
|
float old_bullet_born_angle = bullet_born_angle;
|
|
GlmHelper::RotateY(bullet_born_offset, bullet_born_angle);
|
|
|
|
auto transform = glm::rotate(hero_transform,
|
|
bullet_born_angle * A8_PI,
|
|
glm::vec3(0.0, 1.0, 0.0));
|
|
glm::vec4 gun_muzzle_position(0.0, 0.0, 0.0, 0.0);
|
|
CalcGunMuzzlePosition(c,
|
|
bullet_info.weapon_meta,
|
|
bullet_info.shot_animi,
|
|
gun_muzzle_position,
|
|
bullet_info.bullet_idx,
|
|
bullet_info.bullet_num);
|
|
glm::vec4 v = transform * gun_muzzle_position;
|
|
bullet_born_offset = glm::vec3(v.z *10*1, 0.0f, v.x*10*-1);
|
|
bullet_info.bullet_born_pos.FromGlmVec3(c->GetPos().ToGlmVec3() + bullet_born_offset);
|
|
bullet_info.bullet_dir = c->GetShotDir();
|
|
}
|
|
int bullet_uniid = 0;
|
|
if (mt::Param::s().prebattle_can_use_skill ||
|
|
!(c->HasBuffEffect(kBET_Jump) || c->HasBuffEffect(kBET_Fly))) {
|
|
bullet_uniid = c->room->CreateBullet
|
|
(c,
|
|
c->shot_passenger,
|
|
bullet_info.weapon_meta,
|
|
bullet_info.bullet_meta,
|
|
bullet_info.skill_meta,
|
|
bullet_info.bullet_born_pos.ToGlmVec3(),
|
|
bullet_info.bullet_dir,
|
|
bullet_info.fly_distance,
|
|
bullet_info.weapon_uniid,
|
|
bullet_info.trace_target_uniid,
|
|
bullet_info.hand,
|
|
bullet_info.keep_shot_animi_timer_ptr,
|
|
bullet_info.shot_animi_time);
|
|
#ifdef DEBUG1
|
|
if (bullet_info.c.Get()->IsPlayer()) {
|
|
bullet_info.c.Get()->SendDebugMsg(a8::Format("CreateBullet id:%d",
|
|
{bullet_info.weapon_meta->id()}));
|
|
}
|
|
#endif
|
|
}
|
|
bullet_uniid = bullet_uniid ? bullet_uniid : c->room->AllocUniid();
|
|
#ifdef DEBUG1
|
|
a8::XPrintf("CreateBullet uniid:%d frameno:%d\n", {bullet_uniid, c->room->GetFrameNo()});
|
|
#endif
|
|
#ifdef DEBUG1
|
|
if (c->IsPlayer()) {
|
|
a8::XPrintf("bullet_born_pos:%f,%f,%f bullet_dir:%f,%f,%f pos:%f,%f,%f\n",
|
|
{
|
|
bullet_info.bullet_born_pos.GetX(),
|
|
bullet_info.bullet_born_pos.GetY(),
|
|
bullet_info.bullet_born_pos.GetZ(),
|
|
|
|
bullet_info.bullet_dir.x,
|
|
bullet_info.bullet_dir.y,
|
|
bullet_info.bullet_dir.z,
|
|
|
|
c->GetPos().GetX(),
|
|
c->GetPos().GetY(),
|
|
c->GetPos().GetZ(),
|
|
});
|
|
}
|
|
#endif
|
|
|
|
#ifdef DEBUG1
|
|
DebugCmd::CreateSphere(c,
|
|
glm::vec3(
|
|
bullet_info.bullet_born_pos.x,
|
|
bullet_info.bullet_born_pos.y,
|
|
bullet_info.bullet_born_pos.z),
|
|
glm::vec3(1, 1, 1),
|
|
c->room->AllocUniid());
|
|
#endif
|
|
|
|
c->room->frame_event.AddBullet
|
|
(bullet_uniid,
|
|
c->GetWeakPtrRef(),
|
|
bullet_info.weapon_meta,
|
|
bullet_info.weapon_lv,
|
|
bullet_info.bullet_born_pos.ToGlmVec3(),
|
|
bullet_info.bullet_dir,
|
|
bullet_info.fly_distance,
|
|
bullet_info.trace_target_uniid,
|
|
bullet_info.hand);
|
|
if (bullet_uniid && bullet_info.trace_target_uniid) {
|
|
c->AddTraceBullet(
|
|
bullet_uniid,
|
|
bullet_info.trace_target_uniid,
|
|
bullet_info.weapon_meta->id()
|
|
);
|
|
}
|
|
} else {
|
|
std::shared_ptr<BulletInfo> info_copy = std::make_shared<BulletInfo>();
|
|
*info_copy = bullet_info;
|
|
auto timer = bullet_info.c.Get()->room->xtimer.SetTimeoutWpEx
|
|
(
|
|
bullet_info.delay_time / FRAME_RATE_MS,
|
|
[info_copy] (int event, const a8::Args* args)
|
|
{
|
|
if (a8::TIMER_EXEC_EVENT == event) {
|
|
info_copy->delay_time = 0;
|
|
InternalCreateBullet(*info_copy);
|
|
}
|
|
},
|
|
&bullet_info.c.Get()->xtimer_attacher);
|
|
if (!c->room->BattleStarted()) {
|
|
c->room->AddToPostBattleAutoFreeList(timer);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ProcMissile(Creature* c,
|
|
const mt::Equip* weapon_meta,
|
|
const mt::Equip* bullet_meta,
|
|
const mt::Skill* skill_meta,
|
|
float fly_distance,
|
|
long long weapon_uniid,
|
|
int trace_target_uniid)
|
|
{
|
|
if (!skill_meta) {
|
|
c->room->frame_event.AddShot(c->GetWeakPtrRef());
|
|
}
|
|
if (c->aiming) {
|
|
if (weapon_meta->aiming_cast_time() > 0) {
|
|
int buff_uniid = c->TryAddBuff(c, kVertigoBuffId);
|
|
Buff* buff = c->GetBuffByUniId(buff_uniid);
|
|
if (buff && !buff->remover_timer.expired()) {
|
|
c->room->xtimer.ModifyTime(buff->remover_timer, weapon_meta->aiming_cast_time() / FRAME_RATE_MS);
|
|
}
|
|
}
|
|
} else {
|
|
if (weapon_meta->cast_time() > 0) {
|
|
int buff_uniid = c->TryAddBuff(c, kVertigoBuffId);
|
|
Buff* buff = c->GetBuffByUniId(buff_uniid);
|
|
if (buff && !buff->remover_timer.expired()) {
|
|
c->room->xtimer.ModifyTime(buff->remover_timer, weapon_meta->cast_time() / FRAME_RATE_MS);
|
|
}
|
|
}
|
|
}
|
|
if (weapon_meta->_bullet_born_offset.empty()) {
|
|
return;
|
|
}
|
|
const mt::Buff * buff_meta = mt::Buff::GetById(bullet_meta->buffid());
|
|
if (buff_meta) {
|
|
typedef struct {
|
|
glm::vec3 old_context_dir;
|
|
Position old_context_pos;
|
|
} _T;
|
|
auto context = std::make_shared<_T>();
|
|
|
|
DelayAddBuffHandle* handle = new DelayAddBuffHandle;
|
|
handle->pre_add_cb =
|
|
[fly_distance, context] (Creature* c)
|
|
{
|
|
context->old_context_dir = c->context_dir;
|
|
context->old_context_pos = c->context_pos;
|
|
|
|
c->context_dir = c->GetAttackDir();
|
|
c->context_pos.FromGlmVec3(c->GetPos().ToGlmVec3() + c->GetAttackDir() * fly_distance);
|
|
};
|
|
handle->post_add_cb =
|
|
[context] (Creature* c, int buff_uniid)
|
|
{
|
|
c->context_dir = context->old_context_dir;
|
|
c->context_pos = context->old_context_pos;
|
|
};
|
|
auto tuple = weapon_meta->_bullet_born_offset.at(0);
|
|
c->TryDelayAddBuff(c,
|
|
bullet_meta->buffid(),
|
|
std::get<3>(tuple),
|
|
handle);
|
|
}
|
|
}
|
|
|
|
void InternalShot(Creature* c,
|
|
const mt::Equip* weapon_meta,
|
|
const mt::Equip* bullet_meta,
|
|
const mt::Skill* skill_meta,
|
|
float fly_distance,
|
|
long long weapon_uniid,
|
|
int trace_target_uniid)
|
|
{
|
|
if (weapon_meta->_inventory_slot() == IS_TRAP ||
|
|
weapon_meta->_inventory_slot() == IS_MINE) {
|
|
ProcMissile(c, weapon_meta, bullet_meta, skill_meta, fly_distance, weapon_uniid, trace_target_uniid);
|
|
return;
|
|
}
|
|
for (auto& tuple : weapon_meta->_bullet_born_offset) {
|
|
glm::vec3 bullet_born_offset = glm::vec3(std::get<0>(tuple), 0.0f, std::get<1>(tuple));
|
|
float bullet_born_angle = GlmHelper::CalcAngle(c->GetAttackDir(), GlmHelper::UP);
|
|
if (c->GetAttackDir().x > 0.00001f) {
|
|
bullet_born_angle = -bullet_born_angle;
|
|
}
|
|
GlmHelper::RotateY(bullet_born_offset, bullet_born_angle);
|
|
Position bullet_born_pos;
|
|
bullet_born_pos.FromGlmVec3(c->GetPos().ToGlmVec3() + bullet_born_offset);
|
|
if (c->room->OverBorder(bullet_born_pos.ToGlmVec3(), 0.0f)) {
|
|
return;
|
|
}
|
|
}
|
|
#if 1
|
|
c->room->frame_event.AddShot(c->GetWeakPtrRef());
|
|
#else
|
|
if (skill_meta || weapon_meta->equip_type() == EQUIP_TYPE_THROW) {
|
|
c->room->frame_event.AddShot(c->GetWeakPtrRef());
|
|
}
|
|
#endif
|
|
int invincible_buff_uniid = 0;
|
|
if (weapon_meta->lock_time > 0) {
|
|
int buff_uniid = c->TryAddBuff(c, kVertigoBuffId);
|
|
Buff* buff = c->GetBuffByUniId(buff_uniid);
|
|
if (buff && !buff->remover_timer.expired()) {
|
|
c->room->xtimer.ModifyTime(buff->remover_timer, weapon_meta->lock_time / FRAME_RATE_MS);
|
|
}
|
|
}
|
|
if (c->aiming) {
|
|
if (weapon_meta->aiming_cast_time() > 0) {
|
|
int buff_uniid = c->TryAddBuff(c, kVertigoBuffId);
|
|
Buff* buff = c->GetBuffByUniId(buff_uniid);
|
|
if (buff && !buff->remover_timer.expired()) {
|
|
c->room->xtimer.ModifyTime(buff->remover_timer, weapon_meta->aiming_cast_time() / FRAME_RATE_MS);
|
|
}
|
|
}
|
|
} else {
|
|
if (weapon_meta->cast_time() > 0) {
|
|
int buff_uniid = c->TryAddBuff(c, kVertigoBuffId);
|
|
Buff* buff = c->GetBuffByUniId(buff_uniid);
|
|
if (buff && !buff->remover_timer.expired()) {
|
|
c->room->xtimer.ModifyTime(buff->remover_timer, weapon_meta->cast_time() / FRAME_RATE_MS);
|
|
}
|
|
}
|
|
}
|
|
const mt::HeroShotAnimation* shot_animi = c->GetHeroMeta() ?
|
|
c->GetHeroMeta()->GetShotAnimi(weapon_meta->shootfire()) : nullptr;
|
|
a8::XTimerWp keep_shot_animi_timer_ptr;
|
|
{
|
|
int shot_animi_time = (shot_animi ? shot_animi->t : 0);
|
|
if (weapon_meta && weapon_meta->equip_subtype() == GUN_SUB_EQUIP_TYPE_FLY_HOOk) {
|
|
keep_shot_animi_timer_ptr = c->TryDelayAddBuff(c, kKeepShotAnimiBuffId, shot_animi_time);
|
|
}
|
|
}
|
|
int bulletIdx = 0;
|
|
int bulletNum = weapon_meta->_bullet_born_offset.size();
|
|
for (auto& tuple : weapon_meta->_bullet_born_offset) {
|
|
++bulletIdx;
|
|
glm::vec3 bullet_born_offset = glm::vec3(std::get<0>(tuple), 0.0f, std::get<1>(tuple));
|
|
glm::vec3 bullet_born_pos = c->GetPos().ToGlmVec3() + c->shoot_offset + bullet_born_offset;
|
|
glm::vec3 bullet_dir = c->GetShotDir();
|
|
float bullet_angle = std::get<2>(tuple);
|
|
if (weapon_meta->bullet_angle() >= 0.10f) {
|
|
int angle = (int)weapon_meta->bullet_angle() * 1000;
|
|
if (angle > 0) {
|
|
bullet_angle += (rand() % angle) / 1000.0f * (rand() % 2 == 0 ? 1 : -1);
|
|
}
|
|
}
|
|
#if 1
|
|
GlmHelper::RotateY(bullet_dir, glm::radians(bullet_angle));
|
|
#else
|
|
GlmHelper::RotateY(bullet_dir, bullet_angle / 180.0f);
|
|
#endif
|
|
int shot_animi_time = (shot_animi ? shot_animi->t : 0);
|
|
if (shot_animi_time > 0) {
|
|
shot_animi_time = std::max(100, shot_animi_time);
|
|
}
|
|
{
|
|
bool is_player = c->IsPlayer();
|
|
bool is_car = c->IsCar();
|
|
float bullet_born_angle = GlmHelper::CalcAngle(c->GetAttackDir(), GlmHelper::RIGHT);
|
|
if (c->GetAttackDir().z > 0.00001f) {
|
|
bullet_born_angle = -bullet_born_angle;
|
|
}
|
|
float old_bullet_born_angle = bullet_born_angle;
|
|
GlmHelper::RotateY(bullet_born_offset, bullet_born_angle);
|
|
|
|
auto transform = glm::rotate(hero_transform,
|
|
bullet_born_angle * A8_PI,
|
|
glm::vec3(0.0, 1.0, 0.0));
|
|
glm::vec4 gun_muzzle_position(0.0, 0.0, 0.0, 0.0);
|
|
CalcGunMuzzlePosition(c, weapon_meta, shot_animi, gun_muzzle_position, bulletIdx, bulletNum);
|
|
glm::vec4 v = transform * gun_muzzle_position;
|
|
bullet_born_offset = glm::vec3(v.z *10*1, v.y, v.x*10*-1);
|
|
bullet_born_pos = c->GetPos().ToGlmVec3() + bullet_born_offset;
|
|
if (c->IsPlayer() || c->IsCar()) {
|
|
#ifdef DEBUG1
|
|
a8::XPrintf("idx:%d offset:%f,%f,%f angle:%f old_angle:%f angle_xyz:%f,%f,%f %f %f gun_muzzle_position:%f,%f,%f pos:%f,%f,%f gun_id:%d t:%d\n",
|
|
{
|
|
bulletIdx,
|
|
bullet_born_offset.x,
|
|
bullet_born_offset.y,
|
|
bullet_born_offset.z,
|
|
bullet_born_angle,
|
|
old_bullet_born_angle,
|
|
c->GetAttackDir().x,
|
|
c->GetAttackDir().y,
|
|
c->GetAttackDir().z,
|
|
(bullet_born_angle * 180),
|
|
(bullet_born_angle - glm::radians(90.0f) / A8_PI) * 180,
|
|
gun_muzzle_position.x,
|
|
gun_muzzle_position.y,
|
|
gun_muzzle_position.z,
|
|
bullet_born_pos.x,
|
|
bullet_born_pos.y,
|
|
bullet_born_pos.z,
|
|
weapon_meta->id(),
|
|
shot_animi_time
|
|
});
|
|
#endif
|
|
}
|
|
}
|
|
{
|
|
BulletInfo bullet_info;
|
|
bullet_info.c = c->GetWeakPtrRef();
|
|
bullet_info.weapon_uniid = weapon_uniid;
|
|
bullet_info.weapon_meta = weapon_meta;
|
|
bullet_info.skill_meta = skill_meta;
|
|
bullet_info.bullet_meta = bullet_meta;
|
|
bullet_info.bullet_born_pos.FromGlmVec3(bullet_born_pos);
|
|
bullet_info.bullet_dir = bullet_dir;
|
|
bullet_info.fly_distance = fly_distance;
|
|
bullet_info.delay_time = std::get<3>(tuple);
|
|
bullet_info.recoil_force = std::get<4>(tuple);
|
|
bullet_info.invincible_buff_uniid = invincible_buff_uniid;
|
|
bullet_info.trace_target_uniid = trace_target_uniid;
|
|
bullet_info.keep_shot_animi_timer_ptr = keep_shot_animi_timer_ptr;
|
|
bullet_info.shot_animi_time = shot_animi_time;
|
|
bullet_info.shot_animi = shot_animi;
|
|
bullet_info.bullet_idx = bulletIdx;
|
|
bullet_info.bullet_num = bulletNum;
|
|
if (skill_meta &&
|
|
(skill_meta->GetMagicId() == MAGIC_20101_HL ||
|
|
skill_meta->GetMagicId() == MAGIC_20201_HX)
|
|
) {
|
|
bullet_info.trace_target_uniid = c->GetSkillTargetId();
|
|
}
|
|
if (weapon_meta->double_gun() &&
|
|
bulletIdx > (int)(bulletNum / 2)) {
|
|
bullet_info.hand = 1;
|
|
}
|
|
#ifdef DEBUG1
|
|
if (bullet_info.trace_target_uniid) {
|
|
a8::XPrintf("bullet trace_target_uniid:%d\n", {bullet_info.trace_target_uniid});
|
|
}
|
|
#endif
|
|
if (bullet_info.skill_meta && bullet_info.skill_meta->_number_meta) {
|
|
c->GetTrigger()->SkillBulletPreCreate(bullet_info.delay_time, bullet_info.skill_meta);
|
|
}
|
|
InternalCreateBullet(bullet_info);
|
|
}
|
|
}
|
|
c->GetTrigger()->Shot(weapon_meta);
|
|
if (weapon_meta->recoil_force() > 0.000001) {
|
|
c->DoRecoilForce(weapon_meta->recoil_force());
|
|
}
|
|
if (c->HasBuffEffect(kBET_Hide)) {
|
|
c->RemoveBuffByEffectId(kBET_Hide);
|
|
}
|
|
if (trace_target_uniid) {
|
|
c->LockAttackDir(1000);
|
|
}
|
|
if (c->aiming) {
|
|
c->aiming = false;
|
|
c->aiming_frameno = 0;
|
|
c->power_idx = -1;
|
|
c->ClearAimingBuffs();
|
|
}
|
|
}
|