diff options
Diffstat (limited to 'src/plugins/HPMHooking/HPMHooking.Hooks.inc')
| -rw-r--r-- | src/plugins/HPMHooking/HPMHooking.Hooks.inc | 835 |
1 files changed, 599 insertions, 236 deletions
diff --git a/src/plugins/HPMHooking/HPMHooking.Hooks.inc b/src/plugins/HPMHooking/HPMHooking.Hooks.inc index 7ba95face..6ad4d4199 100644 --- a/src/plugins/HPMHooking/HPMHooking.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking.Hooks.inc @@ -5,13 +5,13 @@ // as it will get overwritten. /* atcommand */ -void HP_atcommand_init(void) { +void HP_atcommand_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19,13 +19,13 @@ void HP_atcommand_init(void) { } } { - HPMHooks.source.atcommand.init(); + HPMHooks.source.atcommand.init(minimal); } if( HPMHooks.count.HP_atcommand_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -763,14 +763,14 @@ void HP_atcommand_base_commands(void) { } return; } -bool HP_atcommand_add(char *name, AtCommandFunc func) { +bool HP_atcommand_add(char *name, AtCommandFunc func, bool replace) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_add_pre ) { - bool (*preHookFunc) (char *name, AtCommandFunc *func); + bool (*preHookFunc) (char *name, AtCommandFunc *func, bool *replace); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_add_pre[hIndex].func; - retVal___ = preHookFunc(name, &func); + retVal___ = preHookFunc(name, &func, &replace); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -778,25 +778,25 @@ bool HP_atcommand_add(char *name, AtCommandFunc func) { } } { - retVal___ = HPMHooks.source.atcommand.add(name, func); + retVal___ = HPMHooks.source.atcommand.add(name, func, replace); } if( HPMHooks.count.HP_atcommand_add_post ) { - bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc *func); + bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc *func, bool *replace); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &func); + retVal___ = postHookFunc(retVal___, name, &func, &replace); } } return retVal___; } /* battle */ -void HP_battle_init(void) { +void HP_battle_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_battle_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -804,13 +804,13 @@ void HP_battle_init(void) { } } { - HPMHooks.source.battle.init(); + HPMHooks.source.battle.init(minimal); } if( HPMHooks.count.HP_battle_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -2087,13 +2087,13 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) { return retVal___; } /* bg */ -void HP_bg_init(void) { +void HP_bg_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_bg_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2101,13 +2101,13 @@ void HP_bg_init(void) { } } { - HPMHooks.source.bg.init(); + HPMHooks.source.bg.init(minimal); } if( HPMHooks.count.HP_bg_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -3382,14 +3382,14 @@ int HP_chrif_final(void) { } return retVal___; } -int HP_chrif_init(void) { +int HP_chrif_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chrif_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3397,13 +3397,13 @@ int HP_chrif_init(void) { } } { - retVal___ = HPMHooks.source.chrif.init(); + retVal___ = HPMHooks.source.chrif.init(minimal); } if( HPMHooks.count.HP_chrif_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -5152,14 +5152,14 @@ int HP_chrif_parse(int fd) { return retVal___; } /* clif */ -int HP_clif_init(void) { +int HP_clif_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5167,13 +5167,13 @@ int HP_clif_init(void) { } } { - retVal___ = HPMHooks.source.clif.init(); + retVal___ = HPMHooks.source.clif.init(minimal); } if( HPMHooks.count.HP_clif_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -21901,13 +21901,13 @@ int HP_duel_checktime(struct map_session_data *sd) { } return retVal___; } -void HP_duel_init(void) { +void HP_duel_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_duel_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21915,13 +21915,13 @@ void HP_duel_init(void) { } } { - HPMHooks.source.duel.init(); + HPMHooks.source.duel.init(minimal); } if( HPMHooks.count.HP_duel_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -21952,14 +21952,14 @@ void HP_duel_final(void) { return; } /* elemental */ -int HP_elemental_init(void) { +int HP_elemental_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21967,13 +21967,13 @@ int HP_elemental_init(void) { } } { - retVal___ = HPMHooks.source.elemental.init(); + retVal___ = HPMHooks.source.elemental.init(minimal); } if( HPMHooks.count.HP_elemental_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -22792,13 +22792,13 @@ int HP_elemental_read_db(void) { return retVal___; } /* guild */ -void HP_guild_init(void) { +void HP_guild_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_guild_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22806,13 +22806,13 @@ void HP_guild_init(void) { } } { - HPMHooks.source.guild.init(); + HPMHooks.source.guild.init(minimal); } if( HPMHooks.count.HP_guild_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -25094,13 +25094,13 @@ struct guild_storage* HP_gstorage_id2storage2(int guild_id) { } return retVal___; } -void HP_gstorage_init(void) { +void HP_gstorage_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_gstorage_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25108,13 +25108,13 @@ void HP_gstorage_init(void) { } } { - HPMHooks.source.gstorage.init(); + HPMHooks.source.gstorage.init(minimal); } if( HPMHooks.count.HP_gstorage_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -25490,13 +25490,13 @@ DBData HP_gstorage_create(DBKey key, va_list args) { return retVal___; } /* homun */ -void HP_homun_init(void) { +void HP_homun_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_homun_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25504,13 +25504,13 @@ void HP_homun_init(void) { } } { - HPMHooks.source.homun.init(); + HPMHooks.source.homun.init(minimal); } if( HPMHooks.count.HP_homun_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -26670,13 +26670,13 @@ void HP_homun_delspiritball(struct homun_data *hd, int count, int type) { return; } /* instance */ -void HP_instance_init(void) { +void HP_instance_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_instance_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_instance_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26684,13 +26684,13 @@ void HP_instance_init(void) { } } { - HPMHooks.source.instance.init(); + HPMHooks.source.instance.init(minimal); } if( HPMHooks.count.HP_instance_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -30442,13 +30442,13 @@ void HP_intif_pDeleteHomunculusOk(int fd) { return; } /* ircbot */ -void HP_ircbot_init(void) { +void HP_ircbot_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30456,13 +30456,13 @@ void HP_ircbot_init(void) { } } { - HPMHooks.source.ircbot.init(); + HPMHooks.source.ircbot.init(minimal); } if( HPMHooks.count.HP_ircbot_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -30848,13 +30848,13 @@ void HP_ircbot_usernick(int fd, char *cmd, char *source, char *target, char *msg return; } /* itemdb */ -void HP_itemdb_init(void) { +void HP_itemdb_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30862,13 +30862,13 @@ void HP_itemdb_init(void) { } } { - HPMHooks.source.itemdb.init(); + HPMHooks.source.itemdb.init(minimal); } if( HPMHooks.count.HP_itemdb_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -32354,13 +32354,13 @@ int HP_itemdb_uid_load(void) { } return retVal___; } -void HP_itemdb_read(void) { +void HP_itemdb_read(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_read_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_read_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32368,13 +32368,13 @@ void HP_itemdb_read(void) { } } { - HPMHooks.source.itemdb.read(); + HPMHooks.source.itemdb.read(minimal); } if( HPMHooks.count.HP_itemdb_read_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_read_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -35895,11 +35895,11 @@ int HP_map_readfromcache(struct map_data *m, char *buffer) { } return retVal___; } -int HP_map_addmap(char *mapname) { +int HP_map_addmap(const char *mapname) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_addmap_pre ) { - int (*preHookFunc) (char *mapname); + int (*preHookFunc) (const char *mapname); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addmap_pre[hIndex].func; retVal___ = preHookFunc(mapname); @@ -35913,7 +35913,7 @@ int HP_map_addmap(char *mapname) { retVal___ = HPMHooks.source.map.addmap(mapname); } if( HPMHooks.count.HP_map_addmap_post ) { - int (*postHookFunc) (int retVal___, char *mapname); + int (*postHookFunc) (int retVal___, const char *mapname); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_addmap_post[hIndex].func; retVal___ = postHookFunc(retVal___, mapname); @@ -37154,13 +37154,13 @@ bool HP_mapreg_config_read(const char *w1, const char *w2) { return retVal___; } /* mercenary */ -void HP_mercenary_init(void) { +void HP_mercenary_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_mercenary_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37168,13 +37168,13 @@ void HP_mercenary_init(void) { } } { - HPMHooks.source.mercenary.init(); + HPMHooks.source.mercenary.init(minimal); } if( HPMHooks.count.HP_mercenary_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -37802,14 +37802,14 @@ bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) { return retVal___; } /* mob */ -int HP_mob_init(void) { +int HP_mob_init(bool mimimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *mimimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&mimimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37817,13 +37817,13 @@ int HP_mob_init(void) { } } { - retVal___ = HPMHooks.source.mob.init(); + retVal___ = HPMHooks.source.mob.init(mimimal); } if( HPMHooks.count.HP_mob_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *mimimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &mimimal); } } return retVal___; @@ -40298,13 +40298,13 @@ bool HP_mob_readdb_itemratio(char *str[], int columns, int current) { } return retVal___; } -void HP_mob_load(void) { +void HP_mob_load(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_mob_load_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_load_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -40312,13 +40312,13 @@ void HP_mob_load(void) { } } { - HPMHooks.source.mob.load(); + HPMHooks.source.mob.load(minimal); } if( HPMHooks.count.HP_mob_load_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_load_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -40349,14 +40349,14 @@ void HP_mob_clear_spawninfo(void) { return; } /* npc */ -int HP_npc_init(void) { +int HP_npc_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -40364,13 +40364,13 @@ int HP_npc_init(void) { } } { - retVal___ = HPMHooks.source.npc.init(); + retVal___ = HPMHooks.source.npc.init(minimal); } if( HPMHooks.count.HP_npc_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -41845,6 +41845,58 @@ void HP_npc_parsename(struct npc_data *nd, const char *name, const char *start, } return; } +int HP_npc_parseview(const char *w4, const char *start, const char *buffer, const char *filepath) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_npc_parseview_pre ) { + int (*preHookFunc) (const char *w4, const char *start, const char *buffer, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parseview_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_npc_parseview_pre[hIndex].func; + retVal___ = preHookFunc(w4, start, buffer, filepath); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.npc.parseview(w4, start, buffer, filepath); + } + if( HPMHooks.count.HP_npc_parseview_post ) { + int (*postHookFunc) (int retVal___, const char *w4, const char *start, const char *buffer, const char *filepath); + for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parseview_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_npc_parseview_post[hIndex].func; + retVal___ = postHookFunc(retVal___, w4, start, buffer, filepath); + } + } + return retVal___; +} +bool HP_npc_viewisid(const char *viewid) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_npc_viewisid_pre ) { + bool (*preHookFunc) (const char *viewid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_viewisid_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_npc_viewisid_pre[hIndex].func; + retVal___ = preHookFunc(viewid); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.npc.viewisid(viewid); + } + if( HPMHooks.count.HP_npc_viewisid_post ) { + bool (*postHookFunc) (bool retVal___, const char *viewid); + for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_viewisid_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_npc_viewisid_post[hIndex].func; + retVal___ = postHookFunc(retVal___, viewid); + } + } + return retVal___; +} struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, short from_y, short xs, short ys, unsigned short to_mapindex, short to_x, short to_y) { int hIndex = 0; struct npc_data* retVal___ = NULL; @@ -42338,30 +42390,31 @@ const char* HP_npc_parse_mapflag(char *w1, char *w2, char *w3, char *w4, const c } return retVal___; } -void HP_npc_parsesrcfile(const char *filepath, bool runOnInit) { +int HP_npc_parsesrcfile(const char *filepath, bool runOnInit) { int hIndex = 0; + int retVal___ = 0; if( HPMHooks.count.HP_npc_parsesrcfile_pre ) { - void (*preHookFunc) (const char *filepath, bool *runOnInit); + int (*preHookFunc) (const char *filepath, bool *runOnInit); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parsesrcfile_pre[hIndex].func; - preHookFunc(filepath, &runOnInit); + retVal___ = preHookFunc(filepath, &runOnInit); } if( *HPMforce_return ) { *HPMforce_return = false; - return; + return retVal___; } } { - HPMHooks.source.npc.parsesrcfile(filepath, runOnInit); + retVal___ = HPMHooks.source.npc.parsesrcfile(filepath, runOnInit); } if( HPMHooks.count.HP_npc_parsesrcfile_post ) { - void (*postHookFunc) (const char *filepath, bool *runOnInit); + int (*postHookFunc) (int retVal___, const char *filepath, bool *runOnInit); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_parsesrcfile_post[hIndex].func; - postHookFunc(filepath, &runOnInit); + retVal___ = postHookFunc(retVal___, filepath, &runOnInit); } } - return; + return retVal___; } int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) { int hIndex = 0; @@ -42632,13 +42685,13 @@ int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) { return retVal___; } /* party */ -void HP_party_init(void) { +void HP_party_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_party_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42646,13 +42699,13 @@ void HP_party_init(void) { } } { - HPMHooks.source.party.init(); + HPMHooks.source.party.init(minimal); } if( HPMHooks.count.HP_party_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -44014,14 +44067,324 @@ 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) { +void HP_pc_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_pc_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44029,13 +44392,13 @@ void HP_pc_init(void) { } } { - HPMHooks.source.pc.init(); + HPMHooks.source.pc.init(minimal); } if( HPMHooks.count.HP_pc_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -44195,11 +44558,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); @@ -44213,7 +44576,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); @@ -49059,14 +49422,14 @@ void HP_pc_scdata_received(struct map_session_data *sd) { return; } /* pet */ -int HP_pet_init(void) { +int HP_pet_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49074,13 +49437,13 @@ int HP_pet_init(void) { } } { - retVal___ = HPMHooks.source.pet.init(); + retVal___ = HPMHooks.source.pet.init(minimal); } if( HPMHooks.count.HP_pet_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -50085,13 +50448,13 @@ int HP_pet_read_db(void) { return retVal___; } /* quest */ -void HP_quest_init(void) { +void HP_quest_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_quest_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50099,13 +50462,13 @@ void HP_quest_init(void) { } } { - HPMHooks.source.quest.init(); + HPMHooks.source.quest.init(minimal); } if( HPMHooks.count.HP_quest_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -50401,13 +50764,13 @@ int HP_quest_read_db(void) { return retVal___; } /* script */ -void HP_script_init(void) { +void HP_script_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_script_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50415,13 +50778,13 @@ void HP_script_init(void) { } } { - HPMHooks.source.script.init(); + HPMHooks.source.script.init(minimal); } if( HPMHooks.count.HP_script_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -53829,14 +54192,14 @@ bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, i return retVal___; } /* skill */ -int HP_skill_init(void) { +int HP_skill_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53844,13 +54207,13 @@ int HP_skill_init(void) { } } { - retVal___ = HPMHooks.source.skill.init(); + retVal___ = HPMHooks.source.skill.init(minimal); } if( HPMHooks.count.HP_skill_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -53906,13 +54269,13 @@ void HP_skill_reload(void) { } return; } -void HP_skill_read_db(void) { +void HP_skill_read_db(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_skill_read_db_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_read_db_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53920,13 +54283,13 @@ void HP_skill_read_db(void) { } } { - HPMHooks.source.skill.read_db(); + HPMHooks.source.skill.read_db(minimal); } if( HPMHooks.count.HP_skill_read_db_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_read_db_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; @@ -58749,14 +59112,14 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) { return retVal___; } /* status */ -int HP_status_init(void) { +int HP_status_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58764,13 +59127,13 @@ int HP_status_init(void) { } } { - retVal___ = HPMHooks.source.status.init(); + retVal___ = HPMHooks.source.status.init(minimal); } if( HPMHooks.count.HP_status_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -59870,13 +60233,13 @@ int HP_status_change_clear_buffs(struct block_list *bl, int type) { } return retVal___; } -void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, bool first) { +void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, enum e_status_calc_opt opt) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_bl__pre ) { - void (*preHookFunc) (struct block_list *bl, enum scb_flag *flag, bool *first); + void (*preHookFunc) (struct block_list *bl, enum scb_flag *flag, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_bl__pre[hIndex].func; - preHookFunc(bl, &flag, &first); + preHookFunc(bl, &flag, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59884,25 +60247,25 @@ void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, bool first) { } } { - HPMHooks.source.status.calc_bl_(bl, flag, first); + HPMHooks.source.status.calc_bl_(bl, flag, opt); } if( HPMHooks.count.HP_status_calc_bl__post ) { - void (*postHookFunc) (struct block_list *bl, enum scb_flag *flag, bool *first); + void (*postHookFunc) (struct block_list *bl, enum scb_flag *flag, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_bl__post[hIndex].func; - postHookFunc(bl, &flag, &first); + postHookFunc(bl, &flag, &opt); } } return; } -int HP_status_calc_mob_(struct mob_data *md, bool first) { +int HP_status_calc_mob_(struct mob_data *md, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_mob__pre ) { - int (*preHookFunc) (struct mob_data *md, bool *first); + int (*preHookFunc) (struct mob_data *md, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mob__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_mob__pre[hIndex].func; - retVal___ = preHookFunc(md, &first); + retVal___ = preHookFunc(md, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59910,25 +60273,25 @@ int HP_status_calc_mob_(struct mob_data *md, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_mob_(md, first); + retVal___ = HPMHooks.source.status.calc_mob_(md, opt); } if( HPMHooks.count.HP_status_calc_mob__post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, bool *first); + int (*postHookFunc) (int retVal___, struct mob_data *md, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mob__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_mob__post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &first); + retVal___ = postHookFunc(retVal___, md, &opt); } } return retVal___; } -int HP_status_calc_pet_(struct pet_data *pd, bool first) { +int HP_status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_pet__pre ) { - int (*preHookFunc) (struct pet_data *pd, bool *first); + int (*preHookFunc) (struct pet_data *pd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pet__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_pet__pre[hIndex].func; - retVal___ = preHookFunc(pd, &first); + retVal___ = preHookFunc(pd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59936,25 +60299,25 @@ int HP_status_calc_pet_(struct pet_data *pd, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_pet_(pd, first); + retVal___ = HPMHooks.source.status.calc_pet_(pd, opt); } if( HPMHooks.count.HP_status_calc_pet__post ) { - int (*postHookFunc) (int retVal___, struct pet_data *pd, bool *first); + int (*postHookFunc) (int retVal___, struct pet_data *pd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pet__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_pet__post[hIndex].func; - retVal___ = postHookFunc(retVal___, pd, &first); + retVal___ = postHookFunc(retVal___, pd, &opt); } } return retVal___; } -int HP_status_calc_pc_(struct map_session_data *sd, bool first) { +int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_pc__pre ) { - int (*preHookFunc) (struct map_session_data *sd, bool *first); + int (*preHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_pc__pre[hIndex].func; - retVal___ = preHookFunc(sd, &first); + retVal___ = preHookFunc(sd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59962,25 +60325,25 @@ int HP_status_calc_pc_(struct map_session_data *sd, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_pc_(sd, first); + retVal___ = HPMHooks.source.status.calc_pc_(sd, opt); } if( HPMHooks.count.HP_status_calc_pc__post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *first); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_pc__post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &first); + retVal___ = postHookFunc(retVal___, sd, &opt); } } return retVal___; } -int HP_status_calc_homunculus_(struct homun_data *hd, bool first) { +int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_homunculus__pre ) { - int (*preHookFunc) (struct homun_data *hd, bool *first); + int (*preHookFunc) (struct homun_data *hd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_homunculus__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_homunculus__pre[hIndex].func; - retVal___ = preHookFunc(hd, &first); + retVal___ = preHookFunc(hd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59988,25 +60351,25 @@ int HP_status_calc_homunculus_(struct homun_data *hd, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_homunculus_(hd, first); + retVal___ = HPMHooks.source.status.calc_homunculus_(hd, opt); } if( HPMHooks.count.HP_status_calc_homunculus__post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, bool *first); + int (*postHookFunc) (int retVal___, struct homun_data *hd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_homunculus__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_homunculus__post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &first); + retVal___ = postHookFunc(retVal___, hd, &opt); } } return retVal___; } -int HP_status_calc_mercenary_(struct mercenary_data *md, bool first) { +int HP_status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_mercenary__pre ) { - int (*preHookFunc) (struct mercenary_data *md, bool *first); + int (*preHookFunc) (struct mercenary_data *md, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mercenary__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_mercenary__pre[hIndex].func; - retVal___ = preHookFunc(md, &first); + retVal___ = preHookFunc(md, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60014,25 +60377,25 @@ int HP_status_calc_mercenary_(struct mercenary_data *md, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_mercenary_(md, first); + retVal___ = HPMHooks.source.status.calc_mercenary_(md, opt); } if( HPMHooks.count.HP_status_calc_mercenary__post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, bool *first); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mercenary__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_mercenary__post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &first); + retVal___ = postHookFunc(retVal___, md, &opt); } } return retVal___; } -int HP_status_calc_elemental_(struct elemental_data *ed, bool first) { +int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_elemental__pre ) { - int (*preHookFunc) (struct elemental_data *ed, bool *first); + int (*preHookFunc) (struct elemental_data *ed, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_elemental__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_elemental__pre[hIndex].func; - retVal___ = preHookFunc(ed, &first); + retVal___ = preHookFunc(ed, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60040,13 +60403,13 @@ int HP_status_calc_elemental_(struct elemental_data *ed, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_elemental_(ed, first); + retVal___ = HPMHooks.source.status.calc_elemental_(ed, opt); } if( HPMHooks.count.HP_status_calc_elemental__post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, bool *first); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_elemental__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_elemental__post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, &first); + retVal___ = postHookFunc(retVal___, ed, &opt); } } return retVal___; @@ -60669,14 +61032,14 @@ unsigned int HP_status_base_pc_maxsp(struct map_session_data *sd, struct status_ } return retVal___; } -int HP_status_calc_npc_(struct npc_data *nd, bool first) { +int HP_status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_npc__pre ) { - int (*preHookFunc) (struct npc_data *nd, bool *first); + int (*preHookFunc) (struct npc_data *nd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_npc__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_npc__pre[hIndex].func; - retVal___ = preHookFunc(nd, &first); + retVal___ = preHookFunc(nd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60684,13 +61047,13 @@ int HP_status_calc_npc_(struct npc_data *nd, bool first) { } } { - retVal___ = HPMHooks.source.status.calc_npc_(nd, first); + retVal___ = HPMHooks.source.status.calc_npc_(nd, opt); } if( HPMHooks.count.HP_status_calc_npc__post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, bool *first); + int (*postHookFunc) (int retVal___, struct npc_data *nd, enum e_status_calc_opt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_npc__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_npc__post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &first); + retVal___ = postHookFunc(retVal___, nd, &opt); } } return retVal___; @@ -62126,14 +62489,14 @@ void HP_trade_commit(struct map_session_data *sd) { return; } /* unit */ -int HP_unit_init(void) { +int HP_unit_init(bool minimal) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_init_pre ) { - int (*preHookFunc) (void); + int (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_init_pre[hIndex].func; - retVal___ = preHookFunc(); + retVal___ = preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62141,13 +62504,13 @@ int HP_unit_init(void) { } } { - retVal___ = HPMHooks.source.unit.init(); + retVal___ = HPMHooks.source.unit.init(minimal); } if( HPMHooks.count.HP_unit_init_post ) { - int (*postHookFunc) (int retVal___); + int (*postHookFunc) (int retVal___, bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___); + retVal___ = postHookFunc(retVal___, &minimal); } } return retVal___; @@ -63320,13 +63683,13 @@ int HP_unit_free(struct block_list *bl, clr_type clrtype) { return retVal___; } /* vending */ -void HP_vending_init(void) { +void HP_vending_init(bool minimal) { int hIndex = 0; if( HPMHooks.count.HP_vending_init_pre ) { - void (*preHookFunc) (void); + void (*preHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_init_pre[hIndex].func; - preHookFunc(); + preHookFunc(&minimal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63334,13 +63697,13 @@ void HP_vending_init(void) { } } { - HPMHooks.source.vending.init(); + HPMHooks.source.vending.init(minimal); } if( HPMHooks.count.HP_vending_init_post ) { - void (*postHookFunc) (void); + void (*postHookFunc) (bool *minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_vending_init_post[hIndex].func; - postHookFunc(); + postHookFunc(&minimal); } } return; |