summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/common/mapindex.h1
-rw-r--r--src/map/battle.c30
-rw-r--r--src/map/battle.h4
-rw-r--r--src/map/skill.c434
-rw-r--r--src/map/skill.h35
-rw-r--r--src/map/unit.c4
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc144
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc38
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.Hooks.inc952
9 files changed, 1578 insertions, 64 deletions
diff --git a/src/common/mapindex.h b/src/common/mapindex.h
index 91bf4562e..8e552261a 100644
--- a/src/common/mapindex.h
+++ b/src/common/mapindex.h
@@ -54,6 +54,7 @@
#define MAP_MALANGDO "malangdo"
#define MAP_MALAYA "malaya"
#define MAP_ECLAGE "eclage"
+#define MAP_ECLAGE_IN "ecl_in01"
#define mapindex_id2name(n) mapindex->id2name((n),__FILE__, __LINE__, __func__)
#define mapindex_exists(n) ( mapindex->list[(n)].name[0] != '\0' )
diff --git a/src/map/battle.c b/src/map/battle.c
index de57e7d2c..edb5fd69f 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -757,6 +757,9 @@ int64 battle_calc_masteryfix(struct block_list *src, struct block_list *target,
case HT_FREEZINGTRAP:
damage += 40 * pc->checkskill(sd, RA_RESEARCHTRAP);
break;
+ default:
+ battle->calc_masteryfix_unknown(src, target, &skill_id, &skill_lv, &damage, &div, &left, &weapon);
+ break;
}
if( sc ){ // sc considered as masteries
@@ -837,6 +840,10 @@ int64 battle_calc_masteryfix(struct block_list *src, struct block_list *target,
return damage;
}
+
+void battle_calc_masteryfix_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon) {
+}
+
/*==========================================
* Elemental attribute fix.
*------------------------------------------*/
@@ -1771,6 +1778,9 @@ int battle_calc_skillratio(int attack_type, struct block_list *src, struct block
}
}
break;
+ default:
+ battle->calc_skillratio_magic_unknown(&attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag);
+ break;
}
break;
case BF_WEAPON:
@@ -2537,6 +2547,9 @@ int battle_calc_skillratio(int attack_type, struct block_list *src, struct block
case MH_MAGMA_FLOW:
skillratio += -100 + 100 * skill_lv;
break;
+ default:
+ battle->calc_skillratio_weapon_unknown(&attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag);
+ break;
}
//Skill damage modifiers that stack linearly
if(sc && skill_id != PA_SACRIFICE){
@@ -2581,6 +2594,13 @@ int battle_calc_skillratio(int attack_type, struct block_list *src, struct block
return 0;
return skillratio;
}
+
+void battle_calc_skillratio_magic_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
+}
+
+void battle_calc_skillratio_weapon_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
+}
+
/*==========================================
* Check damage trough status.
* ATK may be MISS, BLOCKED FAIL, reduce, increase, end status...
@@ -3938,6 +3958,9 @@ struct Damage battle_calc_misc_attack(struct block_list *src,struct block_list *
}
break;
+ default:
+ battle->calc_misc_attack_unknown(src, target, &skill_id, &skill_lv, &mflag, &md);
+ break;
}
if (nk&NK_SPLASHSPLIT){ // Divide ATK among targets
@@ -4078,6 +4101,9 @@ struct Damage battle_calc_misc_attack(struct block_list *src,struct block_list *
return md;
}
+void battle_calc_misc_attack_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md) {
+}
+
/*==========================================
* battle_calc_weapon_attack (by Skotlex)
*------------------------------------------*/
@@ -7262,4 +7288,8 @@ void battle_defaults(void) {
battle->config_adjust = battle_adjust_conf;
battle->get_enemy_area = battle_getenemyarea;
battle->damage_area = battle_damage_area;
+ battle->calc_masteryfix_unknown = battle_calc_masteryfix_unknown;
+ battle->calc_skillratio_magic_unknown = battle_calc_skillratio_magic_unknown;
+ battle->calc_skillratio_weapon_unknown = battle_calc_skillratio_weapon_unknown;
+ battle->calc_misc_attack_unknown = battle_calc_misc_attack_unknown;
}
diff --git a/src/map/battle.h b/src/map/battle.h
index e80e0091d..ea2538c30 100644
--- a/src/map/battle.h
+++ b/src/map/battle.h
@@ -612,6 +612,10 @@ struct battle_interface {
struct block_list* (*get_enemy_area) (struct block_list *src, int x, int y, int range, int type, int ignore_id);
/* damages area, originally for royal guard's reflect damage */
int (*damage_area) (struct block_list *bl, va_list ap);
+ void (*calc_masteryfix_unknown) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
+ void (*calc_skillratio_magic_unknown) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ void (*calc_skillratio_weapon_unknown) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ void (*calc_misc_attack_unknown) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md);
};
struct battle_interface *battle;
diff --git a/src/map/skill.c b/src/map/skill.c
index a89f61a49..2e31c5821 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -493,6 +493,7 @@ int skillnotok (uint16 skill_id, struct map_session_data *sd)
case AL_WARP:
case RETURN_TO_ELDICASTES:
case ALL_GUARDIAN_RECALL:
+ case ECLAGE_RECALL:
if(map->list[m].flag.nowarp) {
clif->skill_mapinfomessage(sd,0);
return 1;
@@ -1348,6 +1349,9 @@ int skill_additional_effect(struct block_list* src, struct block_list *bl, uint1
case MH_XENO_SLASHER:
sc_start2(src, bl, SC_BLOODING, 10 * skill_lv, skill_lv, src->id, skill->get_time(skill_id,skill_lv));
break;
+ default:
+ skill->additional_effect_unknown(src, bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick);
+ break;
}
if (md && battle_config.summons_trigger_autospells && md->master_id && md->special_state.ai) {
@@ -1577,6 +1581,9 @@ int skill_additional_effect(struct block_list* src, struct block_list *bl, uint1
return 0;
}
+void skill_additional_effect_unknown(struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick) {
+}
+
int skill_onskillusage(struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick) {
int temp, skill_lv, i, type, notok;
struct block_list *tbl;
@@ -1744,6 +1751,9 @@ int skill_counter_additional_effect(struct block_list* src, struct block_list *b
clif->millenniumshield(bl, sc->fv_counter++);
}
break;
+ default:
+ skill->counter_additional_effect_unknown(src, bl, &skill_id, &skill_lv, &attack_type, &tick);
+ break;
}
if( sd && (sd->class_&MAPID_UPPERMASK) == MAPID_STAR_GLADIATOR
@@ -1898,6 +1908,10 @@ int skill_counter_additional_effect(struct block_list* src, struct block_list *b
return 0;
}
+
+void skill_counter_additional_effect_unknown(struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick) {
+}
+
/*=========================================================================
* Breaks equipment. On-non players causes the corresponding strip effect.
* - rate goes from 0 to 10000 (100.00%)
@@ -2330,8 +2344,8 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
unit->cancel_combo(src); // Cancel combo wait
break;
default:
- if( src == dsrc ) // Ground skills are exceptions. [Inkfish]
- status_change_end(src, SC_COMBOATTACK, INVALID_TIMER);
+ skill->attack_combo1_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag, sce, &combo);
+ break;
}
}
switch(skill_id) {
@@ -2392,9 +2406,12 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
if( pc->checkskill(sd, SR_TIGERCANNON) > 0 || pc->checkskill(sd, SR_GATEOFHELL) > 0 )
combo = 1;
break;
+ default:
+ skill->attack_combo2_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag, &combo);
+ break;
} //Switch End
if (combo) { //Possible to chain
- if ( (combo = DIFF_TICK32(sd->ud.canact_tick, tick)) < 50 ) combo = 50;/* less is a waste. */
+ combo = max(status_get_amotion(src), DIFF_TICK32(sd->ud.canact_tick, tick));
sc_start2(NULL,src,SC_COMBOATTACK,100,skill_id,bl->id,combo);
clif->combo_delay(src, combo);
}
@@ -2511,14 +2528,7 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
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;
- if( bl->type == BL_SKILL ){
- TBL_SKILL *su = (TBL_SKILL*)bl;
- 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);
- }
- dmg.dmotion = clif->skill_damage(dsrc,bl,tick, dmg.amotion, dmg.dmotion, damage, dmg.div_, skill_id, flag&SD_LEVEL?-1:skill_lv, type);
+ skill->attack_display_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage);
break;
}
@@ -2562,6 +2572,9 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
case LG_OVERBRAND_PLUSATK:
copy_skill = LG_OVERBRAND;
break;
+ default:
+ copy_skill = skill->attack_copy_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+ break;
}
cidx = skill->get_index(copy_skill);
if ((tsd->status.skill[cidx].id == 0 || tsd->status.skill[cidx].flag == SKILL_FLAG_PLAGIARIZED) &&
@@ -2667,6 +2680,9 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
case MC_CARTREVOLUTION:
dir = 6; // Official servers push target to the West
break;
+ default:
+ dir = skill->attack_dir_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+ break;
}
@@ -2690,12 +2706,7 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
}
break;
default:
- skill->blown(dsrc,bl,dmg.blewcount,dir, 0x0 );
- if ( !dmg.blewcount && bl->type == BL_SKILL && damage > 0 ){
- TBL_SKILL *su = (TBL_SKILL*)bl;
- if( su->group && su->group->skill_id == HT_BLASTMINE)
- skill->blown(src, bl, 3, -1, 0);
- }
+ skill->attack_blow_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage, &dir);
break;
}
}
@@ -2784,6 +2795,9 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
case SR_TIGERCANNON:
status_zap(bl, 0, damage/10); // 10% of damage dealt
break;
+ default:
+ skill->attack_post_unknown(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+ break;
}
if( sd )
skill->onskillusage(sd, bl, skill_id, tick);
@@ -2807,6 +2821,45 @@ int skill_attack(int attack_type, struct block_list* src, struct block_list *dsr
return (int)cap_value(damage,INT_MIN,INT_MAX);
}
+void skill_attack_combo1_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo) {
+ if (src == dsrc) // Ground skills are exceptions. [Inkfish]
+ status_change_end(src, SC_COMBOATTACK, INVALID_TIMER);
+}
+
+void skill_attack_combo2_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo) {
+}
+
+void skill_attack_display_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage) {
+ if (*flag & SD_ANIMATION && dmg->div_ < 2) //Disabling skill animation doesn't works on multi-hit.
+ *type = 5;
+ if (bl->type == BL_SKILL ) {
+ TBL_SKILL *su = (TBL_SKILL*)bl;
+ 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);
+ }
+ dmg->dmotion = clif->skill_damage(dsrc, bl, *tick, dmg->amotion, dmg->dmotion, *damage, dmg->div_, *skill_id, *flag & SD_LEVEL ? -1 : *skill_lv, *type);
+}
+
+int skill_attack_copy_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ return *skill_id;
+}
+
+int skill_attack_dir_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ return -1;
+}
+
+void skill_attack_blow_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir) {
+ skill->blown(dsrc, bl, dmg->blewcount, *dir, 0x0);
+ if (!dmg->blewcount && bl->type == BL_SKILL && *damage > 0){
+ TBL_SKILL *su = (TBL_SKILL*)bl;
+ if (su->group && su->group->skill_id == HT_BLASTMINE)
+ skill->blown(src, bl, 3, -1, 0);
+ }
+}
+
+void skill_attack_post_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+}
+
/*==========================================
* sub function for recursive skill call.
* Checking bl battle flag and display damage
@@ -3138,7 +3191,8 @@ int skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
case SR_SKYNETBLOW:
break;
default:
- continue; // Caster is Dead
+ if (!skill->timerskill_dead_unknown(src, ud, skl))
+ continue; // Caster is Dead
}
}
if(status->isdead(target) && skl->skill_id != RG_INTIMIDATE && skl->skill_id != WZ_WATERBALL)
@@ -3294,7 +3348,7 @@ int skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
}
}
default:
- skill->attack(skl->type,src,src,target,skl->skill_id,skl->skill_lv,tick,skl->flag);
+ skill->timerskill_target_unknown(tid, tick, src, target, ud, skl);
break;
}
} else {
@@ -3327,6 +3381,9 @@ int skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
map->foreachinpath(skill->attack_area,src->m,src->x,src->y,skl->x,skl->y,4,2,BL_CHAR,
skill->get_type(skl->skill_id),src,src,skl->skill_id,skl->skill_lv,tick,skl->flag,BCT_ENEMY);
break;
+ default:
+ skill->timerskill_notarget_unknown(tid, tick, src, target, ud, skl);
+ break;
}
}
} while (0);
@@ -3335,6 +3392,20 @@ int skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
return 0;
}
+bool skill_timerskill_dead_unknown(struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl)
+{
+ return false;
+}
+
+void skill_timerskill_target_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl)
+{
+ skill->attack(skl->type, src, src, target, skl->skill_id, skl->skill_lv, tick, skl->flag);
+}
+
+void skill_timerskill_notarget_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl)
+{
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -3388,6 +3459,10 @@ int skill_cleartimerskill (struct block_list *src)
case SR_TIGERCANNON:
case SR_SKYNETBLOW:
continue;
+ default:
+ skill->cleartimerskill_unknown(ud->skilltimerskill[i]->skill_id);
+ continue;
+
}
timer->delete(ud->skilltimerskill[i]->timer, skill->timerskill);
ers_free(skill->timer_ers, ud->skilltimerskill[i]);
@@ -3396,6 +3471,11 @@ int skill_cleartimerskill (struct block_list *src)
}
return 1;
}
+
+void skill_cleartimerskill_unknown(int skill_id)
+{
+}
+
int skill_activate_reverberation(struct block_list *bl, va_list ap) {
struct skill_unit *su = (TBL_SKILL*)bl;
struct skill_unit_group *sg;
@@ -4697,12 +4777,9 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1
break;
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,
- 0, abs(skill->get_num(skill_id, skill_lv)),
- skill_id, skill_lv, skill->get_hit(skill_id));
- map->freeblock_unlock();
- return 1;
+ if (skill->castend_damage_id_unknown(src, bl, &skill_id, &skill_lv, &tick, &flag, tstatus, sc))
+ return 1;
+ break;
}
if( sc && sc->data[SC_CURSEDCIRCLE_ATKER] ) //Should only remove after the skill has been casted.
@@ -4726,6 +4803,16 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1
return 0;
}
+bool skill_castend_damage_id_unknown(struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc)
+{
+ ShowWarning("skill_castend_damage_id: Unknown skill used:%d\n", *skill_id);
+ 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));
+ map->freeblock_unlock();
+ return true;
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -4809,6 +4896,10 @@ int skill_castend_id(int tid, int64 tick, int id, intptr_t data) {
ud->skilly = target->y;
ud->skilltimer = tid;
return skill->castend_pos(tid,tick,id,data);
+ default:
+ if (skill->castend_id_unknown(ud, src, target))
+ return 0;
+ break;
}
if(ud->skill_id == RG_BACKSTAP) {
@@ -5008,6 +5099,9 @@ int skill_castend_id(int tid, int64 tick, int id, intptr_t data) {
else ud->skill_id = 0; //mobs can't clear this one as it is used for skill condition 'afterskill'
ud->skill_lv = ud->skilltarget = 0;
}
+
+ unit->setdir(src, map->calc_dir(src, target->x, target->y));
+
map->freeblock_unlock();
return 1;
} while(0);
@@ -5059,6 +5153,11 @@ int skill_castend_id(int tid, int64 tick, int id, intptr_t data) {
return 0;
}
+bool skill_castend_id_unknown(struct unit_data *ud, struct block_list *src, struct block_list *target)
+{
+ return false;
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -5106,7 +5205,9 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
case WM_DEADHILLHERE:
break;
default:
- return 1;
+ if (skill->castend_nodamage_id_dead_unknown(src, bl, &skill_id, &skill_lv, &tick, &flag))
+ return 1;
+ break;
}
}
@@ -5121,6 +5222,8 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
clif->skill_fail(sd,skill_id,USESKILL_FAIL_TOTARGET,0);
return 0;
default:
+ if (skill->castend_nodamage_id_mado_unknown(src, bl, &skill_id, &skill_lv, &tick, &flag))
+ return 0;
break;
}
}
@@ -5223,9 +5326,13 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
}
break;
default:
- //Skill is actually ground placed.
- if (src == bl && skill->get_unit_id(skill_id,0))
- return skill->castend_pos2(src,bl->x,bl->y,skill_id,skill_lv,tick,0);
+ if (skill->castend_nodamage_id_undead_unknown(src, bl, &skill_id, &skill_lv, &tick, &flag))
+ {
+ //Skill is actually ground placed.
+ if (src == bl && skill->get_unit_id(skill_id,0))
+ return skill->castend_pos2(src,bl->x,bl->y,skill_id,skill_lv,tick,0);
+ }
+ break;
}
type = status->skill2sc(skill_id);
@@ -9167,32 +9274,72 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
}
break;
-
case RETURN_TO_ELDICASTES:
case ALL_GUARDIAN_RECALL:
- if( sd )
- {
- short x, y; // Destiny position.
- unsigned short map_index;
+ case ECLAGE_RECALL:
+ if( sd ) {
+ short x = 0, y = 0; //Destiny position.
+ unsigned short map_index = 0;
- if( skill_id == RETURN_TO_ELDICASTES) {
- x = 198;
- y = 187;
- map_index = mapindex->name2id(MAP_DICASTES);
- } else {
- x = 44;
- y = 151;
- map_index = mapindex->name2id(MAP_MORA);
+ switch( skill_id ) {
+ default:
+ case RETURN_TO_ELDICASTES:
+ x = 198;
+ y = 187;
+ map_index = mapindex->name2id(MAP_DICASTES);
+ break;
+ case ALL_GUARDIAN_RECALL:
+ x = 44;
+ y = 151;
+ map_index = mapindex->name2id(MAP_MORA);
+ break;
+ case ECLAGE_RECALL:
+ x = 47;
+ y = 31;
+ map_index = mapindex->name2id(MAP_ECLAGE_IN);
+ break;
}
-
- if(!map_index) {
- //Given map not found?
+ if( !mapindex ) { //Given map not found?
clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
map->freeblock_unlock();
return 0;
}
- pc->setpos(sd, map_index, x, y, CLR_TELEPORT);
+ pc->setpos(sd,map_index,x,y,CLR_TELEPORT);
+ }
+ break;
+
+ case ECL_SNOWFLIP:
+ case ECL_PEONYMAMY:
+ case ECL_SADAGUI:
+ case ECL_SEQUOIADUST:
+ switch( skill_id ) {
+ case ECL_SNOWFLIP:
+ status_change_end(bl,SC_SLEEP,INVALID_TIMER);
+ status_change_end(bl,SC_BLOODING,INVALID_TIMER);
+ status_change_end(bl,SC_BURNING,INVALID_TIMER);
+ status_change_end(bl,SC_DEEP_SLEEP,INVALID_TIMER);
+ break;
+ case ECL_PEONYMAMY:
+ status_change_end(bl,SC_FREEZE,INVALID_TIMER);
+ status_change_end(bl,SC_FROSTMISTY,INVALID_TIMER);
+ status_change_end(bl,SC_COLD,INVALID_TIMER);
+ break;
+ case ECL_SADAGUI:
+ status_change_end(bl,SC_STUN,INVALID_TIMER);
+ status_change_end(bl,SC_CONFUSION,INVALID_TIMER);
+ status_change_end(bl,SC_ILLUSION,INVALID_TIMER);
+ status_change_end(bl,SC_FEAR,INVALID_TIMER);
+ break;
+ case ECL_SEQUOIADUST:
+ status_change_end(bl,SC_STONE,INVALID_TIMER);
+ status_change_end(bl,SC_POISON,INVALID_TIMER);
+ status_change_end(bl,SC_CURSE,INVALID_TIMER);
+ status_change_end(bl,SC_BLIND,INVALID_TIMER);
+ status_change_end(bl,SC_ORCISH,INVALID_TIMER);
+ break;
}
+ clif->skill_nodamage(src,bl,skill_id,skill_lv,1);
+ clif->skill_damage(src,bl,tick, status_get_amotion(src), 0, 0, 1, skill_id, -2, 6);
break;
case GM_SANDMAN:
@@ -9665,10 +9812,9 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
case SO_ELEMENTAL_SHIELD:/* somehow its handled outside this switch, so we need a empty case otherwise default would be triggered. */
break;
default:
- ShowWarning("skill_castend_nodamage_id: Unknown skill used:%d\n",skill_id);
- clif->skill_nodamage(src,bl,skill_id,skill_lv,1);
- map->freeblock_unlock();
- return 1;
+ if (skill->castend_nodamage_id_unknown(src, bl, &skill_id, &skill_lv, &tick, &flag))
+ return 1;
+ break;
}
if(skill_id != SR_CURSEDCIRCLE) {
@@ -9698,6 +9844,29 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
return 0;
}
+bool skill_castend_nodamage_id_dead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag)
+{
+ return true;
+}
+
+bool skill_castend_nodamage_id_undead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag)
+{
+ return true;
+}
+
+bool skill_castend_nodamage_id_mado_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag)
+{
+ return false;
+}
+
+bool skill_castend_nodamage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag)
+{
+ ShowWarning("skill_castend_nodamage_id: Unknown skill used:%d\n", *skill_id);
+ clif->skill_nodamage(src, bl, *skill_id, *skill_lv, 1);
+ map->freeblock_unlock();
+ return true;
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -9843,6 +10012,8 @@ int skill_castend_pos(int tid, int64 tick, int id, intptr_t data) {
ud->skill_lv = ud->skillx = ud->skilly = 0;
}
+ unit->setdir(src, map->calc_dir(src, ud->skillx, ud->skilly));
+
map->freeblock_unlock();
return 1;
} while(0);
@@ -10046,10 +10217,8 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case SC_ESCAPE:
break; //Effect is displayed on respective switch case.
default:
- if(skill->get_inf(skill_id)&INF_SELF_SKILL)
- clif->skill_nodamage(src,src,skill_id,skill_lv,1);
- else
- clif->skill_poseffect(src,skill_id,skill_lv,x,y,tick);
+ skill->castend_pos2_effect_unknown(src, &x, &y, &skill_id, &skill_lv, &tick, &flag);
+ break;
}
// SC_MAGICPOWER needs to switch states before any damage is actually dealt
@@ -10725,8 +10894,9 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
break;
default:
- ShowWarning("skill_castend_pos2: Unknown skill used:%d\n",skill_id);
- return 1;
+ if (skill->castend_pos2_unknown(src, &x, &y, &skill_id, &skill_lv, &tick, &flag))
+ return 1;
+ break;
}
if( sc && sc->data[SC_CURSEDCIRCLE_ATKER] ) //Should only remove after the skill has been casted.
@@ -10747,6 +10917,18 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
return 0;
}
+void skill_castend_pos2_effect_unknown(struct block_list* src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ if (skill->get_inf(*skill_id) & INF_SELF_SKILL)
+ clif->skill_nodamage(src, src, *skill_id, *skill_lv, 1);
+ else
+ clif->skill_poseffect(src, *skill_id, *skill_lv, *x, *y, *tick);
+}
+
+bool skill_castend_pos2_unknown(struct block_list* src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ ShowWarning("skill_castend_pos2: Unknown skill used:%d\n", *skill_id);
+ return true;
+}
+
/// transforms 'target' skill unit into dissonance (if conditions are met)
int skill_dance_overlap_sub(struct block_list* bl, va_list ap) {
struct skill_unit* target = (struct skill_unit*)bl;
@@ -11211,6 +11393,9 @@ struct skill_unit_group* skill_unitsetting(struct block_list *src, uint16 skill_
}
}
break;
+ default:
+ skill->unitsetting1_unknown(src, &skill_id, &skill_lv, &x, &y, &flag, &val1, &val2, &val3);
+ break;
}
nullpo_retr(NULL, group=skill->init_unitgroup(src,layout->count,skill_id,skill_lv,skill->get_unit_id(skill_id,flag&1)+subunt, limit, interval));
@@ -11312,8 +11497,7 @@ struct skill_unit_group* skill_unitsetting(struct block_list *src, uint16 skill_
val2 = src->id;
break;
default:
- if (group->state.song_dance&0x1)
- val2 = unit_flag&(UF_DANCE|UF_SONG); //Store whether this is a song/dance
+ skill->unitsetting2_unknown(src, &skill_id, &skill_lv, &x, &y, &flag, &unit_flag, &val1, &val2, &val3, group);
break;
}
if (skill->get_unit_flag(skill_id) & UF_RANGEDSINGLEUNIT && i == (layout->count / 2))
@@ -11354,6 +11538,14 @@ struct skill_unit_group* skill_unitsetting(struct block_list *src, uint16 skill_
return group;
}
+void skill_unitsetting1_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3) {
+}
+
+void skill_unitsetting2_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group) {
+ if (group->state.song_dance & 0x1)
+ *val2 = *unit_flag & (UF_DANCE | UF_SONG); //Store whether this is a song/dance
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -11578,10 +11770,16 @@ int skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 tick
if ( !sce && battle->check_target(&sg->unit->bl,bl,sg->target_flag) > 0 )
sc_start4(ss,bl,type,100,sg->skill_lv,0,0,0,1000);
break;
+ default:
+ skill->unit_onplace_unknown(src, bl, &tick);
+ break;
}
return skill_id;
}
+void skill_unit_onplace_unknown(struct skill_unit *src, struct block_list *bl, int64 *tick) {
+}
+
/*==========================================
*
*------------------------------------------*/
@@ -12873,6 +13071,12 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
case KO_YAMIKUMO:
if( sc && sc->data[status->skill2sc(skill_id)] )
return 1;
+ default:
+ {
+ int ret = skill->check_condition_castbegin_off_unknown(sc, &skill_id);
+ if (ret >= 0)
+ return ret;
+ }
}
// Check the skills that can be used while mounted on a warg
@@ -12907,7 +13111,11 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
case ALL_FULL_THROTTLE:
break;
default: // in official there is no message.
- return 0;
+ {
+ int ret = skill->check_condition_castbegin_mount_unknown(sc, &skill_id);
+ if (ret >= 0)
+ return ret;
+ }
}
}
@@ -12946,7 +13154,11 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
case NC_MAGMA_ERUPTION_DOTDAMAGE:
break;
default:
- return 0;
+ {
+ int ret = skill->check_condition_castbegin_madogear_unknown(sc, &skill_id);
+ if (ret >= 0)
+ return ret;
+ }
}
}
@@ -13523,6 +13735,12 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
}
}
break;
+ default:
+ {
+ int ret = skill->check_condition_castbegin_unknown(sc, &skill_id);
+ if (ret >= 0)
+ return ret;
+ }
}
switch(require.state) {
@@ -13705,6 +13923,27 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id
return 1;
}
+int skill_check_condition_castbegin_off_unknown(struct status_change *sc, uint16 *skill_id)
+{
+ return -1;
+}
+
+int skill_check_condition_castbegin_mount_unknown(struct status_change *sc, uint16 *skill_id)
+{
+ return 0;
+}
+
+int skill_check_condition_castbegin_madogear_unknown(struct status_change *sc, uint16 *skill_id)
+{
+ return 0;
+}
+
+int skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 *skill_id)
+{
+ return -1;
+}
+
+
int skill_check_condition_castend(struct map_session_data* sd, uint16 skill_id, uint16 skill_lv) {
struct skill_condition require;
struct status_data *st;
@@ -13809,6 +14048,9 @@ int skill_check_condition_castend(struct map_session_data* sd, uint16 skill_id,
}
}
break;
+ default:
+ skill->check_condition_castend_unknown(sd, &skill_id, &skill_lv);
+ break;
}
st = &sd->battle_status;
@@ -13894,6 +14136,9 @@ int skill_check_condition_castend(struct map_session_data* sd, uint16 skill_id,
return 1;
}
+void skill_check_condition_castend_unknown(struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv) {
+}
+
// type&2: consume items (after skill was used)
// type&1: consume the others (before skill was used)
int skill_consume_requirement( struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type) {
@@ -14022,6 +14267,12 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
case KO_YAMIKUMO:
if( sc && sc->data[status->skill2sc(skill_id)] )
return req;
+ default:
+ {
+ if (skill->get_requirement_off_unknown(sc, &skill_id))
+ return req;
+ break;
+ }
}
idx = skill->get_index(skill_id);
@@ -14133,6 +14384,12 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
if( i < 3 )
continue;
break;
+ default:
+ {
+ if (skill->get_requirement_item_unknown(sc, sd, &skill_id, &skill_lv, &idx, &i))
+ continue;
+ break;
+ }
}
req.itemid[i] = skill->db[idx].itemid[i];
@@ -14281,11 +14538,28 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
if( sc && (sc->data[SC_HEATER_OPTION] || sc->data[SC_COOLER_OPTION] || sc->data[SC_BLAST_OPTION] || sc->data[SC_CURSED_SOIL_OPTION] ))
req.sp += req.sp * 150 / 100;
break;
+ default:
+ skill->get_requirement_unknown(sc, sd, &skill_id, &skill_lv, &req);
+ break;
}
return req;
}
+bool skill_get_requirement_off_unknown(struct status_change *sc, uint16 *skill_id)
+{
+ return false;
+}
+
+int skill_get_requirement_item_unknown(struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i)
+{
+ return -1;
+}
+
+void skill_get_requirement_unknown(struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req)
+{
+}
+
/*==========================================
* Does cast-time reductions based on dex, item bonuses and config setting
*------------------------------------------*/
@@ -15314,7 +15588,9 @@ int skill_cell_overlap(struct block_list *bl, va_list ap) {
skill->delunit(su);
return 1;
}
- if( !(skill->get_inf2(su->group->skill_id)&(INF2_SONG_DANCE|INF2_TRAP)) || su->group->skill_id == WZ_FIREPILLAR || su->group->skill_id == GN_HELLS_PLANT) { //It deletes everything except songs/dances and traps
+ // SA_LANDPROTECTOR blocks everything except songs/dances/traps (and NOLP)
+ // TODO: Do these skills ignore land protector when placed on top?
+ if( !(skill->get_inf2(su->group->skill_id)&(INF2_SONG_DANCE|INF2_TRAP|INF2_NOLP)) || su->group->skill_id == WZ_FIREPILLAR || su->group->skill_id == GN_HELLS_PLANT) {
skill->delunit(su);
return 1;
}
@@ -15371,8 +15647,8 @@ int skill_cell_overlap(struct block_list *bl, va_list ap) {
break;
}
- if (su->group->skill_id == SA_LANDPROTECTOR && !(skill->get_inf2(skill_id)&(INF2_SONG_DANCE|INF2_TRAP))) {
- //It deletes everything except songs/dances/traps
+ if (su->group->skill_id == SA_LANDPROTECTOR && !(skill->get_inf2(skill_id)&(INF2_SONG_DANCE|INF2_TRAP|INF2_NOLP))) {
+ //SA_LANDPROTECTOR blocks everything except songs/dances/traps (and NOLP)
(*alive) = 0;
return 1;
}
@@ -19029,4 +19305,36 @@ void skill_defaults(void) {
skill->cooldown_save = skill_cooldown_save;
skill->get_new_group_id = skill_get_new_group_id;
skill->check_shadowform = skill_check_shadowform;
+ skill->additional_effect_unknown = skill_additional_effect_unknown;
+ skill->counter_additional_effect_unknown = skill_counter_additional_effect_unknown;
+ skill->attack_combo1_unknown = skill_attack_combo1_unknown;
+ skill->attack_combo2_unknown = skill_attack_combo2_unknown;
+ skill->attack_display_unknown = skill_attack_display_unknown;
+ skill->attack_copy_unknown = skill_attack_copy_unknown;
+ skill->attack_dir_unknown = skill_attack_dir_unknown;
+ skill->attack_blow_unknown = skill_attack_blow_unknown;
+ skill->attack_post_unknown = skill_attack_post_unknown;
+ skill->timerskill_dead_unknown = skill_timerskill_dead_unknown;
+ skill->timerskill_target_unknown = skill_timerskill_target_unknown;
+ skill->timerskill_notarget_unknown = skill_timerskill_notarget_unknown;
+ skill->cleartimerskill_unknown = skill_cleartimerskill_unknown;
+ skill->castend_damage_id_unknown = skill_castend_damage_id_unknown;
+ skill->castend_id_unknown = skill_castend_id_unknown;
+ skill->castend_nodamage_id_dead_unknown = skill_castend_nodamage_id_dead_unknown;
+ skill->castend_nodamage_id_mado_unknown = skill_castend_nodamage_id_mado_unknown;
+ skill->castend_nodamage_id_undead_unknown = skill_castend_nodamage_id_undead_unknown;
+ skill->castend_nodamage_id_unknown = skill_castend_nodamage_id_unknown;
+ skill->castend_pos2_effect_unknown = skill_castend_pos2_effect_unknown;
+ skill->castend_pos2_unknown = skill_castend_pos2_unknown;
+ skill->unitsetting1_unknown = skill_unitsetting1_unknown;
+ skill->unitsetting2_unknown = skill_unitsetting2_unknown;
+ skill->unit_onplace_unknown = skill_unit_onplace_unknown;
+ skill->check_condition_castbegin_off_unknown = skill_check_condition_castbegin_off_unknown;
+ skill->check_condition_castbegin_mount_unknown = skill_check_condition_castbegin_mount_unknown;
+ skill->check_condition_castbegin_madogear_unknown = skill_check_condition_castbegin_madogear_unknown;
+ skill->check_condition_castbegin_unknown = skill_check_condition_castbegin_unknown;
+ skill->check_condition_castend_unknown = skill_check_condition_castend_unknown;
+ skill->get_requirement_off_unknown = skill_get_requirement_off_unknown;
+ skill->get_requirement_item_unknown = skill_get_requirement_item_unknown;
+ skill->get_requirement_unknown = skill_get_requirement_unknown;
}
diff --git a/src/map/skill.h b/src/map/skill.h
index f0a54b982..fa88bce99 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -16,9 +16,11 @@
/**
* Declarations
**/
+struct Damage;
struct homun_data;
struct map_session_data;
struct mercenary_data;
+struct unit_data;
struct skill_unit;
struct square;
struct status_change_entry;
@@ -2040,6 +2042,39 @@ struct skill_interface {
void (*cooldown_save) (struct map_session_data * sd);
int (*get_new_group_id) (void);
bool (*check_shadowform) (struct block_list *bl, int64 damage, int hit);
+
+ bool (*castend_damage_id_unknown) (struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc);
+ void (*additional_effect_unknown) (struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick);
+ void (*counter_additional_effect_unknown) (struct block_list* src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick);
+ void (*attack_combo1_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo);
+ void (*attack_combo2_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo);
+ void (*attack_display_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage);
+ int (*attack_copy_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ int (*attack_dir_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ void (*attack_blow_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir);
+ void (*attack_post_unknown) (int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ bool (*timerskill_dead_unknown) (struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
+ void (*timerskill_target_unknown) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ void (*timerskill_notarget_unknown) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ void (*cleartimerskill_unknown) (int skill_id);
+ bool (*castend_id_unknown) (struct unit_data *ud, struct block_list *src, struct block_list *target);
+ bool (*castend_nodamage_id_dead_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ bool (*castend_nodamage_id_undead_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ bool (*castend_nodamage_id_mado_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ bool (*castend_nodamage_id_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ void (*castend_pos2_effect_unknown) (struct block_list* src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ bool (*castend_pos2_unknown) (struct block_list* src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ void (*unitsetting1_unknown) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3);
+ void (*unitsetting2_unknown) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group);
+ void (*unit_onplace_unknown) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+ int (*check_condition_castbegin_off_unknown) (struct status_change *sc, uint16 *skill_id);
+ int (*check_condition_castbegin_mount_unknown) (struct status_change *sc, uint16 *skill_id);
+ int (*check_condition_castbegin_madogear_unknown) (struct status_change *sc, uint16 *skill_id);
+ int (*check_condition_castbegin_unknown) (struct status_change *sc, uint16 *skill_id);
+ void (*check_condition_castend_unknown) (struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv);
+ bool (*get_requirement_off_unknown) (struct status_change *sc, uint16 *skill_id);
+ int (*get_requirement_item_unknown) (struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i);
+ void (*get_requirement_unknown) (struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req);
};
struct skill_interface *skill;
diff --git a/src/map/unit.c b/src/map/unit.c
index deb061f78..7f41f4709 100644
--- a/src/map/unit.c
+++ b/src/map/unit.c
@@ -1599,6 +1599,8 @@ int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, ui
ud->skill_lv = skill_lv;
if( casttime > 0 ) {
+ if (src->id != target->id) // self-targeted skills shouldn't show different direction
+ unit->setdir(src, map->calc_dir(src, target->x, target->y));
ud->skilltimer = timer->add( tick+casttime, skill->castend_id, src->id, 0 );
if( sd && (pc->checkskill(sd,SA_FREECAST) > 0 || skill_id == LG_EXEEDBREAK) )
status_calc_bl(&sd->bl, SCB_SPEED);
@@ -1742,6 +1744,7 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, ui
// in official this is triggered even if no cast time.
clif->skillcasting(src, src->id, 0, skill_x, skill_y, skill_id, skill->get_ele(skill_id, skill_lv), casttime);
if( casttime > 0 ) {
+ unit->setdir(src, map->calc_dir(src, skill_x, skill_y));
ud->skilltimer = timer->add( tick+casttime, skill->castend_pos, src->id, 0 );
if( (sd && pc->checkskill(sd,SA_FREECAST) > 0) || skill_id == LG_EXEEDBREAK)
status_calc_bl(&sd->bl, SCB_SPEED);
@@ -2170,6 +2173,7 @@ int unit_attack_timer_sub(struct block_list* src, int tid, int64 tick) {
}
if(ud->state.attack_continue) {
+ unit->setdir(src, map->calc_dir(src, target->x, target->y));
if( src->type == BL_PC && battle_config.idletime_criteria & BCIDLE_ATTACK )
((TBL_PC*)src)->idletime = sockt->last_tick;
ud->attacktimer = timer->add(ud->attackabletime,unit->attack_timer,src->id,0);
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
index c2c6daf58..9090af876 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
@@ -165,6 +165,14 @@ struct {
struct HPMHookPoint *HP_battle_get_enemy_area_post;
struct HPMHookPoint *HP_battle_damage_area_pre;
struct HPMHookPoint *HP_battle_damage_area_post;
+ struct HPMHookPoint *HP_battle_calc_masteryfix_unknown_pre;
+ struct HPMHookPoint *HP_battle_calc_masteryfix_unknown_post;
+ struct HPMHookPoint *HP_battle_calc_skillratio_magic_unknown_pre;
+ struct HPMHookPoint *HP_battle_calc_skillratio_magic_unknown_post;
+ struct HPMHookPoint *HP_battle_calc_skillratio_weapon_unknown_pre;
+ struct HPMHookPoint *HP_battle_calc_skillratio_weapon_unknown_post;
+ struct HPMHookPoint *HP_battle_calc_misc_attack_unknown_pre;
+ struct HPMHookPoint *HP_battle_calc_misc_attack_unknown_post;
struct HPMHookPoint *HP_bg_init_pre;
struct HPMHookPoint *HP_bg_init_post;
struct HPMHookPoint *HP_bg_final_pre;
@@ -4711,6 +4719,70 @@ struct {
struct HPMHookPoint *HP_skill_get_new_group_id_post;
struct HPMHookPoint *HP_skill_check_shadowform_pre;
struct HPMHookPoint *HP_skill_check_shadowform_post;
+ struct HPMHookPoint *HP_skill_castend_damage_id_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_damage_id_unknown_post;
+ struct HPMHookPoint *HP_skill_additional_effect_unknown_pre;
+ struct HPMHookPoint *HP_skill_additional_effect_unknown_post;
+ struct HPMHookPoint *HP_skill_counter_additional_effect_unknown_pre;
+ struct HPMHookPoint *HP_skill_counter_additional_effect_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_combo1_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_combo1_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_combo2_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_combo2_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_display_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_display_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_copy_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_copy_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_dir_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_dir_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_blow_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_blow_unknown_post;
+ struct HPMHookPoint *HP_skill_attack_post_unknown_pre;
+ struct HPMHookPoint *HP_skill_attack_post_unknown_post;
+ struct HPMHookPoint *HP_skill_timerskill_dead_unknown_pre;
+ struct HPMHookPoint *HP_skill_timerskill_dead_unknown_post;
+ struct HPMHookPoint *HP_skill_timerskill_target_unknown_pre;
+ struct HPMHookPoint *HP_skill_timerskill_target_unknown_post;
+ struct HPMHookPoint *HP_skill_timerskill_notarget_unknown_pre;
+ struct HPMHookPoint *HP_skill_timerskill_notarget_unknown_post;
+ struct HPMHookPoint *HP_skill_cleartimerskill_unknown_pre;
+ struct HPMHookPoint *HP_skill_cleartimerskill_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_id_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_id_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_dead_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_dead_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_undead_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_undead_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_mado_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_mado_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_nodamage_id_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_pos2_effect_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_pos2_effect_unknown_post;
+ struct HPMHookPoint *HP_skill_castend_pos2_unknown_pre;
+ struct HPMHookPoint *HP_skill_castend_pos2_unknown_post;
+ struct HPMHookPoint *HP_skill_unitsetting1_unknown_pre;
+ struct HPMHookPoint *HP_skill_unitsetting1_unknown_post;
+ struct HPMHookPoint *HP_skill_unitsetting2_unknown_pre;
+ struct HPMHookPoint *HP_skill_unitsetting2_unknown_post;
+ struct HPMHookPoint *HP_skill_unit_onplace_unknown_pre;
+ struct HPMHookPoint *HP_skill_unit_onplace_unknown_post;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_off_unknown_pre;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_off_unknown_post;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_mount_unknown_pre;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_mount_unknown_post;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_madogear_unknown_pre;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_madogear_unknown_post;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_unknown_pre;
+ struct HPMHookPoint *HP_skill_check_condition_castbegin_unknown_post;
+ struct HPMHookPoint *HP_skill_check_condition_castend_unknown_pre;
+ struct HPMHookPoint *HP_skill_check_condition_castend_unknown_post;
+ struct HPMHookPoint *HP_skill_get_requirement_off_unknown_pre;
+ struct HPMHookPoint *HP_skill_get_requirement_off_unknown_post;
+ struct HPMHookPoint *HP_skill_get_requirement_item_unknown_pre;
+ struct HPMHookPoint *HP_skill_get_requirement_item_unknown_post;
+ struct HPMHookPoint *HP_skill_get_requirement_unknown_pre;
+ struct HPMHookPoint *HP_skill_get_requirement_unknown_post;
struct HPMHookPoint *HP_status_init_pre;
struct HPMHookPoint *HP_status_init_post;
struct HPMHookPoint *HP_status_final_pre;
@@ -5250,6 +5322,14 @@ struct {
int HP_battle_get_enemy_area_post;
int HP_battle_damage_area_pre;
int HP_battle_damage_area_post;
+ int HP_battle_calc_masteryfix_unknown_pre;
+ int HP_battle_calc_masteryfix_unknown_post;
+ int HP_battle_calc_skillratio_magic_unknown_pre;
+ int HP_battle_calc_skillratio_magic_unknown_post;
+ int HP_battle_calc_skillratio_weapon_unknown_pre;
+ int HP_battle_calc_skillratio_weapon_unknown_post;
+ int HP_battle_calc_misc_attack_unknown_pre;
+ int HP_battle_calc_misc_attack_unknown_post;
int HP_bg_init_pre;
int HP_bg_init_post;
int HP_bg_final_pre;
@@ -9796,6 +9876,70 @@ struct {
int HP_skill_get_new_group_id_post;
int HP_skill_check_shadowform_pre;
int HP_skill_check_shadowform_post;
+ int HP_skill_castend_damage_id_unknown_pre;
+ int HP_skill_castend_damage_id_unknown_post;
+ int HP_skill_additional_effect_unknown_pre;
+ int HP_skill_additional_effect_unknown_post;
+ int HP_skill_counter_additional_effect_unknown_pre;
+ int HP_skill_counter_additional_effect_unknown_post;
+ int HP_skill_attack_combo1_unknown_pre;
+ int HP_skill_attack_combo1_unknown_post;
+ int HP_skill_attack_combo2_unknown_pre;
+ int HP_skill_attack_combo2_unknown_post;
+ int HP_skill_attack_display_unknown_pre;
+ int HP_skill_attack_display_unknown_post;
+ int HP_skill_attack_copy_unknown_pre;
+ int HP_skill_attack_copy_unknown_post;
+ int HP_skill_attack_dir_unknown_pre;
+ int HP_skill_attack_dir_unknown_post;
+ int HP_skill_attack_blow_unknown_pre;
+ int HP_skill_attack_blow_unknown_post;
+ int HP_skill_attack_post_unknown_pre;
+ int HP_skill_attack_post_unknown_post;
+ int HP_skill_timerskill_dead_unknown_pre;
+ int HP_skill_timerskill_dead_unknown_post;
+ int HP_skill_timerskill_target_unknown_pre;
+ int HP_skill_timerskill_target_unknown_post;
+ int HP_skill_timerskill_notarget_unknown_pre;
+ int HP_skill_timerskill_notarget_unknown_post;
+ int HP_skill_cleartimerskill_unknown_pre;
+ int HP_skill_cleartimerskill_unknown_post;
+ int HP_skill_castend_id_unknown_pre;
+ int HP_skill_castend_id_unknown_post;
+ int HP_skill_castend_nodamage_id_dead_unknown_pre;
+ int HP_skill_castend_nodamage_id_dead_unknown_post;
+ int HP_skill_castend_nodamage_id_undead_unknown_pre;
+ int HP_skill_castend_nodamage_id_undead_unknown_post;
+ int HP_skill_castend_nodamage_id_mado_unknown_pre;
+ int HP_skill_castend_nodamage_id_mado_unknown_post;
+ int HP_skill_castend_nodamage_id_unknown_pre;
+ int HP_skill_castend_nodamage_id_unknown_post;
+ int HP_skill_castend_pos2_effect_unknown_pre;
+ int HP_skill_castend_pos2_effect_unknown_post;
+ int HP_skill_castend_pos2_unknown_pre;
+ int HP_skill_castend_pos2_unknown_post;
+ int HP_skill_unitsetting1_unknown_pre;
+ int HP_skill_unitsetting1_unknown_post;
+ int HP_skill_unitsetting2_unknown_pre;
+ int HP_skill_unitsetting2_unknown_post;
+ int HP_skill_unit_onplace_unknown_pre;
+ int HP_skill_unit_onplace_unknown_post;
+ int HP_skill_check_condition_castbegin_off_unknown_pre;
+ int HP_skill_check_condition_castbegin_off_unknown_post;
+ int HP_skill_check_condition_castbegin_mount_unknown_pre;
+ int HP_skill_check_condition_castbegin_mount_unknown_post;
+ int HP_skill_check_condition_castbegin_madogear_unknown_pre;
+ int HP_skill_check_condition_castbegin_madogear_unknown_post;
+ int HP_skill_check_condition_castbegin_unknown_pre;
+ int HP_skill_check_condition_castbegin_unknown_post;
+ int HP_skill_check_condition_castend_unknown_pre;
+ int HP_skill_check_condition_castend_unknown_post;
+ int HP_skill_get_requirement_off_unknown_pre;
+ int HP_skill_get_requirement_off_unknown_post;
+ int HP_skill_get_requirement_item_unknown_pre;
+ int HP_skill_get_requirement_item_unknown_post;
+ int HP_skill_get_requirement_unknown_pre;
+ int HP_skill_get_requirement_unknown_post;
int HP_status_init_pre;
int HP_status_init_post;
int HP_status_final_pre;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
index 89ded9041..d83b398eb 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
@@ -87,6 +87,10 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(battle->config_adjust, HP_battle_config_adjust) },
{ HP_POP(battle->get_enemy_area, HP_battle_get_enemy_area) },
{ HP_POP(battle->damage_area, HP_battle_damage_area) },
+ { HP_POP(battle->calc_masteryfix_unknown, HP_battle_calc_masteryfix_unknown) },
+ { HP_POP(battle->calc_skillratio_magic_unknown, HP_battle_calc_skillratio_magic_unknown) },
+ { HP_POP(battle->calc_skillratio_weapon_unknown, HP_battle_calc_skillratio_weapon_unknown) },
+ { HP_POP(battle->calc_misc_attack_unknown, HP_battle_calc_misc_attack_unknown) },
/* bg */
{ HP_POP(bg->init, HP_bg_init) },
{ HP_POP(bg->final, HP_bg_final) },
@@ -2391,6 +2395,38 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(skill->cooldown_save, HP_skill_cooldown_save) },
{ HP_POP(skill->get_new_group_id, HP_skill_get_new_group_id) },
{ HP_POP(skill->check_shadowform, HP_skill_check_shadowform) },
+ { HP_POP(skill->castend_damage_id_unknown, HP_skill_castend_damage_id_unknown) },
+ { HP_POP(skill->additional_effect_unknown, HP_skill_additional_effect_unknown) },
+ { HP_POP(skill->counter_additional_effect_unknown, HP_skill_counter_additional_effect_unknown) },
+ { HP_POP(skill->attack_combo1_unknown, HP_skill_attack_combo1_unknown) },
+ { HP_POP(skill->attack_combo2_unknown, HP_skill_attack_combo2_unknown) },
+ { HP_POP(skill->attack_display_unknown, HP_skill_attack_display_unknown) },
+ { HP_POP(skill->attack_copy_unknown, HP_skill_attack_copy_unknown) },
+ { HP_POP(skill->attack_dir_unknown, HP_skill_attack_dir_unknown) },
+ { HP_POP(skill->attack_blow_unknown, HP_skill_attack_blow_unknown) },
+ { HP_POP(skill->attack_post_unknown, HP_skill_attack_post_unknown) },
+ { HP_POP(skill->timerskill_dead_unknown, HP_skill_timerskill_dead_unknown) },
+ { HP_POP(skill->timerskill_target_unknown, HP_skill_timerskill_target_unknown) },
+ { HP_POP(skill->timerskill_notarget_unknown, HP_skill_timerskill_notarget_unknown) },
+ { HP_POP(skill->cleartimerskill_unknown, HP_skill_cleartimerskill_unknown) },
+ { HP_POP(skill->castend_id_unknown, HP_skill_castend_id_unknown) },
+ { HP_POP(skill->castend_nodamage_id_dead_unknown, HP_skill_castend_nodamage_id_dead_unknown) },
+ { HP_POP(skill->castend_nodamage_id_undead_unknown, HP_skill_castend_nodamage_id_undead_unknown) },
+ { HP_POP(skill->castend_nodamage_id_mado_unknown, HP_skill_castend_nodamage_id_mado_unknown) },
+ { HP_POP(skill->castend_nodamage_id_unknown, HP_skill_castend_nodamage_id_unknown) },
+ { HP_POP(skill->castend_pos2_effect_unknown, HP_skill_castend_pos2_effect_unknown) },
+ { HP_POP(skill->castend_pos2_unknown, HP_skill_castend_pos2_unknown) },
+ { HP_POP(skill->unitsetting1_unknown, HP_skill_unitsetting1_unknown) },
+ { HP_POP(skill->unitsetting2_unknown, HP_skill_unitsetting2_unknown) },
+ { HP_POP(skill->unit_onplace_unknown, HP_skill_unit_onplace_unknown) },
+ { HP_POP(skill->check_condition_castbegin_off_unknown, HP_skill_check_condition_castbegin_off_unknown) },
+ { HP_POP(skill->check_condition_castbegin_mount_unknown, HP_skill_check_condition_castbegin_mount_unknown) },
+ { HP_POP(skill->check_condition_castbegin_madogear_unknown, HP_skill_check_condition_castbegin_madogear_unknown) },
+ { HP_POP(skill->check_condition_castbegin_unknown, HP_skill_check_condition_castbegin_unknown) },
+ { HP_POP(skill->check_condition_castend_unknown, HP_skill_check_condition_castend_unknown) },
+ { HP_POP(skill->get_requirement_off_unknown, HP_skill_get_requirement_off_unknown) },
+ { HP_POP(skill->get_requirement_item_unknown, HP_skill_get_requirement_item_unknown) },
+ { HP_POP(skill->get_requirement_unknown, HP_skill_get_requirement_unknown) },
/* status */
{ HP_POP(status->init, HP_status_init) },
{ HP_POP(status->final, HP_status_final) },
@@ -2586,4 +2622,4 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(vending->searchall, HP_vending_searchall) },
};
-int HookingPointsLenMax = 41;
+int HookingPointsLenMax = 49;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index ff08b8909..3249949e7 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -2217,6 +2217,110 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) {
}
return retVal___;
}
+void HP_battle_calc_masteryfix_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_battle_calc_masteryfix_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_unknown_pre[hIndex].func;
+ preHookFunc(src, target, skill_id, skill_lv, damage, div, left, weapon);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.battle.calc_masteryfix_unknown(src, target, skill_id, skill_lv, damage, div, left, weapon);
+ }
+ if( HPMHooks.count.HP_battle_calc_masteryfix_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_unknown_post[hIndex].func;
+ postHookFunc(src, target, skill_id, skill_lv, damage, div, left, weapon);
+ }
+ }
+ return;
+}
+void HP_battle_calc_skillratio_magic_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_magic_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.battle.calc_skillratio_magic_unknown(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ if( HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_magic_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ }
+ return;
+}
+void HP_battle_calc_skillratio_weapon_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_weapon_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.battle.calc_skillratio_weapon_unknown(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ if( HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_weapon_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+ }
+ }
+ return;
+}
+void HP_battle_calc_misc_attack_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_unknown_pre[hIndex].func;
+ preHookFunc(src, target, skill_id, skill_lv, mflag, md);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.battle.calc_misc_attack_unknown(src, target, skill_id, skill_lv, mflag, md);
+ }
+ if( HPMHooks.count.HP_battle_calc_misc_attack_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_unknown_post[hIndex].func;
+ postHookFunc(src, target, skill_id, skill_lv, mflag, md);
+ }
+ }
+ return;
+}
/* bg */
void HP_bg_init(bool minimal) {
int hIndex = 0;
@@ -63364,6 +63468,854 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) {
}
return retVal___;
}
+bool HP_skill_castend_damage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_damage_id_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_damage_id_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag, tstatus, sc);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_damage_id_unknown(src, bl, skill_id, skill_lv, tick, flag, tstatus, sc);
+ }
+ if( HPMHooks.count.HP_skill_castend_damage_id_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_damage_id_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag, tstatus, sc);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_additional_effect_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_additional_effect_unknown_pre[hIndex].func;
+ preHookFunc(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.additional_effect_unknown(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
+ }
+ if( HPMHooks.count.HP_skill_additional_effect_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_additional_effect_unknown_post[hIndex].func;
+ postHookFunc(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
+ }
+ }
+ return;
+}
+void HP_skill_counter_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_counter_additional_effect_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_unknown_pre[hIndex].func;
+ preHookFunc(src, bl, skill_id, skill_lv, attack_type, tick);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.counter_additional_effect_unknown(src, bl, skill_id, skill_lv, attack_type, tick);
+ }
+ if( HPMHooks.count.HP_skill_counter_additional_effect_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_unknown_post[hIndex].func;
+ postHookFunc(src, bl, skill_id, skill_lv, attack_type, tick);
+ }
+ }
+ return;
+}
+void HP_skill_attack_combo1_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_attack_combo1_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo1_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_combo1_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.attack_combo1_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo);
+ }
+ if( HPMHooks.count.HP_skill_attack_combo1_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo1_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_combo1_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo);
+ }
+ }
+ return;
+}
+void HP_skill_attack_combo2_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_attack_combo2_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo2_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_combo2_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.attack_combo2_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo);
+ }
+ if( HPMHooks.count.HP_skill_attack_combo2_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo2_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_combo2_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo);
+ }
+ }
+ return;
+}
+void HP_skill_attack_display_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_attack_display_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_display_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_display_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.attack_display_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage);
+ }
+ if( HPMHooks.count.HP_skill_attack_display_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_display_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_display_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage);
+ }
+ }
+ return;
+}
+int HP_skill_attack_copy_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_attack_copy_unknown_pre ) {
+ int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_copy_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_copy_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.attack_copy_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_attack_copy_unknown_post ) {
+ int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_copy_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_copy_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+int HP_skill_attack_dir_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_attack_dir_unknown_pre ) {
+ int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_dir_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_dir_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.attack_dir_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_attack_dir_unknown_post ) {
+ int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_dir_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_dir_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_attack_blow_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_attack_blow_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_blow_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_blow_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.attack_blow_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir);
+ }
+ if( HPMHooks.count.HP_skill_attack_blow_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_blow_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_blow_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir);
+ }
+ }
+ return;
+}
+void HP_skill_attack_post_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_attack_post_unknown_pre ) {
+ void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_attack_post_unknown_pre[hIndex].func;
+ preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.attack_post_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_attack_post_unknown_post ) {
+ void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_attack_post_unknown_post[hIndex].func;
+ postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return;
+}
+bool HP_skill_timerskill_dead_unknown(struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_timerskill_dead_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_dead_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_timerskill_dead_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, ud, skl);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.timerskill_dead_unknown(src, ud, skl);
+ }
+ if( HPMHooks.count.HP_skill_timerskill_dead_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_dead_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_timerskill_dead_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, ud, skl);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_timerskill_target_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_timerskill_target_unknown_pre ) {
+ void (*preHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_pre[hIndex].func;
+ preHookFunc(&tid, &tick, src, target, ud, skl);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.timerskill_target_unknown(tid, tick, src, target, ud, skl);
+ }
+ if( HPMHooks.count.HP_skill_timerskill_target_unknown_post ) {
+ void (*postHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_post[hIndex].func;
+ postHookFunc(&tid, &tick, src, target, ud, skl);
+ }
+ }
+ return;
+}
+void HP_skill_timerskill_notarget_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre ) {
+ void (*preHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_pre[hIndex].func;
+ preHookFunc(&tid, &tick, src, target, ud, skl);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.timerskill_notarget_unknown(tid, tick, src, target, ud, skl);
+ }
+ if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_post ) {
+ void (*postHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_post[hIndex].func;
+ postHookFunc(&tid, &tick, src, target, ud, skl);
+ }
+ }
+ return;
+}
+void HP_skill_cleartimerskill_unknown(int skill_id) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_cleartimerskill_unknown_pre ) {
+ void (*preHookFunc) (int *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_unknown_pre[hIndex].func;
+ preHookFunc(&skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.cleartimerskill_unknown(skill_id);
+ }
+ if( HPMHooks.count.HP_skill_cleartimerskill_unknown_post ) {
+ void (*postHookFunc) (int *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_unknown_post[hIndex].func;
+ postHookFunc(&skill_id);
+ }
+ }
+ return;
+}
+bool HP_skill_castend_id_unknown(struct unit_data *ud, struct block_list *src, struct block_list *target) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_id_unknown_pre ) {
+ bool (*preHookFunc) (struct unit_data *ud, struct block_list *src, struct block_list *target);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_id_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(ud, src, target);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_id_unknown(ud, src, target);
+ }
+ if( HPMHooks.count.HP_skill_castend_id_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct unit_data *ud, struct block_list *src, struct block_list *target);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_id_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, ud, src, target);
+ }
+ }
+ return retVal___;
+}
+bool HP_skill_castend_nodamage_id_dead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_dead_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_nodamage_id_dead_unknown(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_dead_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+bool HP_skill_castend_nodamage_id_undead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_undead_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_nodamage_id_undead_unknown(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_undead_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+bool HP_skill_castend_nodamage_id_mado_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_mado_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_nodamage_id_mado_unknown(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_mado_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+bool HP_skill_castend_nodamage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_nodamage_id_unknown(src, bl, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_nodamage_id_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_castend_pos2_effect_unknown(struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_castend_pos2_effect_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_effect_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_pos2_effect_unknown_pre[hIndex].func;
+ preHookFunc(src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.castend_pos2_effect_unknown(src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_pos2_effect_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_effect_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_pos2_effect_unknown_post[hIndex].func;
+ postHookFunc(src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return;
+}
+bool HP_skill_castend_pos2_unknown(struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_castend_pos2_unknown_pre ) {
+ bool (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_castend_pos2_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.castend_pos2_unknown(src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ if( HPMHooks.count.HP_skill_castend_pos2_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_castend_pos2_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, src, x, y, skill_id, skill_lv, tick, flag);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_unitsetting1_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_unitsetting1_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting1_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_unitsetting1_unknown_pre[hIndex].func;
+ preHookFunc(src, skill_id, skill_lv, x, y, flag, val1, val2, val3);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.unitsetting1_unknown(src, skill_id, skill_lv, x, y, flag, val1, val2, val3);
+ }
+ if( HPMHooks.count.HP_skill_unitsetting1_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting1_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_unitsetting1_unknown_post[hIndex].func;
+ postHookFunc(src, skill_id, skill_lv, x, y, flag, val1, val2, val3);
+ }
+ }
+ return;
+}
+void HP_skill_unitsetting2_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_unitsetting2_unknown_pre ) {
+ void (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting2_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_unitsetting2_unknown_pre[hIndex].func;
+ preHookFunc(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.unitsetting2_unknown(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group);
+ }
+ if( HPMHooks.count.HP_skill_unitsetting2_unknown_post ) {
+ void (*postHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting2_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_unitsetting2_unknown_post[hIndex].func;
+ postHookFunc(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group);
+ }
+ }
+ return;
+}
+void HP_skill_unit_onplace_unknown(struct skill_unit *src, struct block_list *bl, int64 *tick) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_unit_onplace_unknown_pre ) {
+ void (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_unit_onplace_unknown_pre[hIndex].func;
+ preHookFunc(src, bl, tick);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.unit_onplace_unknown(src, bl, tick);
+ }
+ if( HPMHooks.count.HP_skill_unit_onplace_unknown_post ) {
+ void (*postHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_unit_onplace_unknown_post[hIndex].func;
+ postHookFunc(src, bl, tick);
+ }
+ }
+ return;
+}
+int HP_skill_check_condition_castbegin_off_unknown(struct status_change *sc, uint16 *skill_id) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre ) {
+ int (*preHookFunc) (struct status_change *sc, uint16 *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_off_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.check_condition_castbegin_off_unknown(sc, skill_id);
+ }
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_post ) {
+ int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_off_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, skill_id);
+ }
+ }
+ return retVal___;
+}
+int HP_skill_check_condition_castbegin_mount_unknown(struct status_change *sc, uint16 *skill_id) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre ) {
+ int (*preHookFunc) (struct status_change *sc, uint16 *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_mount_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.check_condition_castbegin_mount_unknown(sc, skill_id);
+ }
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_post ) {
+ int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_mount_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, skill_id);
+ }
+ }
+ return retVal___;
+}
+int HP_skill_check_condition_castbegin_madogear_unknown(struct status_change *sc, uint16 *skill_id) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre ) {
+ int (*preHookFunc) (struct status_change *sc, uint16 *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_madogear_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.check_condition_castbegin_madogear_unknown(sc, skill_id);
+ }
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_post ) {
+ int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_madogear_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, skill_id);
+ }
+ }
+ return retVal___;
+}
+int HP_skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 *skill_id) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre ) {
+ int (*preHookFunc) (struct status_change *sc, uint16 *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.check_condition_castbegin_unknown(sc, skill_id);
+ }
+ if( HPMHooks.count.HP_skill_check_condition_castbegin_unknown_post ) {
+ int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, skill_id);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_check_condition_castend_unknown(struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_check_condition_castend_unknown_pre ) {
+ void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_check_condition_castend_unknown_pre[hIndex].func;
+ preHookFunc(sd, skill_id, skill_lv);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.check_condition_castend_unknown(sd, skill_id, skill_lv);
+ }
+ if( HPMHooks.count.HP_skill_check_condition_castend_unknown_post ) {
+ void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_check_condition_castend_unknown_post[hIndex].func;
+ postHookFunc(sd, skill_id, skill_lv);
+ }
+ }
+ return;
+}
+bool HP_skill_get_requirement_off_unknown(struct status_change *sc, uint16 *skill_id) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if( HPMHooks.count.HP_skill_get_requirement_off_unknown_pre ) {
+ bool (*preHookFunc) (struct status_change *sc, uint16 *skill_id);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_off_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_get_requirement_off_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, skill_id);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.get_requirement_off_unknown(sc, skill_id);
+ }
+ if( HPMHooks.count.HP_skill_get_requirement_off_unknown_post ) {
+ bool (*postHookFunc) (bool retVal___, struct status_change *sc, uint16 *skill_id);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_off_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_get_requirement_off_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, skill_id);
+ }
+ }
+ return retVal___;
+}
+int HP_skill_get_requirement_item_unknown(struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if( HPMHooks.count.HP_skill_get_requirement_item_unknown_pre ) {
+ int (*preHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_item_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_get_requirement_item_unknown_pre[hIndex].func;
+ retVal___ = preHookFunc(sc, sd, skill_id, skill_lv, idx, i);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.skill.get_requirement_item_unknown(sc, sd, skill_id, skill_lv, idx, i);
+ }
+ if( HPMHooks.count.HP_skill_get_requirement_item_unknown_post ) {
+ int (*postHookFunc) (int retVal___, struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_item_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_get_requirement_item_unknown_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sc, sd, skill_id, skill_lv, idx, i);
+ }
+ }
+ return retVal___;
+}
+void HP_skill_get_requirement_unknown(struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req) {
+ int hIndex = 0;
+ if( HPMHooks.count.HP_skill_get_requirement_unknown_pre ) {
+ void (*preHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req);
+ *HPMforce_return = false;
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_unknown_pre; hIndex++ ) {
+ preHookFunc = HPMHooks.list.HP_skill_get_requirement_unknown_pre[hIndex].func;
+ preHookFunc(sc, sd, skill_id, skill_lv, req);
+ }
+ if( *HPMforce_return ) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.skill.get_requirement_unknown(sc, sd, skill_id, skill_lv, req);
+ }
+ if( HPMHooks.count.HP_skill_get_requirement_unknown_post ) {
+ void (*postHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req);
+ for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_unknown_post; hIndex++ ) {
+ postHookFunc = HPMHooks.list.HP_skill_get_requirement_unknown_post[hIndex].func;
+ postHookFunc(sc, sd, skill_id, skill_lv, req);
+ }
+ }
+ return;
+}
/* status */
int HP_status_init(bool minimal) {
int hIndex = 0;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-12-29 19:28:56 +0000