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

Refactored clif damage type calls

Browse Source 
* Cleaned up the calls for e_damage_type to use the constant value.
This commit is contained in:
aleos89
2016-06-27 12:48:26 -04:00
parent b8a221fc99
commit 82af619dfd
7 changed files with 76 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/map/atcommand.c
View File

@@ -5649,7 +5649,7 @@ ACMD_FUNC(displayskill)
}
status = status_get_status_data(&sd->bl);
tick = gettick();
clif_skill_damage(&sd->bl,&sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, 5);
clif_skill_damage(&sd->bl,&sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, DMG_SPLASH);
clif_skill_nodamage(&sd->bl, &sd->bl, skill_id, skill_lv, 1);
clif_skill_poseffect(&sd->bl, skill_id, skill_lv, sd->bl.x, sd->bl.y, tick);
return 0;

8
src/map/battle.c
View File

@@ -4964,7 +4964,7 @@ struct Damage battle_calc_weapon_final_atk_modifiers(struct Damage wd, struct bl
rdamage = (int64)rdamage * ratio / 100 + wd.damage * (10 + tsc->data[SC_CRESCENTELBOW]->val1 * 20 / 10) / 10;
skill_blown(target, src, skill_get_blewcount(SR_CRESCENTELBOW_AUTOSPELL, tsc->data[SC_CRESCENTELBOW]->val1), unit_getdir(src), 0);
clif_skill_damage(target, src, gettick(), status_get_amotion(src), 0, rdamage,
1, SR_CRESCENTELBOW_AUTOSPELL, tsc->data[SC_CRESCENTELBOW]->val1, 6); // This is how official does
1, SR_CRESCENTELBOW_AUTOSPELL, tsc->data[SC_CRESCENTELBOW]->val1, DMG_SKILL); // This is how official does
clif_damage(src, target, gettick(), status_get_amotion(src)+1000, 0, rdamage/10, 1, DMG_NORMAL, 0, false);
status_damage(target, src, rdamage, 0, 0, 0);
status_damage(src, target, rdamage/10, 0, 0, 1);
@@ -6747,7 +6747,7 @@ int64 battle_calc_return_damage(struct block_list* bl, struct block_list *src, i
rd1 = min(damage,status_get_max_hp(bl)) * sc->data[SC_DEATHBOUND]->val2 / 100; // Amplify damage.
*dmg = rd1 * 30 / 100; // Received damage = 30% of amplified damage.
clif_skill_damage(src, bl, gettick(), status_get_amotion(src), 0, -30000, 1, RK_DEATHBOUND, sc->data[SC_DEATHBOUND]->val1, 6);
clif_skill_damage(src, bl, gettick(), status_get_amotion(src), 0, -30000, 1, RK_DEATHBOUND, sc->data[SC_DEATHBOUND]->val1, DMG_SKILL);
skill_blown(bl, src, skill_get_blewcount(RK_DEATHBOUND, 1), unit_getdir(src), 0);
status_change_end(bl, SC_DEATHBOUND, INVALID_TIMER);
rdamage += rd1 * 70 / 100; // Target receives 70% of the amplified damage. [Rytech]
@@ -7198,7 +7198,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
}
}
wd.dmotion = clif_damage(src, target, tick, wd.amotion, wd.dmotion, wd.damage, wd.div_ , (enum e_damage_type)wd.type, wd.damage2, wd.isspdamage);
wd.dmotion = clif_damage(src, target, tick, wd.amotion, wd.dmotion, wd.damage, wd.div_ , wd.type, wd.damage2, wd.isspdamage);
if (sd && sd->bonus.splash_range > 0 && damage > 0)
skill_castend_damage_id(src, target, 0, 1, tick, 0);
@@ -7244,7 +7244,7 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t
struct 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->data[SC_CIRCLE_OF_FIRE_OPTION]->val1, 6);
clif_skill_damage(&ed->bl, target, tick, status_get_amotion(src), 0, -30000, 1, EL_CIRCLE_OF_FIRE, tsc->data[SC_CIRCLE_OF_FIRE_OPTION]->val1, DMG_SKILL);
skill_attack(BF_WEAPON,&ed->bl,&ed->bl,src,EL_CIRCLE_OF_FIRE,tsc->data[SC_CIRCLE_OF_FIRE_OPTION]->val1,tick,wd.flag);
}
}

2
src/map/battle.h
View File

@@ -61,7 +61,7 @@ struct Damage {
#endif
int64 damage, /// Right hand damage
damage2; /// Left hand damage
char type; /// chk clif_damage for type (clif.h enum e_damage_type)
enum e_damage_type type; /// Check clif_damage for type
short div_; /// Number of hit
int amotion,
dmotion;

10
src/map/clif.c
View File

@@ -4591,9 +4591,9 @@ void clif_getareachar_unit(struct map_session_data* sd,struct block_list *bl)
//Modifies the type of damage according to status changes [Skotlex]
//Aegis data specifies that: 4 endure against single hit sources, 9 against multi-hit.
static enum e_damage_type clif_calc_delay(char type, int div, int64 damage, int delay)
static enum e_damage_type clif_calc_delay(enum e_damage_type type, int div, int64 damage, int delay)
{
return ( delay == 0 && damage > 0 ) ? ( div > 1 ? DMG_MULTI_HIT_ENDURE : DMG_ENDURE ) : (enum e_damage_type)type;
return ( delay == 0 && damage > 0 ) ? ( div > 1 ? DMG_MULTI_HIT_ENDURE : DMG_ENDURE ) : type;
}
/*==========================================
@@ -5388,7 +5388,7 @@ void clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned
/// 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,unsigned int tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,int type)
int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type)
{
unsigned char buf[64];
struct status_change *sc;
@@ -5484,7 +5484,7 @@ int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int
/// Ground skill attack effect and damage (ZC_NOTIFY_SKILL_POSITION).
/// 0115 <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <x>.W <y>.W <damage>.W <level>.W <div>.W <type>.B
/*
int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type)
int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type)
{
unsigned char buf[64];
struct status_change *sc;
@@ -5492,7 +5492,7 @@ int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned in
nullpo_ret(src);
nullpo_ret(dst);
type = (type>0)?type:skill_get_hit(skill_id);
type = (type>DMG_NORMAL)?type:skill_get_hit(skill_id);
type = clif_calc_delay(type,div,damage,ddelay);
sc = status_get_sc(dst);

4
src/map/clif.h
View File

@@ -618,8 +618,8 @@ void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x,
void clif_skillcastcancel(struct block_list* bl);
void clif_skill_fail(struct map_session_data *sd,uint16 skill_id,enum useskill_fail_cause cause,int btype);
void clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int tick);
int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,int type);
//int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type);
int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int64 sdamage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
//int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,enum e_damage_type type);
int clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 skill_id,int heal,int fail);
void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,int y,int tick);
void clif_skill_estimation(struct map_session_data *sd,struct block_list *dst);

123
src/map/skill.c
View File

@@ -239,7 +239,7 @@ static void skill_chk2(int *idx) {
#define skill_get3(id,x,var) { skill_chk(&id); if (!id) return 0; skill_chk2(&x); return var; }
// Skill DB
int skill_get_hit( uint16 skill_id ) { skill_get (skill_id, skill_db[skill_id]->hit); }
enum e_damage_type skill_get_hit( uint16 skill_id ) { skill_get (skill_id, skill_db[skill_id]->hit); }
int skill_get_inf( uint16 skill_id ) { skill_get (skill_id, skill_db[skill_id]->inf); }
int skill_get_ele( uint16 skill_id , uint16 skill_lv ) { skill_get2 (skill_id, skill_lv, skill_db[skill_id]->element); }
int skill_get_nk( uint16 skill_id ) { skill_get (skill_id, skill_db[skill_id]->nk); }
@@ -3008,6 +3008,7 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
int64 damage;
int8 rmdamage = 0;//magic reflected
int type;
enum e_damage_type dmg_type;
bool shadow_flag = false;
bool additional_effects = true;
@@ -3171,12 +3172,12 @@ 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, status_fix_damage(bl,nbl,damage,0), dmg.div_, OB_OBOROGENSOU_TRANSITION_ATK, -1, 6);
clif_skill_damage(bl, nbl, tick, status_get_amotion(src), 0, status_fix_damage(bl,nbl,damage,0), dmg.div_, OB_OBOROGENSOU_TRANSITION_ATK, -1, DMG_SKILL);
}
}
//Skill hit type
type = (skill_id == 0) ? 5 : skill_get_hit(skill_id);
dmg_type = (skill_id == 0) ? DMG_SPLASH : skill_get_hit(skill_id);
switch( skill_id ) {
case SC_TRIANGLESHOT:
@@ -3195,7 +3196,7 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
if( battle_config.gx_disptype)
dsrc = src;
if( src == bl)
type = 4;
dmg_type = DMG_ENDURE;
else
flag|= SD_ANIMATION;
break;
@@ -3229,7 +3230,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(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, CR_HOLYCROSS, -1, 5);
dmg.dmotion = clif_skill_damage(dsrc,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:
@@ -3242,36 +3243,36 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
case NPC_CRITICALSLASH:
case TF_DOUBLE:
case GS_CHAINACTION:
dmg.dmotion = clif_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,(enum e_damage_type)dmg.type,dmg.damage2,false);
dmg.dmotion = clif_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,dmg.type,dmg.damage2,false);
break;
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, 5); // 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, 5); // 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 GN_SPORE_EXPLOSION:
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, 5);
dmg.dmotion = clif_skill_damage(dsrc, bl, tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, DMG_SPLASH);
break;
case WL_HELLINFERNO:
case SR_EARTHSHAKER:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,1,skill_id,-2,6);
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,1,skill_id,-2,DMG_SKILL);
break;
case WL_SOULEXPANSION:
case WL_COMET:
case KO_MUCHANAGE:
case NJ_HUUMA:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,skill_id,skill_lv,8);
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,6);
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,1,WL_CHAINLIGHTNING_ATK,-2,DMG_SKILL);
break;
case LG_OVERBRAND:
case LG_OVERBRAND_BRANDISH:
dmg.amotion = status_get_amotion(src) * 2;
case LG_OVERBRAND_PLUSATK:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,status_get_amotion(src),dmg.dmotion,damage,dmg.div_,skill_id,-1,5);
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,status_get_amotion(src),dmg.dmotion,damage,dmg.div_,skill_id,-1,DMG_SPLASH);
break;
case EL_FIRE_BOMB:
case EL_FIRE_BOMB_ATK:
@@ -3292,26 +3293,26 @@ int64 skill_attack (int attack_type, struct block_list* src, struct block_list *
case KO_BAKURETSU:
case GN_CRAZYWEED_ATK:
case NC_MAGMA_ERUPTION:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,skill_id,-1,5);
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, 8);
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,6);
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,GN_SLINGITEM,-2,DMG_SKILL);
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)?8:5);
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,5);
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,WM_SEVERE_RAINSTORM,-2,DMG_SPLASH);
break;
case WM_REVERBERATION_MELEE:
case WM_REVERBERATION_MAGIC:
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,WM_REVERBERATION,-2,6);
dmg.dmotion = clif_skill_damage(src,bl,tick,dmg.amotion,dmg.dmotion,damage,dmg.div_,WM_REVERBERATION,-2,DMG_SKILL);
break;
case SR_TIGERCANNON:
dmg.dmotion = clif_skill_damage(src, bl, tick, status_get_amotion(bl), dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, 6);
dmg.dmotion = clif_skill_damage(src, bl, tick, status_get_amotion(bl), dmg.dmotion, damage, dmg.div_, skill_id, skill_lv, DMG_SKILL);
break;
case HT_CLAYMORETRAP:
case HT_BLASTMINE:
@@ -3320,37 +3321,37 @@ 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, 5);
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;
//Fall through
case HT_LANDMINE:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, -1, 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, 5);
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_BANISHING_BUSTER:
case RL_S_STORM:
case RL_SLUGSHOT:
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,status_get_amotion(src),dmg.dmotion,damage,dmg.div_,skill_id,-1,5);
dmg.dmotion = clif_skill_damage(dsrc,bl,tick,status_get_amotion(src),dmg.dmotion,damage,dmg.div_,skill_id,-1,DMG_SPLASH);
break;
case AB_DUPLELIGHT_MELEE:
case AB_DUPLELIGHT_MAGIC:
dmg.amotion = 300;/* makes the damage value not overlap with previous damage (when displayed by the client) */
default:
if( flag&SD_ANIMATION && dmg.div_ < 2 ) //Disabling skill animation doesn't works on multi-hit.
type = 5;
dmg_type = DMG_SPLASH;
if (src->type == BL_SKILL) {
TBL_SKILL *su = (TBL_SKILL*)src;
if (su->group && skill_get_inf2(su->group->skill_id)&INF2_TRAP) { // 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, 5);
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, 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;
}
@@ -3534,7 +3535,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, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if (flag&(SD_SPLASH|SD_PREAMBLE))
skill_area_temp[2]++;
@@ -4509,7 +4510,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
if (sd) pc_overheat(sd,1);
case LG_CANNONSPEAR:
if(skill_id == LG_CANNONSPEAR)
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
skill_area_temp[1] = bl->id;
if (battle_config.skill_eightpath_algorithm) {
//Use official AoE algorithm
@@ -4739,7 +4740,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
break;
case LG_MOONSLASHER:
case MH_XENO_SLASHER:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
break;
case NPC_EARTHQUAKE: //FIXME: Isn't EarthQuake a ground skill after all?
skill_addtimerskill(src,tick+250,src->id,0,0,skill_id,skill_lv,2,flag|BCT_ENEMY|SD_SPLASH|1);
@@ -5434,7 +5435,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
sc_start(src,bl, SC_INFRAREDSCAN, 10000, skill_lv, skill_get_time(skill_id, skill_lv));
} 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|SD_SPLASH|1, skill_castend_damage_id);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if( sd ) pc_overheat(sd,1);
}
break;
@@ -5454,7 +5455,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,6);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
}
break;
case LG_PINPOINTATTACK:
@@ -5514,7 +5515,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(bl, SC__SHADOWFORM, INVALID_TIMER);
} 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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
}
break;
@@ -5591,7 +5592,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, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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
@@ -5601,7 +5602,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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if( rnd()%100 < 50 )
skill_attack(BF_MAGIC,src,src,bl,skill_id,skill_lv,tick,flag);
else
@@ -5614,7 +5615,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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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
@@ -5627,7 +5628,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, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
skill_attack(skill_get_type(skill_id),src,src,bl,skill_id,skill_lv,tick,flag);
break;
@@ -5640,7 +5641,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
type2 = type-1;
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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if( (sc2 && sc2->data[type2]) || (tsc2 && tsc2->data[type]) ) {
elemental_clean_single_effect(ele, skill_id);
}
@@ -6826,7 +6827,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 == NC_AXETORNADO || 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, 6);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
}
break;
@@ -8818,7 +8819,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case RK_IGNITIONBREAK:
case LG_EARTHDRIVE:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
i = skill_get_splash(skill_id,skill_lv);
if( skill_id == LG_EARTHDRIVE ) {
int dummy = 1;
@@ -9010,7 +9011,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, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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);
@@ -9378,7 +9379,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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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;
@@ -9419,7 +9420,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, 6);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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;
@@ -9445,7 +9446,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, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
clif_skill_nodamage(src, bl, skill_id, skill_lv,
sc_start(src,bl,type, 30 + 12 * skill_lv,skill_lv,skill_get_time(skill_id,skill_lv)));
if( sd ) pc_overheat(sd,1);
@@ -9575,7 +9576,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, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if (rnd()%100 < (25 + 25 * skill_lv))
map_foreachinrange(skill_destroy_trap,bl,skill_get_splash(skill_id,skill_lv),BL_SKILL,tick);
status_change_end(bl, SC_SV_ROOTTWIST, INVALID_TIMER);
@@ -9631,7 +9632,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
switch(opt) {
case 1: // Splash AoE ATK
sc_start(src,bl,SC_SHIELDSPELL_DEF,100,opt,INVALID_TIMER);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,6);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
map_foreachinrange(skill_area_sub,src,splashrange,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
status_change_end(bl,SC_SHIELDSPELL_DEF,INVALID_TIMER);
break;
@@ -9665,13 +9666,13 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
switch(opt) {
case 1: // Splash AoE MATK
sc_start(src,bl,SC_SHIELDSPELL_MDEF,100,opt,INVALID_TIMER);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,6);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
map_foreachinrange(skill_area_sub,src,splashrange,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
status_change_end(bl,SC_SHIELDSPELL_MDEF,INVALID_TIMER);
break;
case 2: // Splash AoE Lex Divina
sc_start(src,bl,SC_SHIELDSPELL_MDEF,100,opt,shield_mdef * 2000);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,6);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
map_foreachinrange(skill_area_sub,src,splashrange,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
break;
case 3: // Casts Magnificat.
@@ -9735,7 +9736,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, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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);
@@ -9771,7 +9772,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, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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|BCT_SELF|SD_SPLASH|1, skill_castend_nodamage_id);
}
break;
@@ -10395,7 +10396,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
elemental_clean_single_effect(ele, skill_id);
} else {
clif_skill_nodamage(src,src,skill_id,skill_lv,1);
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, 6);
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_SKILL);
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,0);
sc_start(src,src,type2,100,skill_lv,skill_get_time(skill_id,skill_lv));
@@ -10408,7 +10409,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, 6);
clif_skill_damage(src, bl, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
skill_unitsetting(src,skill_id,skill_lv,bl->x,bl->y,0);
break;
case EL_WATER_SCREEN: {
@@ -10422,7 +10423,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
elemental_clean_single_effect(ele, skill_id);
} else {
// This not heals at the end.
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
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));
}
@@ -10515,7 +10516,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case KG_KAGEMUSYA:
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, 6);
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
break;
case KG_KAGEHUMI:
if( flag&1 ){
@@ -10534,7 +10535,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
status_change_end(bl, SC_HARMONIZE, INVALID_TIMER);
}
if( skill_area_temp[2] == 1 ){
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
sc_start(src,src, SC_STOP, 100, skill_lv, skill_get_time(skill_id, skill_lv));
}
}else{
@@ -11245,7 +11246,7 @@ int skill_castend_id(int tid, unsigned int tick, int id, intptr_t data)
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,5);
clif_skill_damage(src,target,tick,sd->battle_status.amotion,0,0,1,ud->skill_id,ud->skill_lv,DMG_SPLASH);
}
}
@@ -11887,7 +11888,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
break;
case RK_WINDCUTTER:
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
case AC_SHOWER:
case MA_SHOWER:
case NC_COLDSLOWER:
@@ -11915,7 +11916,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,0);
return 0;
}
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,6);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
skill_unitsetting(src, skill_id, skill_lv, x, y, flag);
break;
@@ -11956,7 +11957,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_foreachinarea(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, 6);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
break;
case NC_NEUTRALBARRIER:
@@ -14055,7 +14056,7 @@ int skill_unit_onplace_timer(struct skill_unit *unit, struct block_list *bl, uns
case UNT_FIRE_RAIN:
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,6);
1,sg->skill_id,sg->skill_lv,DMG_SKILL);
break;
case UNT_SV_ROOTTWIST:
@@ -17219,7 +17220,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, 5);
clif_skill_damage(src, bl, tick, 0, 0, -30000, 1, sg->skill_id, sg->skill_lv, DMG_SPLASH);
}
}
break;

2
src/map/skill.h
View File

@@ -372,7 +372,7 @@ int skill_get_index_( uint16 skill_id, bool silent, const char *func, const char
#define skill_get_index(skill_id) skill_get_index_((skill_id), false, __FUNCTION__, __FILE__, __LINE__) /// Get skill index from skill_id (common usage on source)
#define skill_get_index2(skill_id) skill_get_index_((skill_id), true, __FUNCTION__, __FILE__, __LINE__) /// Get skill index from skill_id (used when reading skill_db files)
int skill_get_type( uint16 skill_id );
int skill_get_hit( uint16 skill_id );
enum e_damage_type skill_get_hit( uint16 skill_id );
int skill_get_inf( uint16 skill_id );
int skill_get_ele( uint16 skill_id , uint16 skill_lv );
int skill_get_nk( uint16 skill_id );