From 0a5abb6de766be6a5068da08eb6477e343f2d7b3 Mon Sep 17 00:00:00 2001 From: "Hercules.ws" Date: Tue, 5 Nov 2013 01:46:41 +0100 Subject: HPM Hooks Update Signed-off-by: HerculesWSAPI --- src/plugins/HPMHooking/HPMHooking.GetSymbol.inc | 1 + src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc | 49 ++++ .../HPMHooking/HPMHooking.HookingPoints.inc | 13 + src/plugins/HPMHooking/HPMHooking.Hooks.inc | 316 ++++++++++++++++++++- src/plugins/HPMHooking/HPMHooking.sources.inc | 1 + 5 files changed, 377 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc b/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc index c3845675c..8482b9f80 100644 --- a/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc +++ b/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc @@ -30,6 +30,7 @@ if( !(mob = GET_SYMBOL("mob") ) ) return false; if( !(npc = GET_SYMBOL("npc") ) ) return false; if( !(party = GET_SYMBOL("party") ) ) return false; if( !(path = GET_SYMBOL("path") ) ) return false; +if( !(pcg = GET_SYMBOL("pc_groups") ) ) return false; if( !(pc = GET_SYMBOL("pc") ) ) return false; if( !(pet = GET_SYMBOL("pet") ) ) return false; if( !(quest = GET_SYMBOL("quest") ) ) return false; diff --git a/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc index 9c4c5bc55..a4609ceed 100644 --- a/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc @@ -3421,6 +3421,30 @@ struct { struct HPMHookPoint *HP_path_check_distance_post; struct HPMHookPoint *HP_path_distance_pre; struct HPMHookPoint *HP_path_distance_post; + struct HPMHookPoint *HP_pcg_init_pre; + struct HPMHookPoint *HP_pcg_init_post; + struct HPMHookPoint *HP_pcg_final_pre; + struct HPMHookPoint *HP_pcg_final_post; + struct HPMHookPoint *HP_pcg_reload_pre; + struct HPMHookPoint *HP_pcg_reload_post; + struct HPMHookPoint *HP_pcg_get_dummy_group_pre; + struct HPMHookPoint *HP_pcg_get_dummy_group_post; + struct HPMHookPoint *HP_pcg_exists_pre; + struct HPMHookPoint *HP_pcg_exists_post; + struct HPMHookPoint *HP_pcg_id2group_pre; + struct HPMHookPoint *HP_pcg_id2group_post; + struct HPMHookPoint *HP_pcg_has_permission_pre; + struct HPMHookPoint *HP_pcg_has_permission_post; + struct HPMHookPoint *HP_pcg_should_log_commands_pre; + struct HPMHookPoint *HP_pcg_should_log_commands_post; + struct HPMHookPoint *HP_pcg_get_name_pre; + struct HPMHookPoint *HP_pcg_get_name_post; + struct HPMHookPoint *HP_pcg_get_level_pre; + struct HPMHookPoint *HP_pcg_get_level_post; + struct HPMHookPoint *HP_pcg_get_idx_pre; + struct HPMHookPoint *HP_pcg_get_idx_post; + struct HPMHookPoint *HP_pcg_add_permission_pre; + struct HPMHookPoint *HP_pcg_add_permission_post; struct HPMHookPoint *HP_pc_init_pre; struct HPMHookPoint *HP_pc_init_post; struct HPMHookPoint *HP_pc_final_pre; @@ -8324,6 +8348,30 @@ struct { int HP_path_check_distance_post; int HP_path_distance_pre; int HP_path_distance_post; + int HP_pcg_init_pre; + int HP_pcg_init_post; + int HP_pcg_final_pre; + int HP_pcg_final_post; + int HP_pcg_reload_pre; + int HP_pcg_reload_post; + int HP_pcg_get_dummy_group_pre; + int HP_pcg_get_dummy_group_post; + int HP_pcg_exists_pre; + int HP_pcg_exists_post; + int HP_pcg_id2group_pre; + int HP_pcg_id2group_post; + int HP_pcg_has_permission_pre; + int HP_pcg_has_permission_post; + int HP_pcg_should_log_commands_pre; + int HP_pcg_should_log_commands_post; + int HP_pcg_get_name_pre; + int HP_pcg_get_name_post; + int HP_pcg_get_level_pre; + int HP_pcg_get_level_post; + int HP_pcg_get_idx_pre; + int HP_pcg_get_idx_post; + int HP_pcg_add_permission_pre; + int HP_pcg_add_permission_post; int HP_pc_init_pre; int HP_pc_init_post; int HP_pc_final_pre; @@ -9837,6 +9885,7 @@ struct { struct npc_interface npc; struct party_interface party; struct path_interface path; + struct pc_groups_interface pcg; struct pc_interface pc; struct pet_interface pet; struct quest_interface quest; diff --git a/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc index 75fcdac54..7e357b142 100644 --- a/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc @@ -1739,6 +1739,19 @@ struct HookingPointData HookingPoints[] = { { HP_POP(path->search_long, HP_path_search_long) }, { HP_POP(path->check_distance, HP_path_check_distance) }, { HP_POP(path->distance, HP_path_distance) }, +/* pcg */ + { HP_POP(pcg->init, HP_pcg_init) }, + { HP_POP(pcg->final, HP_pcg_final) }, + { HP_POP(pcg->reload, HP_pcg_reload) }, + { HP_POP(pcg->get_dummy_group, HP_pcg_get_dummy_group) }, + { HP_POP(pcg->exists, HP_pcg_exists) }, + { HP_POP(pcg->id2group, HP_pcg_id2group) }, + { HP_POP(pcg->has_permission, HP_pcg_has_permission) }, + { HP_POP(pcg->should_log_commands, HP_pcg_should_log_commands) }, + { HP_POP(pcg->get_name, HP_pcg_get_name) }, + { HP_POP(pcg->get_level, HP_pcg_get_level) }, + { HP_POP(pcg->get_idx, HP_pcg_get_idx) }, + { HP_POP(pcg->add_permission, HP_pcg_add_permission) }, /* pc */ { HP_POP(pc->init, HP_pc_init) }, { HP_POP(pc->final, HP_pc_final) }, diff --git a/src/plugins/HPMHooking/HPMHooking.Hooks.inc b/src/plugins/HPMHooking/HPMHooking.Hooks.inc index 178369035..91b7e9909 100644 --- a/src/plugins/HPMHooking/HPMHooking.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking.Hooks.inc @@ -44066,6 +44066,316 @@ unsigned int HP_path_distance(int dx, int dy) { } return retVal___; } +/* pcg */ +void HP_pcg_init(void) { + int hIndex = 0; + if( HPMHooks.count.HP_pcg_init_pre ) { + void (*preHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_init_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_init_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.pcg.init(); + } + if( HPMHooks.count.HP_pcg_init_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_init_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_init_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_pcg_final(void) { + int hIndex = 0; + if( HPMHooks.count.HP_pcg_final_pre ) { + void (*preHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_final_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_final_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.pcg.final(); + } + if( HPMHooks.count.HP_pcg_final_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_final_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_final_post[hIndex].func; + postHookFunc(); + } + } + return; +} +void HP_pcg_reload(void) { + int hIndex = 0; + if( HPMHooks.count.HP_pcg_reload_pre ) { + void (*preHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_reload_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_reload_pre[hIndex].func; + preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.pcg.reload(); + } + if( HPMHooks.count.HP_pcg_reload_post ) { + void (*postHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_reload_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_reload_post[hIndex].func; + postHookFunc(); + } + } + return; +} +GroupSettings* HP_pcg_get_dummy_group(void) { + int hIndex = 0; + GroupSettings* retVal___ = NULL; + if( HPMHooks.count.HP_pcg_get_dummy_group_pre ) { + GroupSettings* (*preHookFunc) (void); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_dummy_group_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_get_dummy_group_pre[hIndex].func; + retVal___ = preHookFunc(); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.get_dummy_group(); + } + if( HPMHooks.count.HP_pcg_get_dummy_group_post ) { + GroupSettings* (*postHookFunc) (GroupSettings* retVal___); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_dummy_group_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_get_dummy_group_post[hIndex].func; + retVal___ = postHookFunc(retVal___); + } + } + return retVal___; +} +bool HP_pcg_exists(int group_id) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_pcg_exists_pre ) { + bool (*preHookFunc) (int *group_id); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_exists_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_exists_pre[hIndex].func; + retVal___ = preHookFunc(&group_id); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.exists(group_id); + } + if( HPMHooks.count.HP_pcg_exists_post ) { + bool (*postHookFunc) (bool retVal___, int *group_id); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_exists_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_exists_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &group_id); + } + } + return retVal___; +} +GroupSettings* HP_pcg_id2group(int group_id) { + int hIndex = 0; + GroupSettings* retVal___ = NULL; + if( HPMHooks.count.HP_pcg_id2group_pre ) { + GroupSettings* (*preHookFunc) (int *group_id); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_id2group_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_id2group_pre[hIndex].func; + retVal___ = preHookFunc(&group_id); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.id2group(group_id); + } + if( HPMHooks.count.HP_pcg_id2group_post ) { + GroupSettings* (*postHookFunc) (GroupSettings* retVal___, int *group_id); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_id2group_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_id2group_post[hIndex].func; + retVal___ = postHookFunc(retVal___, &group_id); + } + } + return retVal___; +} +bool HP_pcg_has_permission(GroupSettings *group, unsigned int permission) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_pcg_has_permission_pre ) { + bool (*preHookFunc) (GroupSettings *group, unsigned int *permission); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_has_permission_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_has_permission_pre[hIndex].func; + retVal___ = preHookFunc(group, &permission); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.has_permission(group, permission); + } + if( HPMHooks.count.HP_pcg_has_permission_post ) { + bool (*postHookFunc) (bool retVal___, GroupSettings *group, unsigned int *permission); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_has_permission_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_has_permission_post[hIndex].func; + retVal___ = postHookFunc(retVal___, group, &permission); + } + } + return retVal___; +} +bool HP_pcg_should_log_commands(GroupSettings *group) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_pcg_should_log_commands_pre ) { + bool (*preHookFunc) (GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_should_log_commands_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_should_log_commands_pre[hIndex].func; + retVal___ = preHookFunc(group); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.should_log_commands(group); + } + if( HPMHooks.count.HP_pcg_should_log_commands_post ) { + bool (*postHookFunc) (bool retVal___, GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_should_log_commands_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_should_log_commands_post[hIndex].func; + retVal___ = postHookFunc(retVal___, group); + } + } + return retVal___; +} +const char* HP_pcg_get_name(GroupSettings *group) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_pcg_get_name_pre ) { + const char* (*preHookFunc) (GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_name_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_get_name_pre[hIndex].func; + retVal___ = preHookFunc(group); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.get_name(group); + } + if( HPMHooks.count.HP_pcg_get_name_post ) { + const char* (*postHookFunc) (const char* retVal___, GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_name_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_get_name_post[hIndex].func; + retVal___ = postHookFunc(retVal___, group); + } + } + return retVal___; +} +int HP_pcg_get_level(GroupSettings *group) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_pcg_get_level_pre ) { + int (*preHookFunc) (GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_level_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_get_level_pre[hIndex].func; + retVal___ = preHookFunc(group); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.get_level(group); + } + if( HPMHooks.count.HP_pcg_get_level_post ) { + int (*postHookFunc) (int retVal___, GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_level_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_get_level_post[hIndex].func; + retVal___ = postHookFunc(retVal___, group); + } + } + return retVal___; +} +int HP_pcg_get_idx(GroupSettings *group) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_pcg_get_idx_pre ) { + int (*preHookFunc) (GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_idx_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_get_idx_pre[hIndex].func; + retVal___ = preHookFunc(group); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.get_idx(group); + } + if( HPMHooks.count.HP_pcg_get_idx_post ) { + int (*postHookFunc) (int retVal___, GroupSettings *group); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_idx_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_get_idx_post[hIndex].func; + retVal___ = postHookFunc(retVal___, group); + } + } + return retVal___; +} +unsigned int HP_pcg_add_permission(const char *name) { + int hIndex = 0; + unsigned int retVal___ = 0; + if( HPMHooks.count.HP_pcg_add_permission_pre ) { + unsigned int (*preHookFunc) (const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_add_permission_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pcg_add_permission_pre[hIndex].func; + retVal___ = preHookFunc(name); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pcg.add_permission(name); + } + if( HPMHooks.count.HP_pcg_add_permission_post ) { + unsigned int (*postHookFunc) (unsigned int retVal___, const char *name); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_add_permission_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pcg_add_permission_post[hIndex].func; + retVal___ = postHookFunc(retVal___, name); + } + } + return retVal___; +} /* pc */ void HP_pc_init(void) { int hIndex = 0; @@ -44247,11 +44557,11 @@ bool HP_pc_can_use_command(struct map_session_data *sd, const char *command) { } return retVal___; } -bool HP_pc_has_permission(struct map_session_data *sd, enum e_pc_permission permission) { +bool HP_pc_has_permission(struct map_session_data *sd, unsigned int permission) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_has_permission_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, enum e_pc_permission *permission); + bool (*preHookFunc) (struct map_session_data *sd, unsigned int *permission); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_has_permission_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_has_permission_pre[hIndex].func; retVal___ = preHookFunc(sd, &permission); @@ -44265,7 +44575,7 @@ bool HP_pc_has_permission(struct map_session_data *sd, enum e_pc_permission perm retVal___ = HPMHooks.source.pc.has_permission(sd, permission); } if( HPMHooks.count.HP_pc_has_permission_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum e_pc_permission *permission); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int *permission); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_has_permission_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_has_permission_post[hIndex].func; retVal___ = postHookFunc(retVal___, sd, &permission); diff --git a/src/plugins/HPMHooking/HPMHooking.sources.inc b/src/plugins/HPMHooking/HPMHooking.sources.inc index e6dd89814..53bb6bcad 100644 --- a/src/plugins/HPMHooking/HPMHooking.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking.sources.inc @@ -30,6 +30,7 @@ memcpy(&HPMHooks.source.mob, mob, sizeof(struct mob_interface)); memcpy(&HPMHooks.source.npc, npc, sizeof(struct npc_interface)); memcpy(&HPMHooks.source.party, party, sizeof(struct party_interface)); memcpy(&HPMHooks.source.path, path, sizeof(struct path_interface)); +memcpy(&HPMHooks.source.pcg, pcg, sizeof(struct pc_groups_interface)); memcpy(&HPMHooks.source.pc, pc, sizeof(struct pc_interface)); memcpy(&HPMHooks.source.pet, pet, sizeof(struct pet_interface)); memcpy(&HPMHooks.source.quest, quest, sizeof(struct quest_interface)); -- cgit v1.2.3-60-g2f50