Merge remote-tracking branch 'upstream/master'

Signed-off-by: shennetsind <ind@henn.et>

Conflicts:
	src/map/pc.c

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;