summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorHaru <haru@dotalux.com>2018-10-21 23:45:20 +0200
committerGitHub <noreply@github.com>2018-10-21 23:45:20 +0200
commitb196e2b794bb96c1584c885f50e63326678ae89e (patch)
treecb6858c2f690018c9df097dd96a986ec22089fb5
parentf275d6a7d432953d2af6b9c0fe897be5e7657e1c (diff)
parentdca07b9b9e9640085412b1ceafd691727b871048 (diff)
downloadhercules-b196e2b794bb96c1584c885f50e63326678ae89e.tar.gz
hercules-b196e2b794bb96c1584c885f50e63326678ae89e.tar.bz2
hercules-b196e2b794bb96c1584c885f50e63326678ae89e.tar.xz
hercules-b196e2b794bb96c1584c885f50e63326678ae89e.zip
Merge pull request #2182 from guilherme-gm/201808-trapfix
Fixes some issues with traps
-rw-r--r--conf/map/battle/skill.conf6
-rw-r--r--db/pre-re/skill_db.conf2
-rw-r--r--db/re/skill_db.conf2
-rw-r--r--src/map/battle.c35
-rw-r--r--src/map/battle.h3
-rw-r--r--src/map/skill.c53
-rw-r--r--src/map/skill.h1
-rw-r--r--src/plugins/HPMHooking/HPMHooking.Defs.inc4
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc8
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc2
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.Hooks.inc52
11 files changed, 152 insertions, 16 deletions
diff --git a/conf/map/battle/skill.conf b/conf/map/battle/skill.conf
index d258567a0..64bba68b5 100644
--- a/conf/map/battle/skill.conf
+++ b/conf/map/battle/skill.conf
@@ -307,6 +307,12 @@ dancing_weaponswitch_fix: true
// 1: Traps in GvG make player stop moving right when stepping over it.
skill_trap_type: 0
+// Trap Reflect
+// Whether the damage from traps must be reflected (for example by Reflect Shield or High Orc Card)?
+// true: Aegis - traps are reflected
+// false: Athena - traps are not reflected
+trap_reflect: true
+
// Max Possible Level of Monster skills
// Note: If your MVPs are too tough, reduce it to 10.
mob_max_skilllvl: 100
diff --git a/db/pre-re/skill_db.conf b/db/pre-re/skill_db.conf
index 4873012aa..21a0f0e78 100644
--- a/db/pre-re/skill_db.conf
+++ b/db/pre-re/skill_db.conf
@@ -4299,6 +4299,7 @@ skill_db: (
Element: "Ele_Wind"
DamageType: {
SplashArea: true
+ SplitDamage: true
IgnoreFlee: true
}
SplashRange: 1
@@ -4350,6 +4351,7 @@ skill_db: (
Element: "Ele_Fire"
DamageType: {
SplashArea: true
+ SplitDamage: true
IgnoreFlee: true
}
SplashRange: 2
diff --git a/db/re/skill_db.conf b/db/re/skill_db.conf
index 4863e4051..ec8548ab2 100644
--- a/db/re/skill_db.conf
+++ b/db/re/skill_db.conf
@@ -4520,6 +4520,7 @@ skill_db: (
Element: "Ele_Wind"
DamageType: {
SplashArea: true
+ SplitDamage: true
IgnoreFlee: true
}
SplashRange: 1
@@ -4572,6 +4573,7 @@ skill_db: (
Element: "Ele_Fire"
DamageType: {
SplashArea: true
+ SplitDamage: true
IgnoreFlee: true
}
SplashRange: 2
diff --git a/src/map/battle.c b/src/map/battle.c
index 9d4c416b0..44241bf23 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -4339,6 +4339,8 @@ static struct Damage battle_calc_misc_attack(struct block_list *src, struct bloc
}
break;
}
+
+ battle->reflect_trap(target, src, &md, skill_id);
return md;
}
@@ -6008,6 +6010,37 @@ static void battle_reflect_damage(struct block_list *target, struct block_list *
#undef NORMALIZE_RDAMAGE
}
+/**
+ * Reflects damage from certain traps, if battle_config.trap_reflect is true.
+ * @param target : Player who triggered the trap
+ * @param src : Player who set the trap
+ * @param md : Trap damage structure
+ * @param skill_id : Trap skill ID
+ */
+static void battle_reflect_trap(struct block_list *target, struct block_list *src, struct Damage *md, uint16 skill_id)
+{
+ if (battle_config.trap_reflect == true) {
+ if (src != target) { // Don't reflect your own damage
+ switch (skill_id) {
+ case HT_CLAYMORETRAP:
+ case HT_LANDMINE:
+ case HT_FREEZINGTRAP:
+ case HT_BLASTMINE:
+ // Needs official info
+ //case RA_CLUSTERBOMB:
+ //case RA_FIRINGTRAP:
+ //case RA_ICEBOUNDTRAP:
+ //case GN_THORNS_TRAP:
+ //case KO_MAKIBISHI:
+ case MA_LANDMINE:
+ case MA_FREEZINGTRAP:
+ battle->reflect_damage(target, src, md, skill_id);
+ break;
+ }
+ }
+ }
+}
+
static void battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss)
{
struct weapon_data *wd;
@@ -7325,6 +7358,7 @@ static const struct battle_data {
* Hercules
**/
{ "skill_trap_type", &battle_config.skill_trap_type, 0, 0, 1, },
+ { "trap_reflect", &battle_config.trap_reflect, 1, 0, 1, },
{ "item_restricted_consumption_type", &battle_config.item_restricted_consumption_type,1, 0, 1, },
{ "unequip_restricted_equipment", &battle_config.unequip_restricted_equipment, 0, 0, 3, },
{ "max_walk_path", &battle_config.max_walk_path, 17, 1, MAX_WALKPATH, },
@@ -7616,6 +7650,7 @@ void battle_defaults(void)
battle->delay_damage = battle_delay_damage;
battle->drain = battle_drain;
battle->reflect_damage = battle_reflect_damage;
+ battle->reflect_trap = battle_reflect_trap;
battle->attr_ratio = battle_attr_ratio;
battle->attr_fix = battle_attr_fix;
battle->calc_cardfix = battle_calc_cardfix;
diff --git a/src/map/battle.h b/src/map/battle.h
index 4472c0c52..02536e4a1 100644
--- a/src/map/battle.h
+++ b/src/map/battle.h
@@ -506,6 +506,7 @@ struct Battle_Config {
/** Hercules **/
int skill_trap_type;
+ int trap_reflect;
int item_restricted_consumption_type;
int unequip_restricted_equipment;
int max_walk_path;
@@ -639,6 +640,8 @@ struct battle_interface {
void (*drain) (struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss);
/* damage reflect */
void (*reflect_damage) (struct block_list *target, struct block_list *src, struct Damage *wd,uint16 skill_id);
+ /* trap reflect */
+ void(*reflect_trap) (struct block_list *target, struct block_list *src, struct Damage *md, uint16 skill_id);
/* attribute rate */
int (*attr_ratio) (int atk_elem, int def_type, int def_lv);
/* applies attribute modifiers */
diff --git a/src/map/skill.c b/src/map/skill.c
index 4eaab5457..9857badbe 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -4138,7 +4138,7 @@ static int skill_activate_reverberation(struct block_list *bl, va_list ap)
if( su->alive && (sg = su->group) != NULL && sg->skill_id == WM_REVERBERATION && sg->unit_id == UNT_REVERBERATION ) {
int64 tick = timer->gettick();
clif->changetraplook(bl,UNT_USED_TRAPS);
- map->foreachinrange(skill->trap_splash, bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, bl, tick);
+ skill->trap_do_splash(bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
su->limit = DIFF_TICK32(tick,sg->tick)+1500;
sg->unit_id = UNT_USED_TRAPS;
}
@@ -12644,7 +12644,7 @@ static int skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int
if (sg->src_id == bl->id)
break; //Does not affect the caster.
clif->changetraplook(&src->bl,UNT_USED_TRAPS);
- map->foreachinrange(skill->trap_splash,&src->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &src->bl,tick);
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
sg->unit_id = UNT_USED_TRAPS;
sg->limit = DIFF_TICK32(tick,sg->tick) + 1500;
break;
@@ -12938,7 +12938,7 @@ static int skill_unit_onplace_timer(struct skill_unit *src, struct block_list *b
}
- map->foreachinrange(skill->trap_splash, &src->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &src->bl, tick);
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
sg->unit_id = UNT_USED_TRAPS; //Changed ID so it does not invoke a for each in area again.
}
break;
@@ -12969,10 +12969,10 @@ static int skill_unit_onplace_timer(struct skill_unit *src, struct block_list *b
case UNT_FREEZINGTRAP:
case UNT_FIREPILLAR_ACTIVE:
case UNT_CLAYMORETRAP:
- if( sg->unit_id == UNT_FIRINGTRAP || sg->unit_id == UNT_ICEBOUNDTRAP || sg->unit_id == UNT_CLAYMORETRAP )
- map->foreachinrange(skill->trap_splash,&src->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag|BL_SKILL|~BCT_SELF, &src->bl,tick);
+ if (sg->unit_id == UNT_FIRINGTRAP || sg->unit_id == UNT_ICEBOUNDTRAP || sg->unit_id == UNT_CLAYMORETRAP)
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag | BL_SKILL | ~BCT_SELF, tick);
else
- map->foreachinrange(skill->trap_splash,&src->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &src->bl,tick);
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
if (sg->unit_id != UNT_FIREPILLAR_ACTIVE)
clif->changetraplook(&src->bl, sg->unit_id==UNT_LANDMINE?UNT_FIREPILLAR_ACTIVE:UNT_USED_TRAPS);
sg->limit=DIFF_TICK32(tick,sg->tick)+1500 +
@@ -13203,9 +13203,7 @@ static int skill_unit_onplace_timer(struct skill_unit *src, struct block_list *b
case UNT_GROUNDDRIFT_POISON:
case UNT_GROUNDDRIFT_WATER:
case UNT_GROUNDDRIFT_FIRE:
- map->foreachinrange(skill->trap_splash,&src->bl,
- skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag,
- &src->bl,tick);
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
sg->unit_id = UNT_USED_TRAPS;
//clif->changetraplook(&src->bl, UNT_FIREPILLAR_ACTIVE);
sg->limit=DIFF_TICK32(tick,sg->tick)+1500;
@@ -13266,7 +13264,7 @@ static int skill_unit_onplace_timer(struct skill_unit *src, struct block_list *b
case UNT_REVERBERATION:
clif->changetraplook(&src->bl,UNT_USED_TRAPS);
- map->foreachinrange(skill->trap_splash,&src->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &src->bl,tick);
+ skill->trap_do_splash(&src->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
sg->limit = DIFF_TICK32(tick,sg->tick)+1500;
sg->unit_id = UNT_USED_TRAPS;
break;
@@ -16630,10 +16628,10 @@ static int skill_detonator(struct block_list *bl, va_list ap)
case UNT_CLAYMORETRAP:
case UNT_FIRINGTRAP:
case UNT_ICEBOUNDTRAP:
- map->foreachinrange(skill->trap_splash,bl,skill->get_splash(su->group->skill_id,su->group->skill_lv),su->group->bl_flag|BL_SKILL|~BCT_SELF,bl,su->group->tick);
+ skill->trap_do_splash(bl, su->group->skill_id, su->group->skill_lv, su->group->bl_flag | BL_SKILL | ~BCT_SELF, su->group->tick);
break;
default:
- map->foreachinrange(skill->trap_splash,bl,skill->get_splash(su->group->skill_id,su->group->skill_lv),su->group->bl_flag,bl,su->group->tick);
+ skill->trap_do_splash(bl, su->group->skill_id, su->group->skill_lv, su->group->bl_flag, su->group->tick);
}
clif->changetraplook(bl, UNT_USED_TRAPS);
su->group->limit = DIFF_TICK32(timer->gettick(),su->group->tick) +
@@ -16766,6 +16764,27 @@ static int skill_chastle_mob_changetarget(struct block_list *bl, va_list ap)
return 0;
}
+/**
+ * Does final adjustments (e.g. count enemies affected by splash) then runs trap splash function (skill_trap_splash).
+ *
+ * @param bl : trap skill unit's bl
+ * @param skill_id : Trap Skill ID
+ * @param skill_lv : Trap Skill Level
+ * @param bl_flag : Flag representing units affected by this trap
+ * @param tick : tick related to this trap
+ */
+static void skill_trap_do_splash(struct block_list *bl, uint16 skill_id, uint16 skill_lv, int bl_flag, int64 tick)
+{
+ int enemy_count = 0;
+
+ if (skill->get_nk(skill_id) & NK_SPLASHSPLIT) {
+ enemy_count = map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), BL_CHAR, bl, skill_id, skill_lv, tick, BCT_ENEMY, skill->area_sub_count);
+ enemy_count = max(1, enemy_count); // Don't let enemy_count be 0 when spliting trap damage
+ }
+
+ map->foreachinrange(skill->trap_splash, bl, skill->get_splash(skill_id, skill_lv), bl_flag, bl, tick, enemy_count);
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -16776,6 +16795,7 @@ static int skill_trap_splash(struct block_list *bl, va_list ap)
struct skill_unit *src_su = NULL;
struct skill_unit_group *sg;
struct block_list *ss;
+ int enemy_count = va_arg(ap, int);
nullpo_ret(bl);
nullpo_ret(src);
@@ -16870,7 +16890,7 @@ static int skill_trap_splash(struct block_list *bl, va_list ap)
}
/* Fall through */
default:
- skill->attack(skill->get_type(sg->skill_id),ss,src,bl,sg->skill_id,sg->skill_lv,tick,0);
+ skill->attack(skill->get_type(sg->skill_id), ss, src, bl, sg->skill_id, sg->skill_lv, tick, enemy_count);
break;
}
return 1;
@@ -17585,7 +17605,7 @@ static int skill_unit_timer_sub(union DBKey key, struct DBData *data, va_list ap
break;
}
clif->changetraplook(bl,UNT_USED_TRAPS);
- map->foreachinrange(skill->trap_splash, bl, skill->get_splash(group->skill_id, group->skill_lv), group->bl_flag, bl, tick);
+ skill->trap_do_splash(bl, group->skill_id, group->skill_lv, group->bl_flag, tick);
group->limit = DIFF_TICK32(tick,group->tick)+1500;
su->limit = DIFF_TICK32(tick,group->tick)+1500;
group->unit_id = UNT_USED_TRAPS;
@@ -18973,7 +18993,7 @@ static int skill_destroy_trap(struct block_list *bl, va_list ap)
case UNT_CLAYMORETRAP:
case UNT_FIRINGTRAP:
case UNT_ICEBOUNDTRAP:
- map->foreachinrange(skill->trap_splash,&su->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag|BL_SKILL|~BCT_SELF, &su->bl,tick);
+ skill->trap_do_splash(&su->bl, sg->skill_id, sg->skill_lv, sg->bl_flag | BL_SKILL | ~BCT_SELF, tick);
break;
case UNT_LANDMINE:
case UNT_BLASTMINE:
@@ -18982,7 +19002,7 @@ static int skill_destroy_trap(struct block_list *bl, va_list ap)
case UNT_FLASHER:
case UNT_FREEZINGTRAP:
case UNT_CLUSTERBOMB:
- map->foreachinrange(skill->trap_splash,&su->bl, skill->get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &su->bl,tick);
+ skill->trap_do_splash(&su->bl, sg->skill_id, sg->skill_lv, sg->bl_flag, tick);
break;
}
// Traps aren't recovered.
@@ -21578,6 +21598,7 @@ void skill_defaults(void)
skill->onskillusage = skill_onskillusage;
skill->cell_overlap = skill_cell_overlap;
skill->timerskill = skill_timerskill;
+ skill->trap_do_splash = skill_trap_do_splash;
skill->trap_splash = skill_trap_splash;
skill->check_condition_mercenary = skill_check_condition_mercenary;
skill->locate_element_field = skill_locate_element_field;
diff --git a/src/map/skill.h b/src/map/skill.h
index 97134224e..0ace19927 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -2059,6 +2059,7 @@ struct skill_interface {
int (*onskillusage) (struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick);
int (*cell_overlap) (struct block_list *bl, va_list ap);
int (*timerskill) (int tid, int64 tick, int id, intptr_t data);
+ void (*trap_do_splash) (struct block_list *bl, uint16 skill_id, uint16 skill_lv, int bl_flag, int64 tick);
int (*trap_splash) (struct block_list *bl, va_list ap);
int (*check_condition_mercenary) (struct block_list *bl, int skill_id, int lv, int type);
struct skill_unit_group *(*locate_element_field) (struct block_list *bl);
diff --git a/src/plugins/HPMHooking/HPMHooking.Defs.inc b/src/plugins/HPMHooking/HPMHooking.Defs.inc
index a8d48546d..c60946baf 100644
--- a/src/plugins/HPMHooking/HPMHooking.Defs.inc
+++ b/src/plugins/HPMHooking/HPMHooking.Defs.inc
@@ -282,6 +282,8 @@ typedef void (*HPMHOOK_pre_battle_drain) (struct map_session_data **sd, struct b
typedef void (*HPMHOOK_post_battle_drain) (struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss);
typedef void (*HPMHOOK_pre_battle_reflect_damage) (struct block_list **target, struct block_list **src, struct Damage **wd, uint16 *skill_id);
typedef void (*HPMHOOK_post_battle_reflect_damage) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id);
+typedef void (*HPMHOOK_pre_battle_reflect_trap) (struct block_list **target, struct block_list **src, struct Damage **md, uint16 *skill_id);
+typedef void (*HPMHOOK_post_battle_reflect_trap) (struct block_list *target, struct block_list *src, struct Damage *md, uint16 skill_id);
typedef int (*HPMHOOK_pre_battle_attr_ratio) (int *atk_elem, int *def_type, int *def_lv);
typedef int (*HPMHOOK_post_battle_attr_ratio) (int retVal___, int atk_elem, int def_type, int def_lv);
typedef int64 (*HPMHOOK_pre_battle_attr_fix) (struct block_list **src, struct block_list **target, int64 *damage, int *atk_elem, int *def_type, int *def_lv);
@@ -7198,6 +7200,8 @@ typedef int (*HPMHOOK_pre_skill_cell_overlap) (struct block_list **bl, va_list a
typedef int (*HPMHOOK_post_skill_cell_overlap) (int retVal___, struct block_list *bl, va_list ap);
typedef int (*HPMHOOK_pre_skill_timerskill) (int *tid, int64 *tick, int *id, intptr_t *data);
typedef int (*HPMHOOK_post_skill_timerskill) (int retVal___, int tid, int64 tick, int id, intptr_t data);
+typedef void (*HPMHOOK_pre_skill_trap_do_splash) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *bl_flag, int64 *tick);
+typedef void (*HPMHOOK_post_skill_trap_do_splash) (struct block_list *bl, uint16 skill_id, uint16 skill_lv, int bl_flag, int64 tick);
typedef int (*HPMHOOK_pre_skill_trap_splash) (struct block_list **bl, va_list ap);
typedef int (*HPMHOOK_post_skill_trap_splash) (int retVal___, struct block_list *bl, va_list ap);
typedef int (*HPMHOOK_pre_skill_check_condition_mercenary) (struct block_list **bl, int *skill_id, int *lv, int *type);
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
index 889faa44c..2a2290d6f 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
@@ -236,6 +236,8 @@ struct {
struct HPMHookPoint *HP_battle_drain_post;
struct HPMHookPoint *HP_battle_reflect_damage_pre;
struct HPMHookPoint *HP_battle_reflect_damage_post;
+ struct HPMHookPoint *HP_battle_reflect_trap_pre;
+ struct HPMHookPoint *HP_battle_reflect_trap_post;
struct HPMHookPoint *HP_battle_attr_ratio_pre;
struct HPMHookPoint *HP_battle_attr_ratio_post;
struct HPMHookPoint *HP_battle_attr_fix_pre;
@@ -5714,6 +5716,8 @@ struct {
struct HPMHookPoint *HP_skill_cell_overlap_post;
struct HPMHookPoint *HP_skill_timerskill_pre;
struct HPMHookPoint *HP_skill_timerskill_post;
+ struct HPMHookPoint *HP_skill_trap_do_splash_pre;
+ struct HPMHookPoint *HP_skill_trap_do_splash_post;
struct HPMHookPoint *HP_skill_trap_splash_pre;
struct HPMHookPoint *HP_skill_trap_splash_post;
struct HPMHookPoint *HP_skill_check_condition_mercenary_pre;
@@ -6831,6 +6835,8 @@ struct {
int HP_battle_drain_post;
int HP_battle_reflect_damage_pre;
int HP_battle_reflect_damage_post;
+ int HP_battle_reflect_trap_pre;
+ int HP_battle_reflect_trap_post;
int HP_battle_attr_ratio_pre;
int HP_battle_attr_ratio_post;
int HP_battle_attr_fix_pre;
@@ -12309,6 +12315,8 @@ struct {
int HP_skill_cell_overlap_post;
int HP_skill_timerskill_pre;
int HP_skill_timerskill_post;
+ int HP_skill_trap_do_splash_pre;
+ int HP_skill_trap_do_splash_post;
int HP_skill_trap_splash_pre;
int HP_skill_trap_splash_post;
int HP_skill_check_condition_mercenary_pre;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
index b11e2d61c..051e6fbe2 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
@@ -135,6 +135,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(battle->delay_damage, HP_battle_delay_damage) },
{ HP_POP(battle->drain, HP_battle_drain) },
{ HP_POP(battle->reflect_damage, HP_battle_reflect_damage) },
+ { HP_POP(battle->reflect_trap, HP_battle_reflect_trap) },
{ HP_POP(battle->attr_ratio, HP_battle_attr_ratio) },
{ HP_POP(battle->attr_fix, HP_battle_attr_fix) },
{ HP_POP(battle->calc_cardfix, HP_battle_calc_cardfix) },
@@ -2923,6 +2924,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(skill->onskillusage, HP_skill_onskillusage) },
{ HP_POP(skill->cell_overlap, HP_skill_cell_overlap) },
{ HP_POP(skill->timerskill, HP_skill_timerskill) },
+ { HP_POP(skill->trap_do_splash, HP_skill_trap_do_splash) },
{ HP_POP(skill->trap_splash, HP_skill_trap_splash) },
{ HP_POP(skill->check_condition_mercenary, HP_skill_check_condition_mercenary) },
{ HP_POP(skill->locate_element_field, HP_skill_locate_element_field) },
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index 6405c03a2..b177c12c0 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -2859,6 +2859,32 @@ void HP_battle_reflect_damage(struct block_list *target, struct block_list *src,
}
return;
}
+void HP_battle_reflect_trap(struct block_list *target, struct block_list *src, struct Damage *md, uint16 skill_id) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_battle_reflect_trap_pre > 0) {
+ void (*preHookFunc) (struct block_list **target, struct block_list **src, struct Damage **md, uint16 *skill_id);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_trap_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_battle_reflect_trap_pre[hIndex].func;
+ preHookFunc(&target, &src, &md, &skill_id);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.battle.reflect_trap(target, src, md, skill_id);
+ }
+ if (HPMHooks.count.HP_battle_reflect_trap_post > 0) {
+ void (*postHookFunc) (struct block_list *target, struct block_list *src, struct Damage *md, uint16 skill_id);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_trap_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_battle_reflect_trap_post[hIndex].func;
+ postHookFunc(target, src, md, skill_id);
+ }
+ }
+ return;
+}
int HP_battle_attr_ratio(int atk_elem, int def_type, int def_lv) {
int hIndex = 0;
int retVal___ = 0;
@@ -76342,6 +76368,32 @@ int HP_skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
}
return retVal___;
}
+void HP_skill_trap_do_splash(struct block_list *bl, uint16 skill_id, uint16 skill_lv, int bl_flag, int64 tick) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_skill_trap_do_splash_pre > 0) {
+ void (*preHookFunc) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *bl_flag, int64 *tick);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_do_splash_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_skill_trap_do_splash_pre[hIndex].func;
+ preHookFunc(&bl, &skill_id, &skill_lv, &bl_flag, &tick);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.trap_do_splash(bl, skill_id, skill_lv, bl_flag, tick);
+ }
+ if (HPMHooks.count.HP_skill_trap_do_splash_post > 0) {
+ void (*postHookFunc) (struct block_list *bl, uint16 skill_id, uint16 skill_lv, int bl_flag, int64 tick);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_do_splash_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_skill_trap_do_splash_post[hIndex].func;
+ postHookFunc(bl, skill_id, skill_lv, bl_flag, tick);
+ }
+ }
+ return;
+}
int HP_skill_trap_splash(struct block_list *bl, va_list ap) {
int hIndex = 0;
int retVal___ = 0;