summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorHaru <haru@dotalux.com>2018-04-25 17:26:24 +0200
committerGitHub <noreply@github.com>2018-04-25 17:26:24 +0200
commita4df55e940057e2882a4b01dd1471c73af70e2bd (patch)
treec4fba2860de8dd7dc59c98fee61c2213478d95d6
parent611c7db42af28fad06a2b2e56c327403d9af3d6f (diff)
parent296eb152a9b870a7615c3c7dbeb2ebe48551d1ce (diff)
downloadhercules-a4df55e940057e2882a4b01dd1471c73af70e2bd.tar.gz
hercules-a4df55e940057e2882a4b01dd1471c73af70e2bd.tar.bz2
hercules-a4df55e940057e2882a4b01dd1471c73af70e2bd.tar.xz
hercules-a4df55e940057e2882a4b01dd1471c73af70e2bd.zip
Merge pull request #2022 from 4144/extend
Refactor some functions to move MAPID_* related code into separate functions.
-rw-r--r--src/map/pc.c180
-rw-r--r--src/map/pc.h8
-rw-r--r--src/map/status.c19
-rw-r--r--src/map/status.h1
-rw-r--r--src/plugins/HPMHooking/HPMHooking.Defs.inc18
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc36
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc9
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.Hooks.inc239
8 files changed, 451 insertions, 59 deletions
diff --git a/src/map/pc.c b/src/map/pc.c
index ee1fcd7da..8dd216f55 100644
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -249,11 +249,18 @@ int pc_addspiritball(struct map_session_data *sd,int interval,int max)
memmove(sd->spirit_timer+i+1, sd->spirit_timer+i, (sd->spiritball-i)*sizeof(int));
sd->spirit_timer[i] = tid;
sd->spiritball++;
+ pc->addspiritball_sub(sd);
+
+ return 0;
+}
+
+int pc_addspiritball_sub(struct map_session_data *sd)
+{
+ nullpo_ret(sd);
if ((sd->job & MAPID_THIRDMASK) == MAPID_ROYAL_GUARD)
clif->millenniumshield(&sd->bl,sd->spiritball);
else
clif->spiritball(&sd->bl);
-
return 0;
}
@@ -287,14 +294,22 @@ int pc_delspiritball(struct map_session_data *sd,int count,int type)
sd->spirit_timer[i] = INVALID_TIMER;
}
- if(!type) {
- if ((sd->job & MAPID_THIRDMASK) == MAPID_ROYAL_GUARD)
- clif->millenniumshield(&sd->bl,sd->spiritball);
- else
- clif->spiritball(&sd->bl);
+ if (!type) {
+ pc->delspiritball_sub(sd);
}
return 0;
}
+
+int pc_delspiritball_sub(struct map_session_data *sd)
+{
+ nullpo_ret(sd);
+ if ((sd->job & MAPID_THIRDMASK) == MAPID_ROYAL_GUARD)
+ clif->millenniumshield(&sd->bl,sd->spiritball);
+ else
+ clif->spiritball(&sd->bl);
+ return 0;
+}
+
int pc_check_banding(struct block_list *bl, va_list ap)
{
int *c, *b_sd;
@@ -1586,6 +1601,30 @@ int pc_calc_skillpoint(struct map_session_data* sd) {
return skill_point;
}
+void pc_calc_skilltree_clear(struct map_session_data *sd)
+{
+ int i;
+
+ nullpo_retv(sd);
+
+ for (i = 0; i < MAX_SKILL_DB; i++) {
+ if (sd->status.skill[i].flag != SKILL_FLAG_PLAGIARIZED && sd->status.skill[i].flag != SKILL_FLAG_PERM_GRANTED) //Don't touch these
+ sd->status.skill[i].id = 0; //First clear skills.
+ /* permanent skills that must be re-checked */
+ if (sd->status.skill[i].flag == SKILL_FLAG_PERMANENT) {
+ switch (skill->dbs->db[i].nameid) {
+ case NV_TRICKDEAD:
+ if ((sd->job & MAPID_UPPERMASK) != MAPID_NOVICE) {
+ sd->status.skill[i].id = 0;
+ sd->status.skill[i].lv = 0;
+ sd->status.skill[i].flag = 0;
+ }
+ break;
+ }
+ }
+ }
+}
+
/*==========================================
* Calculation of skill level.
*------------------------------------------*/
@@ -1604,22 +1643,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
}
classidx = pc->class2idx(class);
- for (i = 0; i < MAX_SKILL_DB; i++) {
- if( sd->status.skill[i].flag != SKILL_FLAG_PLAGIARIZED && sd->status.skill[i].flag != SKILL_FLAG_PERM_GRANTED ) //Don't touch these
- sd->status.skill[i].id = 0; //First clear skills.
- /* permanent skills that must be re-checked */
- if( sd->status.skill[i].flag == SKILL_FLAG_PERMANENT ) {
- switch( skill->dbs->db[i].nameid ) {
- case NV_TRICKDEAD:
- if ((sd->job & MAPID_UPPERMASK) != MAPID_NOVICE) {
- sd->status.skill[i].id = 0;
- sd->status.skill[i].lv = 0;
- sd->status.skill[i].flag = 0;
- }
- break;
- }
- }
- }
+ pc->calc_skilltree_clear(sd);
for (i = 0; i < MAX_SKILL_DB; i++) {
if( sd->status.skill[i].flag != SKILL_FLAG_PERMANENT && sd->status.skill[i].flag != SKILL_FLAG_PERM_GRANTED && sd->status.skill[i].flag != SKILL_FLAG_PLAGIARIZED )
@@ -1746,6 +1770,19 @@ int pc_calc_skilltree(struct map_session_data *sd)
}
} while(flag);
+ pc->calc_skilltree_bonus(sd, classidx);
+
+ return 0;
+}
+
+void pc_calc_skilltree_bonus(struct map_session_data *sd, int classidx)
+{
+ int i;
+ int id = 0;
+
+ nullpo_retv(sd);
+ Assert_retv(classidx >= 0 && classidx < CLASS_COUNT);
+
//
if (classidx > 0 && (sd->job & MAPID_UPPERMASK) == MAPID_TAEKWON
&& sd->status.base_level >= 90 && sd->status.skill_point == 0
@@ -1771,8 +1808,6 @@ int pc_calc_skilltree(struct map_session_data *sd)
sd->status.skill[idx].lv = skill->tree_get_max(id, sd->status.class);
}
}
-
- return 0;
}
//Checks if you can learn a new skill after having leveled up a skill.
@@ -6788,18 +6823,7 @@ int pc_checkbaselevelup(struct map_session_data *sd)
status_calc_pc(sd,SCO_FORCE);
status_percent_heal(&sd->bl,100,100);
- if ((sd->job & MAPID_UPPERMASK) == MAPID_SUPER_NOVICE) {
- sc_start(NULL,&sd->bl,status->skill2sc(PR_KYRIE),100,1,skill->get_time(PR_KYRIE,1));
- sc_start(NULL,&sd->bl,status->skill2sc(PR_IMPOSITIO),100,1,skill->get_time(PR_IMPOSITIO,1));
- sc_start(NULL,&sd->bl,status->skill2sc(PR_MAGNIFICAT),100,1,skill->get_time(PR_MAGNIFICAT,1));
- sc_start(NULL,&sd->bl,status->skill2sc(PR_GLORIA),100,1,skill->get_time(PR_GLORIA,1));
- sc_start(NULL,&sd->bl,status->skill2sc(PR_SUFFRAGIUM),100,1,skill->get_time(PR_SUFFRAGIUM,1));
- if (sd->state.snovice_dead_flag)
- sd->state.snovice_dead_flag = 0; //Reenable steelbody resurrection on dead.
- } else if ((sd->job & MAPID_BASEMASK) == MAPID_TAEKWON) {
- sc_start(NULL,&sd->bl,status->skill2sc(AL_INCAGI),100,10,600000);
- sc_start(NULL,&sd->bl,status->skill2sc(AL_BLESSING),100,10,600000);
- }
+ pc->checkbaselevelup_sc(sd);
clif->misceffect(&sd->bl,0);
npc->script_event(sd, NPCE_BASELVUP); //LORDALFA - LVLUPEVENT
@@ -6810,6 +6834,24 @@ int pc_checkbaselevelup(struct map_session_data *sd)
return 1;
}
+void pc_checkbaselevelup_sc(struct map_session_data *sd)
+{
+ nullpo_retv(sd);
+
+ if ((sd->job & MAPID_UPPERMASK) == MAPID_SUPER_NOVICE) {
+ sc_start(NULL, &sd->bl, status->skill2sc(PR_KYRIE), 100, 1, skill->get_time(PR_KYRIE, 1));
+ sc_start(NULL, &sd->bl, status->skill2sc(PR_IMPOSITIO), 100, 1, skill->get_time(PR_IMPOSITIO, 1));
+ sc_start(NULL, &sd->bl, status->skill2sc(PR_MAGNIFICAT), 100, 1, skill->get_time(PR_MAGNIFICAT, 1));
+ sc_start(NULL, &sd->bl, status->skill2sc(PR_GLORIA), 100, 1, skill->get_time(PR_GLORIA, 1));
+ sc_start(NULL, &sd->bl, status->skill2sc(PR_SUFFRAGIUM), 100, 1, skill->get_time(PR_SUFFRAGIUM, 1));
+ if (sd->state.snovice_dead_flag)
+ sd->state.snovice_dead_flag = 0; //Reenable steelbody resurrection on dead.
+ } else if ((sd->job & MAPID_BASEMASK) == MAPID_TAEKWON) {
+ sc_start(NULL, &sd->bl, status->skill2sc(AL_INCAGI), 100, 10, 600000);
+ sc_start(NULL, &sd->bl, status->skill2sc(AL_BLESSING), 100, 10, 600000);
+ }
+}
+
void pc_baselevelchanged(struct map_session_data *sd) {
int i;
nullpo_retv(sd);
@@ -7597,7 +7639,6 @@ int pc_resetskill(struct map_session_data* sd, int flag)
}
for (i = 1; i < MAX_SKILL_DB; i++) {
- uint16 skill_id = 0;
int lv = sd->status.skill[i].lv;
if (lv < 1) continue;
@@ -7606,19 +7647,7 @@ int pc_resetskill(struct map_session_data* sd, int flag)
if( inf2&(INF2_WEDDING_SKILL|INF2_SPIRIT_SKILL) ) //Avoid reseting wedding/linker skills.
continue;
- skill_id = skill->dbs->db[i].nameid;
-
- // Don't reset trick dead if not a novice/baby
- if (skill_id == NV_TRICKDEAD && (sd->job & MAPID_UPPERMASK) != MAPID_NOVICE) {
- sd->status.skill[i].lv = 0;
- sd->status.skill[i].flag = 0;
- continue;
- }
-
- // do not reset basic skill
- if (skill_id == NV_BASIC && (sd->job & MAPID_UPPERMASK) != MAPID_NOVICE)
- continue;
- if (skill_id == SU_BASIC_SKILL && (sd->job & MAPID_BASEMASK) != MAPID_SUMMONER)
+ if (pc->resetskill_job(sd, i))
continue;
if( sd->status.skill[i].flag == SKILL_FLAG_PERM_GRANTED )
@@ -7673,6 +7702,30 @@ int pc_resetskill(struct map_session_data* sd, int flag)
return skill_point;
}
+bool pc_resetskill_job(struct map_session_data* sd, int index)
+{
+ uint16 skill_id;
+
+ nullpo_retr(false, sd);
+ Assert_retr(false, index >= 0 && index < MAX_SKILL_DB);
+
+ skill_id = skill->dbs->db[index].nameid;
+
+ // Don't reset trick dead if not a novice/baby
+ if (skill_id == NV_TRICKDEAD && (sd->job & MAPID_UPPERMASK) != MAPID_NOVICE) {
+ sd->status.skill[index].lv = 0;
+ sd->status.skill[index].flag = 0;
+ return true;
+ }
+
+ // do not reset basic skill
+ if (skill_id == NV_BASIC && (sd->job & MAPID_UPPERMASK) != MAPID_NOVICE)
+ return true;
+ if (skill_id == SU_BASIC_SKILL && (sd->job & MAPID_BASEMASK) != MAPID_SUMMONER)
+ return true;
+ return false;
+}
+
/*==========================================
* /resetfeel [Komurka]
*------------------------------------------*/
@@ -8035,8 +8088,8 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) {
}
// changed penalty options, added death by player if pk_mode [Valaris]
- if( battle_config.death_penalty_type
- && (sd->job & MAPID_UPPERMASK) != MAPID_NOVICE // only novices will receive no penalty
+ if (battle_config.death_penalty_type
+ && pc->isDeathPenaltyJob(sd->job)
&& !map->list[sd->bl.m].flag.noexppenalty && !map_flag_gvg2(sd->bl.m)
&& !sd->sc.data[SC_BABY] && !sd->sc.data[SC_CASH_DEATHPENALTY]
) {
@@ -8184,6 +8237,11 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) {
return 1;
}
+bool pc_isDeathPenaltyJob(uint16 job)
+{
+ return (job & MAPID_UPPERMASK) != MAPID_NOVICE; // only novices will receive no penalty
+}
+
void pc_revive(struct map_session_data *sd,unsigned int hp, unsigned int sp) {
nullpo_retv(sd);
if(hp) clif->updatestatus(sd,SP_HP);
@@ -11077,6 +11135,11 @@ int pc_split_atoui64(char* str, uint64* val, char sep, int max)
return i;
}
+bool pc_read_skill_job_skip(short skill_id, int job_id)
+{
+ return skill_id == NV_TRICKDEAD && ((pc->jobid2mapid(job_id) & (MAPID_BASEMASK | JOBL_2)) != MAPID_NOVICE); // skip trickdead for non-novices
+}
+
/**
* Parses the skill tree config file.
*
@@ -11157,8 +11220,8 @@ void pc_read_skill_tree(void)
ShowWarning("pc_read_skill_tree: '%s' can't inherit '%s', skill tree is full!\n", job_name, ijob_name);
break;
}
- if (src->id == NV_TRICKDEAD && ((pc->jobid2mapid(job_id)&(MAPID_BASEMASK | JOBL_2)) != MAPID_NOVICE))
- continue; // skip trickdead for non-novices
+ if (pc->read_skill_job_skip(src->id, job_id))
+ continue;
dst = &pc->skill_tree[job_idx][cur];
dst->inherited = 1;
if (dst->id == 0) {
@@ -12211,6 +12274,8 @@ void pc_defaults(void) {
pc->checkequip = pc_checkequip;
pc->calc_skilltree = pc_calc_skilltree;
+ pc->calc_skilltree_bonus = pc_calc_skilltree_bonus;
+ pc->calc_skilltree_clear = pc_calc_skilltree_clear;
pc->calc_skilltree_normalize_job = pc_calc_skilltree_normalize_job;
pc->clean_skilltree = pc_clean_skilltree;
@@ -12273,6 +12338,7 @@ void pc_defaults(void) {
pc->maxbaselv = pc_maxbaselv;
pc->maxjoblv = pc_maxjoblv;
pc->checkbaselevelup = pc_checkbaselevelup;
+ pc->checkbaselevelup_sc = pc_checkbaselevelup_sc;
pc->checkjoblevelup = pc_checkjoblevelup;
pc->gainexp = pc_gainexp;
pc->nextbaseexp = pc_nextbaseexp;
@@ -12289,6 +12355,7 @@ void pc_defaults(void) {
pc->resetlvl = pc_resetlvl;
pc->resetstate = pc_resetstate;
pc->resetskill = pc_resetskill;
+ pc->resetskill_job = pc_resetskill_job;
pc->resetfeel = pc_resetfeel;
pc->resethate = pc_resethate;
pc->equipitem = pc_equipitem;
@@ -12363,7 +12430,9 @@ void pc_defaults(void) {
pc->delinvincibletimer = pc_delinvincibletimer;
pc->addspiritball = pc_addspiritball;
+ pc->addspiritball_sub = pc_addspiritball_sub;
pc->delspiritball = pc_delspiritball;
+ pc->delspiritball_sub = pc_delspiritball_sub;
pc->addfame = pc_addfame;
pc->fame_rank = pc_fame_rank;
pc->famelist_type = pc_famelist_type;
@@ -12417,6 +12486,7 @@ void pc_defaults(void) {
pc->autosave = pc_autosave;
pc->follow_timer = pc_follow_timer;
pc->read_skill_tree = pc_read_skill_tree;
+ pc->read_skill_job_skip = pc_read_skill_job_skip;
pc->clear_skill_tree = pc_clear_skill_tree;
pc->isUseitem = pc_isUseitem;
pc->show_steal = pc_show_steal;
@@ -12458,4 +12528,6 @@ void pc_defaults(void) {
pc->have_magnifier = pc_have_magnifier;
pc->check_basicskill = pc_check_basicskill;
+
+ pc->isDeathPenaltyJob = pc_isDeathPenaltyJob;
}
diff --git a/src/map/pc.h b/src/map/pc.h
index e699e5750..49c102206 100644
--- a/src/map/pc.h
+++ b/src/map/pc.h
@@ -889,6 +889,8 @@ END_ZEROED_BLOCK; /* End */
int (*checkequip) (struct map_session_data *sd,int pos);
int (*calc_skilltree) (struct map_session_data *sd);
+ void (*calc_skilltree_clear) (struct map_session_data *sd);
+ void (*calc_skilltree_bonus) (struct map_session_data *sd, int classidx);
int (*calc_skilltree_normalize_job) (struct map_session_data *sd);
int (*clean_skilltree) (struct map_session_data *sd);
@@ -952,6 +954,7 @@ END_ZEROED_BLOCK; /* End */
int (*maxbaselv) (const struct map_session_data *sd);
int (*maxjoblv) (const struct map_session_data *sd);
int (*checkbaselevelup) (struct map_session_data *sd);
+ void (*checkbaselevelup_sc) (struct map_session_data *sd);
int (*checkjoblevelup) (struct map_session_data *sd);
bool (*gainexp) (struct map_session_data *sd, struct block_list *src, uint64 base_exp, uint64 job_exp, bool is_quest);
uint64 (*nextbaseexp) (const struct map_session_data *sd);
@@ -968,6 +971,7 @@ END_ZEROED_BLOCK; /* End */
int (*resetlvl) (struct map_session_data *sd,int type);
int (*resetstate) (struct map_session_data *sd);
int (*resetskill) (struct map_session_data *sd, int flag);
+ bool (*resetskill_job) (struct map_session_data *sd, int index);
int (*resetfeel) (struct map_session_data *sd);
int (*resethate) (struct map_session_data *sd);
int (*equipitem) (struct map_session_data *sd,int n,int req_pos);
@@ -1040,7 +1044,9 @@ END_ZEROED_BLOCK; /* End */
void (*delinvincibletimer) (struct map_session_data* sd);
int (*addspiritball) (struct map_session_data *sd,int interval,int max);
+ int (*addspiritball_sub) (struct map_session_data *sd);
int (*delspiritball) (struct map_session_data *sd,int count,int type);
+ int (*delspiritball_sub) (struct map_session_data *sd);
int (*getmaxspiritball) (struct map_session_data *sd, int min);
void (*addfame) (struct map_session_data *sd, int ranktype, int count);
int (*fame_rank) (int char_id, int ranktype);
@@ -1095,6 +1101,7 @@ END_ZEROED_BLOCK; /* End */
int (*autosave) (int tid, int64 tick, int id, intptr_t data);
int (*follow_timer) (int tid, int64 tick, int id, intptr_t data);
void (*read_skill_tree) (void);
+ bool (*read_skill_job_skip) (short skill_id, int job_id);
void (*clear_skill_tree) (void);
int (*isUseitem) (struct map_session_data *sd,int n);
int (*show_steal) (struct block_list *bl,va_list ap);
@@ -1137,6 +1144,7 @@ END_ZEROED_BLOCK; /* End */
bool (*process_chat_message) (struct map_session_data *sd, const char *message);
void (*check_supernovice_call) (struct map_session_data *sd, const char *message);
bool (*check_basicskill) (struct map_session_data *sd, int level);
+ bool (*isDeathPenaltyJob) (uint16 job);
};
#ifdef HERCULES_CORE
diff --git a/src/map/status.c b/src/map/status.c
index a39449b11..972d1eca9 100644
--- a/src/map/status.c
+++ b/src/map/status.c
@@ -2333,6 +2333,18 @@ void status_calc_pc_additional(struct map_session_data* sd, enum e_status_calc_o
return;
}
+void status_calc_pc_recover_hp(struct map_session_data* sd, struct status_data *bstatus)
+{
+ nullpo_retv(sd);
+ nullpo_retv(bstatus);
+
+ if ((sd->job & MAPID_BASEMASK) == MAPID_NOVICE && (sd->job & JOBL_2) == 0
+ && battle_config.restart_hp_rate < 50)
+ bstatus->hp = bstatus->max_hp>>1;
+ else
+ bstatus->hp = APPLY_RATE(bstatus->max_hp, battle_config.restart_hp_rate);
+}
+
//Calculates player data from scratch without counting SC adjustments.
//Should be invoked whenever players raise stats, learn passive skills or change equipment.
int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt)
@@ -2874,11 +2886,7 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt)
bstatus->hp = bstatus->max_hp;
bstatus->sp = bstatus->max_sp;
} else {
- if ((sd->job & MAPID_BASEMASK) == MAPID_NOVICE && (sd->job & JOBL_2) == 0
- && battle_config.restart_hp_rate < 50)
- bstatus->hp = bstatus->max_hp>>1;
- else
- bstatus->hp = APPLY_RATE(bstatus->max_hp, battle_config.restart_hp_rate);
+ status->calc_pc_recover_hp(sd, bstatus);
if(!bstatus->hp)
bstatus->hp = 1;
@@ -13658,6 +13666,7 @@ void status_defaults(void)
status->calc_pet_ = status_calc_pet_;
status->calc_pc_ = status_calc_pc_;
status->calc_pc_additional = status_calc_pc_additional;
+ status->calc_pc_recover_hp = status_calc_pc_recover_hp;
status->calc_homunculus_ = status_calc_homunculus_;
status->calc_mercenary_ = status_calc_mercenary_;
status->calc_elemental_ = status_calc_elemental_;
diff --git a/src/map/status.h b/src/map/status.h
index 5a031fa48..5df439237 100644
--- a/src/map/status.h
+++ b/src/map/status.h
@@ -2355,6 +2355,7 @@ struct status_interface {
int (*calc_pet_) (struct pet_data* pd, enum e_status_calc_opt opt);
int (*calc_pc_) (struct map_session_data* sd, enum e_status_calc_opt opt);
void (*calc_pc_additional) (struct map_session_data* sd, enum e_status_calc_opt opt);
+ void (*calc_pc_recover_hp) (struct map_session_data* sd, struct status_data *bstatus);
int (*calc_homunculus_) (struct homun_data *hd, enum e_status_calc_opt opt);
int (*calc_mercenary_) (struct mercenary_data *md, enum e_status_calc_opt opt);
int (*calc_elemental_) (struct elemental_data *ed, enum e_status_calc_opt opt);
diff --git a/src/plugins/HPMHooking/HPMHooking.Defs.inc b/src/plugins/HPMHooking/HPMHooking.Defs.inc
index fe95b7074..21c3f76cb 100644
--- a/src/plugins/HPMHooking/HPMHooking.Defs.inc
+++ b/src/plugins/HPMHooking/HPMHooking.Defs.inc
@@ -5558,6 +5558,10 @@ typedef int (*HPMHOOK_pre_pc_checkequip) (struct map_session_data **sd, int *pos
typedef int (*HPMHOOK_post_pc_checkequip) (int retVal___, struct map_session_data *sd, int pos);
typedef int (*HPMHOOK_pre_pc_calc_skilltree) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_calc_skilltree) (int retVal___, struct map_session_data *sd);
+typedef void (*HPMHOOK_pre_pc_calc_skilltree_clear) (struct map_session_data **sd);
+typedef void (*HPMHOOK_post_pc_calc_skilltree_clear) (struct map_session_data *sd);
+typedef void (*HPMHOOK_pre_pc_calc_skilltree_bonus) (struct map_session_data **sd, int *classidx);
+typedef void (*HPMHOOK_post_pc_calc_skilltree_bonus) (struct map_session_data *sd, int classidx);
typedef int (*HPMHOOK_pre_pc_calc_skilltree_normalize_job) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_calc_skilltree_normalize_job) (int retVal___, struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_clean_skilltree) (struct map_session_data **sd);
@@ -5654,6 +5658,8 @@ typedef int (*HPMHOOK_pre_pc_maxjoblv) (const struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_maxjoblv) (int retVal___, const struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_checkbaselevelup) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_checkbaselevelup) (int retVal___, struct map_session_data *sd);
+typedef void (*HPMHOOK_pre_pc_checkbaselevelup_sc) (struct map_session_data **sd);
+typedef void (*HPMHOOK_post_pc_checkbaselevelup_sc) (struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_checkjoblevelup) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_checkjoblevelup) (int retVal___, struct map_session_data *sd);
typedef bool (*HPMHOOK_pre_pc_gainexp) (struct map_session_data **sd, struct block_list **src, uint64 *base_exp, uint64 *job_exp, bool *is_quest);
@@ -5686,6 +5692,8 @@ typedef int (*HPMHOOK_pre_pc_resetstate) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_resetstate) (int retVal___, struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_resetskill) (struct map_session_data **sd, int *flag);
typedef int (*HPMHOOK_post_pc_resetskill) (int retVal___, struct map_session_data *sd, int flag);
+typedef bool (*HPMHOOK_pre_pc_resetskill_job) (struct map_session_data **sd, int *index);
+typedef bool (*HPMHOOK_post_pc_resetskill_job) (bool retVal___, struct map_session_data *sd, int index);
typedef int (*HPMHOOK_pre_pc_resetfeel) (struct map_session_data **sd);
typedef int (*HPMHOOK_post_pc_resetfeel) (int retVal___, struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_resethate) (struct map_session_data **sd);
@@ -5806,8 +5814,12 @@ typedef void (*HPMHOOK_pre_pc_delinvincibletimer) (struct map_session_data **sd)
typedef void (*HPMHOOK_post_pc_delinvincibletimer) (struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_addspiritball) (struct map_session_data **sd, int *interval, int *max);
typedef int (*HPMHOOK_post_pc_addspiritball) (int retVal___, struct map_session_data *sd, int interval, int max);
+typedef int (*HPMHOOK_pre_pc_addspiritball_sub) (struct map_session_data **sd);
+typedef int (*HPMHOOK_post_pc_addspiritball_sub) (int retVal___, struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_delspiritball) (struct map_session_data **sd, int *count, int *type);
typedef int (*HPMHOOK_post_pc_delspiritball) (int retVal___, struct map_session_data *sd, int count, int type);
+typedef int (*HPMHOOK_pre_pc_delspiritball_sub) (struct map_session_data **sd);
+typedef int (*HPMHOOK_post_pc_delspiritball_sub) (int retVal___, struct map_session_data *sd);
typedef int (*HPMHOOK_pre_pc_getmaxspiritball) (struct map_session_data **sd, int *min);
typedef int (*HPMHOOK_post_pc_getmaxspiritball) (int retVal___, struct map_session_data *sd, int min);
typedef void (*HPMHOOK_pre_pc_addfame) (struct map_session_data **sd, int *ranktype, int *count);
@@ -5896,6 +5908,8 @@ typedef int (*HPMHOOK_pre_pc_follow_timer) (int *tid, int64 *tick, int *id, intp
typedef int (*HPMHOOK_post_pc_follow_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data);
typedef void (*HPMHOOK_pre_pc_read_skill_tree) (void);
typedef void (*HPMHOOK_post_pc_read_skill_tree) (void);
+typedef bool (*HPMHOOK_pre_pc_read_skill_job_skip) (short *skill_id, int *job_id);
+typedef bool (*HPMHOOK_post_pc_read_skill_job_skip) (bool retVal___, short skill_id, int job_id);
typedef void (*HPMHOOK_pre_pc_clear_skill_tree) (void);
typedef void (*HPMHOOK_post_pc_clear_skill_tree) (void);
typedef int (*HPMHOOK_pre_pc_isUseitem) (struct map_session_data **sd, int *n);
@@ -5954,6 +5968,8 @@ typedef void (*HPMHOOK_pre_pc_check_supernovice_call) (struct map_session_data *
typedef void (*HPMHOOK_post_pc_check_supernovice_call) (struct map_session_data *sd, const char *message);
typedef bool (*HPMHOOK_pre_pc_check_basicskill) (struct map_session_data **sd, int *level);
typedef bool (*HPMHOOK_post_pc_check_basicskill) (bool retVal___, struct map_session_data *sd, int level);
+typedef bool (*HPMHOOK_pre_pc_isDeathPenaltyJob) (uint16 *job);
+typedef bool (*HPMHOOK_post_pc_isDeathPenaltyJob) (bool retVal___, uint16 job);
#endif // MAP_PC_H
#ifdef MAP_NPC_H /* libpcre */
typedef pcre* (*HPMHOOK_pre_libpcre_compile) (const char **pattern, int *options, const char ***errptr, int **erroffset, const unsigned char **tableptr);
@@ -7304,6 +7320,8 @@ typedef int (*HPMHOOK_pre_status_calc_pc_) (struct map_session_data **sd, enum e
typedef int (*HPMHOOK_post_status_calc_pc_) (int retVal___, struct map_session_data *sd, enum e_status_calc_opt opt);
typedef void (*HPMHOOK_pre_status_calc_pc_additional) (struct map_session_data **sd, enum e_status_calc_opt *opt);
typedef void (*HPMHOOK_post_status_calc_pc_additional) (struct map_session_data *sd, enum e_status_calc_opt opt);
+typedef void (*HPMHOOK_pre_status_calc_pc_recover_hp) (struct map_session_data **sd, struct status_data **bstatus);
+typedef void (*HPMHOOK_post_status_calc_pc_recover_hp) (struct map_session_data *sd, struct status_data *bstatus);
typedef int (*HPMHOOK_pre_status_calc_homunculus_) (struct homun_data **hd, enum e_status_calc_opt *opt);
typedef int (*HPMHOOK_post_status_calc_homunculus_) (int retVal___, struct homun_data *hd, enum e_status_calc_opt opt);
typedef int (*HPMHOOK_pre_status_calc_mercenary_) (struct mercenary_data **md, enum e_status_calc_opt *opt);
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
index cbfaf1b65..204749f10 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
@@ -4212,6 +4212,10 @@ struct {
struct HPMHookPoint *HP_pc_checkequip_post;
struct HPMHookPoint *HP_pc_calc_skilltree_pre;
struct HPMHookPoint *HP_pc_calc_skilltree_post;
+ struct HPMHookPoint *HP_pc_calc_skilltree_clear_pre;
+ struct HPMHookPoint *HP_pc_calc_skilltree_clear_post;
+ struct HPMHookPoint *HP_pc_calc_skilltree_bonus_pre;
+ struct HPMHookPoint *HP_pc_calc_skilltree_bonus_post;
struct HPMHookPoint *HP_pc_calc_skilltree_normalize_job_pre;
struct HPMHookPoint *HP_pc_calc_skilltree_normalize_job_post;
struct HPMHookPoint *HP_pc_clean_skilltree_pre;
@@ -4308,6 +4312,8 @@ struct {
struct HPMHookPoint *HP_pc_maxjoblv_post;
struct HPMHookPoint *HP_pc_checkbaselevelup_pre;
struct HPMHookPoint *HP_pc_checkbaselevelup_post;
+ struct HPMHookPoint *HP_pc_checkbaselevelup_sc_pre;
+ struct HPMHookPoint *HP_pc_checkbaselevelup_sc_post;
struct HPMHookPoint *HP_pc_checkjoblevelup_pre;
struct HPMHookPoint *HP_pc_checkjoblevelup_post;
struct HPMHookPoint *HP_pc_gainexp_pre;
@@ -4340,6 +4346,8 @@ struct {
struct HPMHookPoint *HP_pc_resetstate_post;
struct HPMHookPoint *HP_pc_resetskill_pre;
struct HPMHookPoint *HP_pc_resetskill_post;
+ struct HPMHookPoint *HP_pc_resetskill_job_pre;
+ struct HPMHookPoint *HP_pc_resetskill_job_post;
struct HPMHookPoint *HP_pc_resetfeel_pre;
struct HPMHookPoint *HP_pc_resetfeel_post;
struct HPMHookPoint *HP_pc_resethate_pre;
@@ -4460,8 +4468,12 @@ struct {
struct HPMHookPoint *HP_pc_delinvincibletimer_post;
struct HPMHookPoint *HP_pc_addspiritball_pre;
struct HPMHookPoint *HP_pc_addspiritball_post;
+ struct HPMHookPoint *HP_pc_addspiritball_sub_pre;
+ struct HPMHookPoint *HP_pc_addspiritball_sub_post;
struct HPMHookPoint *HP_pc_delspiritball_pre;
struct HPMHookPoint *HP_pc_delspiritball_post;
+ struct HPMHookPoint *HP_pc_delspiritball_sub_pre;
+ struct HPMHookPoint *HP_pc_delspiritball_sub_post;
struct HPMHookPoint *HP_pc_getmaxspiritball_pre;
struct HPMHookPoint *HP_pc_getmaxspiritball_post;
struct HPMHookPoint *HP_pc_addfame_pre;
@@ -4550,6 +4562,8 @@ struct {
struct HPMHookPoint *HP_pc_follow_timer_post;
struct HPMHookPoint *HP_pc_read_skill_tree_pre;
struct HPMHookPoint *HP_pc_read_skill_tree_post;
+ struct HPMHookPoint *HP_pc_read_skill_job_skip_pre;
+ struct HPMHookPoint *HP_pc_read_skill_job_skip_post;
struct HPMHookPoint *HP_pc_clear_skill_tree_pre;
struct HPMHookPoint *HP_pc_clear_skill_tree_post;
struct HPMHookPoint *HP_pc_isUseitem_pre;
@@ -4608,6 +4622,8 @@ struct {
struct HPMHookPoint *HP_pc_check_supernovice_call_post;
struct HPMHookPoint *HP_pc_check_basicskill_pre;
struct HPMHookPoint *HP_pc_check_basicskill_post;
+ struct HPMHookPoint *HP_pc_isDeathPenaltyJob_pre;
+ struct HPMHookPoint *HP_pc_isDeathPenaltyJob_post;
struct HPMHookPoint *HP_libpcre_compile_pre;
struct HPMHookPoint *HP_libpcre_compile_post;
struct HPMHookPoint *HP_libpcre_study_pre;
@@ -5902,6 +5918,8 @@ struct {
struct HPMHookPoint *HP_status_calc_pc__post;
struct HPMHookPoint *HP_status_calc_pc_additional_pre;
struct HPMHookPoint *HP_status_calc_pc_additional_post;
+ struct HPMHookPoint *HP_status_calc_pc_recover_hp_pre;
+ struct HPMHookPoint *HP_status_calc_pc_recover_hp_post;
struct HPMHookPoint *HP_status_calc_homunculus__pre;
struct HPMHookPoint *HP_status_calc_homunculus__post;
struct HPMHookPoint *HP_status_calc_mercenary__pre;
@@ -10531,6 +10549,10 @@ struct {
int HP_pc_checkequip_post;
int HP_pc_calc_skilltree_pre;
int HP_pc_calc_skilltree_post;
+ int HP_pc_calc_skilltree_clear_pre;
+ int HP_pc_calc_skilltree_clear_post;
+ int HP_pc_calc_skilltree_bonus_pre;
+ int HP_pc_calc_skilltree_bonus_post;
int HP_pc_calc_skilltree_normalize_job_pre;
int HP_pc_calc_skilltree_normalize_job_post;
int HP_pc_clean_skilltree_pre;
@@ -10627,6 +10649,8 @@ struct {
int HP_pc_maxjoblv_post;
int HP_pc_checkbaselevelup_pre;
int HP_pc_checkbaselevelup_post;
+ int HP_pc_checkbaselevelup_sc_pre;
+ int HP_pc_checkbaselevelup_sc_post;
int HP_pc_checkjoblevelup_pre;
int HP_pc_checkjoblevelup_post;
int HP_pc_gainexp_pre;
@@ -10659,6 +10683,8 @@ struct {
int HP_pc_resetstate_post;
int HP_pc_resetskill_pre;
int HP_pc_resetskill_post;
+ int HP_pc_resetskill_job_pre;
+ int HP_pc_resetskill_job_post;
int HP_pc_resetfeel_pre;
int HP_pc_resetfeel_post;
int HP_pc_resethate_pre;
@@ -10779,8 +10805,12 @@ struct {
int HP_pc_delinvincibletimer_post;
int HP_pc_addspiritball_pre;
int HP_pc_addspiritball_post;
+ int HP_pc_addspiritball_sub_pre;
+ int HP_pc_addspiritball_sub_post;
int HP_pc_delspiritball_pre;
int HP_pc_delspiritball_post;
+ int HP_pc_delspiritball_sub_pre;
+ int HP_pc_delspiritball_sub_post;
int HP_pc_getmaxspiritball_pre;
int HP_pc_getmaxspiritball_post;
int HP_pc_addfame_pre;
@@ -10869,6 +10899,8 @@ struct {
int HP_pc_follow_timer_post;
int HP_pc_read_skill_tree_pre;
int HP_pc_read_skill_tree_post;
+ int HP_pc_read_skill_job_skip_pre;
+ int HP_pc_read_skill_job_skip_post;
int HP_pc_clear_skill_tree_pre;
int HP_pc_clear_skill_tree_post;
int HP_pc_isUseitem_pre;
@@ -10927,6 +10959,8 @@ struct {
int HP_pc_check_supernovice_call_post;
int HP_pc_check_basicskill_pre;
int HP_pc_check_basicskill_post;
+ int HP_pc_isDeathPenaltyJob_pre;
+ int HP_pc_isDeathPenaltyJob_post;
int HP_libpcre_compile_pre;
int HP_libpcre_compile_post;
int HP_libpcre_study_pre;
@@ -12221,6 +12255,8 @@ struct {
int HP_status_calc_pc__post;
int HP_status_calc_pc_additional_pre;
int HP_status_calc_pc_additional_post;
+ int HP_status_calc_pc_recover_hp_pre;
+ int HP_status_calc_pc_recover_hp_post;
int HP_status_calc_homunculus__pre;
int HP_status_calc_homunculus__post;
int HP_status_calc_mercenary__pre;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
index 5fdfd9e03..a848beab4 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
@@ -2162,6 +2162,8 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->checkallowskill, HP_pc_checkallowskill) },
{ HP_POP(pc->checkequip, HP_pc_checkequip) },
{ HP_POP(pc->calc_skilltree, HP_pc_calc_skilltree) },
+ { HP_POP(pc->calc_skilltree_clear, HP_pc_calc_skilltree_clear) },
+ { HP_POP(pc->calc_skilltree_bonus, HP_pc_calc_skilltree_bonus) },
{ HP_POP(pc->calc_skilltree_normalize_job, HP_pc_calc_skilltree_normalize_job) },
{ HP_POP(pc->clean_skilltree, HP_pc_clean_skilltree) },
{ HP_POP(pc->setpos, HP_pc_setpos) },
@@ -2210,6 +2212,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->maxbaselv, HP_pc_maxbaselv) },
{ HP_POP(pc->maxjoblv, HP_pc_maxjoblv) },
{ HP_POP(pc->checkbaselevelup, HP_pc_checkbaselevelup) },
+ { HP_POP(pc->checkbaselevelup_sc, HP_pc_checkbaselevelup_sc) },
{ HP_POP(pc->checkjoblevelup, HP_pc_checkjoblevelup) },
{ HP_POP(pc->gainexp, HP_pc_gainexp) },
{ HP_POP(pc->nextbaseexp, HP_pc_nextbaseexp) },
@@ -2226,6 +2229,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->resetlvl, HP_pc_resetlvl) },
{ HP_POP(pc->resetstate, HP_pc_resetstate) },
{ HP_POP(pc->resetskill, HP_pc_resetskill) },
+ { HP_POP(pc->resetskill_job, HP_pc_resetskill_job) },
{ HP_POP(pc->resetfeel, HP_pc_resetfeel) },
{ HP_POP(pc->resethate, HP_pc_resethate) },
{ HP_POP(pc->equipitem, HP_pc_equipitem) },
@@ -2286,7 +2290,9 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->setinvincibletimer, HP_pc_setinvincibletimer) },
{ HP_POP(pc->delinvincibletimer, HP_pc_delinvincibletimer) },
{ HP_POP(pc->addspiritball, HP_pc_addspiritball) },
+ { HP_POP(pc->addspiritball_sub, HP_pc_addspiritball_sub) },
{ HP_POP(pc->delspiritball, HP_pc_delspiritball) },
+ { HP_POP(pc->delspiritball_sub, HP_pc_delspiritball_sub) },
{ HP_POP(pc->getmaxspiritball, HP_pc_getmaxspiritball) },
{ HP_POP(pc->addfame, HP_pc_addfame) },
{ HP_POP(pc->fame_rank, HP_pc_fame_rank) },
@@ -2331,6 +2337,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->autosave, HP_pc_autosave) },
{ HP_POP(pc->follow_timer, HP_pc_follow_timer) },
{ HP_POP(pc->read_skill_tree, HP_pc_read_skill_tree) },
+ { HP_POP(pc->read_skill_job_skip, HP_pc_read_skill_job_skip) },
{ HP_POP(pc->clear_skill_tree, HP_pc_clear_skill_tree) },
{ HP_POP(pc->isUseitem, HP_pc_isUseitem) },
{ HP_POP(pc->show_steal, HP_pc_show_steal) },
@@ -2360,6 +2367,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(pc->process_chat_message, HP_pc_process_chat_message) },
{ HP_POP(pc->check_supernovice_call, HP_pc_check_supernovice_call) },
{ HP_POP(pc->check_basicskill, HP_pc_check_basicskill) },
+ { HP_POP(pc->isDeathPenaltyJob, HP_pc_isDeathPenaltyJob) },
/* pcre_interface */
{ HP_POP(libpcre->compile, HP_libpcre_compile) },
{ HP_POP(libpcre->study, HP_libpcre_study) },
@@ -3019,6 +3027,7 @@ struct HookingPointData HookingPoints[] = {
{ HP_POP(status->calc_pet_, HP_status_calc_pet_) },
{ HP_POP(status->calc_pc_, HP_status_calc_pc_) },
{ HP_POP(status->calc_pc_additional, HP_status_calc_pc_additional) },
+ { HP_POP(status->calc_pc_recover_hp, HP_status_calc_pc_recover_hp) },
{ HP_POP(status->calc_homunculus_, HP_status_calc_homunculus_) },
{ HP_POP(status->calc_mercenary_, HP_status_calc_mercenary_) },
{ HP_POP(status->calc_elemental_, HP_status_calc_elemental_) },
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index ca19685a9..1fbc47731 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -56041,6 +56041,58 @@ int HP_pc_calc_skilltree(struct map_session_data *sd) {
}
return retVal___;
}
+void HP_pc_calc_skilltree_clear(struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_pc_calc_skilltree_clear_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_clear_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_clear_pre[hIndex].func;
+ preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.pc.calc_skilltree_clear(sd);
+ }
+ if (HPMHooks.count.HP_pc_calc_skilltree_clear_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_clear_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_clear_post[hIndex].func;
+ postHookFunc(sd);
+ }
+ }
+ return;
+}
+void HP_pc_calc_skilltree_bonus(struct map_session_data *sd, int classidx) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_pc_calc_skilltree_bonus_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd, int *classidx);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_bonus_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_bonus_pre[hIndex].func;
+ preHookFunc(&sd, &classidx);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.pc.calc_skilltree_bonus(sd, classidx);
+ }
+ if (HPMHooks.count.HP_pc_calc_skilltree_bonus_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd, int classidx);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_bonus_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_bonus_post[hIndex].func;
+ postHookFunc(sd, classidx);
+ }
+ }
+ return;
+}
int HP_pc_calc_skilltree_normalize_job(struct map_session_data *sd) {
int hIndex = 0;
int retVal___ = 0;
@@ -57337,6 +57389,32 @@ int HP_pc_checkbaselevelup(struct map_session_data *sd) {
}
return retVal___;
}
+void HP_pc_checkbaselevelup_sc(struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_pc_checkbaselevelup_sc_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_sc_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_sc_pre[hIndex].func;
+ preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.pc.checkbaselevelup_sc(sd);
+ }
+ if (HPMHooks.count.HP_pc_checkbaselevelup_sc_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_sc_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_sc_post[hIndex].func;
+ postHookFunc(sd);
+ }
+ }
+ return;
+}
int HP_pc_checkjoblevelup(struct map_session_data *sd) {
int hIndex = 0;
int retVal___ = 0;
@@ -57769,6 +57847,33 @@ int HP_pc_resetskill(struct map_session_data *sd, int flag) {
}
return retVal___;
}
+bool HP_pc_resetskill_job(struct map_session_data *sd, int index) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_pc_resetskill_job_pre > 0) {
+ bool (*preHookFunc) (struct map_session_data **sd, int *index);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_job_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_resetskill_job_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &index);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.pc.resetskill_job(sd, index);
+ }
+ if (HPMHooks.count.HP_pc_resetskill_job_post > 0) {
+ bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int index);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_job_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_resetskill_job_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, index);
+ }
+ }
+ return retVal___;
+}
int HP_pc_resetfeel(struct map_session_data *sd) {
int hIndex = 0;
int retVal___ = 0;
@@ -59372,6 +59477,33 @@ int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) {
}
return retVal___;
}
+int HP_pc_addspiritball_sub(struct map_session_data *sd) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_pc_addspiritball_sub_pre > 0) {
+ int (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_sub_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_addspiritball_sub_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.pc.addspiritball_sub(sd);
+ }
+ if (HPMHooks.count.HP_pc_addspiritball_sub_post > 0) {
+ int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_sub_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_addspiritball_sub_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd);
+ }
+ }
+ return retVal___;
+}
int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) {
int hIndex = 0;
int retVal___ = 0;
@@ -59399,6 +59531,33 @@ int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) {
}
return retVal___;
}
+int HP_pc_delspiritball_sub(struct map_session_data *sd) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_pc_delspiritball_sub_pre > 0) {
+ int (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_sub_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_delspiritball_sub_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.pc.delspiritball_sub(sd);
+ }
+ if (HPMHooks.count.HP_pc_delspiritball_sub_post > 0) {
+ int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_sub_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_delspiritball_sub_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd);
+ }
+ }
+ return retVal___;
+}
int HP_pc_getmaxspiritball(struct map_session_data *sd, int min) {
int hIndex = 0;
int retVal___ = 0;
@@ -60594,6 +60753,33 @@ void HP_pc_read_skill_tree(void) {
}
return;
}
+bool HP_pc_read_skill_job_skip(short skill_id, int job_id) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_pc_read_skill_job_skip_pre > 0) {
+ bool (*preHookFunc) (short *skill_id, int *job_id);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_read_skill_job_skip_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_read_skill_job_skip_pre[hIndex].func;
+ retVal___ = preHookFunc(&skill_id, &job_id);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.pc.read_skill_job_skip(skill_id, job_id);
+ }
+ if (HPMHooks.count.HP_pc_read_skill_job_skip_post > 0) {
+ bool (*postHookFunc) (bool retVal___, short skill_id, int job_id);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_read_skill_job_skip_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_read_skill_job_skip_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, skill_id, job_id);
+ }
+ }
+ return retVal___;
+}
void HP_pc_clear_skill_tree(void) {
int hIndex = 0;
if (HPMHooks.count.HP_pc_clear_skill_tree_pre > 0) {
@@ -61373,6 +61559,33 @@ bool HP_pc_check_basicskill(struct map_session_data *sd, int level) {
}
return retVal___;
}
+bool HP_pc_isDeathPenaltyJob(uint16 job) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_pc_isDeathPenaltyJob_pre > 0) {
+ bool (*preHookFunc) (uint16 *job);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_isDeathPenaltyJob_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_pc_isDeathPenaltyJob_pre[hIndex].func;
+ retVal___ = preHookFunc(&job);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.pc.isDeathPenaltyJob(job);
+ }
+ if (HPMHooks.count.HP_pc_isDeathPenaltyJob_post > 0) {
+ bool (*postHookFunc) (bool retVal___, uint16 job);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_pc_isDeathPenaltyJob_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_pc_isDeathPenaltyJob_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, job);
+ }
+ }
+ return retVal___;
+}
/* pcre_interface */
pcre* HP_libpcre_compile(const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr) {
int hIndex = 0;
@@ -79027,6 +79240,32 @@ void HP_status_calc_pc_additional(struct map_session_data *sd, enum e_status_cal
}
return;
}
+void HP_status_calc_pc_recover_hp(struct map_session_data *sd, struct status_data *bstatus) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_status_calc_pc_recover_hp_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd, struct status_data **bstatus);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_recover_hp_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_status_calc_pc_recover_hp_pre[hIndex].func;
+ preHookFunc(&sd, &bstatus);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.status.calc_pc_recover_hp(sd, bstatus);
+ }
+ if (HPMHooks.count.HP_status_calc_pc_recover_hp_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd, struct status_data *bstatus);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_recover_hp_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_status_calc_pc_recover_hp_post[hIndex].func;
+ postHookFunc(sd, bstatus);
+ }
+ }
+ return;
+}
int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt) {
int hIndex = 0;
int retVal___ = 0;