summaryrefslogtreecommitdiff
path: root/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/HPMHooking/HPMHooking_map.Hooks.inc')
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.Hooks.inc267
1 files changed, 252 insertions, 15 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index fa80a68fd..af1f11fe2 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -44624,6 +44624,32 @@ void HP_map_zone_remove(int m) {
}
return;
}
+void HP_map_zone_remove_all(int m) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_map_zone_remove_all_pre > 0) {
+ void (*preHookFunc) (int *m);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_all_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_map_zone_remove_all_pre[hIndex].func;
+ preHookFunc(&m);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.map.zone_remove_all(m);
+ }
+ if (HPMHooks.count.HP_map_zone_remove_all_post > 0) {
+ void (*postHookFunc) (int m);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_all_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_map_zone_remove_all_post[hIndex].func;
+ postHookFunc(m);
+ }
+ }
+ return;
+}
void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) {
int hIndex = 0;
if (HPMHooks.count.HP_map_zone_apply_pre > 0) {
@@ -56451,6 +56477,111 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const
}
return;
}
+/* packets_interface */
+void HP_packets_init(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_packets_init_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_init_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_packets_init_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.packets.init();
+ }
+ if (HPMHooks.count.HP_packets_init_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_init_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_packets_init_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+void HP_packets_final(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_packets_final_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_final_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_packets_final_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.packets.final();
+ }
+ if (HPMHooks.count.HP_packets_final_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_final_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_packets_final_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+void HP_packets_addLens(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_packets_addLens_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_addLens_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_packets_addLens_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.packets.addLens();
+ }
+ if (HPMHooks.count.HP_packets_addLens_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_addLens_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_packets_addLens_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+void HP_packets_addLen(int id, int len) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_packets_addLen_pre > 0) {
+ void (*preHookFunc) (int *id, int *len);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_addLen_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_packets_addLen_pre[hIndex].func;
+ preHookFunc(&id, &len);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.packets.addLen(id, len);
+ }
+ if (HPMHooks.count.HP_packets_addLen_post > 0) {
+ void (*postHookFunc) (int id, int len);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_packets_addLen_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_packets_addLen_post[hIndex].func;
+ postHookFunc(id, len);
+ }
+ }
+ return;
+}
/* party_interface */
void HP_party_init(bool minimal) {
int hIndex = 0;
@@ -79813,15 +79944,15 @@ int HP_sockt_realloc_writefifo(int fd, size_t addition) {
}
return retVal___;
}
-int HP_sockt_wfifoset(int fd, size_t len) {
+int HP_sockt_wfifoset(int fd, size_t len, bool validate) {
int hIndex = 0;
int retVal___ = 0;
if (HPMHooks.count.HP_sockt_wfifoset_pre > 0) {
- int (*preHookFunc) (int *fd, size_t *len);
+ int (*preHookFunc) (int *fd, size_t *len, bool *validate);
*HPMforce_return = false;
for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_pre; hIndex++) {
preHookFunc = HPMHooks.list.HP_sockt_wfifoset_pre[hIndex].func;
- retVal___ = preHookFunc(&fd, &len);
+ retVal___ = preHookFunc(&fd, &len, &validate);
}
if (*HPMforce_return) {
*HPMforce_return = false;
@@ -79829,17 +79960,43 @@ int HP_sockt_wfifoset(int fd, size_t len) {
}
}
{
- retVal___ = HPMHooks.source.sockt.wfifoset(fd, len);
+ retVal___ = HPMHooks.source.sockt.wfifoset(fd, len, validate);
}
if (HPMHooks.count.HP_sockt_wfifoset_post > 0) {
- int (*postHookFunc) (int retVal___, int fd, size_t len);
+ int (*postHookFunc) (int retVal___, int fd, size_t len, bool validate);
for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++) {
postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func;
- retVal___ = postHookFunc(retVal___, fd, len);
+ retVal___ = postHookFunc(retVal___, fd, len, validate);
}
}
return retVal___;
}
+void HP_sockt_wfifohead(int fd, size_t len) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_sockt_wfifohead_pre > 0) {
+ void (*preHookFunc) (int *fd, size_t *len);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifohead_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_sockt_wfifohead_pre[hIndex].func;
+ preHookFunc(&fd, &len);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.sockt.wfifohead(fd, len);
+ }
+ if (HPMHooks.count.HP_sockt_wfifohead_post > 0) {
+ void (*postHookFunc) (int fd, size_t len);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifohead_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_sockt_wfifohead_post[hIndex].func;
+ postHookFunc(fd, len);
+ }
+ }
+ return;
+}
int HP_sockt_rfifoskip(int fd, size_t len) {
int hIndex = 0;
int retVal___ = 0;
@@ -79893,6 +80050,32 @@ void HP_sockt_close(int fd) {
}
return;
}
+void HP_sockt_validateWfifo(int fd, size_t len) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_sockt_validateWfifo_pre > 0) {
+ void (*preHookFunc) (int *fd, size_t *len);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_validateWfifo_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_sockt_validateWfifo_pre[hIndex].func;
+ preHookFunc(&fd, &len);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.sockt.validateWfifo(fd, len);
+ }
+ if (HPMHooks.count.HP_sockt_validateWfifo_post > 0) {
+ void (*postHookFunc) (int fd, size_t len);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_sockt_validateWfifo_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_sockt_validateWfifo_post[hIndex].func;
+ postHookFunc(fd, len);
+ }
+ }
+ return;
+}
bool HP_sockt_session_is_valid(int fd) {
int hIndex = 0;
bool retVal___ = false;
@@ -81514,11 +81697,11 @@ int HP_status_percent_change(struct block_list *src, struct block_list *target,
}
return retVal___;
}
-int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
+int HP_status_set_hp(struct block_list *bl, unsigned int hp, enum status_heal_flag flag) {
int hIndex = 0;
int retVal___ = 0;
if (HPMHooks.count.HP_status_set_hp_pre > 0) {
- int (*preHookFunc) (struct block_list **bl, unsigned int *hp, int *flag);
+ int (*preHookFunc) (struct block_list **bl, unsigned int *hp, enum status_heal_flag *flag);
*HPMforce_return = false;
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_pre; hIndex++) {
preHookFunc = HPMHooks.list.HP_status_set_hp_pre[hIndex].func;
@@ -81533,7 +81716,7 @@ int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
retVal___ = HPMHooks.source.status.set_hp(bl, hp, flag);
}
if (HPMHooks.count.HP_status_set_hp_post > 0) {
- int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int hp, int flag);
+ int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int hp, enum status_heal_flag flag);
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_post; hIndex++) {
postHookFunc = HPMHooks.list.HP_status_set_hp_post[hIndex].func;
retVal___ = postHookFunc(retVal___, bl, hp, flag);
@@ -81541,11 +81724,11 @@ int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
}
return retVal___;
}
-int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
+int HP_status_set_sp(struct block_list *bl, unsigned int sp, enum status_heal_flag flag) {
int hIndex = 0;
int retVal___ = 0;
if (HPMHooks.count.HP_status_set_sp_pre > 0) {
- int (*preHookFunc) (struct block_list **bl, unsigned int *sp, int *flag);
+ int (*preHookFunc) (struct block_list **bl, unsigned int *sp, enum status_heal_flag *flag);
*HPMforce_return = false;
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_pre; hIndex++) {
preHookFunc = HPMHooks.list.HP_status_set_sp_pre[hIndex].func;
@@ -81560,7 +81743,7 @@ int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
retVal___ = HPMHooks.source.status.set_sp(bl, sp, flag);
}
if (HPMHooks.count.HP_status_set_sp_post > 0) {
- int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int sp, int flag);
+ int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int sp, enum status_heal_flag flag);
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_post; hIndex++) {
postHookFunc = HPMHooks.list.HP_status_set_sp_post[hIndex].func;
retVal___ = postHookFunc(retVal___, bl, sp, flag);
@@ -81568,11 +81751,11 @@ int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
}
return retVal___;
}
-int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) {
+int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, enum status_heal_flag flag) {
int hIndex = 0;
int retVal___ = 0;
if (HPMHooks.count.HP_status_heal_pre > 0) {
- int (*preHookFunc) (struct block_list **bl, int64 *hp, int64 *sp, int *flag);
+ int (*preHookFunc) (struct block_list **bl, int64 *hp, int64 *sp, enum status_heal_flag *flag);
*HPMforce_return = false;
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_pre; hIndex++) {
preHookFunc = HPMHooks.list.HP_status_heal_pre[hIndex].func;
@@ -81587,7 +81770,7 @@ int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) {
retVal___ = HPMHooks.source.status.heal(bl, hp, sp, flag);
}
if (HPMHooks.count.HP_status_heal_post > 0) {
- int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp, int flag);
+ int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp, enum status_heal_flag flag);
for (hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_post; hIndex++) {
postHookFunc = HPMHooks.list.HP_status_heal_post[hIndex].func;
retVal___ = postHookFunc(retVal___, bl, hp, sp, flag);
@@ -83505,6 +83688,60 @@ unsigned int HP_status_get_base_maxsp(const struct map_session_data *sd, const s
}
return retVal___;
}
+unsigned int HP_status_get_restart_hp(const struct map_session_data *sd, const struct status_data *st) {
+ int hIndex = 0;
+ unsigned int retVal___ = 0;
+ if (HPMHooks.count.HP_status_get_restart_hp_pre > 0) {
+ unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_get_restart_hp_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_status_get_restart_hp_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &st);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.status.get_restart_hp(sd, st);
+ }
+ if (HPMHooks.count.HP_status_get_restart_hp_post > 0) {
+ unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_get_restart_hp_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_status_get_restart_hp_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, st);
+ }
+ }
+ return retVal___;
+}
+unsigned int HP_status_get_restart_sp(const struct map_session_data *sd, const struct status_data *st) {
+ int hIndex = 0;
+ unsigned int retVal___ = 0;
+ if (HPMHooks.count.HP_status_get_restart_sp_pre > 0) {
+ unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_get_restart_sp_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_status_get_restart_sp_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &st);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.status.get_restart_sp(sd, st);
+ }
+ if (HPMHooks.count.HP_status_get_restart_sp_post > 0) {
+ unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_status_get_restart_sp_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_status_get_restart_sp_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, st);
+ }
+ }
+ return retVal___;
+}
int HP_status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) {
int hIndex = 0;
int retVal___ = 0;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-10-02 11:58:57 +0000