Mirroristas/rathena
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ZC_NOTIFY_SKILL

Browse Source
This commit is contained in:
Atemo
2024-05-25 20:40:06 +02:00
parent 545417ef11
commit f95829581f
6 changed files with 136 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/map/atcommand.cpp
View File

@@ -6268,9 +6268,9 @@ ACMD_FUNC(displayskill)
status = status_get_status_data(&sd->bl);
tick = gettick();
if (type == 0 || type == 1)
clif_skill_damage(&sd->bl, &sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( sd->bl, sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SINGLE );
if (type == 0 || type == 2)
clif_skill_damage(&sd->bl, &sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SPLASH);
clif_skill_damage( sd->bl, sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SPLASH );
if (type == 0 || type == 3)
clif_skill_nodamage(&sd->bl, &sd->bl, skill_id, skill_lv, 1);
if (type == 0 || type == 4)

8
src/map/battle.cpp
View File

@@ -6989,8 +6989,8 @@ static void battle_calc_weapon_final_atk_modifiers(struct Damage* wd, struct blo
rdamage = battle_calc_base_damage(target,tstatus,&tstatus->rhw,tsc,sstatus->size,0);
rdamage = (int64)rdamage * ratio / 100 + wd->damage * (10 + tsc->getSCE(SC_CRESCENTELBOW)->val1 * 20 / 10) / 10;
skill_blown(target, src, skill_get_blewcount(SR_CRESCENTELBOW_AUTOSPELL, tsc->getSCE(SC_CRESCENTELBOW)->val1), unit_getdir(src), BLOWN_NONE);
clif_skill_damage(target, src, gettick(), status_get_amotion(src), 0, rdamage,
1, SR_CRESCENTELBOW_AUTOSPELL, tsc->getSCE(SC_CRESCENTELBOW)->val1, DMG_SINGLE); // This is how official does
clif_skill_damage( *target, *src, gettick(), status_get_amotion(src), 0, rdamage,
1, SR_CRESCENTELBOW_AUTOSPELL, tsc->getSCE(SC_CRESCENTELBOW)->val1, DMG_SINGLE ); // This is how official does
clif_damage(src, target, gettick(), status_get_amotion(src)+1000, 0, rdamage/10, 1, DMG_NORMAL, 0, false);
battle_fix_damage(target, src, rdamage, 0, SR_CRESCENTELBOW);
status_damage(src, target, rdamage/10, 0, 0, 1, 0);
@@ -9501,7 +9501,7 @@ int64 battle_calc_return_damage(struct block_list* tbl, struct block_list *src,
int64 rd1 = i64min(damage, status_get_max_hp(tbl)) * tsc->getSCE(SC_DEATHBOUND)->val2 / 100; // Amplify damage.
*dmg = rd1 * 30 / 100; // Received damage = 30% of amplified damage.
clif_skill_damage(src, tbl, gettick(), status_get_amotion(src), 0, -30000, 1, RK_DEATHBOUND, tsc->getSCE(SC_DEATHBOUND)->val1, DMG_SINGLE);
clif_skill_damage( *src, *tbl, gettick(), status_get_amotion(src), 0, -30000, 1, RK_DEATHBOUND, tsc->getSCE(SC_DEATHBOUND)->val1, DMG_SINGLE );
skill_blown(tbl, src, skill_get_blewcount(RK_DEATHBOUND, tsc->getSCE(SC_DEATHBOUND)->val1), unit_getdir(src), BLOWN_NONE);
status_change_end(tbl, SC_DEATHBOUND);
rdamage += rd1 * 70 / 100; // Target receives 70% of the amplified damage. [Rytech]
@@ -10101,7 +10101,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
s_elemental_data *ed = ((TBL_PC*)target)->ed;
if (ed) {
clif_skill_damage(&ed->bl, target, tick, status_get_amotion(src), 0, -30000, 1, EL_CIRCLE_OF_FIRE, tsc->getSCE(SC_CIRCLE_OF_FIRE_OPTION)->val1, DMG_SINGLE);
clif_skill_damage( ed->bl, *target, tick, status_get_amotion(src), 0, -30000, 1, EL_CIRCLE_OF_FIRE, tsc->getSCE(SC_CIRCLE_OF_FIRE_OPTION)->val1, DMG_SINGLE );
skill_attack(BF_WEAPON,&ed->bl,&ed->bl,src,EL_CIRCLE_OF_FIRE,tsc->getSCE(SC_CIRCLE_OF_FIRE_OPTION)->val1,tick,wd.flag);
}
}

148
src/map/clif.cpp
View File

@@ -5138,8 +5138,13 @@ static int clif_calc_walkdelay(struct block_list *bl,int delay, char type, int64
/*========================================== [Playtester]
* Returns hallucination damage the client displays
*------------------------------------------*/
static int clif_hallucination_damage()
{
static int64 clif_hallucination_damage( block_list& bl, int64 damage ){
status_change *sc;
if (!((sc = status_get_sc(&bl)) && sc->count && sc->getSCE(SC_HALLUCINATION) && damage)) {
return damage;
}
int digit = rnd() % 5 + 1;
switch (digit)
{
@@ -5178,10 +5183,10 @@ static int clif_hallucination_damage()
/// 13 = multi-hit critical
int clif_damage(struct block_list* src, struct block_list* dst, t_tick tick, int sdelay, int ddelay, int64 sdamage, int div, enum e_damage_type type, int64 sdamage2, bool spdamage)
{
nullpo_ret(src);
nullpo_ret(dst);
unsigned char buf[34];
status_change *sc;
int damage = (int)cap_value(sdamage,INT_MIN,INT_MAX);
int damage2 = (int)cap_value(sdamage2,INT_MIN,INT_MAX);
#if PACKETVER < 20071113
const int cmd = 0x8a;
int offset = 0;
@@ -5193,18 +5198,15 @@ int clif_damage(struct block_list* src, struct block_list* dst, t_tick tick, int
int offset = 3;
#endif
nullpo_ret(src);
nullpo_ret(dst);
int damage = (int)cap_value(sdamage,INT_MIN,INT_MAX);
int damage2 = (int)cap_value(sdamage2,INT_MIN,INT_MAX);
if (type != DMG_MULTI_HIT_CRITICAL)
type = clif_calc_delay(type,div,damage+damage2,ddelay);
sc = status_get_sc(dst);
if(sc && sc->count) {
if(sc->getSCE(SC_HALLUCINATION)) {
damage = clif_hallucination_damage();
if(damage2) damage2 = clif_hallucination_damage();
}
}
damage = static_cast<int32>(clif_hallucination_damage( *dst, damage ));
if (damage2)
damage2 = static_cast<int32>(clif_hallucination_damage( *dst, damage2 ));
// Calculate what sdelay to send to the client so it applies damage at the same time as the server
if (battle_config.synchronize_damage && src->type == BL_MOB) {
@@ -6006,96 +6008,61 @@ void clif_skill_cooldown( map_session_data &sd, uint16 skill_id, t_tick tick ){
/// Skill attack effect and damage.
/// 0114 <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <damage>.W <level>.W <div>.W <type>.B (ZC_NOTIFY_SKILL)
/// 01de <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <damage>.L <level>.W <div>.W <type>.B (ZC_NOTIFY_SKILL2)
int clif_skill_damage(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type)
{
unsigned char buf[64];
status_change *sc;
int damage = (int)cap_value(sdamage,INT_MIN,INT_MAX);
int clif_skill_damage( block_list& src, block_list& dst, t_tick tick, int32 sdelay, int32 ddelay, int64 sdamage, int32 div, uint16 skill_id, uint16 skill_lv, e_damage_type type ){
type = clif_calc_delay( type, div, sdamage, ddelay );
sdamage = clif_hallucination_damage( dst, sdamage );
nullpo_ret(src);
nullpo_ret(dst);
PACKET_ZC_NOTIFY_SKILL packet{};
type = clif_calc_delay(type,div,damage,ddelay);
packet.PacketType = HEADER_ZC_NOTIFY_SKILL;
packet.SKID = skill_id;
packet.AID = src.id;
packet.targetID = dst.id;
packet.startTime = client_tick( tick );
packet.attackMT = sdelay;
packet.attackedMT = ddelay;
if( ( sc = status_get_sc(dst) ) && sc->count ) {
if(sc->getSCE(SC_HALLUCINATION) && damage)
damage = clif_hallucination_damage();
}
auto damage = std::min( static_cast<decltype(packet.damage)>( sdamage ), std::numeric_limits<decltype(packet.damage)>::max() );
#if PACKETVER < 3
WBUFW(buf,0)=0x114;
WBUFW(buf,2)=skill_id;
WBUFL(buf,4)=src->id;
WBUFL(buf,8)=dst->id;
WBUFL(buf,12)=client_tick(tick);
WBUFL(buf,16)=sdelay;
WBUFL(buf,20)=ddelay;
if (battle_config.hide_woe_damage && map_flag_gvg(src->m)) {
WBUFW(buf,24)=damage?div:0;
if (battle_config.hide_woe_damage && map_flag_gvg(src.m)) {
packet.damage = static_cast<decltype(packet.damage)>(damage ? div : 0);
} else {
WBUFW(buf,24)=damage;
packet.damage = damage;
}
WBUFW(buf,26)=skill_lv;
WBUFW(buf,28)=div;
WBUFB(buf,30)=type;
if (disguised(dst)) {
clif_send(buf,packet_len(0x114),dst,AREA_WOS);
WBUFL(buf,8)=disguised_bl_id(dst->id);
clif_send(buf,packet_len(0x114),dst,SELF);
} else
clif_send(buf,packet_len(0x114),dst,AREA);
packet.level = skill_lv;
packet.count = static_cast<decltype(packet.count)>(div);
if(disguised(src)) {
WBUFL(buf,4)=disguised_bl_id(src->id);
if (disguised(dst))
WBUFL(buf,8)=dst->id;
if(damage > 0)
WBUFW(buf,24)=-1;
clif_send(buf,packet_len(0x114),src,SELF);
}
#else
WBUFW(buf,0)=0x1de;
WBUFW(buf,2)=skill_id;
WBUFL(buf,4)=src->id;
WBUFL(buf,8)=dst->id;
WBUFL(buf,12)=client_tick(tick);
WBUFL(buf,16)=sdelay;
WBUFL(buf,20)=ddelay;
if (battle_config.hide_woe_damage && map_flag_gvg(src->m)) {
WBUFL(buf,24)=damage?div:0;
} else {
WBUFL(buf,24)=damage;
}
WBUFW(buf,28)=skill_lv;
WBUFW(buf,30)=div;
// For some reason, late 2013 and newer clients have
// a issue that causes players and monsters to endure
// type 6 (ACTION_SKILL) skills. So we have to do a small
// hack to set all type 6 to be sent as type 8 ACTION_ATTACK_MULTIPLE
#if PACKETVER < 20131223
WBUFB(buf,32)=type;
packet.action = static_cast<decltype(packet.action)>(type);
#else
WBUFB(buf,32)=( type == DMG_SINGLE ) ? DMG_MULTI_HIT : type;
packet.action = static_cast<decltype(packet.action)>(( type == DMG_SINGLE ) ? DMG_MULTI_HIT : type);
#endif
if (disguised(dst)) {
clif_send(buf,packet_len(0x1de),dst,AREA_WOS);
WBUFL(buf,8)=disguised_bl_id(dst->id);
clif_send(buf,packet_len(0x1de),dst,SELF);
} else
clif_send(buf,packet_len(0x1de),dst,AREA);
if(disguised(src)) {
WBUFL(buf,4)=disguised_bl_id(src->id);
if (disguised(dst))
WBUFL(buf,8)=dst->id;
if(damage > 0)
WBUFL(buf,24)=-1;
clif_send(buf,packet_len(0x1de),src,SELF);
if (disguised(&dst)) {
clif_send( &packet, sizeof( packet ), &dst, AREA_WOS );
packet.targetID = disguised_bl_id( dst.id );
clif_send( &packet, sizeof( packet ), &dst, SELF );
} else {
clif_send( &packet, sizeof( packet ), &dst, AREA );
}
if (disguised(&src)) {
packet.AID = disguised_bl_id( src.id );
if (disguised(&dst)) {
packet.targetID = dst.id;
}
if (damage > 0) {
packet.damage = -1;
}
clif_send( &packet, sizeof( packet ), &src, SELF );
}
#endif
//Because the damage delay must be synced with the client, here is where the can-walk tick must be updated. [Skotlex]
return clif_calc_walkdelay(dst,ddelay,type,damage,div);
return clif_calc_walkdelay( &dst, ddelay, type, damage, div );
}
@@ -6105,19 +6072,14 @@ int clif_skill_damage(struct block_list *src,struct block_list *dst,t_tick tick,
int clif_skill_damage2(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type)
{
unsigned char buf[64];
status_change *sc;
nullpo_ret(src);
nullpo_ret(dst);
type = (type>DMG_NORMAL)?type:skill_get_hit(skill_id);
type = clif_calc_delay(type,div,damage,ddelay);
sc = status_get_sc(dst);
if(sc && sc->count) {
if(sc->getSCE(SC_HALLUCINATION) && damage)
damage = clif_hallucination_damage();
}
damage = clif_hallucination_damage( *dst, damage );
WBUFW(buf,0)=0x115;
WBUFW(buf,2)=skill_id;

2
src/map/clif.hpp
View File

@@ -915,7 +915,7 @@ void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x,
void clif_skillcastcancel( block_list& bl );
void clif_skill_fail( map_session_data& sd, uint16 skill_id, enum useskill_fail_cause cause = USESKILL_FAIL_LEVEL, int btype = 0, t_itemid itemId = 0 );
void clif_skill_cooldown( map_session_data &sd, uint16 skill_id, t_tick tick );
int clif_skill_damage(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
int clif_skill_damage( block_list& src, block_list& dst, t_tick tick, int32 sdelay, int32 ddelay, int64 sdamage, int32 div, uint16 skill_id, uint16 skill_lv, e_damage_type type );
//int clif_skill_damage2(struct block_list *src,struct block_list *dst,t_tick tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
bool clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 skill_id,int heal,t_tick tick);
void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,int y,t_tick tick);

2
src/map/script.cpp
View File

@@ -15341,7 +15341,7 @@ static inline void script_skill_effect(block_list *bl, uint16 skill_id, uint16 s
clif_skill_nodamage(bl, bl, skill_id, skill_lv, 1);
break;
case CAST_DAMAGE:
clif_skill_damage(bl, bl, gettick(), status_get_amotion(bl), status_get_dmotion(bl), 0, 1, skill_id, skill_lv, skill_get_hit(skill_id));
clif_skill_damage( *bl, *bl, gettick(), status_get_amotion(bl), status_get_dmotion(bl), 0, 1, skill_id, skill_lv, skill_get_hit(skill_id) );
break;
}
}

146
src/map/skill.cpp
View File

@@ -3722,7 +3722,7 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
nbl = battle_getenemyarea(bl,bl->x,bl->y,2,BL_CHAR,bl->id);
if( nbl ){ // Only one target is chosen.
damage = damage / 2; // Deflect half of the damage to a target nearby
clif_skill_damage(bl, nbl, tick, status_get_amotion(src), 0, battle_fix_damage(bl,nbl,damage,0,0), dmg.div_, OB_OBOROGENSOU_TRANSITION_ATK, -1, DMG_SINGLE);
clif_skill_damage( *bl, *nbl, tick, status_get_amotion(src), 0, battle_fix_damage(bl,nbl,damage,0,0), dmg.div_, OB_OBOROGENSOU_TRANSITION_ATK, -1, DMG_SINGLE );
}
}
@@ -3795,7 +3795,7 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
//Display damage.
switch( skill_id ) {
case PA_GOSPEL: //Should look like Holy Cross [Skotlex]
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, CR_HOLYCROSS, -1, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, CR_HOLYCROSS, -1, DMG_SPLASH );
break;
//Skills that need be passed as a normal attack for the client to display correctly.
case HVAN_EXPLOSION:
@@ -3813,12 +3813,12 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
case AS_SPLASHER:
if( flag&SD_ANIMATION ) // the surrounding targets
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH); // needs -1 as skill level
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH ); // needs -1 as skill level
else // the central target doesn't display an animation
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_SPLASH); // needs -2(!) as skill level
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_SPLASH ); // needs -2(!) as skill level
break;
case SR_EARTHSHAKER:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,1,skill_id,-2,DMG_SINGLE);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, 1, skill_id, -2, DMG_SINGLE );
break;
case WL_SOULEXPANSION:
case WL_COMET:
@@ -3827,19 +3827,19 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
#ifndef RENEWAL
case NJ_HUUMA:
#endif
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,skill_id,skill_lv,DMG_MULTI_HIT);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, DMG_MULTI_HIT );
break;
case WL_CHAINLIGHTNING_ATK:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,1,WL_CHAINLIGHTNING_ATK,-2,DMG_SINGLE);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, 1, WL_CHAINLIGHTNING_ATK, -2, DMG_SINGLE );
break;
case WL_TETRAVORTEX_FIRE:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, WL_TETRAVORTEX_WIND, -1, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, WL_TETRAVORTEX_WIND, -1, DMG_SPLASH );
break;
case LG_SHIELDPRESS:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, status_get_amotion(src), dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SINGLE);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, status_get_amotion(src), dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SINGLE );
break;
case NPC_EARTHQUAKE:
dmg.dmotion = clif_skill_damage(src, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_ENDURE);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_ENDURE );
break;
case NPC_DARKPIERCING:
case EL_FIRE_BOMB:
@@ -3861,19 +3861,19 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
case KO_BAKURETSU:
case GN_HELLS_PLANT_ATK:
case SU_SV_ROOTTWIST_ATK:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,skill_id,-1,DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH );
break;
case GN_FIRE_EXPANSION_ACID:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, CR_ACIDDEMONSTRATION, skill_lv, DMG_MULTI_HIT);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, CR_ACIDDEMONSTRATION, skill_lv, DMG_MULTI_HIT );
break;
case GN_SLINGITEM_RANGEMELEEATK:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,GN_SLINGITEM,-2,DMG_SINGLE);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, GN_SLINGITEM, -2, DMG_SINGLE );
break;
case EL_STONE_RAIN:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,skill_id,-1,(flag&1)?DMG_MULTI_HIT:DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, (flag&1) ? DMG_MULTI_HIT : DMG_SPLASH );
break;
case WM_SEVERE_RAINSTORM_MELEE:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,WM_SEVERE_RAINSTORM,-2,DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, WM_SEVERE_RAINSTORM, -2, DMG_SPLASH );
break;
case HT_CLAYMORETRAP:
case HT_BLASTMINE:
@@ -3882,20 +3882,20 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
case RA_CLUSTERBOMB:
case RA_FIRINGTRAP:
case RA_ICEBOUNDTRAP:
dmg.dmotion = clif_skill_damage(src, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, (flag&SD_LEVEL) ? -1 : skill_lv, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, (flag&SD_LEVEL) ? -1 : skill_lv, DMG_SPLASH );
if( dsrc != src ) // avoid damage display redundancy
break;
[[fallthrough]];
case HT_LANDMINE:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, dmg_type);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, dmg_type );
break;
case WZ_SIGHTBLASTER:
//Sightblaster should never call clif_skill_damage twice
dmg.dmotion = clif_skill_damage(src, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, (flag&SD_LEVEL) ? -1 : skill_lv, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, (flag&SD_LEVEL) ? -1 : skill_lv, DMG_SPLASH );
break;
case RL_R_TRIP_PLUSATK:
case RL_S_STORM:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,status_get_amotion(src),dmg.dmotion,damage,dmg.div_,skill_id,-1,DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, status_get_amotion(src), dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH );
break;
case SU_LUNATICCARROTBEAT:
case SU_LUNATICCARROTBEAT2:
@@ -3908,31 +3908,31 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
clif_skill_nodamage(dsrc, bl, skill_id, skill_lv, 1);
[[fallthrough]];
case WM_REVERBERATION:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, dmg_type);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, dmg_type );
break;
case SJ_FALLINGSTAR_ATK:
case SJ_FALLINGSTAR_ATK2:
dmg.dmotion = clif_skill_damage(src,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_MULTI_HIT);
dmg.dmotion = clif_skill_damage( *src, *bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_MULTI_HIT );
break;
case SJ_NOVAEXPLOSING:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_SINGLE);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -2, DMG_SINGLE );
break;
case DK_HACKANDSLASHER_ATK:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, dmg_type);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, dmg_type );
break;
case AG_STORM_CANNON:
case AG_CRIMSON_ARROW:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, DMG_SPLASH );
break;
case TR_ROSEBLOSSOM_ATK:
case ABC_FROM_THE_ABYSS_ATK:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH );
break;
case TR_SOUNDBLEND:
if (flag&SD_ANIMATION)// For some reason the caster reacts on the splash flag. Best reduce amotion to minimize it for now. [Rytech]
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, 10, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, 10, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH );
else
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, dmg_type);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, dmg_type );
break;
case AB_DUPLELIGHT_MELEE:
case AB_DUPLELIGHT_MAGIC:
@@ -3944,11 +3944,11 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
if (src->type == BL_SKILL) {
TBL_SKILL *su = (TBL_SKILL*)src;
if (su->group && skill_get_inf2(su->group->skill_id, INF2_ISTRAP)) { // show damage on trap targets
clif_skill_damage(src, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, flag&SD_LEVEL ? -1 : skill_lv, DMG_SPLASH);
clif_skill_damage( *src, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, flag&SD_LEVEL ? -1 : skill_lv, DMG_SPLASH );
break;
}
}
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, flag&SD_LEVEL?-1:skill_lv, dmg_type);
dmg.dmotion = clif_skill_damage( *dsrc, *bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, (flag&SD_LEVEL) ? -1 : skill_lv, dmg_type );
break;
}
@@ -4062,10 +4062,10 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
if (e_bl) {
if (!rmdamage) {
clif_skill_damage(e_bl, e_bl, gettick(), 0, 0, damage, dmg.div_, skill_id, -1, skill_get_hit(skill_id));
clif_skill_damage( *e_bl, *e_bl, gettick(), 0, 0, damage, dmg.div_, skill_id, -1, skill_get_hit(skill_id) );
battle_fix_damage(src, e_bl, damage, 0, 0);
} else {
clif_skill_damage(bl, bl, gettick(), 0, 0, damage, dmg.div_, skill_id, -1, skill_get_hit(skill_id));
clif_skill_damage( *bl, *bl, gettick(), 0, 0, damage, dmg.div_, skill_id, -1, skill_get_hit(skill_id) );
battle_fix_damage(bl, bl, damage, 0, 0);
}
}
@@ -4171,7 +4171,7 @@ int skill_area_sub(struct block_list *bl, va_list ap)
if(battle_check_target(src,bl,flag) > 0) {
// several splash skills need this initial dummy packet to display correctly
if (flag&SD_PREAMBLE && skill_area_temp[2] == 0)
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if (flag&(SD_SPLASH|SD_PREAMBLE))
skill_area_temp[2]++;
@@ -4531,7 +4531,7 @@ static TIMER_FUNC(skill_timerskill){
if (skl->skill_id == SR_SKYNETBLOW) {
skill_area_temp[1] = 0;
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skl->skill_id,skl->skill_lv,DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skl->skill_id, skl->skill_lv, DMG_SINGLE );
map_foreachinallrange(skill_area_sub,src,skill_get_splash(skl->skill_id,skl->skill_lv),BL_CHAR|BL_SKILL,src,
skl->skill_id,skl->skill_lv,tick,skl->flag|BCT_ENEMY|SD_SPLASH|1,skill_castend_damage_id);
break;
@@ -5116,7 +5116,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
sc_type sct = skill_get_sc(skill_id);
if(sct != SC_NONE)
status_change_end(bl, sct);
clif_skill_damage(src, bl, tick, status_get_amotion(src), status_get_dmotion(bl), 0, 1, skill_id, skill_lv, skill_get_hit(skill_id));
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), status_get_dmotion(bl), 0, 1, skill_id, skill_lv, skill_get_hit(skill_id));
return 1;
}
@@ -5804,7 +5804,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
#endif
case LG_MOONSLASHER:
case MH_XENO_SLASHER:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
break;
case NPC_REVERBERATION_ATK:
case NC_ARMSCANNON:
@@ -6679,7 +6679,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(bl, SC__SHADOWFORM);
sc_start(src,bl, SC_INFRAREDSCAN, 10000, skill_lv, skill_get_time(skill_id, skill_lv));
} else {
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
}
break;
@@ -6688,7 +6688,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag);
else {
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_damage_id);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
}
break;
@@ -6703,7 +6703,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
skill_area_temp[5] = y;
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_damage_id);
skill_addtimerskill(src,tick + 800,src->id,x,y,skill_id,skill_lv,0,flag); // To teleport Self
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
}
break;
@@ -6753,7 +6753,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(bl, SC__SHADOWFORM);
} else {
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
}
break;
@@ -6819,7 +6819,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
else {
int i = skill_get_splash(skill_id,skill_lv);
clif_skill_nodamage(src,battle_get_master(src),skill_id,skill_lv,1);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if( rnd()%100 < 30 )
map_foreachinrange(skill_area_sub,bl,i,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
else
@@ -6829,7 +6829,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case EL_ROCK_CRUSHER:
clif_skill_nodamage(src,battle_get_master(src),skill_id,skill_lv,1);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if( rnd()%100 < 50 )
skill_attack(BF_MAGIC,src,src,bl,skill_id,skill_lv,tick,flag);
else
@@ -6842,7 +6842,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
else {
int i = skill_get_splash(skill_id,skill_lv);
clif_skill_nodamage(src,battle_get_master(src),skill_id,skill_lv,1);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if( rnd()%100 < 30 )
map_foreachinrange(skill_area_sub,bl,i,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
else
@@ -6855,7 +6855,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
case EL_WIND_SLASH:
case EL_STONE_HAMMER:
clif_skill_nodamage(src,battle_get_master(src),skill_id,skill_lv,1);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
skill_attack(skill_get_type(skill_id),src,src,bl,skill_id,skill_lv,tick,flag);
break;
@@ -6866,7 +6866,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
sc_type type = SC_TIDAL_WEAPON_OPTION, type2 = SC_TIDAL_WEAPON;
clif_skill_nodamage(src,battle_get_master(src),skill_id,skill_lv,1);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if( (tsc_ele && tsc_ele->getSCE(type2)) || (tsc && tsc->getSCE(type)) ) {
status_change_end(battle_get_master(src),type);
status_change_end(src,type2);
@@ -7135,9 +7135,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
default:
ShowWarning("skill_castend_damage_id: Unknown skill used:%d\n",skill_id);
clif_skill_damage(src, bl, tick, status_get_amotion(src), tstatus->dmotion,
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), tstatus->dmotion,
0, abs(skill_get_num(skill_id, skill_lv)),
skill_id, skill_lv, skill_get_hit(skill_id));
skill_id, skill_lv, skill_get_hit(skill_id) );
map_freeblock_unlock();
return 1;
}
@@ -7805,7 +7805,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
clif_blown(bl);
// If caster is not a boss, switch coordinates with the target
@@ -8033,7 +8033,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case NPC_ALL_STAT_DOWN:
status_change_start(src, bl, type, 10000, skill_lv, 0, 0, 0, skill_get_time(skill_id, skill_lv), SCSTART_NOAVOID|SCSTART_NOTICKDEF|SCSTART_NORATEDEF);
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
break;
// EDP also give +25% WATK poison pseudo element to user.
@@ -8655,7 +8655,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
i = map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), starget,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
if( !i && ( skill_id == RK_WINDCUTTER || skill_id == NC_AXETORNADO || skill_id == LG_CANNONSPEAR || skill_id == SR_SKYNETBLOW || skill_id == KO_HAPPOKUNAI ) )
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
}
break;
@@ -8739,7 +8739,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
#if PACKETVER >= 20180207
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
#else
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
#endif
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
break;
@@ -10849,7 +10849,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case LG_EARTHDRIVE: {
int dummy = 1;
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
i = skill_get_splash(skill_id,skill_lv);
map_foreachinallarea(skill_cell_overlap, src->m, src->x-i, src->y-i, src->x+i, src->y+i, BL_SKILL, LG_EARTHDRIVE, &dummy, src);
map_foreachinrange(skill_area_sub, bl,i,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
@@ -10963,7 +10963,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case GC_PHANTOMMENACE:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub,src,skill_get_splash(skill_id,skill_lv),BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
@@ -11305,7 +11305,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case RA_FEARBREEZE:
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
clif_skill_nodamage(src, bl, skill_id, skill_lv, sc_start(src,bl, type, 100, skill_lv, skill_get_time(skill_id, skill_lv)));
break;
@@ -11346,7 +11346,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case RA_SENSITIVEKEEN:
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
map_foreachinrange(skill_area_sub,src,skill_get_splash(skill_id,skill_lv),BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY,skill_castend_damage_id);
break;
@@ -11388,7 +11388,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case NC_ANALYZE:
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
sc_start(src,bl,type, 30 + 12 * skill_lv,skill_lv,skill_get_time(skill_id,skill_lv));
break;
@@ -11399,7 +11399,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if (map_flag_vs(src->m)) // Doesn't affect the caster in non-PVP maps [exneval]
sc_start2(src, bl, type, 100, skill_lv, src->id, skill_get_time(skill_id, skill_lv));
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag | BCT_ENEMY | SD_SPLASH | 1, skill_castend_nodamage_id);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
}
break;
@@ -11519,7 +11519,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case LG_TRAMPLE:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if (rnd()%100 < (25 + 25 * skill_lv))
map_foreachinallrange(skill_destroy_trap,bl,skill_get_splash(skill_id,skill_lv),BL_SKILL,tick);
status_change_end(bl, SC_SV_ROOTTWIST);
@@ -11556,7 +11556,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
} else {
int count = 0;
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
count = map_forcountinrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv), (sd)?sd->spiritball_old:15, // Assume 15 spiritballs in non-charactors
BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
if( sd ) pc_delspiritball(sd, count, 0);
@@ -11578,7 +11578,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
} else {
int count = 0;
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
count = map_forcountinrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv), (sd)?sd->spiritball_old:15, // Assume 15 spiritballs in non-charactors
BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
if( sd ) pc_delspiritball(sd, count, 0);
@@ -11614,7 +11614,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
status_percent_heal(src, 0, i);
clif_skill_nodamage(src, bl, skill_id, skill_lv, i ? 1:0);
} else {
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF|SD_SPLASH|1, skill_castend_nodamage_id);
}
break;
@@ -11906,7 +11906,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
status_change_end(bl, SC_DECREASEAGI);
break;
}
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, 1, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, 1, DMG_SINGLE );
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
break;
@@ -12166,7 +12166,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
} else {
clif_skill_nodamage(src,src,skill_id,skill_lv,1);
if (!(skill_id >= EM_EL_FLAMETECHNIC && skill_id <= EM_EL_DEADLY_POISON))
clif_skill_damage(src, ( skill_id == EL_GUST || skill_id == EL_BLAST || skill_id == EL_WILD_STORM )?src:bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, ( skill_id == EL_GUST || skill_id == EL_BLAST || skill_id == EL_WILD_STORM ) ? *src : *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
if( skill_id == EL_WIND_STEP ) // There aren't teleport, just push the master away.
skill_blown(src,bl,(rnd()%skill_get_blewcount(skill_id,skill_lv))+1,rnd()%8,BLOWN_NONE);
sc_start(src,src,type2,100,skill_lv,skill_get_time(skill_id,skill_lv));
@@ -12179,7 +12179,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case EL_WATER_BARRIER:
case EL_ZEPHYR:
case EL_POWER_OF_GAIA:
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
skill_unitsetting(src,skill_id,skill_lv,bl->x,bl->y,0);
break;
case EL_WATER_SCREEN: {
@@ -12194,7 +12194,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
status_change_end(src,type2);
} else {
// This not heals at the end.
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
sc_start(src,src,type2,100,skill_lv,skill_get_time(skill_id,skill_lv));
sc_start(src,bl,type,100,src->id,skill_get_time(skill_id,skill_lv));
}
@@ -12299,7 +12299,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,skill_id,skill_lv,
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)));
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
break;
case KG_KAGEHUMI:
if( flag&1 ){
@@ -12319,7 +12319,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
}else{
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
}
break;
@@ -13513,7 +13513,7 @@ TIMER_FUNC(skill_castend_id){
clif_blown(src);
clif_spiritball(src);
}
clif_skill_damage(src,target,tick,sd->battle_status.amotion,0,0,1,ud->skill_id,ud->skill_lv,DMG_SPLASH);
clif_skill_damage( *src, *target, tick, sd->battle_status.amotion, 0, 0, 1, ud->skill_id, ud->skill_lv, DMG_SPLASH );
}
}
@@ -13962,7 +13962,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
flag|=1;
break;
case NPC_EARTHQUAKE:
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
skill_unitsetting(src, skill_id, skill_lv, x, y, 0);
break;
#ifndef RENEWAL
@@ -14290,7 +14290,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
clif_skill_fail( *sd, skill_id, USESKILL_FAIL_GC_POISONINGWEAPON );
return 0;
}
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
skill_unitsetting(src, skill_id, skill_lv, x, y, flag);
break;
@@ -14322,7 +14322,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case RA_DETONATOR:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinallarea(skill_detonator, src->m, x-i, y-i, x+i, y+i, BL_SKILL, src);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE);
clif_skill_damage( *src, *src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SINGLE );
break;
case NC_NEUTRALBARRIER:
@@ -16690,9 +16690,9 @@ int skill_unit_onplace_timer(struct skill_unit *unit, struct block_list *bl, t_t
break;
case UNT_FIRE_RAIN:
clif_skill_damage(ss,bl,tick,status_get_amotion(ss),0,
clif_skill_damage( *ss, *bl, tick, status_get_amotion(ss), 0,
skill_attack(skill_get_type(sg->skill_id),ss,&unit->bl,bl,sg->skill_id,sg->skill_lv,tick,SD_ANIMATION|SD_SPLASH),
1,sg->skill_id,sg->skill_lv,DMG_SINGLE);
1, sg->skill_id, sg->skill_lv, DMG_SINGLE );
break;
case UNT_MAGMA_ERUPTION:
@@ -20451,7 +20451,7 @@ static int skill_trap_splash(struct block_list *bl, va_list ap)
if (status_change_start(ss, bl, SC_ELECTRICSHOCKER, 10000, sg->skill_lv, sg->group_id, 0, 0, skill_get_time2(sg->skill_id, sg->skill_lv), SCSTART_NORATEDEF)) {
map_moveblock(bl, unit->bl.x, unit->bl.y, tick);
clif_fixpos( *bl );
clif_skill_damage(src, bl, tick, 0, 0, -30000, 1, sg->skill_id, sg->skill_lv, DMG_SPLASH);
clif_skill_damage( *src, *bl, tick, 0, 0, -30000, 1, sg->skill_id, sg->skill_lv, DMG_SPLASH );
}
}
break;