summaryrefslogtreecommitdiff
path: root/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
diff options
context:
space:
mode:
authorMurilo Pereti Tavares <murilopereti@gmail.com>2018-01-25 01:17:38 -0200
committerMurilo Pereti Tavares <murilopereti@gmail.com>2018-01-25 01:17:38 -0200
commit587dd19c0269b3c8089838a5442260a185b19ead (patch)
tree88cd95538d7b636d4f62b3ede9685cd3847e5641 /src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
parentfc1684c82d92de81e5688e33a8386cde3c2407db (diff)
downloadhercules-587dd19c0269b3c8089838a5442260a185b19ead.tar.gz
hercules-587dd19c0269b3c8089838a5442260a185b19ead.tar.bz2
hercules-587dd19c0269b3c8089838a5442260a185b19ead.tar.xz
hercules-587dd19c0269b3c8089838a5442260a185b19ead.zip
HPM Hooks Update
Diffstat (limited to 'src/plugins/HPMHooking/HPMHooking_map.Hooks.inc')
-rw-r--r--src/plugins/HPMHooking/HPMHooking_map.Hooks.inc933
1 files changed, 933 insertions, 0 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index 5b0ae00a7..467c57dd9 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -6495,6 +6495,729 @@ void HP_chrif_del_scdata_single(int account_id, int char_id, short type) {
}
return;
}
+/* clan_interface */
+void HP_clan_init(bool minimal) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_init_pre > 0) {
+ void (*preHookFunc) (bool *minimal);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_init_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_init_pre[hIndex].func;
+ preHookFunc(&minimal);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.init(minimal);
+ }
+ if (HPMHooks.count.HP_clan_init_post > 0) {
+ void (*postHookFunc) (bool minimal);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_init_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_init_post[hIndex].func;
+ postHookFunc(minimal);
+ }
+ }
+ return;
+}
+void HP_clan_final(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_final_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_final_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_final_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.final();
+ }
+ if (HPMHooks.count.HP_clan_final_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_final_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_final_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+bool HP_clan_config_read(bool reload) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_clan_config_read_pre > 0) {
+ bool (*preHookFunc) (bool *reload);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_config_read_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_config_read_pre[hIndex].func;
+ retVal___ = preHookFunc(&reload);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.config_read(reload);
+ }
+ if (HPMHooks.count.HP_clan_config_read_post > 0) {
+ bool (*postHookFunc) (bool retVal___, bool reload);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_config_read_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_config_read_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, reload);
+ }
+ }
+ return retVal___;
+}
+void HP_clan_config_read_additional_settings(struct config_setting_t *settings, const char *source) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_config_read_additional_settings_pre > 0) {
+ void (*preHookFunc) (struct config_setting_t **settings, const char **source);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_config_read_additional_settings_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_config_read_additional_settings_pre[hIndex].func;
+ preHookFunc(&settings, &source);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.config_read_additional_settings(settings, source);
+ }
+ if (HPMHooks.count.HP_clan_config_read_additional_settings_post > 0) {
+ void (*postHookFunc) (struct config_setting_t *settings, const char *source);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_config_read_additional_settings_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_config_read_additional_settings_post[hIndex].func;
+ postHookFunc(settings, source);
+ }
+ }
+ return;
+}
+void HP_clan_read_db(struct config_setting_t *settings, const char *source, bool reload) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_read_db_pre > 0) {
+ void (*preHookFunc) (struct config_setting_t **settings, const char **source, bool *reload);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_read_db_pre[hIndex].func;
+ preHookFunc(&settings, &source, &reload);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.read_db(settings, source, reload);
+ }
+ if (HPMHooks.count.HP_clan_read_db_post > 0) {
+ void (*postHookFunc) (struct config_setting_t *settings, const char *source, bool reload);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_read_db_post[hIndex].func;
+ postHookFunc(settings, source, reload);
+ }
+ }
+ return;
+}
+int HP_clan_read_db_sub(struct config_setting_t *settings, const char *source, bool reload) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_read_db_sub_pre > 0) {
+ int (*preHookFunc) (struct config_setting_t **settings, const char **source, bool *reload);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_sub_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_read_db_sub_pre[hIndex].func;
+ retVal___ = preHookFunc(&settings, &source, &reload);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.read_db_sub(settings, source, reload);
+ }
+ if (HPMHooks.count.HP_clan_read_db_sub_post > 0) {
+ int (*postHookFunc) (int retVal___, struct config_setting_t *settings, const char *source, bool reload);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_sub_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_read_db_sub_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, settings, source, reload);
+ }
+ }
+ return retVal___;
+}
+void HP_clan_read_db_additional_fields(struct clan *entry, struct config_setting_t *t, int n, const char *source) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_read_db_additional_fields_pre > 0) {
+ void (*preHookFunc) (struct clan **entry, struct config_setting_t **t, int *n, const char **source);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_additional_fields_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_read_db_additional_fields_pre[hIndex].func;
+ preHookFunc(&entry, &t, &n, &source);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.read_db_additional_fields(entry, t, n, source);
+ }
+ if (HPMHooks.count.HP_clan_read_db_additional_fields_post > 0) {
+ void (*postHookFunc) (struct clan *entry, struct config_setting_t *t, int n, const char *source);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_db_additional_fields_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_read_db_additional_fields_post[hIndex].func;
+ postHookFunc(entry, t, n, source);
+ }
+ }
+ return;
+}
+void HP_clan_read_buffs(struct clan *c, struct config_setting_t *buff, const char *source) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_read_buffs_pre > 0) {
+ void (*preHookFunc) (struct clan **c, struct config_setting_t **buff, const char **source);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_buffs_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_read_buffs_pre[hIndex].func;
+ preHookFunc(&c, &buff, &source);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.read_buffs(c, buff, source);
+ }
+ if (HPMHooks.count.HP_clan_read_buffs_post > 0) {
+ void (*postHookFunc) (struct clan *c, struct config_setting_t *buff, const char *source);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_read_buffs_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_read_buffs_post[hIndex].func;
+ postHookFunc(c, buff, source);
+ }
+ }
+ return;
+}
+struct clan* HP_clan_search(int clan_id) {
+ int hIndex = 0;
+ struct clan* retVal___ = NULL;
+ if (HPMHooks.count.HP_clan_search_pre > 0) {
+ struct clan* (*preHookFunc) (int *clan_id);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_search_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_search_pre[hIndex].func;
+ retVal___ = preHookFunc(&clan_id);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.search(clan_id);
+ }
+ if (HPMHooks.count.HP_clan_search_post > 0) {
+ struct clan* (*postHookFunc) (struct clan* retVal___, int clan_id);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_search_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_search_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, clan_id);
+ }
+ }
+ return retVal___;
+}
+struct clan* HP_clan_searchname(const char *name) {
+ int hIndex = 0;
+ struct clan* retVal___ = NULL;
+ if (HPMHooks.count.HP_clan_searchname_pre > 0) {
+ struct clan* (*preHookFunc) (const char **name);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_searchname_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_searchname_pre[hIndex].func;
+ retVal___ = preHookFunc(&name);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.searchname(name);
+ }
+ if (HPMHooks.count.HP_clan_searchname_post > 0) {
+ struct clan* (*postHookFunc) (struct clan* retVal___, const char *name);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_searchname_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_searchname_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, name);
+ }
+ }
+ return retVal___;
+}
+struct map_session_data* HP_clan_getonlinesd(struct clan *c) {
+ int hIndex = 0;
+ struct map_session_data* retVal___ = NULL;
+ if (HPMHooks.count.HP_clan_getonlinesd_pre > 0) {
+ struct map_session_data* (*preHookFunc) (struct clan **c);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_getonlinesd_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_getonlinesd_pre[hIndex].func;
+ retVal___ = preHookFunc(&c);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.getonlinesd(c);
+ }
+ if (HPMHooks.count.HP_clan_getonlinesd_post > 0) {
+ struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct clan *c);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_getonlinesd_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_getonlinesd_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, c);
+ }
+ }
+ return retVal___;
+}
+int HP_clan_getindex(const struct clan *c, int char_id) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_getindex_pre > 0) {
+ int (*preHookFunc) (const struct clan **c, int *char_id);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_getindex_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_getindex_pre[hIndex].func;
+ retVal___ = preHookFunc(&c, &char_id);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.getindex(c, char_id);
+ }
+ if (HPMHooks.count.HP_clan_getindex_post > 0) {
+ int (*postHookFunc) (int retVal___, const struct clan *c, int char_id);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_getindex_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_getindex_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, c, char_id);
+ }
+ }
+ return retVal___;
+}
+bool HP_clan_join(struct map_session_data *sd, int clan_id) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_clan_join_pre > 0) {
+ bool (*preHookFunc) (struct map_session_data **sd, int *clan_id);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_join_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_join_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &clan_id);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.join(sd, clan_id);
+ }
+ if (HPMHooks.count.HP_clan_join_post > 0) {
+ bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int clan_id);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_join_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_join_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, clan_id);
+ }
+ }
+ return retVal___;
+}
+void HP_clan_member_online(struct map_session_data *sd, bool first) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_member_online_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd, bool *first);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_member_online_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_member_online_pre[hIndex].func;
+ preHookFunc(&sd, &first);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.member_online(sd, first);
+ }
+ if (HPMHooks.count.HP_clan_member_online_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd, bool first);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_member_online_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_member_online_post[hIndex].func;
+ postHookFunc(sd, first);
+ }
+ }
+ return;
+}
+bool HP_clan_leave(struct map_session_data *sd, bool first) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_clan_leave_pre > 0) {
+ bool (*preHookFunc) (struct map_session_data **sd, bool *first);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_leave_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_leave_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &first);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.leave(sd, first);
+ }
+ if (HPMHooks.count.HP_clan_leave_post > 0) {
+ bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, bool first);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_leave_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_leave_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, first);
+ }
+ }
+ return retVal___;
+}
+bool HP_clan_send_message(struct map_session_data *sd, const char *mes) {
+ int hIndex = 0;
+ bool retVal___ = false;
+ if (HPMHooks.count.HP_clan_send_message_pre > 0) {
+ bool (*preHookFunc) (struct map_session_data **sd, const char **mes);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_send_message_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_send_message_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, &mes);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.send_message(sd, mes);
+ }
+ if (HPMHooks.count.HP_clan_send_message_post > 0) {
+ bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *mes);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_send_message_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_send_message_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, mes);
+ }
+ }
+ return retVal___;
+}
+void HP_clan_recv_message(struct clan *c, const char *mes, int len) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_recv_message_pre > 0) {
+ void (*preHookFunc) (struct clan **c, const char **mes, int *len);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_recv_message_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_recv_message_pre[hIndex].func;
+ preHookFunc(&c, &mes, &len);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.recv_message(c, mes, len);
+ }
+ if (HPMHooks.count.HP_clan_recv_message_post > 0) {
+ void (*postHookFunc) (struct clan *c, const char *mes, int len);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_recv_message_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_recv_message_post[hIndex].func;
+ postHookFunc(c, mes, len);
+ }
+ }
+ return;
+}
+void HP_clan_member_offline(struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_member_offline_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_member_offline_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_member_offline_pre[hIndex].func;
+ preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.member_offline(sd);
+ }
+ if (HPMHooks.count.HP_clan_member_offline_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_member_offline_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_member_offline_post[hIndex].func;
+ postHookFunc(sd);
+ }
+ }
+ return;
+}
+void HP_clan_set_constants(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_set_constants_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_set_constants_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_set_constants_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.set_constants();
+ }
+ if (HPMHooks.count.HP_clan_set_constants_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_set_constants_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_set_constants_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+int HP_clan_get_id(const struct block_list *bl) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_get_id_pre > 0) {
+ int (*preHookFunc) (const struct block_list **bl);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_get_id_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_get_id_pre[hIndex].func;
+ retVal___ = preHookFunc(&bl);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.get_id(bl);
+ }
+ if (HPMHooks.count.HP_clan_get_id_post > 0) {
+ int (*postHookFunc) (int retVal___, const struct block_list *bl);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_get_id_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_get_id_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, bl);
+ }
+ }
+ return retVal___;
+}
+void HP_clan_buff_start(struct map_session_data *sd, struct clan *c) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_buff_start_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd, struct clan **c);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_buff_start_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_buff_start_pre[hIndex].func;
+ preHookFunc(&sd, &c);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.buff_start(sd, c);
+ }
+ if (HPMHooks.count.HP_clan_buff_start_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd, struct clan *c);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_buff_start_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_buff_start_post[hIndex].func;
+ postHookFunc(sd, c);
+ }
+ }
+ return;
+}
+void HP_clan_buff_end(struct map_session_data *sd, struct clan *c) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_buff_end_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd, struct clan **c);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_buff_end_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_buff_end_pre[hIndex].func;
+ preHookFunc(&sd, &c);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.buff_end(sd, c);
+ }
+ if (HPMHooks.count.HP_clan_buff_end_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd, struct clan *c);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_buff_end_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_buff_end_post[hIndex].func;
+ postHookFunc(sd, c);
+ }
+ }
+ return;
+}
+void HP_clan_reload(void) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clan_reload_pre > 0) {
+ void (*preHookFunc) (void);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_reload_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_reload_pre[hIndex].func;
+ preHookFunc();
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clan.reload();
+ }
+ if (HPMHooks.count.HP_clan_reload_post > 0) {
+ void (*postHookFunc) (void);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_reload_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_reload_post[hIndex].func;
+ postHookFunc();
+ }
+ }
+ return;
+}
+int HP_clan_rejoin(struct map_session_data *sd, va_list ap) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_rejoin_pre > 0) {
+ int (*preHookFunc) (struct map_session_data **sd, va_list ap);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_rejoin_pre; hIndex++) {
+ va_list ap___copy; va_copy(ap___copy, ap);
+ preHookFunc = HPMHooks.list.HP_clan_rejoin_pre[hIndex].func;
+ retVal___ = preHookFunc(&sd, ap___copy);
+ va_end(ap___copy);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ va_list ap___copy; va_copy(ap___copy, ap);
+ retVal___ = HPMHooks.source.clan.rejoin(sd, ap___copy);
+ va_end(ap___copy);
+ }
+ if (HPMHooks.count.HP_clan_rejoin_post > 0) {
+ int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_rejoin_post; hIndex++) {
+ va_list ap___copy; va_copy(ap___copy, ap);
+ postHookFunc = HPMHooks.list.HP_clan_rejoin_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, sd, ap___copy);
+ va_end(ap___copy);
+ }
+ }
+ return retVal___;
+}
+int HP_clan_inactivity_kick(int tid, int64 tick, int id, intptr_t data) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_inactivity_kick_pre > 0) {
+ int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_inactivity_kick_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_inactivity_kick_pre[hIndex].func;
+ retVal___ = preHookFunc(&tid, &tick, &id, &data);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.inactivity_kick(tid, tick, id, data);
+ }
+ if (HPMHooks.count.HP_clan_inactivity_kick_post > 0) {
+ int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_inactivity_kick_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_inactivity_kick_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, tid, tick, id, data);
+ }
+ }
+ return retVal___;
+}
+int HP_clan_request_kickoffline(int tid, int64 tick, int id, intptr_t data) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_request_kickoffline_pre > 0) {
+ int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_request_kickoffline_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_request_kickoffline_pre[hIndex].func;
+ retVal___ = preHookFunc(&tid, &tick, &id, &data);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.request_kickoffline(tid, tick, id, data);
+ }
+ if (HPMHooks.count.HP_clan_request_kickoffline_post > 0) {
+ int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_request_kickoffline_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_request_kickoffline_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, tid, tick, id, data);
+ }
+ }
+ return retVal___;
+}
+int HP_clan_request_membercount(int tid, int64 tick, int id, intptr_t data) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_clan_request_membercount_pre > 0) {
+ int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_request_membercount_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clan_request_membercount_pre[hIndex].func;
+ retVal___ = preHookFunc(&tid, &tick, &id, &data);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.clan.request_membercount(tid, tick, id, data);
+ }
+ if (HPMHooks.count.HP_clan_request_membercount_post > 0) {
+ int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clan_request_membercount_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clan_request_membercount_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, tid, tick, id, data);
+ }
+ }
+ return retVal___;
+}
/* clif_interface */
int HP_clif_init(bool minimal) {
int hIndex = 0;
@@ -25165,6 +25888,136 @@ void HP_clif_skill_scale(struct block_list *bl, int src_id, int x, int y, uint16
}
return;
}
+void HP_clif_clan_basicinfo(struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clif_clan_basicinfo_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_basicinfo_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clif_clan_basicinfo_pre[hIndex].func;
+ preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clif.clan_basicinfo(sd);
+ }
+ if (HPMHooks.count.HP_clif_clan_basicinfo_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_basicinfo_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clif_clan_basicinfo_post[hIndex].func;
+ postHookFunc(sd);
+ }
+ }
+ return;
+}
+void HP_clif_clan_onlinecount(struct clan *c) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clif_clan_onlinecount_pre > 0) {
+ void (*preHookFunc) (struct clan **c);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_onlinecount_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clif_clan_onlinecount_pre[hIndex].func;
+ preHookFunc(&c);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clif.clan_onlinecount(c);
+ }
+ if (HPMHooks.count.HP_clif_clan_onlinecount_post > 0) {
+ void (*postHookFunc) (struct clan *c);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_onlinecount_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clif_clan_onlinecount_post[hIndex].func;
+ postHookFunc(c);
+ }
+ }
+ return;
+}
+void HP_clif_clan_leave(struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clif_clan_leave_pre > 0) {
+ void (*preHookFunc) (struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_leave_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clif_clan_leave_pre[hIndex].func;
+ preHookFunc(&sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clif.clan_leave(sd);
+ }
+ if (HPMHooks.count.HP_clif_clan_leave_post > 0) {
+ void (*postHookFunc) (struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_leave_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clif_clan_leave_post[hIndex].func;
+ postHookFunc(sd);
+ }
+ }
+ return;
+}
+void HP_clif_clan_message(struct clan *c, const char *mes, int len) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clif_clan_message_pre > 0) {
+ void (*preHookFunc) (struct clan **c, const char **mes, int *len);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_message_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clif_clan_message_pre[hIndex].func;
+ preHookFunc(&c, &mes, &len);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clif.clan_message(c, mes, len);
+ }
+ if (HPMHooks.count.HP_clif_clan_message_post > 0) {
+ void (*postHookFunc) (struct clan *c, const char *mes, int len);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_clan_message_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clif_clan_message_post[hIndex].func;
+ postHookFunc(c, mes, len);
+ }
+ }
+ return;
+}
+void HP_clif_pClanMessage(int fd, struct map_session_data *sd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_clif_pClanMessage_pre > 0) {
+ void (*preHookFunc) (int *fd, struct map_session_data **sd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_pClanMessage_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_clif_pClanMessage_pre[hIndex].func;
+ preHookFunc(&fd, &sd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.clif.pClanMessage(fd, sd);
+ }
+ if (HPMHooks.count.HP_clif_pClanMessage_post > 0) {
+ void (*postHookFunc) (int fd, struct map_session_data *sd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_clif_pClanMessage_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_clif_pClanMessage_post[hIndex].func;
+ postHookFunc(fd, sd);
+ }
+ }
+ return;
+}
/* cmdline_interface */
void HP_cmdline_init(void) {
int hIndex = 0;
@@ -33854,6 +34707,60 @@ int HP_intif_rodex_checkname(struct map_session_data *sd, const char *name) {
}
return retVal___;
}
+int HP_intif_clan_kickoffline(int clan_id, int kick_interval) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_intif_clan_kickoffline_pre > 0) {
+ int (*preHookFunc) (int *clan_id, int *kick_interval);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_clan_kickoffline_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_intif_clan_kickoffline_pre[hIndex].func;
+ retVal___ = preHookFunc(&clan_id, &kick_interval);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.intif.clan_kickoffline(clan_id, kick_interval);
+ }
+ if (HPMHooks.count.HP_intif_clan_kickoffline_post > 0) {
+ int (*postHookFunc) (int retVal___, int clan_id, int kick_interval);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_clan_kickoffline_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_intif_clan_kickoffline_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, clan_id, kick_interval);
+ }
+ }
+ return retVal___;
+}
+int HP_intif_clan_membercount(int clan_id, int kick_interval) {
+ int hIndex = 0;
+ int retVal___ = 0;
+ if (HPMHooks.count.HP_intif_clan_membercount_pre > 0) {
+ int (*preHookFunc) (int *clan_id, int *kick_interval);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_clan_membercount_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_intif_clan_membercount_pre[hIndex].func;
+ retVal___ = preHookFunc(&clan_id, &kick_interval);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return retVal___;
+ }
+ }
+ {
+ retVal___ = HPMHooks.source.intif.clan_membercount(clan_id, kick_interval);
+ }
+ if (HPMHooks.count.HP_intif_clan_membercount_post > 0) {
+ int (*postHookFunc) (int retVal___, int clan_id, int kick_interval);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_clan_membercount_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_intif_clan_membercount_post[hIndex].func;
+ retVal___ = postHookFunc(retVal___, clan_id, kick_interval);
+ }
+ }
+ return retVal___;
+}
void HP_intif_request_accinfo(int u_fd, int aid, int group_lv, char *query) {
int hIndex = 0;
if (HPMHooks.count.HP_intif_request_accinfo_pre > 0) {
@@ -35682,6 +36589,32 @@ void HP_intif_pRodexCheckName(int fd) {
}
return;
}
+void HP_intif_pRecvClanMemberAction(int fd) {
+ int hIndex = 0;
+ if (HPMHooks.count.HP_intif_pRecvClanMemberAction_pre > 0) {
+ void (*preHookFunc) (int *fd);
+ *HPMforce_return = false;
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvClanMemberAction_pre; hIndex++) {
+ preHookFunc = HPMHooks.list.HP_intif_pRecvClanMemberAction_pre[hIndex].func;
+ preHookFunc(&fd);
+ }
+ if (*HPMforce_return) {
+ *HPMforce_return = false;
+ return;
+ }
+ }
+ {
+ HPMHooks.source.intif.pRecvClanMemberAction(fd);
+ }
+ if (HPMHooks.count.HP_intif_pRecvClanMemberAction_post > 0) {
+ void (*postHookFunc) (int fd);
+ for (hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvClanMemberAction_post; hIndex++) {
+ postHookFunc = HPMHooks.list.HP_intif_pRecvClanMemberAction_post[hIndex].func;
+ postHookFunc(fd);
+ }
+ }
+ return;
+}
/* irc_bot_interface */
void HP_ircbot_init(bool minimal) {
int hIndex = 0;